af-db-ts 2.0.19 → 2.0.73

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

@@ -0,0 +1,70 @@
+import { getTableSchemaPg } from '../table-schema-pg';
+import { prepareSqlValuePg } from '../prepare-value';
+import { ITableSchemaPg } from '../../@types/i-pg';
+import { schemaTable } from '../../utils/utils';
+import { TDBRecord, TRecordSet } from '../../@types/i-common';
+
+export const getMergeSqlPg = async <U extends TDBRecord = TDBRecord> (arg: {
+  connectionId: string,
+  commonSchemaAndTable: string,
+  recordset: TRecordSet<U>,
+  omitFields?: string[],
+  noUpdateIfNull?: boolean,
+  mergeCorrection?: (_sql: string) => string,
+}): Promise<string> => {
+  const { connectionId, commonSchemaAndTable, recordset, omitFields = [], noUpdateIfNull } = arg;
+  if (!recordset?.length) {
+    return '';
+  }
+  const schemaTableStr = schemaTable.to.pg(commonSchemaAndTable);
+  const tableSchema: ITableSchemaPg = await getTableSchemaPg(connectionId, commonSchemaAndTable);
+  const { columnsSchema, pk, fieldsWoSerialsAndRO, defaults } = tableSchema;
+
+  let mergeFieldsArr: string[] = fieldsWoSerialsAndRO;
+  if (omitFields.length) {
+    const set = new Set(omitFields);
+    mergeFieldsArr = fieldsWoSerialsAndRO.filter((fieldName) => !set.has(fieldName));
+  }
+
+  const mergeValues = recordset.map((record: U) => {
+    const preparedValues: (string | number)[] = [];
+
+    mergeFieldsArr.forEach((f) => {
+      const value = record[f];
+      let sqlValue = prepareSqlValuePg({ value, fieldDef: columnsSchema[f] });
+      if (defaults[f] != null && (sqlValue == null || sqlValue === 'null')) {
+        sqlValue = defaults[f];
+      }
+      preparedValues.push(sqlValue);
+    });
+    return `(${preparedValues.join(', ')})`;
+  }).join(',\n  ').trim();
+
+  const updateSetStr = mergeFieldsArr.map((f) => {
+    const vArr = [`EXCLUDED."${f}"`];
+    if (noUpdateIfNull) {
+      vArr.push(`${schemaTableStr}."${f}"`);
+    }
+    if (defaults[f]) {
+      vArr.push(defaults[f]);
+    }
+    return `"${f}" = ${vArr.length > 1 ? `COALESCE(${vArr.join(', ')})` : vArr[0]}`;
+  }).join(',\n  ');
+
+  const mergeFieldsList = mergeFieldsArr.map((f) => `"${f}"`).join(',\n  ');
+  // noinspection UnnecessaryLocalVariableJS
+  let mergeSQL = `--
+INSERT INTO ${schemaTableStr} (
+  ${mergeFieldsList}
+)
+VALUES
+  ${mergeValues}
+ON CONFLICT (${pk.map((f) => `"${f}"`).join(', ')})
+DO UPDATE SET
+  ${updateSetStr}
+;`;
+  if (typeof arg.mergeCorrection === 'function') {
+    mergeSQL = arg.mergeCorrection(mergeSQL);
+  }
+  return mergeSQL;
+};

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

@@ -0,0 +1,46 @@
+import { getTableSchemaPg } from '../table-schema-pg';
+import { prepareSqlValuePg } from '../prepare-value';
+import { ITableSchemaPg } from '../../@types/i-pg';
+import { TDBRecord } from '../../@types/i-common';
+import { schemaTable } from '../../utils/utils';
+
+export const getUpdateSqlPg = async <U extends TDBRecord = TDBRecord>(arg: {
+  connectionId: string,
+  commonSchemaAndTable: string,
+  record: U,
+  customSets: TDBRecord,
+  updateIdentity?: string[],
+}): Promise<string> => {
+  const {
+    connectionId,
+    commonSchemaAndTable,
+    record,
+    customSets = {},
+  } = arg;
+  const tableSchema: ITableSchemaPg = await getTableSchemaPg(connectionId, commonSchemaAndTable);
+  const { columnsSchema, pk, fieldsWoSerialsAndRO } = tableSchema;
+
+  const { updateIdentity = pk } = arg;
+
+  const updateFields = fieldsWoSerialsAndRO.filter((f) => (!updateIdentity.includes(f)));
+
+  const getPreparedSqlValue = (f: string) => prepareSqlValuePg({ value: record[f], fieldDef: columnsSchema[f] });
+
+  const preparedRecord: TDBRecord = {};
+  updateFields.forEach((f) => {
+    if (customSets[f] !== undefined) {
+      preparedRecord[f] = customSets[f];
+    } else if (record[f] !== undefined) {
+      preparedRecord[f] = getPreparedSqlValue(f);
+    }
+  });
+  const sets = Object.entries(preparedRecord).map(([f, v]) => `"${f}" = ${v}`).join(', ');
+
+  const where = updateIdentity.map((f) => `"${f}" = ${getPreparedSqlValue(f)}`).join(' AND ');
+
+  // noinspection UnnecessaryLocalVariableJS
+  const updateSql = `${'UPDATE'} ${schemaTable.to.pg(commonSchemaAndTable)} SET
+    ${sets}
+  WHERE ${where};`;
+  return updateSql;
+};

package/src/pg/{insert.ts → insert-pg.ts}

@@ -1,9 +1,9 @@
 // noinspection SqlResolve
-import { QueryResultRow } from 'pg';
 import { omitBy } from 'af-tools-ts';
-import { getFieldsAndValuesPg, getTableSchemaPg } from './table-schema';
+import { getFieldsAndValuesPg, getTableSchemaPg } from './table-schema-pg';
 import { queryPg } from './query-pg';
 import { logger } from '../logger-error';
+import { TDBRecord } from '../@types/i-common';
 
 export enum EUpdateLevel {
   NEVER_UPDATE,
@@ -11,9 +11,9 @@ export enum EUpdateLevel {
   UPDATE_ALWAYS
 }
 
-const hasAllValues = <T extends QueryResultRow> (fieldList: string[] | undefined, record: T) => fieldList?.length && fieldList.every((f) => record[f] !== undefined);
+const hasAllValues = <T extends TDBRecord> (fieldList: string[] | undefined, record: T) => fieldList?.length && fieldList.every((f) => record[f] !== undefined);
 
-const selectByAnyIdentity = async <T extends QueryResultRow, R extends QueryResultRow = T> (
+const selectByAnyIdentity = async <T extends TDBRecord, R extends TDBRecord = T> (
   connectionId: string,
   identities: string[][],
   record: T,
@@ -40,7 +40,7 @@ const selectByAnyIdentity = async <T extends QueryResultRow, R extends QueryResu
   }
 };
 
-export const insertPg = async <T extends QueryResultRow, R extends QueryResultRow = T> (
+export const insertPg = async <T extends TDBRecord, R extends TDBRecord = T> (
   {
     connectionId,
     record,
@@ -57,13 +57,13 @@ export const insertPg = async <T extends QueryResultRow, R extends QueryResultRo
     updateLevel?: EUpdateLevel, // Flag: Update entry when unique constraints conflict.
   },
 ): Promise<R | undefined> => {
-  const { recordSchema, pk = [], serials = [], uc = [] } = await getTableSchemaPg(connectionId, target);
+  const { columnsSchema, pk = [], serialsFields = [], uc = [] } = await getTableSchemaPg(connectionId, target);
   // Cleaning the record: deleting properties not included in the set of fields, with the value undefined and auto-incrementing fields
-  const recordWoSerials: T = omitBy(record, (fieldValue: any, fieldName: string) => !recordSchema[fieldName] || fieldValue === undefined || serials.includes(fieldName)) as T;
+  const recordWoSerials: T = omitBy(record, (fieldValue: any, fieldName: string) => !columnsSchema[fieldName] || fieldValue === undefined || serialsFields.includes(fieldName)) as T;
 
   // We form all possible sets of fields, which we then use to search for an added (or already existing) record
   // Normalize (sort) sets
-  let identities: string[][] = [pk, ...serials.map((f) => [f]), ...Object.values(uc)].filter((a) => a.length).map((a) => a.sort());
+  let identities: string[][] = [pk, ...serialsFields.map((f) => [f]), ...Object.values(uc)].filter((a) => a.length).map((a) => a.sort());
   // Removing duplicates
   identities = [...(new Set(identities.map((a) => a.join('|'))))].map((s) => s.split('|'));
   source = source || target;
@@ -85,7 +85,7 @@ export const insertPg = async <T extends QueryResultRow, R extends QueryResultRo
     }
 
     // There is no suitable record in the database, we insert it
-    const { values, positionsList, fieldsList, upsertFields } = getFieldsAndValuesPg(recordWoSerials, recordSchema);
+    const { values, positionsList, fieldsList, upsertFields } = getFieldsAndValuesPg(recordWoSerials, columnsSchema);
     const insertSQL = `INSERT INTO ${target} (${fieldsList})
                        VALUES (${positionsList}) ON CONFLICT ${
                                updateLevel === EUpdateLevel.NEVER_UPDATE

package/src/pg/prepare-value.ts

@@ -1,92 +1,154 @@
 // noinspection SqlResolve
 import { DateTime } from 'luxon';
-import { EDataTypePg, IFieldDefPg } from '../@types/i-pg';
+import { getBool } from 'af-tools-ts';
+import { IFieldDefPg } from '../@types/i-pg';
+import { NULL } from '../common';
+import { dateTimeValue, getDatetimeWithPrecisionAndOffset } from '../utils/utils-dt';
+import { prepareBigIntNumber, prepareFloatNumber, prepareIntNumber, prepareNumeric } from '../utils/utils-num';
+import { IFieldDef } from '../@types/i-common';
+import { binToHexString, prepareJSON, prepareUUID, q } from '../utils/utils';
+import { arrayToJsonList } from '../utils/utils-array';
 
-const NULL = 'null';
-const utc$ = (millis?: number): DateTime => DateTime.fromMillis(millis == null ? Date.now() : millis).setZone('UTC');
+export const quoteStringPg = (value: string): string => {
+  if (value == null) {
+    return NULL;
+  }
+  return /['\\]|\${2,}/.test(value) ? `$s$${value}$s$` : `'${value}'`;
+};
 
-export const prepareSqlStringPg = (s: any): string => {
-  s = String(s);
-  if (/['\\]|\${2,}/.test(s)) {
-    return `$s$${s}$s$`;
+export const prepareSqlStringPg = (value: any, fieldDef: IFieldDefPg): string | typeof NULL => {
+  if (value == null) {
+    return NULL;
   }
-  return `'${s}'`;
+  let v = String(value);
+  const { length = 0, noQuotes } = fieldDef;
+  if (length > 0 && v.length > length) {
+    v = v.substring(0, length);
+  }
+  if (noQuotes) {
+    return v;
+  }
+  return quoteStringPg(v);
 };
 
-export const prepareSqlValuePg = (arg: {
+const prepareDateTimeOffset = (
   value: any,
-  fieldDef: IFieldDefPg,
-}): any => {
+  fieldDef: IFieldDef,
+): string | typeof NULL => getDatetimeWithPrecisionAndOffset({ value, fieldDef, defaultDtPrecision: 6 });
+
+const prepareTimeOffset = (value: any, fieldDefOriginal: IFieldDefPg): string | typeof NULL => {
+  const fieldDef: IFieldDefPg = { ...fieldDefOriginal, noQuotes: true };
+  fieldDef.dateTimeOptions = fieldDef.dateTimeOptions || {};
+  const { includeOffset = fieldDef.dataType === 'timetz' } = fieldDef.dateTimeOptions;
+  fieldDef.dateTimeOptions.includeOffset = includeOffset;
+  const dts = getDatetimeWithPrecisionAndOffset({ value, fieldDef, defaultDtPrecision: 6, stripTrailingZeros: true });
+  return dts === NULL ? NULL : `'${dts.substring(11, dts.length)}'::${fieldDef.dataType}`;
+};
+
+const prepareJsonPg = (value: any, dataType: 'json' | 'jsonb'): string | typeof NULL => {
+  const v = prepareJSON(value);
+  if (v === NULL) {
+    return NULL;
+  }
+  return `${quoteStringPg(v)}::${dataType}`;
+};
+
+export const prepareSqlValuePg = (arg: { value: any, fieldDef: IFieldDefPg }): any => {
   const { value, fieldDef } = arg;
-  if (value == null && fieldDef.isNullable) {
+  if (value == null) {
     return NULL;
   }
-  switch (fieldDef.dataType) {
-    case EDataTypePg.boolean: {
-      return value ? 'true' : 'false';
-    }
+  const fieldDefWithNoQuotes = { ...fieldDef, noQuotes: true };
 
-    case EDataTypePg.bigint: {
-      return `'${value}'`;
-    }
+  let v = value;
+  const { noQuotes, dataType } = fieldDef;
 
-    case EDataTypePg.numeric:
-    case EDataTypePg.real: {
-      const v: string | number = Number(value);
-      return Number.isNaN(v) ? NULL : v;
-    }
+  switch (dataType) {
+    case 'bit':
+      return getBool(value) ? '1' : '0';
 
-    case EDataTypePg.integer:
-    case EDataTypePg.smallint: {
-      const v: string | number = Number(value);
-      return Number.isNaN(v) ? NULL : Math.floor(v);
-    }
+    case 'bool':
+    case 'boolean':
+      return getBool(value) ? 'true' : 'false';
 
-    case EDataTypePg.text:
-    case EDataTypePg.character:
-    case EDataTypePg.varchar:
-    case EDataTypePg.uuid: {
-      return prepareSqlStringPg(value);
-    }
+    case 'smallint':
+    case 'int2':
+      return prepareIntNumber(value, -32768, 32767);
+    case 'int':
+    case 'integer':
+    case 'int4':
+      return prepareIntNumber(value, -2147483648, 2147483647);
+    case 'bigint':
+    case 'int8':
+      return prepareBigIntNumber(value);
+
+    case 'numeric':
+    case 'decimal':
+      return prepareNumeric(value, fieldDef.precision, fieldDef.scale);
+
+    case 'real':
+    case 'float4':
+    case 'money':
+    case 'double precision':
+    case 'float8':
+      return prepareFloatNumber(value);
+
+    case 'json':
+    case 'jsonb':
+      return prepareJsonPg(value, dataType);
 
-    case EDataTypePg.json:
-    case EDataTypePg.jsonb: {
-      return prepareSqlStringPg(JSON.stringify(value));
+    case 'uuid':
+      return prepareUUID(v, true, fieldDef.noQuotes);
+
+    case 'string':
+    case 'text':
+    case 'character':
+    case 'char':
+    case 'varchar':
+    case 'character varying':
+      return prepareSqlStringPg(value, fieldDef);
+
+    case 'timestamp':
+    case 'timestamp without time zone': {
+      // '2023-09-05T02:23:54.105+03:00'::timestamp
+      // '2023-09-05T02:23:54.105'::timestamp
+      const { includeOffset = false } = fieldDef.dateTimeOptions || {}; // По умолчанию для timestamp includeOffset = false
+      const str = prepareDateTimeOffset(value, { ...fieldDef, noQuotes: true, dateTimeOptions: { ...(fieldDef.dateTimeOptions || {}), includeOffset } });
+      return str === NULL ? NULL : `'${str}'::timestamp`;
     }
 
-    case EDataTypePg.date:
-    case EDataTypePg.timestamp:
-    case EDataTypePg.timestamptz: {
-      let v = value;
-      if (value instanceof Date) {
-        v = +value;
-      } else if (value instanceof DateTime) {
-        v = value.toMillis();
-      } else if (typeof value === 'string') {
-        v = DateTime.fromISO(value).toMillis();
-      }
-      switch (fieldDef.dataType) {
-        case EDataTypePg.date: {
-          return `'${typeof v === 'number' ? utc$(v).toISODate() : v}'::date`;
-        }
-        case EDataTypePg.timestamp:
-        case EDataTypePg.timestamptz: {
-          return `'${typeof v === 'number' ? utc$(v).toISO() : v}'::timestamptz`;
-        }
-        default:
-          return `'${v}'`;
-      }
+    case 'timestamptz':
+    case 'timestamp with time zone': {
+      // '2023-09-05T02:23:54.105'::timestamptz
+      // '2023-09-05T02:23:54.105+03:00'::timestamptz
+      const str = prepareDateTimeOffset(value, fieldDefWithNoQuotes);
+      return str === NULL ? NULL : `'${str}'::timestamptz`;
     }
 
-    case EDataTypePg.USER_DEFINED:
-      return prepareSqlStringPg(value);
+    case 'date':
+      // '2023-09-05'::date
+      return dateTimeValue(value, fieldDefWithNoQuotes, (dt: DateTime) => `'${dt.toISODate()}'::date`);
 
-    case EDataTypePg.ARRAY: {
-      let v = JSON.stringify(value);
-      v = v.replace(/^\[(.*?)]$/, '{$1}');
-      return prepareSqlStringPg(v);
+    case 'timetz': // '02:22:17.368+03:00'::time
+    case 'time with time zone':
+    case 'time': // '02:22:17.368'::time
+    case 'time without time zone':
+      return prepareTimeOffset(value, fieldDef);
+
+    case 'bytea':
+      v = binToHexString(value);
+      return v ? q(v, noQuotes) : NULL;
+
+    case 'ARRAY': {
+      v = arrayToJsonList(value, fieldDef.arrayType);
+      if (v === NULL) {
+        return NULL;
+      }
+      v = `{${v}}`;
+      return fieldDef.noQuotes ? v : quoteStringPg(v);
     }
+    // 'USER_DEFINED'
     default:
-      return prepareSqlStringPg(value);
+      return prepareSqlStringPg(value, fieldDef);
   }
 };

package/src/pg/query-pg.ts

@@ -1,9 +1,10 @@
-import { QueryResult, QueryResultRow } from 'pg';
-import { getPoolPg } from './pg-pool';
+import { QueryResult } from 'pg';
+import { getPoolPg } from './pool-pg';
 import { logSqlError } from '../common';
 import { IPoolPg } from '../@types/i-pg';
+import { TDBRecord } from '../@types/i-common';
 
-export const queryPg = async <R extends QueryResultRow = any> (
+export const queryPg = async <R extends TDBRecord = any> (
   connectionId: string,
   sqlText: string,
   sqlValues?: any[],

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

@@ -0,0 +1,196 @@
+// noinspection SqlResolve
+import { queryPg } from './query-pg';
+import { logger } from '../logger-error';
+import { graceExit } from '../common';
+import { IFieldDefPg, ITableSchemaPg, TColumnsSchemaPg, TUniqueConstraintsPg } from '../@types/i-pg';
+import { schemaTable } from '../utils/utils';
+import { TDBRecord } from '../@types/i-common';
+import { TDataTypePg } from '../@types/i-data-types-pg';
+import { getNormalizedTypePg, getTypeByUdtNamePg } from './utils-pg';
+
+// commonSchemaAndTable: <schema>.<table> :  Staff.nnPersones-personGuid
+// schemaAndTablePg: "<schema>"."<table>" :  "Staff"."nnPersones-personGuid"
+
+const tableSchemaHash: { [commonSchemaAndTable: string]: ITableSchemaPg } = {};
+
+const getColumnsSchemaPg_ = async (connectionId: string, commonSchemaAndTable: string): Promise<TColumnsSchemaPg> => {
+  const [schema, table] = schemaTable.to.common(commonSchemaAndTable).split('.');
+  const sql = `SELECT column_name,
+                      column_default,
+                      is_nullable,
+                      data_type,
+                      character_maximum_length,
+                      numeric_precision,
+                      numeric_precision_radix,
+                      numeric_scale,
+                      datetime_precision,
+                      udt_name,
+                      is_generated
+               FROM information_schema.columns
+               WHERE table_name = '${table}'
+                 AND table_schema = '${schema}';`;
+  const result = await queryPg(connectionId, sql);
+  const fields = result?.rows || [];
+  const columnsSchema: TColumnsSchemaPg = {};
+  fields.forEach((fieldDef) => {
+    const columnDefault = fieldDef.column_default != null ? fieldDef.column_default : undefined;
+    const name = fieldDef.column_name;
+    const dataType: TDataTypePg = getNormalizedTypePg(fieldDef.data_type);
+    const fieldSchema: IFieldDefPg = {
+      name,
+      isNullable: /yes/i.test(fieldDef.is_nullable || ''),
+      columnDefault: fieldDef.column_default,
+      hasDefault: columnDefault != null,
+      dataType,
+      length: fieldDef.character_maximum_length,
+      precision: fieldDef.numeric_precision,
+      scale: fieldDef.numeric_scale,
+      radix: fieldDef.numeric_precision_radix,
+      dtPrecision: fieldDef.datetime_precision,
+      arrayType: dataType === 'ARRAY' ? getTypeByUdtNamePg(fieldDef.udt_name) : undefined,
+      readOnly: fieldDef.is_generated === 'ALWAYS', // boolean;
+    };
+    Object.entries(fieldSchema).forEach(([prop, value]) => {
+      if (value == null) {
+        delete fieldSchema[prop as keyof IFieldDefPg];
+      }
+    });
+    columnsSchema[name] = fieldSchema;
+  });
+  return columnsSchema;
+};
+
+const getPrimaryKey = async (connectionId: string, commonSchemaAndTable: string): Promise<string[]> => {
+  const schemaTablePg = schemaTable.to.pg(commonSchemaAndTable);
+  const sql = `
+    SELECT a.attname as f
+    FROM pg_index i
+           JOIN pg_attribute a
+                ON a.attrelid = i.indrelid AND a.attnum = ANY (i.indkey)
+    WHERE i.indrelid = '${schemaTablePg}'::regclass
+    AND i.indisprimary;`;
+  const result = await queryPg(connectionId, sql);
+
+  return (result?.rows || []).map(({ f }) => f);
+};
+
+const getUniqueConstraints = async (connectionId: string, commonSchemaAndTable: string): Promise<TUniqueConstraintsPg> => {
+  const schemaTablePg = schemaTable.to.pg(commonSchemaAndTable);
+  const [schema, table] = schemaTable.to.common(commonSchemaAndTable).split('.');
+  const sql = `
+    SELECT UI.cn as cn, UI.cols as cols, CASE WHEN UC.cn IS NULL THEN 'UX' ELSE 'UC' END AS typ
+    FROM (SELECT c.relname as cn, array_to_json(array_agg(a.attname ORDER BY a.attname)) AS cols
+          FROM pg_index i
+                 JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = ANY (i.indkey)
+                 JOIN pg_class AS c ON c.oid = i.indexrelid
+          WHERE i.indrelid = '${schemaTablePg}'::regclass
+              AND i.indisunique
+              AND NOT i.indisprimary
+          GROUP BY c.relname) AS UI
+           LEFT OUTER JOIN (SELECT ccu.constraint_name AS cn
+                            FROM information_schema.table_constraints tc
+                                   JOIN information_schema.constraint_column_usage AS ccu USING (constraint_schema, constraint_name)
+                                   JOIN information_schema.columns AS c ON c.table_schema = tc.constraint_schema
+                              AND tc.table_name = c.table_name AND ccu.column_name = c.column_name
+                            WHERE tc.table_schema = '${schema}'
+                              AND tc.table_name = '${table}'
+                              AND tc.constraint_type = 'UNIQUE'
+                            GROUP BY ccu.constraint_name) AS UC ON UC.cn = UI.cn
+    ORDER BY CASE WHEN UC.cn IS NULL THEN 2 ELSE 1 END
+  `;
+  const result = await queryPg(connectionId, sql);
+  const uc: TUniqueConstraintsPg = {};
+  result?.rows?.forEach(({ cn, cols }) => {
+    uc[cn] = cols;
+  });
+  return uc;
+};
+
+const getSerials = async (connectionId: string, commonSchemaAndTable: string): Promise<string[]> => {
+  const fqName = schemaTable.to.common(commonSchemaAndTable);
+  const sql = `
+    WITH fq_objects AS (SELECT c.oid,
+                               n.nspname || '.' || c.relname AS fqname,
+                               c.relkind,
+                               c.relname                     AS relation
+                        FROM pg_class c
+                               JOIN pg_namespace n ON n.oid = c.relnamespace),
+         sequences AS (SELECT oid, fqname FROM fq_objects WHERE relkind = 'S'),
+         tables AS (SELECT oid, fqname FROM fq_objects WHERE relkind = 'r')
+    SELECT t.fqname AS tbl, array_to_json(array_agg(a.attname ORDER BY a.attname)) AS cols
+    FROM pg_depend d
+           JOIN sequences s ON s.oid = d.objid
+           JOIN tables t ON t.oid = d.refobjid
+           JOIN pg_attribute a ON a.attrelid = d.refobjid and a.attnum = d.refobjsubid
+    WHERE d.deptype = 'a'
+      AND t.fqname = '${fqName}'
+    GROUP BY t.fqname
+  `;
+  const result = await queryPg(connectionId, sql);
+  return result?.rows?.[0]?.cols || [];
+};
+
+export const getTableSchemaPg = async (connectionId: string, commonSchemaAndTable: string): Promise<ITableSchemaPg> => {
+  let tableSchema = tableSchemaHash[commonSchemaAndTable];
+  if (tableSchema) {
+    return tableSchema;
+  }
+  try {
+    const columnsSchema = await getColumnsSchemaPg_(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;
+};
+
+export const getFieldsAndValuesPg = <U extends TDBRecord = TDBRecord> (record: U, columnsSchema: TColumnsSchemaPg):
+  {
+    fields: string[],
+    fieldsList: string,
+    values: any[],
+    positionsList: string,
+    setFields: string,
+    upsertFields: string
+  } => {
+  const recordNormalized: TDBRecord = {};
+  Object.entries(record).forEach(([f, v]) => {
+    const { dataType } = columnsSchema[f] || {};
+    if (!dataType) {
+      return;
+    }
+    if ((dataType === 'jsonb' || dataType === 'json') && Array.isArray(v)) {
+      recordNormalized[f] = JSON.stringify(v);
+    } else {
+      recordNormalized[f] = v;
+    }
+  });
+  const fields: string[] = Object.keys(recordNormalized);
+  const fieldsList: string = fields.join(', ');
+  const values: any[] = Object.values(recordNormalized);
+  const positionsList: string = fields.map((__, i) => `$${++i}`).join(', ');
+  const setFields: string = fields.map((f, i) => `${f} = $${++i}`).join(', ');
+  const upsertFields: string = fields.map((f) => `${f} = EXCLUDED.${f}`).join(',\n');
+  return {
+    fields, fieldsList, values, positionsList, setFields, upsertFields,
+  };
+};