rake-db 2.2.6 → 2.3.0

package/src/pull/dbStructure.ts

@@ -4,6 +4,7 @@ export namespace DbStructure {
   export type Table = {
     schemaName: string;
     name: string;
+    comment?: string;
   };
 
   export type View = {
@@ -35,17 +36,31 @@ export namespace DbStructure {
     dateTimePrecision?: number;
     default?: string;
     isNullable: boolean;
+    collation?: string;
+    compression?: 'p' | 'l'; // p for pglz, l for lz4
+    comment?: string;
   };
 
   export type Index = {
     schemaName: string;
     tableName: string;
-    columnNames: string[];
     name: string;
+    using: string;
     isUnique: boolean;
-    isPrimary: boolean;
+    columns: (({ column: string } | { expression: string }) & {
+      collate?: string;
+      opclass?: string;
+      order?: string;
+    })[];
+    include?: string[];
+    with?: string;
+    tablespace?: string;
+    where?: string;
   };
 
+  // a = no action, r = restrict, c = cascade, n = set null, d = set default
+  type ForeignKeyAction = 'a' | 'r' | 'c' | 'n' | 'd';
+
   export type ForeignKey = {
     schemaName: string;
     tableName: string;
@@ -54,13 +69,15 @@ export namespace DbStructure {
     name: string;
     columnNames: string[];
     foreignColumnNames: string[];
+    match: 'f' | 'p' | 's'; // FULL | PARTIAL | SIMPLE
+    onUpdate: ForeignKeyAction;
+    onDelete: ForeignKeyAction;
   };
 
-  export type Constraint = {
+  export type PrimaryKey = {
     schemaName: string;
     tableName: string;
     name: string;
-    type: 'CHECK' | 'FOREIGN KEY' | 'PRIMARY KEY' | 'UNIQUE';
     columnNames: string[];
   };
 
@@ -101,12 +118,14 @@ ORDER BY "name"`,
   async getTables() {
     const { rows } = await this.db.query<DbStructure.Table>(
       `SELECT
-  table_schema "schemaName",
-  table_name "name"
-FROM information_schema.tables
-WHERE table_type = 'BASE TABLE'
-  AND ${filterSchema('table_schema')}
-ORDER BY table_name`,
+  nspname AS "schemaName",
+  relname AS "name",
+  obj_description(c.oid) AS comment
+FROM pg_class c
+JOIN pg_catalog.pg_namespace n ON n.oid = relnamespace
+WHERE relkind = 'r'
+  AND ${filterSchema('nspname')}
+ORDER BY relname`,
     );
     return rows;
   }
@@ -156,7 +175,8 @@ WHERE ${filterSchema('n.nspname')}`,
 
   async getColumns() {
     const { rows } = await this.db.query<DbStructure.Column>(
-      `SELECT table_schema "schemaName",
+      `SELECT
+  table_schema "schemaName",
   table_name "tableName",
   column_name "name",
   udt_name "type",
@@ -165,10 +185,22 @@ WHERE ${filterSchema('n.nspname')}`,
   numeric_scale AS "numericScale",
   datetime_precision AS "dateTimePrecision",
   column_default "default",
-  is_nullable::boolean "isNullable"
-FROM information_schema.columns
+  is_nullable::boolean "isNullable",
+  collation_name AS "collation",
+  NULLIF(a.attcompression, '') AS compression,
+  pgd.description AS "comment"
+FROM information_schema.columns c
+LEFT JOIN pg_catalog.pg_statio_all_tables AS st
+  ON c.table_schema = st.schemaname
+ AND c.table_name = st.relname
+LEFT JOIN pg_catalog.pg_description pgd
+  ON pgd.objoid = st.relid
+ AND pgd.objsubid = c.ordinal_position
+LEFT JOIN pg_catalog.pg_attribute a
+  ON a.attrelid = st.relid
+ AND a.attnum = c.ordinal_position
 WHERE ${filterSchema('table_schema')}
-ORDER BY ordinal_position`,
+ORDER BY c.ordinal_position`,
     );
     return rows;
   }
@@ -176,64 +208,152 @@ ORDER BY ordinal_position`,
   async getIndexes() {
     const { rows } = await this.db.query<DbStructure.Index>(
       `SELECT
-  nspname "schemaName",
+  n.nspname "schemaName",
   t.relname "tableName",
-  json_agg(attname) "columnNames",
   ic.relname "name",
-  indisunique "isUnique",
-  indisprimary "isPrimary"
-FROM pg_index
-JOIN pg_class t ON t.oid = indrelid
+  am.amname AS "using",
+  i.indisunique "isUnique",
+  (
+    SELECT json_agg(
+      (
+        CASE WHEN t.e = 0
+        THEN jsonb_build_object('expression', pg_get_indexdef(i.indexrelid, t.i::int4, false))
+        ELSE jsonb_build_object('column', (
+          (
+            SELECT attname
+            FROM pg_catalog.pg_attribute
+            WHERE attrelid = i.indrelid
+              AND attnum = t.e
+          )
+        ))
+        END
+      ) || (
+        CASE WHEN i.indcollation[t.i - 1] = 0
+        THEN '{}'::jsonb
+        ELSE (
+          SELECT (
+            CASE WHEN collname = 'default'
+            THEN '{}'::jsonb
+            ELSE jsonb_build_object('collate', collname)
+            END
+          )
+          FROM pg_catalog.pg_collation
+          WHERE oid = i.indcollation[t.i - 1]
+        )
+        END
+      ) || (
+        SELECT
+          CASE WHEN opcdefault AND attoptions IS NULL
+          THEN '{}'::jsonb
+          ELSE jsonb_build_object(
+            'opclass', opcname || COALESCE('(' || array_to_string(attoptions, ', ') || ')', '')
+          )
+          END
+        FROM pg_opclass
+        LEFT JOIN pg_attribute
+          ON attrelid = i.indexrelid
+         AND attnum = t.i
+        WHERE oid = i.indclass[t.i - 1]
+      ) || (
+        CASE WHEN i.indoption[t.i - 1] = 0
+        THEN '{}'::jsonb
+        ELSE jsonb_build_object(
+          'order',
+          CASE
+            WHEN i.indoption[t.i - 1] = 1 THEN 'DESC NULLS LAST'
+            WHEN i.indoption[t.i - 1] = 2 THEN 'ASC NULLS FIRST'
+            WHEN i.indoption[t.i - 1] = 3 THEN 'DESC'
+            ELSE NULL
+          END
+        )
+        END
+      )
+    )
+    FROM unnest(i.indkey[:indnkeyatts - 1]) WITH ORDINALITY AS t(e, i)
+  ) "columns",
+  (
+    SELECT json_agg(
+      (
+        SELECT attname
+        FROM pg_catalog.pg_attribute
+        WHERE attrelid = i.indrelid
+          AND attnum = j.e
+      )
+    )
+    FROM unnest(i.indkey[indnkeyatts:]) AS j(e)
+  ) AS "include",
+  NULLIF(pg_catalog.array_to_string(
+    ic.reloptions || array(SELECT 'toast.' || x FROM pg_catalog.unnest(tc.reloptions) x),
+    ', '
+  ), '') AS "with",
+  (
+    SELECT tablespace
+    FROM pg_indexes
+    WHERE schemaname = n.nspname
+      AND indexname = ic.relname
+  ) AS tablespace,
+  pg_get_expr(i.indpred, i.indrelid) AS "where"
+FROM pg_index i
+JOIN pg_class t ON t.oid = i.indrelid
 JOIN pg_namespace n ON n.oid = t.relnamespace
-JOIN pg_attribute ON attrelid = t.oid AND attnum = any(indkey)
-JOIN pg_class ic ON ic.oid = indexrelid
+JOIN pg_class ic ON ic.oid = i.indexrelid
+JOIN pg_am am ON am.oid = ic.relam
+LEFT JOIN pg_catalog.pg_class tc ON (ic.reltoastrelid = tc.oid)
 WHERE ${filterSchema('n.nspname')}
-GROUP BY "schemaName", "tableName", "name", "isUnique", "isPrimary"
-ORDER BY "name"`,
+  AND NOT i.indisprimary
+ORDER BY ic.relname`,
     );
     return rows;
   }
 
   async getForeignKeys() {
     const { rows } = await this.db.query<DbStructure.ForeignKey>(
-      `SELECT tc.table_schema AS "schemaName",
-  tc.table_name AS "tableName",
-  ccu.table_schema AS "foreignTableSchemaName",
-  ccu.table_name AS "foreignTableName",
-  tc.constraint_name AS "name",
+      `SELECT
+  s.nspname AS "schemaName",
+  t.relname AS "tableName",
+  fs.nspname AS "foreignTableSchemaName",
+  ft.relname AS "foreignTableName",
+  c.conname AS "name",
   (
-    SELECT json_agg(kcu.column_name)
-    FROM information_schema.key_column_usage kcu
-    WHERE kcu.constraint_name = tc.constraint_name
-      AND kcu.table_schema = tc.table_schema
+    SELECT json_agg(ccu.column_name)
+    FROM information_schema.key_column_usage ccu
+    WHERE ccu.constraint_name = c.conname
+      AND ccu.table_schema = cs.nspname
   ) AS "columnNames",
-  json_agg(ccu.column_name) AS "foreignColumnNames"
-FROM information_schema.table_constraints tc
-JOIN information_schema.constraint_column_usage ccu
-  ON ccu.constraint_name = tc.constraint_name
- AND ccu.table_schema = tc.table_schema
-WHERE tc.constraint_type = 'FOREIGN KEY'
-  AND ${filterSchema('tc.table_schema')}
-GROUP BY "schemaName", "tableName", "name", "foreignTableSchemaName", "foreignTableName"
-ORDER BY "name"`,
+  (
+    SELECT json_agg(ccu.column_name)
+    FROM information_schema.constraint_column_usage ccu
+    WHERE ccu.constraint_name = c.conname
+      AND ccu.table_schema = cs.nspname
+  ) AS "foreignColumnNames",
+  c.confmatchtype AS match,
+  c.confupdtype AS "onUpdate",
+  c.confdeltype AS "onDelete"
+FROM pg_catalog.pg_constraint c
+JOIN pg_class t ON t.oid = conrelid
+JOIN pg_catalog.pg_namespace s ON s.oid = t.relnamespace
+JOIN pg_class ft ON ft.oid = confrelid
+JOIN pg_catalog.pg_namespace fs ON fs.oid = ft.relnamespace
+JOIN pg_catalog.pg_namespace cs ON cs.oid = c.connamespace
+WHERE contype = 'f'
+ORDER BY c.conname`,
     );
     return rows;
   }
 
-  async getConstraints() {
-    const { rows } = await this.db.query<DbStructure.Constraint>(
+  async getPrimaryKeys() {
+    const { rows } = await this.db.query<DbStructure.PrimaryKey>(
       `SELECT tc.table_schema AS "schemaName",
   tc.table_name AS "tableName",
   tc.constraint_name AS "name",
-  tc.constraint_type AS "type",
   json_agg(ccu.column_name) "columnNames"
 FROM information_schema.table_constraints tc
 JOIN information_schema.constraint_column_usage ccu
   ON ccu.constraint_name = tc.constraint_name
  AND ccu.table_schema = tc.table_schema
-WHERE tc.constraint_type != 'FOREIGN KEY'
+WHERE tc.constraint_type = 'PRIMARY KEY'
   AND ${filterSchema('tc.table_schema')}
-GROUP BY "schemaName", "tableName", "name", "type"
+GROUP BY "schemaName", "tableName", "name"
 ORDER BY "name"`,
     );
     return rows;

package/src/pull/structureToAst.test.ts

@@ -1,5 +1,12 @@
 import { DbStructure } from './dbStructure';
-import { Adapter, IntegerColumn, TextColumn } from 'pqb';
+import {
+  Adapter,
+  DecimalColumn,
+  IntegerColumn,
+  TextColumn,
+  TimestampColumn,
+  VarCharColumn,
+} from 'pqb';
 import { structureToAst } from './structureToAst';
 import { RakeDbAst } from '../ast';
 
@@ -8,7 +15,7 @@ const query = jest.fn().mockImplementation(() => ({ rows: [] }));
 adapter.query = query;
 adapter.arrays = query;
 
-const tableColumn: DbStructure.Column = {
+const intColumn: DbStructure.Column = {
   schemaName: 'public',
   tableName: 'table',
   name: 'column',
@@ -17,32 +24,54 @@ const tableColumn: DbStructure.Column = {
   isNullable: false,
 };
 
+const varCharColumn: DbStructure.Column = {
+  ...intColumn,
+  name: 'varchar',
+  type: 'character varying',
+  collation: 'en_US',
+  maxChars: 10,
+};
+
+const decimalColumn: DbStructure.Column = {
+  ...intColumn,
+  name: 'decimal',
+  type: 'decimal',
+  numericPrecision: 10,
+  numericScale: 2,
+};
+
+const timestampColumn: DbStructure.Column = {
+  ...intColumn,
+  name: 'timestamp',
+  type: 'timestamp',
+  dateTimePrecision: 10,
+};
+
 const tableColumns = [
-  { ...tableColumn, name: 'id' },
-  { ...tableColumn, name: 'name', type: 'text' },
+  { ...intColumn, name: 'id' },
+  { ...intColumn, name: 'name', type: 'text' },
 ];
 
-const otherTableColumn = { ...tableColumn, tableName: 'otherTable' };
+const otherTableColumn = { ...intColumn, tableName: 'otherTable' };
 
 const table = { schemaName: 'public', name: 'table' };
 
 const columns = [...tableColumns, otherTableColumn];
 
-const primaryKey: DbStructure.Constraint = {
+const primaryKey: DbStructure.PrimaryKey = {
   schemaName: 'public',
   tableName: 'table',
   name: 'pkey',
-  type: 'PRIMARY KEY',
   columnNames: ['id'],
 };
 
 const index: DbStructure.Index = {
   schemaName: 'public',
   tableName: 'table',
-  columnNames: ['name'],
   name: 'index',
+  using: 'btree',
   isUnique: false,
-  isPrimary: false,
+  columns: [{ column: 'name' }],
 };
 
 const foreignKey: DbStructure.ForeignKey = {
@@ -53,6 +82,9 @@ const foreignKey: DbStructure.ForeignKey = {
   name: 'fkey',
   columnNames: ['otherId'],
   foreignColumnNames: ['id'],
+  match: 'f',
+  onUpdate: 'c',
+  onDelete: 'c',
 };
 
 const extension: DbStructure.Extension = {
@@ -83,13 +115,16 @@ describe('structureToAst', () => {
   describe('table', () => {
     it('should add table', async () => {
       const db = new DbStructure(adapter);
-      db.getTables = async () => [{ schemaName: 'public', name: 'table' }];
+      db.getTables = async () => [
+        { schemaName: 'public', name: 'table', comment: 'comment' },
+      ];
       const ast = await structureToAst(db);
       expect(ast).toEqual([
         {
           type: 'table',
           action: 'create',
           name: 'table',
+          comment: 'comment',
           shape: {},
           noPrimaryKey: 'ignore',
           indexes: [],
@@ -129,11 +164,50 @@ describe('structureToAst', () => {
       expect(ast.shape.name).toBeInstanceOf(TextColumn);
     });
 
+    it('should set maxChars to char column', async () => {
+      const db = new DbStructure(adapter);
+      db.getTables = async () => [{ schemaName: 'public', name: 'table' }];
+      db.getColumns = async () => [varCharColumn];
+
+      const [ast] = (await structureToAst(db)) as [RakeDbAst.Table];
+
+      const column = ast.shape[varCharColumn.name];
+      expect(column).toBeInstanceOf(VarCharColumn);
+      expect(column.data.maxChars).toBe(varCharColumn.maxChars);
+    });
+
+    it('should set numericPrecision and numericScale to decimal column', async () => {
+      const db = new DbStructure(adapter);
+      db.getTables = async () => [{ schemaName: 'public', name: 'table' }];
+      db.getColumns = async () => [decimalColumn];
+
+      const [ast] = (await structureToAst(db)) as [RakeDbAst.Table];
+
+      const column = ast.shape[decimalColumn.name];
+      expect(column).toBeInstanceOf(DecimalColumn);
+      expect(column.data.numericPrecision).toBe(decimalColumn.numericPrecision);
+      expect(column.data.numericScale).toBe(decimalColumn.numericScale);
+    });
+
+    it('should set dateTimePrecision to timestamp column', async () => {
+      const db = new DbStructure(adapter);
+      db.getTables = async () => [{ schemaName: 'public', name: 'table' }];
+      db.getColumns = async () => [timestampColumn];
+
+      const [ast] = (await structureToAst(db)) as [RakeDbAst.Table];
+
+      const column = ast.shape[timestampColumn.name];
+      expect(column).toBeInstanceOf(TimestampColumn);
+      expect(column.data.dateTimePrecision).toBe(
+        timestampColumn.dateTimePrecision,
+      );
+    });
+
     it('should set primaryKey to column', async () => {
       const db = new DbStructure(adapter);
       db.getTables = async () => [{ schemaName: 'public', name: 'table' }];
       db.getColumns = async () => columns;
-      db.getConstraints = async () => [primaryKey];
+      db.getPrimaryKeys = async () => [primaryKey];
 
       const [ast] = (await structureToAst(db)) as [RakeDbAst.Table];
 
@@ -146,7 +220,7 @@ describe('structureToAst', () => {
       const db = new DbStructure(adapter);
       db.getTables = async () => [{ schemaName: 'public', name: 'table' }];
       db.getColumns = async () => columns;
-      db.getConstraints = async () => [
+      db.getPrimaryKeys = async () => [
         { ...primaryKey, columnNames: ['id', 'name'] },
       ];
 
@@ -164,7 +238,7 @@ describe('structureToAst', () => {
       const db = new DbStructure(adapter);
       db.getTables = async () => [{ schemaName: 'public', name: 'table' }];
       db.getColumns = async () => columns;
-      db.getConstraints = async () => [
+      db.getPrimaryKeys = async () => [
         { ...primaryKey, columnNames: ['id', 'name'], name: 'table_pkey' },
       ];
 
@@ -177,42 +251,79 @@ describe('structureToAst', () => {
       });
     });
 
-    it('should ignore primary key indexes', async () => {
+    it('should add index to column', async () => {
       const db = new DbStructure(adapter);
-      db.getTables = async () => [{ schemaName: 'public', name: 'table' }];
+      db.getTables = async () => [table];
       db.getColumns = async () => columns;
-      db.getIndexes = async () => [{ ...index, isPrimary: true }];
+      db.getIndexes = async () => [index];
 
       const [ast] = (await structureToAst(db)) as [RakeDbAst.Table];
-      expect(ast.shape.name.data.index).toBe(undefined);
+      expect(ast.shape.name.data.indexes).toEqual([
+        {
+          name: 'index',
+          unique: false,
+        },
+      ]);
       expect(ast.indexes).toHaveLength(0);
     });
 
-    it('should add index to column', async () => {
+    it('should set index options to column index', async () => {
       const db = new DbStructure(adapter);
       db.getTables = async () => [table];
       db.getColumns = async () => columns;
-      db.getIndexes = async () => [index];
+      db.getIndexes = async () => [
+        {
+          ...index,
+          using: 'gist',
+          isUnique: true,
+          columns: [
+            {
+              column: 'name',
+              collate: 'en_US',
+              opclass: 'varchar_ops',
+              order: 'DESC',
+            },
+          ],
+          include: ['id'],
+          with: 'fillfactor=80',
+          tablespace: 'tablespace',
+          where: 'condition',
+        },
+      ];
 
       const [ast] = (await structureToAst(db)) as [RakeDbAst.Table];
-      expect(ast.shape.name.data.index).toEqual({
-        name: 'index',
-        unique: false,
-      });
+      expect(ast.shape.name.data.indexes).toEqual([
+        {
+          name: 'index',
+          using: 'gist',
+          unique: true,
+          collate: 'en_US',
+          opclass: 'varchar_ops',
+          order: 'DESC',
+          include: ['id'],
+          with: 'fillfactor=80',
+          tablespace: 'tablespace',
+          where: 'condition',
+        },
+      ]);
       expect(ast.indexes).toHaveLength(0);
     });
 
-    it('should add composite indexes to table', async () => {
+    it('should add composite indexes to the table', async () => {
       const db = new DbStructure(adapter);
       db.getTables = async () => [table];
       db.getColumns = async () => columns;
       db.getIndexes = async () => [
-        { ...index, columnNames: ['id', 'name'] },
-        { ...index, columnNames: ['id', 'name'], isUnique: true },
+        { ...index, columns: [{ column: 'id' }, { column: 'name' }] },
+        {
+          ...index,
+          columns: [{ column: 'id' }, { column: 'name' }],
+          isUnique: true,
+        },
       ];
 
       const [ast] = (await structureToAst(db)) as [RakeDbAst.Table];
-      expect(ast.shape.name.data.index).toBe(undefined);
+      expect(ast.shape.name.data.indexes).toBe(undefined);
       expect(ast.indexes).toEqual([
         {
           columns: [{ column: 'id' }, { column: 'name' }],
@@ -225,22 +336,76 @@ describe('structureToAst', () => {
       ]);
     });
 
+    it('should add index with expression and options to the table', async () => {
+      const db = new DbStructure(adapter);
+      db.getTables = async () => [table];
+      db.getColumns = async () => columns;
+      db.getIndexes = async () => [
+        {
+          ...index,
+          using: 'gist',
+          isUnique: true,
+          columns: [
+            {
+              expression: 'lower(name)',
+              collate: 'en_US',
+              opclass: 'varchar_ops',
+              order: 'DESC',
+            },
+          ],
+          include: ['id'],
+          with: 'fillfactor=80',
+          tablespace: 'tablespace',
+          where: 'condition',
+        },
+      ];
+
+      const [ast] = (await structureToAst(db)) as [RakeDbAst.Table];
+      expect(ast.shape.name.data.indexes).toBe(undefined);
+      expect(ast.indexes).toEqual([
+        {
+          columns: [
+            {
+              expression: 'lower(name)',
+              collate: 'en_US',
+              opclass: 'varchar_ops',
+              order: 'DESC',
+            },
+          ],
+          options: {
+            name: 'index',
+            using: 'gist',
+            unique: true,
+            include: ['id'],
+            with: 'fillfactor=80',
+            tablespace: 'tablespace',
+            where: 'condition',
+          },
+        },
+      ]);
+    });
+
     it('should add foreign key to the column', async () => {
       const db = new DbStructure(adapter);
       db.getTables = async () => [table];
       db.getColumns = async () => [
         ...columns,
-        { ...tableColumn, name: 'otherId' },
+        { ...intColumn, name: 'otherId' },
       ];
       db.getForeignKeys = async () => [foreignKey];
 
       const [ast] = (await structureToAst(db)) as [RakeDbAst.Table];
 
-      expect(ast.shape.otherId.data.foreignKey).toEqual({
-        columns: ['id'],
-        name: 'fkey',
-        table: 'otherTable',
-      });
+      expect(ast.shape.otherId.data.foreignKeys).toEqual([
+        {
+          columns: ['id'],
+          name: 'fkey',
+          table: 'otherTable',
+          match: 'FULL',
+          onUpdate: 'CASCADE',
+          onDelete: 'CASCADE',
+        },
+      ]);
       expect(ast.foreignKeys).toHaveLength(0);
     });
 
@@ -249,7 +414,7 @@ describe('structureToAst', () => {
       db.getTables = async () => [table];
       db.getColumns = async () => [
         ...columns,
-        { ...tableColumn, name: 'otherId' },
+        { ...intColumn, name: 'otherId' },
       ];
       db.getForeignKeys = async () => [
         {
@@ -261,7 +426,7 @@ describe('structureToAst', () => {
 
       const [ast] = (await structureToAst(db)) as [RakeDbAst.Table];
 
-      expect(ast.shape.otherId.data.foreignKey).toBe(undefined);
+      expect(ast.shape.otherId.data.foreignKeys).toBe(undefined);
       expect(ast.foreignKeys).toEqual([
         {
           columns: ['name', 'otherId'],
@@ -269,6 +434,9 @@ describe('structureToAst', () => {
           foreignColumns: ['name', 'id'],
           options: {
             name: 'fkey',
+            match: 'FULL',
+            onUpdate: 'CASCADE',
+            onDelete: 'CASCADE',
           },
         },
       ]);