@or-sdk/pgsql 0.22.5-pgsql.0 → 0.23.1

package/dist/types/utils/getDropSchemaQuery.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (schema: string) => string;
+export default _default;

package/dist/types/utils/getDropTableQuery.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (schema: string, table: string) => string;
+export default _default;

package/dist/types/utils/getEditRowQuery.d.ts

@@ -0,0 +1,3 @@
+import { Row } from '../types';
+declare function getEditRowQuery(schema: string, table: string, key: string, value: unknown, row: Row, primaryKeys: string): string;
+export default getEditRowQuery;

package/dist/types/utils/getGenerateTableSchemaQuery.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (schema: string, table: string) => string;
+export default _default;

package/dist/types/utils/getGetPrimaryKeysQuery.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (schema: string, table: string) => string;
+export default _default;

package/dist/types/utils/getInsertKeys.d.ts

@@ -0,0 +1,3 @@
+import { Row } from '../types';
+declare function getInsertKeys(rows: Row[]): string[];
+export default getInsertKeys;

package/dist/types/utils/getInsertQueries.d.ts

@@ -0,0 +1,3 @@
+import { Row } from '../types';
+declare function getInsertQueries(schema: string, table: string, insertRows: Row[], chunkSize: number): string[];
+export default getInsertQueries;

package/dist/types/utils/getListTablesQuery.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (schema: string) => string;
+export default _default;

package/dist/types/utils/getSelectAllCountQuery.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (query: string) => string;
+export default _default;

package/dist/types/utils/getSelectAllQuery.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (query: string, offset: number, chunkSize: number) => string;
+export default _default;

package/dist/types/utils/index.d.ts

@@ -1 +1,17 @@
 export { default as extractDatabaseNames } from './extractDatabaseNames';
+export { default as getInsertKeys } from './getInsertKeys';
+export { default as encodeValue } from './encodeValue';
+export { default as splitPrimaryKeys } from './splitPrimaryKeys';
+export { default as getListTablesQuery } from './getListTablesQuery';
+export { default as createSchemaQuery } from './createSchemaQuery';
+export { default as getDropSchemaQuery } from './getDropSchemaQuery';
+export { default as getCreateTableQuery } from './getCreateTableQuery';
+export { default as getDropTableQuery } from './getDropTableQuery';
+export { default as getAddColumnsQuery } from './getAddColumnsQuery';
+export { default as getInsertQueries } from './getInsertQueries';
+export { default as getSelectAllCountQuery } from './getSelectAllCountQuery';
+export { default as getSelectAllQuery } from './getSelectAllQuery';
+export { default as getEditRowQuery } from './getEditRowQuery';
+export { default as getDeleteRowsQuery } from './getDeleteRowsQuery';
+export { default as getGenerateTableSchemaQuery } from './getGenerateTableSchemaQuery';
+export { default as getGetPrimaryKeysQuery } from './getGetPrimaryKeysQuery';

package/dist/types/utils/splitPrimaryKeys.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (primaryKeys: string) => string[];
+export default _default;

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.22.5-pgsql.0",
+  "version": "0.23.1",
   "name": "@or-sdk/pgsql",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
@@ -16,6 +16,7 @@
     "clean": "rm -rf ./dist"
   },
   "devDependencies": {
+    "@types/lodash": "^4.14.176",
     "concurrently": "^6.4.0",
     "typescript": "^4.4.4"
   },
@@ -23,7 +24,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@or-sdk/base": "^0.23.0-pgsql.0"
+    "@or-sdk/base": "^0.22.4",
+    "lodash": "^4.17.21"
   },
-  "gitHead": "1ae7d9d2916f04d84b9cd47b525cb56d1ce1274c"
+  "gitHead": "7e23200e4cd2ce4b700487bc4fe7c28e722d10f6"
 }

package/src/Pgsql.ts

@@ -1,12 +1,20 @@
 import { Base, ServiceDiscoveryResponse, List, makeList } from '@or-sdk/base';
 import {
-  CreateDatabaseResponse, DropDatabaseResponse,
-  ExecuteQueryArgs, ExecuteQueryResponse,
+  AddColumnsArgs,
+  CreateDatabaseResponse, CreateTableArgs, DeleteRowsArgs, DropDatabaseResponse, EditRowArgs,
+  ExecuteQueryArgs, ExecuteQueryResponse, GetDBSizeResult, InsertArgs,
   ListDatabasesResponse,
-  PgsqlConfig
+  PgsqlConfig, Row, SelectAllArgs,
 } from './types';
-import { SERVICE_KEY } from './constants';
-import { extractDatabaseNames } from './utils';
+import { LIST_SCHEMAS_QUERY, SERVICE_KEY } from './constants';
+import {
+  extractDatabaseNames, getAddColumnsQuery,
+  getCreateTableQuery,
+  getDropSchemaQuery,
+  getDropTableQuery, getEditRowQuery, getGenerateTableSchemaQuery, getInsertQueries,
+  getListTablesQuery, getSelectAllCountQuery, getSelectAllQuery,
+  getDeleteRowsQuery, createSchemaQuery, getGetPrimaryKeysQuery,
+} from './utils';
 
 /**
  * OneReach Pgsql service client
@@ -43,12 +51,19 @@ export class Pgsql extends Base {
   /**
    * Execute query
    * ```typescript
-   * const result = await pgsql.executeQuery();
+   * const result = await pgsql.executeQuery({
+   *   query: 'select * from table',
+   *   database: 'db-name'
+   * });
    * ```
    */
-  public async executeQuery({ query, params, database }: ExecuteQueryArgs): Promise<ExecuteQueryResponse> {
-    return this.callApi<ExecuteQueryResponse>({
-      data: { query, params, database },
+  public async executeQuery<T>({ query, params, database }: ExecuteQueryArgs): Promise<ExecuteQueryResponse<T>> {
+    return this.callApi<ExecuteQueryResponse<T>>({
+      data: {
+        query,
+        params,
+        database,
+      },
       method: 'POST',
       route: 'query',
     });
@@ -63,7 +78,7 @@ export class Pgsql extends Base {
   public async listDatabases(): Promise<List<string>> {
     const { databases } = await this.callApi<ListDatabasesResponse>({
       method: 'GET',
-      route: 'databases'
+      route: 'databases',
     });
 
     return makeList<string>(extractDatabaseNames(databases));
@@ -72,15 +87,15 @@ export class Pgsql extends Base {
   /**
    * Create database
    * ```typescript
-   * const result = await pgsql.createDatabase();
+   * const result = await pgsql.createDatabase({ database: 'db-name' });
    * ```
    */
-  public async createDatabase(database: string): Promise<CreateDatabaseResponse> {
+  public async createDatabase({ database }: { database: string; }): Promise<CreateDatabaseResponse> {
     return this.callApi<CreateDatabaseResponse>({
       data: { database },
       method: 'PUT',
-      route: 'databases'
-    })
+      route: 'databases',
+    });
   }
 
   /**
@@ -88,11 +103,11 @@ export class Pgsql extends Base {
    *
    * @deprecated route not available
    * ```typescript
-   * const result = await pgsql.getDatabaseInfo();
+   * const result = await pgsql.getDatabaseInfo({ database: 'db-name' });
    * ```
    */
   // TODO: uncomment or replace route?
-  // public async getDatabaseInfo(database: string): Promise<unknown> {
+  // public async getDatabaseInfo({ database }: { database: string; }): Promise<unknown> {
   //   return this.callApi<unknown>({
   //     method: 'GET',
   //     route: `databases/${encodeURIComponent(database)}`
@@ -102,14 +117,289 @@ export class Pgsql extends Base {
   /**
    * Drop database
    * ```typescript
-   * const result = await pgsql.dropDatabase();
+   * const result = await pgsql.dropDatabase({ database: 'db-name' });
    * ```
    */
-  public async dropDatabase(database: string): Promise<DropDatabaseResponse> {
+  public async dropDatabase({ database }: { database: string; }): Promise<DropDatabaseResponse> {
     return this.callApi<DropDatabaseResponse>({
       data: { database },
       method: 'DELETE',
-      route: 'databases'
-    })
+      route: 'databases',
+    });
+  }
+
+  /**
+   * List tables
+   * ```typescript
+   * const result = await pgsql.listTables({ database: 'db-name', schema: 'schema-name' });
+   * ```
+   */
+  public async listTables({ database, schema = 'public' }: { database: string; schema?: string; }): Promise<List<string>> {
+    const { rows } = await this.executeQuery<{ table_name: string; }>({
+      query: getListTablesQuery(schema),
+      database,
+    });
+    return makeList<string>(rows.map(x => x.table_name));
+  }
+
+  /**
+   * List schemas
+   * ```typescript
+   * const result = await pgsql.listSchemas({ database: 'db-name' });
+   * ```
+   */
+  public async listSchemas({ database }: { database: string; }): Promise<List<string>> {
+    const { rows } = await this.executeQuery<{ schema_name: string; }>({
+      query: LIST_SCHEMAS_QUERY,
+      database,
+    });
+    return makeList<string>(rows.map(x => x.schema_name));
+  }
+
+  /**
+   * Create schema
+   * ```typescript
+   * const result = await pgsql.createSchema({ database: 'db-name', schema: 'schema-name' });
+   * ```
+   */
+  public async createSchema({ database, schema }: { database: string; schema: string; }): Promise<ExecuteQueryResponse<void>> {
+    return this.executeQuery<void>({
+      query: createSchemaQuery(schema),
+      database,
+    });
+  }
+
+  /**
+   * Drop schema
+   * ```typescript
+   * const result = await pgsql.dropSchema({ database: 'db-name', schema: 'schema-name' });
+   * ```
+   */
+  public async dropSchema({ database, schema }: { database: string; schema: string; }): Promise<ExecuteQueryResponse<void>> {
+    return this.executeQuery<void>({
+      query: getDropSchemaQuery(schema),
+      database,
+    });
+  }
+
+  /**
+   * Drop table
+   * ```typescript
+   * const result = await pgsql.dropSchema({ database: 'db-name', schema: 'schema-name', table: 'table-name' });
+   * ```
+   */
+  public async dropTable({ database, schema, table }: { database: string; schema: string; table: string; }): Promise<ExecuteQueryResponse<void>> {
+    return this.executeQuery<void>({
+      query: getDropTableQuery(schema, table),
+      database,
+    });
+  }
+
+  /**
+   * Create table
+   * ```typescript
+   * const result = await pgsql.createTable({
+   *   database: 'db-name',
+   *   schema: 'schema-name',
+   *   table: 'table-name',
+   *   columns: [
+   *    { name: 'col1', type: 'integer' },
+   *    { name: 'col2', type: 'text' }
+   *   ],
+   *   primaryKey: 'col1,col2'
+   * });
+   * ```
+   */
+  public async createTable({ database, schema, table, columns, primaryKey }: CreateTableArgs): Promise<ExecuteQueryResponse<void>> {
+    return this.executeQuery<void>({
+      query: getCreateTableQuery(schema, table, columns, primaryKey),
+      database,
+    });
+  }
+
+  /**
+   * Drop database
+   * ```typescript
+   * const result = await pgsql.addColumns({
+   *   database: 'db-name',
+   *   schema: 'schema-name',
+   *   table: 'table-name',
+   *   columns: [
+   *    { name: 'col1', type: 'integer' },
+   *    { name: 'col2', type: 'text' }
+   *   ],
+   * });
+   * ```
+   */
+  public async addColumns({ database, schema, table, columns }: AddColumnsArgs): Promise<ExecuteQueryResponse<void>> {
+    return this.executeQuery<void>({
+      query: getAddColumnsQuery(schema, table, columns),
+      database,
+    });
+  }
+
+  /**
+   * Insert
+   * ```typescript
+   * const result = await pgsql.insert({
+   *   database: 'db-name',
+   *   schema: 'schema-name',
+   *   table: 'table-name',
+   *   rows: [
+   *    { col1: 'value' }
+   *   ],
+   *   chunkSize: 300,
+   *   context: { progress: 0 } // progress of insert will be set from 0 to 100
+   * });
+   * ```
+   */
+  public async insert({ database, schema, table, rows, chunkSize = 300, context }: InsertArgs): Promise<ExecuteQueryResponse<void>[]> {
+    const res = [];
+
+    const queries = getInsertQueries(schema, table, rows, chunkSize);
+
+    for (const [index, query] of Array.from(queries.entries())) {
+      res.push(await this.executeQuery<void>({
+        query,
+        database,
+      }));
+
+      if (context) {
+        context.progress = Math.min((index + 1) / (rows.length / Math.min(chunkSize, rows.length)), 1) * 100;
+      }
+    }
+
+    return res;
+  }
+
+  /**
+   * Select all
+   * ```typescript
+   * const result = await pgsql.selectAll({
+   *   database: 'db-name',
+   *   query: 'select * from table', // must be select only, without limit and offset
+   *   chunkSize: 300,
+   *   offset: 0,
+   *   limit: 0,
+   *   context: { progress: 0, total: 0 } // progress of select will be set from 0 to 100
+   * });
+   * ```
+   */
+  public async selectAll({ database, query, context, chunkSize = 1000, offset = 0, limit }: SelectAllArgs): Promise<List<Row>> {
+    let count: number, rows, result: Row[] = [];
+    if (limit && limit < chunkSize) {
+      chunkSize = limit;
+    }
+
+    if (context) {
+      const { rows } = await this.executeQuery<{ count: number; }>({
+        query: getSelectAllCountQuery(query),
+        database,
+      });
+      count = rows[0].count;
+      context.total = count;
+    }
+
+    do {
+      ({ rows } = await this.executeQuery<Row>({
+        query: getSelectAllQuery(query, offset, chunkSize),
+        database,
+      }));
+      offset += chunkSize;
+      result = result.concat(rows);
+      if (context) {
+        context.progress = Math.min(offset / count! * 100, 100);
+      }
+      if (limit && result.length >= limit) {
+        result = result.slice(0, limit);
+        break;
+      }
+    } while (rows.length);
+
+    return makeList<Row>(result);
+  }
+
+  /**
+   * Get primary keys
+   * ```typescript
+   * const result = await pgsql.getPrimaryKeys({ database: 'db-name', schema: 'schema-name', table: 'table-name' });
+   * ```
+   */
+  public async getPrimaryKeys({ database, schema, table }: { database: string; schema: string; table: string; }): Promise<string> {
+    const { rows } = await this.executeQuery<{ pk: string; }>({
+      database,
+      query: getGetPrimaryKeysQuery(schema, table),
+    });
+    return rows[0].pk;
+  }
+
+  /**
+   * Edit row
+   * ```typescript
+   * const result = await pgsql.editRow({
+   *   database: 'db-name',
+   *   schema: 'schema-name',
+   *   table: 'table-name',
+   *   key: 'col1',
+   *   value: 'new_value',
+   *   row: { pk: 'pk_val', col1: 'old_value' },
+   *   primaryKeys: 'pk',
+   * });
+   * ```
+   */
+  public async editRow({ database, schema, table, key, value, row, primaryKeys }: EditRowArgs): Promise<ExecuteQueryResponse<void>> {
+    return this.executeQuery({
+      database,
+      query: getEditRowQuery(schema, table, key, value, row, primaryKeys),
+    });
+  }
+
+  /**
+   * Delete rows
+   * ```typescript
+   * const result = await pgsql.deleteRows({
+   *   database: 'db-name',
+   *   schema: 'schema-name',
+   *   table: 'table-name',
+   *   rows: [
+   *    { pk: 'pk_val', col1: 'value' }
+   *   ],
+   *   primaryKeys: 'pk',
+   * });
+   * ```
+   */
+  public async deleteRows({ database, schema, table, rows, primaryKeys }: DeleteRowsArgs): Promise<ExecuteQueryResponse<void>> {
+    return this.executeQuery({
+      database,
+      query: getDeleteRowsQuery(schema, table, rows, primaryKeys),
+    });
+  }
+
+  /**
+   * Generate create table query for existing table
+   * ```typescript
+   * const result = await pgsql.generateTableSchema({ database: 'db-name', schema: 'schema-name', table: 'table-name' });
+   * ```
+   */
+  public async generateTableSchema({ database, schema, table }: { database: string; schema: string; table: string; }): Promise<string> {
+    const { rows } = await this.executeQuery<{ code: string; }>({
+      database,
+      query: getGenerateTableSchemaQuery(schema, table),
+    });
+
+    return rows[0].code;
+  }
+
+  /**
+   * Get database size
+   * ```typescript
+   * const result = await pgsql.getDBSize();
+   * ```
+   */
+  public async getDBSize(): Promise<GetDBSizeResult> {
+    return await this.callApi<GetDBSizeResult>({
+      method: 'GET',
+      route: 'size',
+    });
   }
 }

package/src/constants.ts

@@ -1 +1,4 @@
 export const SERVICE_KEY = 'pgsql';
+
+export const LIST_SCHEMAS_QUERY = `SELECT schema_name FROM information_schema.schemata
+        where schema_name not in ('pg_catalog', 'information_schema')`;

package/src/types.ts

@@ -22,10 +22,6 @@ export type PgsqlConfig = {
   pgsqlUrl?: string;
 };
 
-export type QueryRow = {
-  [key: string]: unknown;
-};
-
 export type QueryField = {
   name: string;
   tableID: number;
@@ -36,11 +32,11 @@ export type QueryField = {
   format: string;
 };
 
-export type ExecuteQueryResponse = {
+export type ExecuteQueryResponse<T> = {
   command: string;
-  rowCount: number;
+  rowCount: null | number;
   oid: null | number;
-  rows: QueryRow[];
+  rows: T[];
   fields: QueryField[];
   RowCtor: null | unknown;
   rowAsArray: boolean;
@@ -48,7 +44,7 @@ export type ExecuteQueryResponse = {
 
 export type ExecuteQueryArgs = {
   query: string;
-  params: {
+  params?: {
     [key: string]: unknown;
   };
   database: string;
@@ -73,3 +69,75 @@ export type ListDatabasesResponse = {
 export type DropDatabaseResponse = {
   ok?: number;
 };
+
+export type GetDBSizeResult = {
+  usedSize: number;
+  sizeLimit: string | number;
+};
+
+export type TableColumn = {
+  name: string;
+  type: number;
+};
+
+export type CreateTableArgs = {
+  database: string;
+  schema: string;
+  table: string;
+  columns: TableColumn[];
+  primaryKey: string;
+};
+
+export type AddColumnsArgs = {
+  database: string;
+  schema: string;
+  table: string;
+  columns: TableColumn[];
+};
+
+export type Row = {
+  [key: string]: unknown;
+};
+
+export type InsertArgs = {
+  database: string;
+  schema: string;
+  table: string;
+  rows: Row[];
+  chunkSize: number;
+  context?: {
+    progress?: number;
+  };
+};
+
+export type EncodedValue = string | number | boolean;
+
+export type SelectAllArgs = {
+  database: string;
+  query: string;
+  context?: {
+    progress?: number;
+    total?: number;
+  };
+  chunkSize?: number;
+  offset?: number;
+  limit?: number;
+};
+
+export type EditRowArgs = {
+  database: string;
+  schema: string;
+  table: string;
+  key: string;
+  value: unknown;
+  row: Row;
+  primaryKeys: string;
+};
+
+export type DeleteRowsArgs = {
+  database: string;
+  schema: string;
+  table: string;
+  rows: Row[];
+  primaryKeys: string;
+};

package/src/utils/createSchemaQuery.ts

@@ -0,0 +1 @@
+export default (schema: string) => `create schema ${schema};`;

package/src/utils/encodeValue.ts

@@ -0,0 +1,11 @@
+import { EncodedValue } from '../types';
+import _ from 'lodash';
+
+function encodeValue(value: unknown): EncodedValue {
+  if (_.isUndefined(value) || value === '' || _.isNull(value)) return 'NULL';
+  if (_.isString(value)) return `'${value.replaceAll('\'', '\'\'')}'`;
+  if (_.isNumber(value) || _.isBoolean(value)) return value;
+  return `'${JSON.stringify(value).replaceAll('\'', '\'\'')}'`;
+}
+
+export default encodeValue;

package/src/utils/getAddColumnsQuery.ts

@@ -0,0 +1,4 @@
+import { TableColumn } from '../types';
+
+export default (schema: string, table: string, columns: TableColumn[]) =>
+  `alter table ${schema}.${table} ${columns.map(x => `add column ${x.name} ${x.type}`).join(', ')};`;

package/src/utils/getCreateTableQuery.ts

@@ -0,0 +1,4 @@
+import { TableColumn } from '../types';
+
+export default (schema: string, table: string, columns: TableColumn[], primaryKey: string) =>
+  `create table ${schema}.${table} (${columns.map(x => `${x.name} ${x.type}`).join(', ')}, primary key (${primaryKey}));`;

package/src/utils/getDeleteRowsQuery.ts

@@ -0,0 +1,10 @@
+import { Row } from '../types';
+import { encodeValue, splitPrimaryKeys } from '../utils';
+
+function getDeleteRowQuery(schema: string, table: string, rows: Row[], primaryKeys: string): string {
+  const pk = splitPrimaryKeys(primaryKeys);
+  return `delete from ${schema}.${table}
+where (${rows.map(row => `${pk.map(primaryKey => `${primaryKey} = ${encodeValue(row[primaryKey])}`).join(' AND ')}`).join(') \nOR (')})`;
+}
+
+export default getDeleteRowQuery;

package/src/utils/getDropSchemaQuery.ts

@@ -0,0 +1 @@
+export default (schema: string) => `drop schema ${schema} cascade;`;

package/src/utils/getDropTableQuery.ts

@@ -0,0 +1 @@
+export default (schema: string, table: string) => `drop table ${schema}.${table};`;

package/src/utils/getEditRowQuery.ts

@@ -0,0 +1,12 @@
+import { encodeValue, splitPrimaryKeys } from '../utils';
+import { Row } from '../types';
+
+function getEditRowQuery(schema: string, table: string, key: string, value: unknown, row: Row, primaryKeys: string): string {
+  value = encodeValue(value);
+  const pk = splitPrimaryKeys(primaryKeys);
+  return `update ${schema}.${table}
+set ${key} = ${value}
+where ${pk.map(primaryKey => `${primaryKey} = ${encodeValue(row[primaryKey])}`).join(' AND ')}`;
+}
+
+export default getEditRowQuery;

package/src/utils/getGenerateTableSchemaQuery.ts

@@ -0,0 +1,17 @@
+export default (schema: string, table: string) => `SELECT 'CREATE TABLE ' || '${schema}.${table}' || ' (' || '\n' || '' ||
+        string_agg(column_list.column_expr, ', ' || '\n' || '') ||
+        '' || ',\n' || 'PRIMARY KEY (' || (SELECT string_agg(a.attname, ', ') AS pk
+    FROM
+        pg_constraint AS c
+        CROSS JOIN LATERAL UNNEST(c.conkey) AS cols(colnum) -- conkey is a list of the columns of the constraint; so we split it into rows so that we can join all column numbers onto their names in pg_attribute
+        INNER JOIN pg_attribute AS a ON a.attrelid = c.conrelid AND cols.colnum = a.attnum
+    WHERE
+        c.contype = 'p' -- p = primary key constraint
+        AND c.conrelid = '${schema}.${table}'::REGCLASS limit 1) || '));'  code
+    FROM (
+      SELECT '    ' || column_name || ' ' || data_type ||
+           coalesce('(' || character_maximum_length || ')', '') ||
+           case when is_nullable = 'YES' then '' else ' NOT NULL' end as column_expr
+      FROM information_schema.columns
+      WHERE table_schema = '${schema}' AND table_name = '${table}'
+      ORDER BY ordinal_position)  column_list;`;

package/src/utils/getGetPrimaryKeysQuery.ts

@@ -0,0 +1,8 @@
+export default (schema: string, table: string) => `SELECT string_agg(a.attname, ', ') AS pk
+FROM
+    pg_constraint AS c
+    CROSS JOIN LATERAL UNNEST(c.conkey) AS cols(colnum) -- conkey is a list of the columns of the constraint; so we split it into rows so that we can join all column numbers onto their names in pg_attribute
+    INNER JOIN pg_attribute AS a ON a.attrelid = c.conrelid AND cols.colnum = a.attnum
+WHERE
+    c.contype = 'p' -- p = primary key constraint
+    AND c.conrelid = '${schema}.${table}'::REGCLASS;`;