af-db-ts 2.0.19 → 2.0.73

package/src/ms/prepare-value.ts

@@ -0,0 +1,175 @@
+// noinspection SqlResolve
+import { DateTime } from 'luxon';
+import { getBool } from 'af-tools-ts';
+import * as sql from 'mssql';
+import { IFieldDefMs } from '../@types/i-ms';
+import { binToHexString, prepareJSON, prepareUUID, q } from '../utils/utils';
+import { dateTimeValue, getDatetimeWithPrecisionAndOffset } from '../utils/utils-dt';
+import { parseIntNumberS, prepareBigIntNumber, prepareFloatNumber } from '../utils/utils-num';
+import { NULL } from '../common';
+import { TDataTypeMs } from '../@types/i-data-types-ms';
+import { IFieldDef } from '../@types/i-common';
+import { arrayToJsonList } from '../utils/utils-array';
+
+export const escapeStringMs = (value: any, escapeOnlySingleQuotes: boolean = false): string | typeof NULL => {
+  if (value == null) {
+    return NULL;
+  }
+  let v = String(value);
+  v = v.replace(/'/g, `''`);
+  if (!escapeOnlySingleQuotes) {
+    v = v.replace(/%/g, '%%');
+  }
+  return v;
+};
+
+/**
+ * Подготовка строки для передачи в SQL
+ */
+export const prepareSqlStringMs = (value: any, fieldDef: IFieldDefMs): string | typeof NULL => {
+  if (value == null) {
+    return NULL;
+  }
+  let v = escapeStringMs(value, fieldDef.escapeOnlySingleQuotes);
+  const { length = 0, noQuotes } = fieldDef;
+  if (length > 0 && v.length > length) {
+    v = v.substring(0, length);
+  }
+  return q(v, noQuotes);
+};
+
+const prepareDateTimeOffset = (
+  value: any,
+  fieldDef: IFieldDef,
+): string | typeof NULL => getDatetimeWithPrecisionAndOffset({ value, fieldDef });
+
+export const prepareSqlValueMs = (arg: { value: any, fieldDef: IFieldDefMs, }): string | typeof NULL => {
+  const { value, fieldDef } = arg;
+  if (value == null) {
+    return NULL;
+  }
+  const { noQuotes } = fieldDef;
+  let { dataType } = fieldDef;
+  if (typeof dataType === 'string') {
+    dataType = dataType.toLowerCase() as TDataTypeMs;
+  }
+  let v: any = value;
+  switch (dataType) {
+    case 'bool':
+    case 'boolean':
+    case 'bit':
+    case sql.Bit:
+      return getBool(value) ? '1' : '0';
+
+    case 'tinyint':
+    case sql.TinyInt:
+      return String(parseIntNumberS(value, 'tinyint'));
+    case 'smallint':
+    case sql.SmallInt:
+      return String(parseIntNumberS(value, 'smallint'));
+    case 'int':
+    case 'integer':
+    case sql.Int:
+      return String(parseIntNumberS(value, 'int'));
+
+    case 'bigint':
+    case sql.BigInt:
+      return prepareBigIntNumber(value);
+
+    case 'number':
+    case 'decimal':
+    case 'float':
+    case 'money':
+    case 'numeric':
+    case 'smallmoney':
+    case 'real':
+    case sql.Decimal:
+    case sql.Float:
+    case sql.Money:
+    case sql.Numeric:
+    case sql.SmallMoney:
+    case sql.Real:
+      return prepareFloatNumber(value);
+
+    case 'json':
+      v = prepareJSON(v);
+      return v === NULL ? NULL : q(v, noQuotes);
+
+    case 'string':
+    case 'char':
+    case 'nchar':
+    case 'text':
+    case 'ntext':
+    case 'varchar':
+    case 'nvarchar':
+    case 'xml':
+    case sql.Char:
+    case sql.NChar:
+    case sql.Text:
+    case sql.NText:
+    case sql.VarChar:
+    case sql.NVarChar:
+    case sql.Xml:
+      return prepareSqlStringMs(v, fieldDef);
+
+    case 'uid':
+    case 'uuid':
+    case 'uniqueIdentifier':
+    case sql.UniqueIdentifier:
+      return prepareUUID(v, false, fieldDef.noQuotes);
+
+    case 'datetime':
+    case sql.DateTime:
+    case sql.DateTime2: {
+      const { includeOffset = false } = fieldDef.dateTimeOptions || {};
+      // 2023-09-05T02:23:54.105
+      return dateTimeValue(value, fieldDef, (dt: DateTime) => dt.toISO({ includeOffset }));
+    }
+
+    case 'date':
+    case sql.Date:
+      // 2023-09-05
+      return dateTimeValue(value, fieldDef, (dt: DateTime) => dt.toISODate());
+
+    case 'time':
+    case sql.Time:
+      // 02:22:17.368
+      return dateTimeValue(value, fieldDef, (dt: DateTime) => dt.toISOTime()?.substring(0, 12));
+
+    case 'smalldatetime':
+    case sql.SmallDateTime:
+      // 2023-09-05T02:20:00
+      return dateTimeValue(value, fieldDef, (dt: DateTime) => `${dt.toISO()?.substring(0, 17)}00`);
+
+    case 'datetimeoffset':
+    case sql.DateTimeOffset:
+      // 2023-09-05T02:20:00.1234567Z
+      return prepareDateTimeOffset(value, fieldDef);
+
+    case 'binary':
+    case 'varbinary':
+    case 'image':
+    case sql.Binary:
+    case sql.VarBinary:
+    case sql.Image:
+      v = binToHexString(value);
+      return v ? q(v, noQuotes) : NULL;
+
+    case 'udt':
+    case 'geography':
+    case 'geometry':
+    case 'variant':
+    case sql.UDT:
+    case sql.Geography:
+    case sql.Geometry:
+    case sql.Variant:
+      return prepareSqlStringMs(v, fieldDef);
+
+    case 'array':
+      v = arrayToJsonList(value, fieldDef.arrayType);
+      return v === NULL ? NULL : q(`[${escapeStringMs(v)}]`, fieldDef.noQuotes);
+
+    default:
+      return prepareSqlStringMs(v, fieldDef);
+  }
+};

package/src/{mssql → ms}/query-ms.ts

@@ -3,12 +3,12 @@ import * as sql from 'mssql';
 import { logSqlError } from '../common';
 import { closeDbConnectionsMs, getPoolMs } from './pool-ms';
 
-export const queryMs = async (
+export const queryMs = async <ColumnSetDescription = any>(
   connectionId: string,
   sqlText: string,
   throwError?: boolean,
   prefix?: string,
-): Promise<IResult<any> | undefined> => {
+): Promise<IResult<ColumnSetDescription> | undefined> => {
   try {
     const pool = await getPoolMs(connectionId, throwError);
     if (!pool?.connected && !pool?.connecting) {

package/src/ms/table-schema-ms.ts

@@ -0,0 +1,231 @@
+// noinspection SqlResolve
+import * as sql from 'mssql';
+import { each } from 'af-tools-ts';
+import { removePairBrackets, schemaTable } from '../utils/utils';
+import { IFieldDefMs, ITableSchemaMs, TColumnsSchemaMs, TUniqueConstraintsMs } from '../@types/i-ms';
+import { queryMs } from './query-ms';
+import { logger } from '../logger-error';
+import { graceExit } from '../common';
+import { TFieldName } from '../@types/i-common';
+import { TDataTypeMs } from '../@types/i-data-types-ms';
+
+// commonSchemaAndTable: <schema>.<table> :  Staff.nnPersones-personGuid
+// schemaAndTableMs: "<schema>"."<table>" :  "Staff"."nnPersones-personGuid"
+
+const tableSchemaHash: { [commonSchemaAndTable: string]: ITableSchemaMs } = {};
+
+const FIELD_SCHEMA_PROPS = [
+  'arrayType',
+  'caseSensitive',
+  'charSetName',
+  'collation',
+  'columnDefault',
+  'dataType',
+  'dateTimeOptions',
+  'dtPrecision',
+  'escapeOnlySingleQuotes',
+  'hasDefault',
+  'identity',
+  'index',
+  'inputDateFormat',
+  'isNullable',
+  'length',
+  'name',
+  'noQuotes',
+  'octetLength',
+  'precision',
+  'radix',
+  'readOnly',
+  'scale', // VVQ
+];
+
+/**
+ * Корректировка схемы таблицы
+ * Поля с суффиксом _json получают тип "json". Остальные корректировки берутся из fieldTypeCorrection
+ * Например, для полей типа datetime можно передавать свойство inputDateFormat
+ */
+export const correctRecordSchemaMs = (
+  columnsSchema: TColumnsSchemaMs,
+  // объект корректировок
+  fieldTypeCorrection?: TColumnsSchemaMs,
+) => {
+  each(columnsSchema, (fieldSchema: IFieldDefMs, fieldName: TFieldName) => {
+    if (/_json$/i.test(fieldName)) {
+      fieldSchema.dataType = 'json';
+    }
+    switch (fieldSchema.dataType) {
+      case sql.NChar:
+      case sql.NText:
+      case sql.NVarChar:
+        if (fieldSchema.length) {
+          fieldSchema.length = Math.floor(fieldSchema.length / 2);
+        }
+        break;
+      case sql.UniqueIdentifier:
+        fieldSchema.length = 36;
+        break;
+      default:
+    }
+  });
+  if (fieldTypeCorrection && typeof fieldTypeCorrection === 'object') {
+    each(fieldTypeCorrection, (correction: IFieldDefMs, fieldName: TFieldName) => {
+      FIELD_SCHEMA_PROPS.forEach((prop) => {
+        if (correction[prop] !== undefined) {
+          if (!columnsSchema[fieldName]) {
+            columnsSchema[fieldName] = {} as IFieldDefMs;
+          }
+          columnsSchema[fieldName][prop] = correction[prop];
+        }
+      });
+    });
+  }
+};
+
+const getColumnsSchemaMs_ = async (
+  connectionId: string,
+  commonSchemaAndTable: string,
+): Promise<TColumnsSchemaMs> => {
+  const [schema, table] = schemaTable.to.common(commonSchemaAndTable).split('.');
+  let sqlText = `
+  --
+  SELECT 
+    TABLE_SCHEMA,
+    TABLE_NAME,
+    COLUMN_NAME,
+    IS_NULLABLE,
+    COLUMN_DEFAULT,
+    DATA_TYPE,
+    CHARACTER_MAXIMUM_LENGTH,
+    CHARACTER_OCTET_LENGTH,
+    NUMERIC_PRECISION,
+    NUMERIC_PRECISION_RADIX,
+    NUMERIC_SCALE,
+    DATETIME_PRECISION,
+    CHARACTER_SET_NAME,
+    COLLATION_NAME
+  FROM INFORMATION_SCHEMA.COLUMNS
+    WHERE TABLE_NAME = '${table}' AND TABLE_SCHEMA = '${schema}';
+  `;
+
+  let res = await queryMs(connectionId, sqlText, true, `getRecordSchemaMs SQL ERROR`);
+  const columnsSchema: TColumnsSchemaMs = {};
+  (res?.recordset || []).forEach((fieldDef) => {
+    const name = fieldDef.COLUMN_NAME;
+    const columnDefault = fieldDef.COLUMN_DEFAULT != null ? removePairBrackets(fieldDef.COLUMN_DEFAULT) : undefined;
+    // noinspection UnnecessaryLocalVariableJS
+    const fieldSchema: IFieldDefMs = {
+      name,
+      isNullable: /YES/i.test(fieldDef.IS_NULLABLE || ''),
+      columnDefault,
+      hasDefault: columnDefault != null,
+      dataType: fieldDef.DATA_TYPE,
+      length: fieldDef.CHARACTER_MAXIMUM_LENGTH,
+      octetLength: fieldDef.CHARACTER_OCTET_LENGTH,
+      precision: fieldDef.NUMERIC_PRECISION, // VVq Числовые?
+      radix: fieldDef.NUMERIC_PRECISION_RADIX,
+      scale: fieldDef.NUMERIC_SCALENUMERIC_SCALE, // VVQ
+      dtPrecision: fieldDef.DATETIME_PRECISION,
+      charSetName: fieldDef.CHARACTER_SET_NAME, // cp1251
+      collation: fieldDef.COLLATION_NAME, // Cyrillic_General_BIN
+    };
+    columnsSchema[name] = fieldSchema;
+  });
+
+  sqlText = `/**/ SELECT TOP(1) * FROM ${schemaTable.to.ms(commonSchemaAndTable)}`;
+  res = await queryMs(connectionId, sqlText, true, 'getRecordSchemaMs() SQL ERROR');
+  const { columns = {} } = res?.recordset || {};
+  Object.entries(columns).forEach(([fieldName, fieldDefC]) => {
+    const fieldDef = columnsSchema[fieldName];
+    if (fieldDef) {
+      fieldDef.dataType = fieldDefC.type as TDataTypeMs;
+      fieldDef.arrayType = fieldDefC.udt; // VVQ
+      fieldDef.caseSensitive = fieldDefC.caseSensitive;
+      fieldDef.identity = fieldDefC.identity; // boolean;
+      fieldDef.readOnly = fieldDefC.readOnly; // boolean;
+    }
+  });
+  return columnsSchema;
+};
+
+const getPrimaryKey = async (connectionId: string, commonSchemaAndTable: string): Promise<string[]> => {
+  const [schema, table] = schemaTable.to.common(commonSchemaAndTable).split('.');
+  const sqlText = `
+    --
+    SELECT 
+      C.COLUMN_NAME AS f
+    FROM
+      INFORMATION_SCHEMA.TABLE_CONSTRAINTS T
+      JOIN INFORMATION_SCHEMA.CONSTRAINT_COLUMN_USAGE C ON C.CONSTRAINT_NAME = T.CONSTRAINT_NAME
+    WHERE 
+      C.TABLE_SCHEMA = '${schema}' 
+      AND C.TABLE_NAME = '${table}'
+      AND T.CONSTRAINT_TYPE='PRIMARY KEY'`;
+  const res = await queryMs(connectionId, sqlText, true, 'getPrimaryKey() SQL ERROR');
+  return (res?.recordset || []).map(({ f }) => f);
+};
+
+const getUniqueConstraints = async (connectionId: string, commonSchemaAndTable: string): Promise<TUniqueConstraintsMs> => {
+  const schemaTableMs = schemaTable.to.ms(commonSchemaAndTable);
+  const sqlText = `EXEC sp_helpindex '${schemaTableMs}'`;
+  const res = await queryMs(connectionId, sqlText, true, 'getUniqueConstraints() SQL ERROR');
+  const uc: TUniqueConstraintsMs = {};
+  (res?.recordset || []).forEach((row) => {
+    const { index_description: d } = row;
+    const isUc = d.includes('unique') && !d.includes('primary key');
+    if (isUc) {
+      uc[row.index_name] = row.index_keys.split(/,\s*/);
+    }
+  });
+  return uc;
+};
+
+const getSerials = async (connectionId: string, commonSchemaAndTable: string): Promise<string[]> => {
+  const schemaTableMs = schemaTable.to.ms(commonSchemaAndTable);
+  const sqlText = `
+      ---
+      SELECT
+          idc.name,
+          idc.seed_value,
+          idc.increment_value,
+          idc.last_value
+      FROM sys.identity_columns idc
+      WHERE
+          idc.object_id = OBJECT_ID('${schemaTableMs}')
+  `;
+  const res = await queryMs(connectionId, sqlText, true, 'getUniqueConstraints() SQL ERROR');
+  const serialFieldName = res?.recordset?.[0]?.name;
+  return [serialFieldName];
+};
+
+export const getTableSchemaMs = async (connectionId: string, commonSchemaAndTable: string): Promise<ITableSchemaMs> => {
+  let tableSchema: ITableSchemaMs = tableSchemaHash[commonSchemaAndTable];
+  if (tableSchema) {
+    return tableSchema;
+  }
+  try {
+    const columnsSchema = await getColumnsSchemaMs_(connectionId, commonSchemaAndTable);
+    const pk = await getPrimaryKey(connectionId, commonSchemaAndTable);
+    const uc = await getUniqueConstraints(connectionId, commonSchemaAndTable);
+    const serialsFields = await getSerials(connectionId, commonSchemaAndTable);
+    const defaults: { [fieldName: string]: string } = {};
+    Object.values(columnsSchema).forEach((fieldDef) => {
+      const { name: f = '', columnDefault, hasDefault } = fieldDef;
+      if (hasDefault && !serialsFields.includes(f)) {
+        defaults[f] = `${columnDefault}`;
+      }
+    });
+    const fieldsArray: string[] = Object.keys(columnsSchema);
+    const readOnlyFields: string[] = Object.values(columnsSchema).filter((s) => s.readOnly).map((s) => s.name as string);
+    const fieldsWoSerialsAndRO: string[] = fieldsArray.filter((f) => !serialsFields.includes(f) && !readOnlyFields.includes(f));
+
+    tableSchema = {
+      columnsSchema, pk, uc, defaults, serialsFields, fieldsArray, fieldsWoSerialsAndRO, readOnlyFields,
+    };
+    tableSchemaHash[commonSchemaAndTable] = tableSchema;
+  } catch (err) {
+    logger.error(`Failed to get schema for table ${commonSchemaAndTable}`);
+    logger.error(err);
+    await graceExit();
+  }
+  return tableSchema;
+};

package/src/ms/utils-ms.ts

@@ -0,0 +1,72 @@
+import * as sql from 'mssql';
+import { TDataTypeMs } from '../@types/i-data-types-ms';
+
+export const getJsTypeByTypeMs = (dataType?: TDataTypeMs, arrayType?: TDataTypeMs): string => {
+  switch (dataType) {
+    case 'boolean':
+    case sql.Bit:
+      return 'boolean';
+
+    case 'bigint':
+    case sql.BigInt:
+      return 'string | number';
+
+    case 'tinyint':
+    case sql.TinyInt:
+    case 'smallint':
+    case sql.SmallInt:
+    case 'int':
+    case 'integer':
+    case sql.Int:
+    case 'number':
+    case sql.Decimal:
+    case sql.Float:
+    case sql.Money:
+    case sql.Numeric:
+    case sql.SmallMoney:
+    case sql.Real:
+      return 'number';
+
+    case 'string':
+    case sql.Char:
+    case sql.NChar:
+    case sql.Text:
+    case sql.NText:
+    case sql.VarChar:
+    case sql.NVarChar:
+    case sql.Xml:
+    case 'uid':
+    case 'uuid':
+    case 'uniqueIdentifier':
+    case sql.UniqueIdentifier:
+      return 'string';
+
+    case 'datetime':
+    case 'date':
+    case 'time':
+    case sql.DateTime:
+    case sql.DateTime2:
+    case sql.Time:
+    case sql.Date:
+    case sql.SmallDateTime:
+    case sql.DateTimeOffset:
+      return 'string | Date | number';
+
+    case sql.Binary:
+    case sql.VarBinary:
+    case sql.Image:
+      return 'any';
+
+    case sql.UDT:
+    case sql.Geography:
+    case sql.Geometry:
+    case sql.Variant:
+      return 'any';
+    case 'array': {
+      const jsType = getJsTypeByTypeMs(arrayType);
+      return `${jsType}[]`;
+    }
+    default:
+      return 'string';
+  }
+};

package/src/ms/wrap-transaction-ms.ts

@@ -0,0 +1,27 @@
+/**
+ * Оборачивает инструкции SQL в транзакцию
+ */
+export const wrapTransactionMs = (strSQL: string): string => `BEGIN TRY
+    BEGIN TRANSACTION;
+
+    ${strSQL}
+
+    COMMIT TRANSACTION;
+END TRY
+BEGIN CATCH
+    DECLARE @ErrorMessage  NVARCHAR(MAX)
+          , @ErrorSeverity INT
+          , @ErrorState    INT;
+
+    SELECT
+        @ErrorMessage = ERROR_MESSAGE() + ' Line ' + CAST(ERROR_LINE() AS NVARCHAR(5))
+      , @ErrorSeverity = ERROR_SEVERITY()
+      , @ErrorState = ERROR_STATE();
+
+    IF @@trancount > 0
+    BEGIN
+        ROLLBACK TRANSACTION;
+    END;
+
+    RAISERROR(@ErrorMessage, @ErrorSeverity, @ErrorState);
+END CATCH;`;

package/src/pg/gen-table-interfaces-pg.ts

@@ -0,0 +1,74 @@
+/* eslint-disable no-await-in-loop */
+import * as path from 'path';
+import * as fs from 'fs';
+import { echo } from 'af-echo-ts';
+import { IFieldDefPg } from '../@types/i-pg';
+import { getTableSchemaPg } from './table-schema-pg';
+import { closeAllPgConnectionsPg } from './pool-pg';
+import { getJsTypeByTypePg } from './utils-pg';
+
+// export const getJsTypeByUdtNamePg = (udtName?: TArrayTypesPg): string => { // VVR
+//   switch (udtName) {
+//     case '_int2':
+//     case '_int4':
+//     case '_int8':
+//     case '_float8':
+//     case '_float4':
+//     case '_numeric':
+//     case '_money':
+//       return 'number';
+//     case '_text':
+//     case '_varchar':
+//       return 'string';
+//     case '_bool':
+//       return 'boolean';
+//     case '_time':
+//     case '_date':
+//     case '_timestamp':
+//     case '_timestamptz':
+//       return '(string | Date | number)';
+//     default:
+//       return 'any';
+//   }
+// };
+
+const getFieldDefinition = (
+  d: IFieldDefPg,
+): string => `${d.name}${d.isNullable || d.hasDefault ? '?' : ''}: ${getJsTypeByTypePg(d.dataType)}${d.isNullable ? ' | null' : ''}`;
+
+const TABLE_INTERFACES_DIR = __dirname.replace(/\\/g, '/').replace(/\/dist\//, '/');
+
+export const genTableInterfacePg = async (
+  connectionId: string,
+  commonSchemaAndTable: string,
+  tableInterfacesDir: string = TABLE_INTERFACES_DIR,
+): Promise<void> => {
+  const tableSchema = await getTableSchemaPg(connectionId, commonSchemaAndTable);
+  const interfaceName = `I${commonSchemaAndTable
+    .replace('.', '_')
+    .split('_')
+    .map((word) => word[0].toUpperCase() + word.substring(1)).join('')}Record`;
+
+  const linesArr = Object.values(tableSchema.columnsSchema).map(getFieldDefinition);
+  const content = `export interface ${interfaceName} {\n${linesArr.map((v) => `  ${v}`).join(',\n')},\n}\n`;
+
+  const fileName = `${commonSchemaAndTable.replace('.', '-').toLowerCase()}.ts`;
+  const filePath = path.resolve(path.join(tableInterfacesDir, fileName));
+
+  fs.writeFileSync(filePath, content);
+};
+
+export const genTableInterfacesPg = async (
+  connectionId: string,
+  tables: string[],
+  tableInterfacesDir: string = TABLE_INTERFACES_DIR,
+): Promise<void> => {
+  for (let i = 0; i < tables.length; i++) {
+    const commonSchemaAndTable = tables[i];
+    await genTableInterfacePg(connectionId, commonSchemaAndTable, tableInterfacesDir);
+  }
+  echo.g(`Generated ${tables.length} table interfaces in folder '.${
+    tableInterfacesDir.replace(process.cwd().replace(/\\/g, '/'), '')}/'`);
+  await closeAllPgConnectionsPg();
+  process.exit(0);
+};

package/src/pg/get-sql/insert.ts

@@ -0,0 +1,46 @@
+import { getTableSchemaPg } from '../table-schema-pg';
+import { prepareSqlValuePg } from '../prepare-value';
+import { ITableSchemaPg } from '../../@types/i-pg';
+import { TDBRecord, TRecordSet } from '../../@types/i-common';
+import { schemaTable } from '../../utils/utils';
+import { NULL } from '../../common';
+
+export const getInsertSqlPg = async <U extends TDBRecord = TDBRecord> (arg: {
+  connectionId: string,
+  commonSchemaAndTable: string,
+  recordset: TRecordSet<U>,
+  excludeFromInsert?: string[],
+  addOutputInserted?: boolean,
+}): Promise<string> => {
+  const { commonSchemaAndTable } = arg;
+
+  const tableSchema: ITableSchemaPg = await getTableSchemaPg(arg.connectionId, commonSchemaAndTable);
+  const { columnsSchema, fieldsWoSerialsAndRO, defaults } = tableSchema;
+
+  const insertFieldsArray = fieldsWoSerialsAndRO.filter((f) => (!(arg.excludeFromInsert || []).includes(f)));
+  const insertFieldsList = insertFieldsArray.map((f) => `"${f}"`).join(', ');
+
+  const preparedRowsArray = arg.recordset.map((record) => {
+    const preparedRecordValuesArray = insertFieldsArray.map((f) => {
+      const value = record[f];
+      const fieldDef = columnsSchema[f];
+      if (value != null) {
+        return prepareSqlValuePg({ value, fieldDef });
+      }
+      const defVal = defaults[f];
+      if (!fieldDef.isNullable && defVal != null) {
+        return defVal;
+      }
+      return NULL;
+    });
+    return preparedRecordValuesArray.join(',');
+  });
+
+  const values = preparedRowsArray.map((v) => `(${v})`).join('\n,');
+  const out = arg.addOutputInserted ? ' RETURNING * ' : '';
+  const target = schemaTable.to.pg(commonSchemaAndTable);
+  // noinspection UnnecessaryLocalVariableJS
+  const insertSQL = `INSERT INTO ${target} (${insertFieldsList})
+                     VALUES ${values} ON CONFLICT DO NOTHING ${out};`;
+  return insertSQL;
+};