@dbml/connector 5.0.0 → 5.2.0

package/src/connectors/bigqueryConnector.ts

@@ -72,8 +72,7 @@ function getDbDefault (
 
   if (defaultValueType === 'string') {
     // bigquery store the double qoutes and quotes at the end and the beginning of the string: "string" or 'string'
-    // eslint-disable-next-line no-useless-escape
-    return { value: columnDefault.slice(1, -1).replaceAll("'", "\'"), type: defaultValueType };
+    return { value: columnDefault.slice(1, -1).replaceAll('\'', '\''), type: defaultValueType };
   }
 
   return { value: columnDefault, type: defaultValueType };
@@ -297,7 +296,7 @@ async function generateTableConstraints (
     }
 
     if (!inlinePrimaryKeyMap[key][columnNames]) {
-      inlinePrimaryKeyMap[key][columnNames] = {};
+      inlinePrimaryKeyMap[key][columnNames] = { checks: [] };
     }
 
     inlinePrimaryKeyMap[key][columnNames].pk = true;
@@ -372,6 +371,8 @@ async function fetchSchemaJsonByDataset (
     enums: [],
     indexes: mergeIndexDictionary(indexMap, compositePrimaryKeyMap),
     tableConstraints: inlinePrimaryKeyMap,
+    // Checks are not supported in BigQuery
+    checks: {},
   };
 }
 
@@ -401,7 +402,7 @@ async function fetchSchemaJson (keyFilename: string): Promise<DatabaseSchema> {
       return acc;
     },
     {
-      tables: [], fields: {}, tableConstraints: {}, indexes: {}, refs: [], enums: [],
+      tables: [], fields: {}, tableConstraints: {}, indexes: {}, refs: [], enums: [], checks: {},
     },
   );
 

package/src/connectors/mssqlConnector.ts

@@ -1,11 +1,15 @@
-/* eslint-disable camelcase */
+/* TDD 72
+ * - In MSSQL, there's no notion of ENUM.
+ * - MSSQL connector used to extract ENUMS from CHECK constraints, for example: `CHECK ([col]=value1 OR [col]=value2)` would be translated to an enum with 2 values, `value1` and `value2`.
+ * - Since DBML 4.0.0, we have supported CHECK constraints, so we no longer extract ENUMS out from CHECK constraints but rather keep them as CHECK constraints.
+ * */
 import sql from 'mssql';
 import { buildSchemaQuery, parseConnectionString } from '../utils/parseSchema';
 import {
+  CheckConstraintDictionary,
   DatabaseSchema,
   DefaultInfo,
   DefaultType,
-  Enum,
   Field,
   FieldsDictionary,
   IndexesDictionary,
@@ -13,7 +17,6 @@ import {
   RefEndpoint,
   Table,
   TableConstraintsDictionary,
-  EnumValuesDict,
 } from './types';
 
 // https://learn.microsoft.com/en-us/sql/t-sql/data-types/date-and-time-types?view=sql-server-ver15
@@ -111,66 +114,6 @@ const getDbdefault = (data_type: string, column_default: string, default_type: D
   };
 };
 
-const getEnumValues = (definition: string, constraint_name: string): EnumValuesDict[] => {
-  // Use the example below to understand the regex:
-  // ([quantity]>(0))
-  // ([unit_price]>(0))
-  // ([status]='cancelled' OR [status]='delivered' OR [status]='shipped' OR [status]='processing' OR [status]='pending')
-  // ([total_amount]>(0))
-  // ([price]>(0))
-  // ([stock_quantity]>=(0))
-  // ([age_start]<=[age_end])
-  // ([age_start]<=[age_end])
-  // ([gender]='Other' OR [gender]='Female' OR [gender]='Male')
-  // ([date_of_birth]<=dateadd(year,(-13),getdate()))
-  // ([email] like '%_@_%._%')
-  if (!definition) return [];
-  const values = definition.match(/\[([^\]]+)\]='([^']+)'/g); // Extracting the enum values when the definition contains ]='
-  if (!values) return [];
-
-  const colMap: { [key: string]: string[] } = {};
-  values.forEach((value) => {
-    const [columnName, enumValue] = value.split("]='");
-    const cleanColumnName = columnName.slice(1); // Remove the leading '['
-    const cleanEnumValue = enumValue.slice(0, -1); // Remove the trailing "'"
-    if (!colMap[cleanColumnName]) {
-      colMap[cleanColumnName] = [cleanEnumValue];
-    } else {
-      colMap[cleanColumnName].push(cleanEnumValue);
-    }
-  });
-
-  const arraysEqual = (a: string[], b: string[]): boolean => {
-    if (a.length !== b.length) return false;
-    const sortedA = [...a].sort();
-    const sortedB = [...b].sort();
-    return sortedA.every((value, index) => value === sortedB[index]);
-  };
-
-  // Please check the comments of the EnumValuesDict type in types.ts to understand the structure
-  const result: EnumValuesDict[] = [];
-  const processedKeys = new Set<string>();
-
-  Object.keys(colMap).forEach((key) => {
-    if (processedKeys.has(key)) return;
-
-    const mergedColumns = [key];
-    const colValues = colMap[key];
-
-    Object.keys(colMap).forEach((innerKey) => {
-      if (key !== innerKey && arraysEqual(colValues, colMap[innerKey])) {
-        mergedColumns.push(innerKey);
-        processedKeys.add(innerKey);
-      }
-    });
-    const enumValues = colValues.map((value) => ({ name: value }));
-    result.push({ columns: mergedColumns, enumValues, constraint_name: `${constraint_name}_${mergedColumns.join('_')}` });
-    processedKeys.add(key);
-  });
-
-  return result;
-};
-
 const generateField = (row: Record<string, any>): Field => {
   const {
     column_name,
@@ -202,15 +145,11 @@ const generateField = (row: Record<string, any>): Field => {
   };
 };
 
-const generateTablesFieldsAndEnums = async (client: sql.ConnectionPool, schemas: string[]): Promise<{
-  tables: Table[],
-  fields: FieldsDictionary,
-  enums: Enum[],
+const generateTablesFields = async (client: sql.ConnectionPool, schemas: string[]): Promise<{
+  tables: Table[];
+  fields: FieldsDictionary;
 }> => {
-  const checkConstraintDefinitionDedup: { [key: string]: EnumValuesDict[] } = {};
-
   const fields: FieldsDictionary = {};
-  const enums: Enum[] = [];
   const tablesAndFieldsSql = `
     WITH tables_and_fields AS (
       SELECT
@@ -249,35 +188,6 @@ const generateTablesFieldsAndEnums = async (client: sql.ConnectionPool, schemas:
           AND ep.name like '%description%'
       WHERE
         t.type = 'U' -- User-defined tables
-    ),
-    constraints_with_nulls AS (
-      SELECT
-        tf.*,
-        cc.name AS check_constraint_name,
-        CASE
-          WHEN cc.definition LIKE '%[' + tf.column_name + ']%=''%' THEN cc.definition
-          ELSE NULL
-        END AS check_constraint_definition
-      FROM
-        tables_and_fields AS tf
-      LEFT JOIN sys.check_constraints cc
-        ON cc.parent_object_id = OBJECT_ID(tf.table_schema + '.' + tf.table_name)
-        AND cc.definition LIKE '%' + tf.column_name + '%' -- Ensure the constraint references the column
-    ),
-    constraints_with_row_number AS (
-      SELECT
-        *,
-        ROW_NUMBER() OVER (
-          PARTITION BY table_schema, table_name, column_name
-          ORDER BY
-            CASE
-              WHEN check_constraint_definition IS NOT NULL THEN 1
-              ELSE 2
-            END,
-            check_constraint_name
-        ) AS rn
-      FROM
-        constraints_with_nulls
     )
     SELECT
       table_schema,
@@ -292,17 +202,15 @@ const generateTablesFieldsAndEnums = async (client: sql.ConnectionPool, schemas:
       column_default,
       table_comment,
       column_comment,
-      check_constraint_name,
-      check_constraint_definition,
       CASE
         WHEN column_default LIKE '((%))' THEN 'number'
         WHEN column_default LIKE '(''%'')' THEN 'string'
         ELSE 'expression'
       END AS default_type
     FROM
-      constraints_with_row_number
+      tables_and_fields
     WHERE
-      rn = 1
+      1 = 1
       ${buildSchemaQuery('table_schema', schemas)}
     ORDER BY
       table_schema,
@@ -317,8 +225,6 @@ const generateTablesFieldsAndEnums = async (client: sql.ConnectionPool, schemas:
       table_schema,
       table_name,
       table_comment,
-      check_constraint_name,
-      check_constraint_definition,
     } = row;
     const key = `${table_schema}.${table_name}`;
 
@@ -332,30 +238,6 @@ const generateTablesFieldsAndEnums = async (client: sql.ConnectionPool, schemas:
 
     if (!fields[key]) fields[key] = [];
     const field = generateField(row);
-
-    if (check_constraint_definition && !checkConstraintDefinitionDedup[check_constraint_name]) {
-      const enumValuesByColumns = getEnumValues(check_constraint_definition, check_constraint_name);
-      enumValuesByColumns.forEach((item) => {
-        enums.push({
-          name: item.constraint_name,
-          schemaName: table_schema,
-          values: item.enumValues,
-        });
-      });
-      checkConstraintDefinitionDedup[check_constraint_name] = enumValuesByColumns;
-    }
-
-    if (checkConstraintDefinitionDedup[check_constraint_name]) {
-      const enumValuesByColumns = checkConstraintDefinitionDedup[check_constraint_name];
-      const columnEnumValues = enumValuesByColumns.find((item) => item.columns.includes(field.name));
-      if (columnEnumValues) {
-        field.type = {
-          type_name: columnEnumValues.constraint_name,
-          schemaName: table_schema,
-        };
-      }
-    }
-
     fields[key].push(field);
 
     return acc;
@@ -364,7 +246,6 @@ const generateTablesFieldsAndEnums = async (client: sql.ConnectionPool, schemas:
   return {
     tables: Object.values(tables),
     fields,
-    enums,
   };
 };
 
@@ -411,9 +292,9 @@ const generateRefs = async (client: sql.ConnectionPool, schemas: string[]): Prom
     if (ep1.length !== ep2.length) return false;
     return ep1.every(
       (endpoint, index) => endpoint.tableName === ep2[index].tableName
-      && endpoint.schemaName === ep2[index].schemaName
-      && endpoint.fieldNames.length === ep2[index].fieldNames.length
-      && endpoint.fieldNames.every((field, fieldIndex) => field === ep2[index].fieldNames[fieldIndex]),
+        && endpoint.schemaName === ep2[index].schemaName
+        && endpoint.fieldNames.length === ep2[index].fieldNames.length
+        && endpoint.fieldNames.every((field, fieldIndex) => field === ep2[index].fieldNames[fieldIndex]),
     );
   };
 
@@ -451,7 +332,7 @@ const generateRefs = async (client: sql.ConnectionPool, schemas: string[]): Prom
       onUpdate: on_update === 'NO_ACTION' ? null : on_update,
     };
 
-    const isDuplicate = refs.some(ref => endpointsEqual(ref.endpoints, newRef.endpoints));
+    const isDuplicate = refs.some((ref) => endpointsEqual(ref.endpoints, newRef.endpoints));
 
     if (!isDuplicate) {
       refs.push(newRef);
@@ -461,7 +342,7 @@ const generateRefs = async (client: sql.ConnectionPool, schemas: string[]): Prom
   return refs;
 };
 
-const generateIndexes = async (client: sql.ConnectionPool, schemas: string[]) => {
+const generateIndexesAndConstraints = async (client: sql.ConnectionPool, schemas: string[]) => {
   const indexListSql = `
     WITH user_tables AS (
       SELECT
@@ -537,19 +418,19 @@ const generateIndexes = async (client: sql.ConnectionPool, schemas: string[]) =>
       ii.index_name;
   `;
   const indexListResult = await client.query(indexListSql);
-  const { outOfLineConstraints, inlineConstraints } = indexListResult.recordset.reduce((acc, row) => {
+  const { outOfLineIndexes, inlineIndexes } = indexListResult.recordset.reduce((acc, row) => {
     const { constraint_type, columns } = row;
 
     if (columns === 'null' || columns.trim() === '') return acc;
     if (constraint_type === 'PRIMARY KEY' || constraint_type === 'UNIQUE') {
-      acc.inlineConstraints.push(row);
+      acc.inlineIndexes.push(row);
     } else {
-      acc.outOfLineConstraints.push(row);
+      acc.outOfLineIndexes.push(row);
     }
     return acc;
-  }, { outOfLineConstraints: [], inlineConstraints: [] });
+  }, { inlineIndexes: [], outOfLineIndexes: [] });
 
-  const indexes = outOfLineConstraints.reduce((acc: IndexesDictionary, indexRow: Record<string, any>) => {
+  const indexes = outOfLineIndexes.reduce((acc: IndexesDictionary, indexRow: Record<string, any>) => {
     const {
       table_schema,
       table_name,
@@ -557,6 +438,8 @@ const generateIndexes = async (client: sql.ConnectionPool, schemas: string[]) =>
       index_type,
       columns,
       expressions,
+      is_unique,
+      is_primary,
     } = indexRow;
     const indexColumns = columns.split(',').map((column: string) => {
       return {
@@ -565,12 +448,14 @@ const generateIndexes = async (client: sql.ConnectionPool, schemas: string[]) =>
       };
     });
 
-    const indexExpressions = expressions ? expressions.split(',').map((expression: string) => {
-      return {
-        type: 'expression',
-        value: expression,
-      };
-    }) : [];
+    const indexExpressions = expressions
+      ? expressions.split(',').map((expression: string) => {
+          return {
+            type: 'expression',
+            value: expression,
+          };
+        })
+      : [];
 
     const index = {
       name: index_name,
@@ -579,6 +464,8 @@ const generateIndexes = async (client: sql.ConnectionPool, schemas: string[]) =>
         ...indexColumns,
         ...indexExpressions,
       ],
+      pk: !!is_primary,
+      unique: !is_primary && !!is_unique,
     };
 
     const key = `${table_schema}.${table_name}`;
@@ -591,7 +478,9 @@ const generateIndexes = async (client: sql.ConnectionPool, schemas: string[]) =>
     return acc;
   }, {});
 
-  const tableConstraints = inlineConstraints.reduce((acc: TableConstraintsDictionary, row: Record<string, any>) => {
+  const tableConstraints: TableConstraintsDictionary = {};
+
+  inlineIndexes.forEach((row: Record<string, any>) => {
     const {
       table_schema,
       table_name,
@@ -599,24 +488,64 @@ const generateIndexes = async (client: sql.ConnectionPool, schemas: string[]) =>
       constraint_type,
     } = row;
     const key = `${table_schema}.${table_name}`;
-    if (!acc[key]) acc[key] = {};
+    if (!tableConstraints[key]) tableConstraints[key] = {};
 
     const columnNames = columns.split(',').map((column: string) => column.trim());
     columnNames.forEach((columnName: string) => {
-      if (!acc[key][columnName]) acc[key][columnName] = {};
+      if (!tableConstraints[key][columnName]) tableConstraints[key][columnName] = { checks: [] };
       if (constraint_type === 'PRIMARY KEY') {
-        acc[key][columnName].pk = true;
+        tableConstraints[key][columnName].pk = true;
       }
-      if (constraint_type === 'UNIQUE' && !acc[key][columnName].pk) {
-        acc[key][columnName].unique = true;
+      if (constraint_type === 'UNIQUE' && !tableConstraints[key][columnName].pk) {
+        tableConstraints[key][columnName].unique = true;
       }
     });
-    return acc;
-  }, {});
+  });
+
+  const checkListSql = `
+    SELECT
+      OBJECT_SCHEMA_NAME(cc.parent_object_id) AS table_schema,
+      OBJECT_NAME(cc.parent_object_id) AS table_name,
+      c.name AS column_name,
+      cc.name AS check_name,
+      cc.definition AS check_expression
+    FROM
+      sys.check_constraints cc
+    LEFT JOIN
+      sys.columns c ON cc.parent_object_id = c.object_id AND cc.parent_column_id = c.column_id
+    WHERE 1 = 1
+      ${buildSchemaQuery('OBJECT_SCHEMA_NAME(cc.parent_object_id)', schemas)}
+  `;
+
+  const checkListResult = await client.query(checkListSql);
+  const checks: CheckConstraintDictionary = {};
+  checkListResult.recordset.forEach((row) => {
+    const {
+      table_schema,
+      table_name,
+      column_name,
+      check_name,
+      check_expression,
+    } = row;
+    const key = `${table_schema}.${table_name}`;
+    if (column_name) {
+      if (!tableConstraints[key]) tableConstraints[key] = {};
+      if (!tableConstraints[key][column_name]) tableConstraints[key][column_name] = { checks: [] };
+      // The check definition has the form: `(expr)`
+      // The expression starts at 1 and ends at -1
+      tableConstraints[key][column_name].checks.push({ name: check_name, expression: check_expression.slice(1, -1) });
+      return;
+    }
+    if (!checks[key]) checks[key] = [];
+    // The check definition has the form: `(expr)`
+    // The expression starts at 1 and ends at -1
+    checks[key].push({ name: check_name, expression: check_expression.slice(1, -1) });
+  });
 
   return {
     indexes,
     tableConstraints,
+    checks,
   };
 };
 
@@ -624,28 +553,29 @@ const fetchSchemaJson = async (connection: string): Promise<DatabaseSchema> => {
   const { connectionString, schemas } = parseConnectionString(connection, 'odbc');
   const client = await getValidatedClient(connectionString);
 
-  const tablesFieldsAndEnumsRes = generateTablesFieldsAndEnums(client, schemas);
-  const indexesRes = generateIndexes(client, schemas);
+  const tablesRes = generateTablesFields(client, schemas);
+  const indexesAndConstraintsRes = generateIndexesAndConstraints(client, schemas);
   const refsRes = generateRefs(client, schemas);
 
   const res = await Promise.all([
-    tablesFieldsAndEnumsRes,
-    indexesRes,
+    tablesRes,
+    indexesAndConstraintsRes,
     refsRes,
   ]);
-  client.close();
 
-  const { tables, fields, enums } = res[0];
-  const { indexes, tableConstraints } = res[1];
+  const { tables, fields } = res[0];
+  const { indexes, tableConstraints, checks } = res[1];
   const refs = res[2];
 
   return {
     tables,
     fields,
-    enums,
+    // MSSQL doesn't support the notion of enums
+    enums: [],
     refs,
     indexes,
     tableConstraints,
+    checks,
   };
 };
 

package/src/connectors/mysqlConnector.ts

@@ -1,6 +1,8 @@
 import { createConnection, Connection } from 'mysql2/promise';
 import { flatten } from 'lodash';
-import { DefaultInfo, DatabaseSchema, DefaultType, Field, IndexColumn, FieldsDictionary, Table, Enum, IndexesDictionary, TableConstraintsDictionary, Index, TableConstraint, Ref } from './types';
+import {
+  CheckConstraintDictionary, DefaultInfo, DatabaseSchema, DefaultType, Field, IndexColumn, FieldsDictionary, Table, Enum, IndexesDictionary, TableConstraintsDictionary, Index, Ref,
+} from './types';
 
 const NUMBER_REGEX = '^-?[0-9]+(.[0-9]+)?$';
 
@@ -221,7 +223,7 @@ async function generateEnums (client: Connection, schemaName: string): Promise<E
 }
 
 /**
- * Mysql is automatically create index for primary keys, foreign keys, unique constraint. -> Ignore
+ * Mysql automatically creates index for primary keys, foreign keys, unique constraint. -> Ignore
  */
 async function generateIndexes (client: Connection, schemaName: string): Promise<IndexesDictionary> {
   const query = `
@@ -321,9 +323,9 @@ async function generatePrimaryAndUniqueConstraint (client: Connection, schemaNam
   const rows: any = queryResponse[0];
 
   const inlineConstraintList = rows.filter((constraint: Record<string, any>) => constraint.columnCount === 1);
-  const outOfConstraintList = rows.filter((constraint: Record<string, any>) => constraint.columnCount > 1);
+  const outOfLineConstraintList = rows.filter((constraint: Record<string, any>) => constraint.columnCount > 1);
 
-  const compositeTableConstraintMap = outOfConstraintList.reduce((acc: any, row: Record<string, any>) => {
+  const compositeTableConstraintMap = outOfLineConstraintList.reduce((acc: any, row: Record<string, any>) => {
     const {
       tableName, constraintName, columnNames, constraintType,
     } = row;
@@ -340,7 +342,7 @@ async function generatePrimaryAndUniqueConstraint (client: Connection, schemaNam
     }
 
     if (constraintType === 'PRIMARY KEY') {
-      acc[key][constraintName].primary = true;
+      acc[key][constraintName].pk = true;
     }
 
     if (constraintType === 'UNIQUE') {
@@ -355,12 +357,12 @@ async function generatePrimaryAndUniqueConstraint (client: Connection, schemaNam
     return acc;
   }, {});
 
-  const compositeConstraintMap: any = {};
+  const compositeConstraintMap: IndexesDictionary = {};
   Object.keys(compositeTableConstraintMap).forEach((tableName) => {
     compositeConstraintMap[tableName] = flatten(Object.values(compositeTableConstraintMap[tableName]));
   });
 
-  const constraintMap = inlineConstraintList.reduce((acc: any, row: Record<string, any>) => {
+  const constraintMap = inlineConstraintList.reduce((acc: TableConstraintsDictionary, row: Record<string, any>) => {
     const { tableName, columnNames, constraintType } = row;
 
     const key = tableName;
@@ -372,7 +374,7 @@ async function generatePrimaryAndUniqueConstraint (client: Connection, schemaNam
 
     columnList.forEach((columnName: string) => {
       if (!acc[key][columnName]) {
-        acc[key][columnName] = {};
+        acc[key][columnName] = { checks: [] };
       }
 
       if (constraintType === 'PRIMARY KEY') {
@@ -386,7 +388,58 @@ async function generatePrimaryAndUniqueConstraint (client: Connection, schemaNam
     return acc;
   }, {});
 
-  return { compositeConstraintMap, constraintMap };
+  return { compositeConstraintMap, primaryAndUniqueConstraintMap: constraintMap };
+}
+
+function extractColumnsFromCheckConstraint (checkClause: string): string[] {
+  return [...checkClause.matchAll(/`(?:``|[^`])*`/g)].map((col) => col.toString().slice(1, -1));
+}
+
+async function generateCheckConstraints (client: Connection, schemaName: string): Promise<{ checks: CheckConstraintDictionary; tableConstraints: TableConstraintsDictionary }> {
+  const query = `
+    select
+      cc.constraint_name as constraintName,
+      tc.table_name as tableName,
+      cc.check_clause as checkClause
+    from information_schema.check_constraints cc
+    join information_schema.table_constraints tc
+      on cc.constraint_name = tc.constraint_name
+    where cc.constraint_schema = ?
+  `;
+
+  const queryResponse = await client.query(query, [schemaName]);
+  const rows: any = queryResponse[0];
+  const checks: CheckConstraintDictionary = {};
+  const tableConstraints: TableConstraintsDictionary = {};
+  rows.forEach((row: any) => {
+    const {
+      constraintName,
+      tableName,
+      checkClause,
+    } = row;
+    const key = tableName;
+    const cols = extractColumnsFromCheckConstraint(checkClause);
+    if (cols.length === 1) {
+      const col = cols[0];
+      if (!tableConstraints[key]) tableConstraints[key] = {};
+      if (!tableConstraints[key][col]) tableConstraints[key][col] = { checks: [] };
+      tableConstraints[key][col].checks.push({
+        name: constraintName,
+        // The check definition has the form: `(expr)`
+        // The expression starts at 1 and ends at -1
+        expression: checkClause.slice(1, -1),
+      });
+      return;
+    }
+    if (!checks[key]) checks[key] = [];
+    checks[key].push({
+      name: constraintName,
+      // The check definition has the form: `(expr)`
+      // The expression starts at 1 and ends at -1
+      expression: checkClause.slice(1, -1),
+    });
+  });
+  return { checks, tableConstraints };
 }
 
 async function generateForeignKeys (client: Connection, schemaName: string): Promise<Ref[]> {
@@ -453,7 +506,7 @@ async function generateForeignKeys (client: Connection, schemaName: string): Pro
   return foreignKeyList;
 }
 
-function combineIndexAndCompositeConstraint (userDefinedIndexMap: any, compositeConstraintMap: any) {
+function combineIndexAndCompositeConstraint (userDefinedIndexMap: IndexesDictionary, compositeConstraintMap: IndexesDictionary): IndexesDictionary {
   const indexMap = Object.assign(userDefinedIndexMap, {});
 
   Object.keys(compositeConstraintMap).forEach((tableName) => {
@@ -484,6 +537,7 @@ async function fetchSchemaJson (connection: string): Promise<DatabaseSchema> {
     generateIndexes(client, schemaName),
     generatePrimaryAndUniqueConstraint(client, schemaName),
     generateForeignKeys(client, schemaName),
+    generateCheckConstraints(client, schemaName),
   ]);
   client.end();
 
@@ -491,20 +545,31 @@ async function fetchSchemaJson (connection: string): Promise<DatabaseSchema> {
     { tableList, fieldMap },
     enumList,
     rawIndexMap,
-    { constraintMap, compositeConstraintMap },
+    { primaryAndUniqueConstraintMap, compositeConstraintMap },
     foreignKeyList,
+    { checks: tableCheckConstraintMap, tableConstraints: columnCheckConstraintMap },
   ] = result;
 
   // combine normal index and composite key
   const indexMap = combineIndexAndCompositeConstraint(rawIndexMap, compositeConstraintMap);
 
+  const tableConstraints: TableConstraintsDictionary = { ...primaryAndUniqueConstraintMap };
+  Object.keys(columnCheckConstraintMap).forEach((tableName) => {
+    if (!tableConstraints[tableName]) tableConstraints[tableName] = {};
+    Object.keys(columnCheckConstraintMap[tableName]).forEach((colName) => {
+      if (!tableConstraints[tableName][colName]) tableConstraints[tableName][colName] = { checks: [] };
+      tableConstraints[tableName][colName].checks.push(...columnCheckConstraintMap[tableName][colName].checks);
+    });
+  });
+
   return {
     tables: tableList,
     fields: fieldMap,
     refs: foreignKeyList,
     enums: enumList,
     indexes: indexMap,
-    tableConstraints: constraintMap,
+    tableConstraints,
+    checks: tableCheckConstraintMap,
   };
 }