Import from postgres

src/components/EditorHeader/ControlPanel.jsx

@@ -749,9 +749,12 @@ export default function ControlPanel({
                 setImportDb(DB.MYSQL);
               },
             },
-            // {
+            {
-            //   PostgreSQL: () => setModal(MODAL.IMPORT_SRC),
+              PostgreSQL: () => {
-            // },
+                setModal(MODAL.IMPORT_SRC);
+                setImportDb(DB.POSTGRES);
+              },
+            },
             {
               SQLite: () => {
                 setModal(MODAL.IMPORT_SRC);

src/data/datatypes.js

@@ -680,49 +680,422 @@ export const mysqlTypes = {
 };
 
 export const postgresTypes = {
-  SMALLINT: { type: "SMALLINT", checkDefault: (field) => {} },
+  SMALLINT: {
-  INTEGER: { type: "INTEGER", checkDefault: (field) => {} },
+    type: "SMALLINT",
-  BIGINT: { type: "BIGINT", checkDefault: (field) => {} },
+    checkDefault: (field) => {
-  DECIMAL: { type: "DECIMAL", checkDefault: (field) => {} },
+      return intRegex.test(field.default);
-  NUMERIC: { type: "NUMERIC", checkDefault: (field) => {} },
+    },
-  REAL: { type: "REAL", checkDefault: (field) => {} },
+    hasCheck: true,
-  "DOUBLE PRECISION": { type: "DOUBLE PRECISION", checkDefault: (field) => {} },
+    isSized: false,
-  SMALLSERIAL: { type: "SMALLSERIAL", checkDefault: (field) => {} },
+    hasPrecision: false,
-  SERIAL: { type: "SERIAL", checkDefault: (field) => {} },
+    canIncrement: true,
-  BIGSERIAL: { type: "BIGSERIAL", checkDefault: (field) => {} },
+  },
-  MONEY: { type: "MONEY", checkDefault: (field) => {} },
+  INTEGER: {
-  CHARACTER: { type: "CHARACTER", checkDefault: (field) => {} },
+    type: "INTEGER",
-  CHAR: { type: "CHAR", checkDefault: (field) => {} },
+    checkDefault: (field) => {
-  VARCHAR: { type: "VARCHAR", checkDefault: (field) => {} },
+      return intRegex.test(field.default);
-  TEXT: { type: "TEXT", checkDefault: (field) => {} },
+    },
-  BYTEA: { type: "BYTEA", checkDefault: (field) => {} },
+    hasCheck: true,
-  DATE: { type: "DATE", checkDefault: (field) => {} },
+    isSized: false,
-  TIME: { type: "TIME", checkDefault: (field) => {} },
+    hasPrecision: false,
-  TIMESTAMP: { type: "TIMESTAMP", checkDefault: (field) => {} },
+    canIncrement: true,
-  TIMESTAMPTZ: { type: "TIMESTAMPTZ", checkDefault: (field) => {} },
+  },
-  INTERVAL: { type: "INTERVAL", checkDefault: (field) => {} },
+  BIGINT: {
-  BOOLEAN: { type: "BOOLEAN", checkDefault: (field) => {} },
+    type: "BIGINT",
-  ENUM: { type: "ENUM", checkDefault: (field) => {} },
+    checkDefault: (field) => {
-  POINT: { type: "POINT", checkDefault: (field) => {} },
+      return intRegex.test(field.default);
-  LINE: { type: "LINE", checkDefault: (field) => {} },
+    },
-  LSEG: { type: "LSEG", checkDefault: (field) => {} },
+    hasCheck: true,
-  BOX: { type: "BOX", checkDefault: (field) => {} },
+    isSized: false,
-  PATH: { type: "PATH", checkDefault: (field) => {} },
+    hasPrecision: false,
-  POLYGON: { type: "POLYGON", checkDefault: (field) => {} },
+    canIncrement: true,
-  CIRCLE: { type: "CIRCLE", checkDefault: (field) => {} },
+  },
-  CIDR: { type: "CIDR", checkDefault: (field) => {} },
+  DECIMAL: {
-  INET: { type: "INET", checkDefault: (field) => {} },
+    type: "DECIMAL",
-  MACADDR: { type: "MACADDR", checkDefault: (field) => {} },
+    checkDefault: (field) => {
-  MACADDR8: { type: "", checkDefault: (field) => {} },
+      return doubleRegex.test(field.default);
-  BIT: { type: "", checkDefault: (field) => {} },
+    },
-  VARBIT: { type: "", checkDefault: (field) => {} },
+    hasCheck: true,
-  TSVECTOR: { type: "", checkDefault: (field) => {} },
+    isSized: false,
-  TSQUERY: { type: "", checkDefault: (field) => {} },
+    hasPrecision: true,
-  JSON: { type: "", checkDefault: (field) => {} },
+  },
-  JSONB: { type: "", checkDefault: (field) => {} },
+  NUMERIC: {
-  UUID: { type: "", checkDefault: (field) => {} },
+    type: "NUMERIC",
-  XML: { type: "", checkDefault: (field) => {} },
+    checkDefault: (field) => {
-  ARRAY: { type: "", checkDefault: (field) => {} },
+      return doubleRegex.test(field.default);
+    },
+    hasCheck: true,
+    isSized: false,
+    hasPrecision: true,
+  },
+  REAL: {
+    type: "REAL",
+    checkDefault: (field) => {
+      return doubleRegex.test(field.default);
+    },
+    hasCheck: true,
+    isSized: false,
+    hasPrecision: true,
+  },
+  "DOUBLE PRECISION": {
+    type: "DOUBLE PRECISION",
+    checkDefault: (field) => {
+      return doubleRegex.test(field.default);
+    },
+    hasCheck: true,
+    isSized: false,
+    hasPrecision: true,
+  },
+  SMALLSERIAL: {
+    type: "SMALLSERIAL",
+    checkDefault: (field) => {
+      return intRegex.test(field.default);
+    },
+    hasCheck: true,
+    isSized: false,
+    hasPrecision: false,
+  },
+  SERIAL: {
+    type: "SERIAL",
+    checkDefault: (field) => {
+      return intRegex.test(field.default);
+    },
+    hasCheck: true,
+    isSized: false,
+    hasPrecision: false,
+  },
+  BIGSERIAL: {
+    type: "BIGSERIAL",
+    checkDefault: (field) => {
+      return intRegex.test(field.default);
+    },
+    hasCheck: true,
+    isSized: false,
+    hasPrecision: false,
+  },
+  MONEY: {
+    type: "MONEY",
+    checkDefault: (field) => {
+      return doubleRegex.test(field.default);
+    },
+    hasCheck: true,
+    isSized: false,
+    hasPrecision: true,
+  },
+  CHAR: {
+    type: "CHAR",
+    checkDefault: (field) => {
+      if (strHasQuotes(field.default)) {
+        return field.default.length - 2 <= field.size;
+      }
+      return field.default.length <= field.size;
+    },
+    hasCheck: true,
+    isSized: true,
+    hasPrecision: false,
+    defaultSize: 1,
+    hasQuotes: true,
+  },
+  VARCHAR: {
+    type: "VARCHAR",
+    checkDefault: (field) => {
+      if (strHasQuotes(field.default)) {
+        return field.default.length - 2 <= field.size;
+      }
+      return field.default.length <= field.size;
+    },
+    hasCheck: true,
+    isSized: true,
+    hasPrecision: false,
+    defaultSize: 255,
+    hasQuotes: true,
+  },
+  TEXT: {
+    type: "TEXT",
+    checkDefault: (field) => {
+      if (strHasQuotes(field.default)) {
+        return field.default.length - 2 <= field.size;
+      }
+      return field.default.length <= field.size;
+    },
+    hasCheck: true,
+    isSized: true,
+    hasPrecision: false,
+    defaultSize: 65535,
+    hasQuotes: true,
+  },
+  BYTEA: {
+    type: "BYTEA",
+    checkDefault: (field) => {
+      return /^[0-9a-fA-F]*$/.test(field.default);
+    },
+    hasCheck: false,
+    isSized: false,
+    hasPrecision: false,
+    defaultSize: null,
+    hasQuotes: true,
+  },
+  DATE: {
+    type: "DATE",
+    checkDefault: (field) => {
+      return /^\d{4}-\d{2}-\d{2}$/.test(field.default);
+    },
+    hasCheck: false,
+    isSized: false,
+    hasPrecision: false,
+    hasQuotes: true,
+  },
+  TIME: {
+    type: "TIME",
+    checkDefault: (field) => {
+      return /^(?:[01]?\d|2[0-3]):[0-5]?\d:[0-5]?\d$/.test(field.default);
+    },
+    hasCheck: false,
+    isSized: false,
+    hasPrecision: false,
+    hasQuotes: true,
+  },
+  TIMESTAMP: {
+    type: "TIMESTAMP",
+    checkDefault: (field) => {
+      if (field.default.toUpperCase() === "CURRENT_TIMESTAMP") {
+        return true;
+      }
+      if (!/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/.test(field.default)) {
+        return false;
+      }
+      const content = field.default.split(" ");
+      const date = content[0].split("-");
+      return parseInt(date[0]) >= 1970 && parseInt(date[0]) <= 2038;
+    },
+    hasCheck: false,
+    isSized: false,
+    hasPrecision: false,
+    hasQuotes: true,
+  },
+  TIMESTAMPTZ: {
+    type: "TIMESTAMPTZ",
+    checkDefault: (field) => {
+      if (field.default.toUpperCase() === "CURRENT_TIMESTAMP") {
+        return true;
+      }
+      return /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}([+-]\d{2}:\d{2})?$/.test(
+        field.default,
+      );
+    },
+    hasCheck: false,
+    isSized: false,
+    hasPrecision: false,
+    hasQuotes: true,
+  },
+  INTERVAL: {
+    type: "INTERVAL",
+    checkDefault: (field) => /^['"\d\s\\-]+$/.test(field.default),
+    hasCheck: false,
+    isSized: false,
+    hasPrecision: false,
+    hasQuotes: true,
+  },
+  BOOLEAN: {
+    type: "BOOLEAN",
+    checkDefault: (field) => /^(true|false)$/i.test(field.default),
+    hasCheck: false,
+    isSized: false,
+    hasPrecision: false,
+    hasQuotes: false,
+  },
+  ENUM: {
+    type: "ENUM",
+    checkDefault: (field) => true,
+    hasCheck: false,
+    isSized: false,
+    hasPrecision: false,
+    hasQuotes: true,
+  },
+  POINT: {
+    type: "POINT",
+    checkDefault: (field) => /^\(\d+,\d+\)$/.test(field.default),
+    hasCheck: false,
+    isSized: false,
+    hasPrecision: false,
+    hasQuotes: false,
+  },
+  LINE: {
+    type: "LINE",
+    checkDefault: (field) => /^(\(\d+,\d+\),)+\(\d+,\d+\)$/.test(field.default),
+    hasCheck: false,
+    isSized: false,
+    hasPrecision: false,
+    hasQuotes: false,
+  },
+  LSEG: {
+    type: "LSEG",
+    checkDefault: (field) => /^(\(\d+,\d+\),)+\(\d+,\d+\)$/.test(field.default),
+    hasCheck: false,
+    isSized: false,
+    hasPrecision: false,
+    hasQuotes: false,
+  },
+  BOX: {
+    type: "BOX",
+    checkDefault: (field) =>
+      /^\(\d+(\.\d+)?,\d+(\.\d+)?\),\(\d+(\.\d+)?,\d+(\.\d+)?\)$/.test(
+        field.default,
+      ),
+    hasCheck: false,
+    isSized: false,
+    hasPrecision: false,
+    hasQuotes: true,
+  },
+  PATH: {
+    type: "PATH",
+    checkDefault: (field) =>
+      /^\((\d+(\.\d+)?,\d+(\.\d+)?(,\d+(\.\d+)?,\d+(\.\d+)?)*?)\)$/.test(
+        field.default,
+      ),
+    hasCheck: false,
+    isSized: false,
+    hasPrecision: false,
+    hasQuotes: true,
+  },
+  POLYGON: {
+    type: "POLYGON",
+    checkDefault: (field) =>
+      /^\((\d+(\.\d+)?,\d+(\.\d+)?(,\d+(\.\d+)?,\d+(\.\d+)?)*?)\)$/.test(
+        field.default,
+      ),
+    hasCheck: false,
+    isSized: false,
+    hasPrecision: false,
+    hasQuotes: true,
+  },
+  CIRCLE: {
+    type: "CIRCLE",
+    checkDefault: (field) =>
+      /^<\(\d+(\.\d+)?,\d+(\.\d+)?\),\d+(\.\d+)?\\>$/.test(field.default),
+    hasCheck: false,
+    isSized: false,
+    hasPrecision: false,
+    hasQuotes: true,
+  },
+  CIDR: {
+    type: "CIDR",
+    checkDefault: (field) =>
+      /^(\d{1,3}\.){3}\d{1,3}\/\d{1,2}$/.test(field.default),
+    hasCheck: false,
+    isSized: false,
+    hasPrecision: false,
+    hasQuotes: true,
+  },
+  INET: {
+    type: "INET",
+    checkDefault: (field) =>
+      /^(\d{1,3}\.){3}\d{1,3}(\/\d{1,2})?$/.test(field.default),
+    hasCheck: false,
+    isSized: false,
+    hasPrecision: false,
+    hasQuotes: true,
+  },
+  MACADDR: {
+    type: "MACADDR",
+    checkDefault: (field) =>
+      /^([A-Fa-f0-9]{2}:){5}[A-Fa-f0-9]{2}$/.test(field.default),
+    hasCheck: false,
+    isSized: false,
+    hasPrecision: false,
+    hasQuotes: true,
+  },
+  MACADDR8: {
+    type: "MACADDR8",
+    checkDefault: (field) =>
+      /^([A-Fa-f0-9]{2}:){7}[A-Fa-f0-9]{2}$/.test(field.default),
+    hasCheck: false,
+    isSized: false,
+    hasPrecision: false,
+    hasQuotes: true,
+  },
+  BIT: {
+    type: "BIT",
+    checkDefault: (field) => /^[01]{1,}$/.test(field.default),
+    hasCheck: true,
+    isSized: true,
+    hasPrecision: false,
+    defaultSize: 1,
+    hasQuotes: false,
+  },
+  VARBIT: {
+    type: "VARBIT",
+    checkDefault: (field) => /^[01]*$/.test(field.default),
+    hasCheck: true,
+    isSized: true,
+    hasPrecision: false,
+    defaultSize: 1,
+    hasQuotes: false,
+  },
+  TSVECTOR: {
+    type: "TSVECTOR",
+    checkDefault: (field) => /^[A-Za-z0-9: ]*$/.test(field.default),
+    hasCheck: false,
+    isSized: false,
+    hasPrecision: false,
+    hasQuotes: false,
+  },
+  TSQUERY: {
+    type: "TSQUERY",
+    checkDefault: (field) => /^[A-Za-z0-9: &|!()]*$/.test(field.default),
+    hasCheck: false,
+    isSized: false,
+    hasPrecision: false,
+    hasQuotes: false,
+  },
+  JSON: {
+    type: "JSON",
+    checkDefault: (field) => true,
+    hasCheck: false,
+    isSized: false,
+    hasPrecision: false,
+    hasQuotes: true,
+    noDefault: true,
+  },
+  JSONB: {
+    type: "JSONB",
+    checkDefault: (field) => true,
+    hasCheck: false,
+    isSized: false,
+    hasPrecision: false,
+    hasQuotes: true,
+    noDefault: true,
+  },
+  UUID: {
+    type: "UUID",
+    checkDefault: (field) =>
+      /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(
+        field.default,
+      ),
+    hasCheck: false,
+    isSized: false,
+    hasPrecision: false,
+    hasQuotes: true,
+    noDefault: true,
+  },
+  XML: {
+    type: "XML",
+    checkDefault: (field) => true,
+    hasCheck: false,
+    isSized: false,
+    hasPrecision: false,
+    hasQuotes: true,
+    noDefault: true,
+  },
+  ARRAY: {
+    type: "ARRAY",
+    checkDefault: (field) => true,
+    hasCheck: false,
+    isSized: false,
+    hasPrecision: false,
+    hasQuotes: false,
+    noDefault: true,
+  },
 };
 
 export const sqliteTypes = {

src/utils/exportSQL/index.js

@@ -1,6 +1,7 @@
 import { DB } from "../../data/constants";
 import { toMariaDB } from "./mariadb";
 import { toMySQL } from "./mysql";
+import { toPostgres } from "./postgres";
 import { toSqlite } from "./sqlite";
 
 export function exportSQL(diagram) {
@@ -10,7 +11,7 @@ export function exportSQL(diagram) {
     case DB.MYSQL:
       return toMySQL(diagram);
     case DB.POSTGRES:
-      return "hi from postgres";
+      return toPostgres(diagram);
     case DB.MARIADB:
       return toMariaDB(diagram);
     case DB.MSSQL:

src/utils/exportSQL/postgres.js

@@ -0,0 +1,91 @@
+import { dbToTypes } from "../../data/datatypes";
+import { parseDefault } from "./shared";
+
+export function toPostgres(diagram) {
+  return `${diagram.types.map((type) => {
+    const typeStatements = type.fields
+      .filter((f) => f.type === "ENUM" || f.type === "SET")
+      .map(
+        (f) =>
+          `CREATE TYPE "${f.name}_t" AS ENUM (${f.values
+            .map((v) => `'${v}'`)
+            .join(", ")});\n`,
+      );
+    if (typeStatements.length > 0) {
+      return (
+        typeStatements.join("") +
+        `${
+          type.comment === "" ? "" : `/**\n${type.comment}\n*/\n`
+        }CREATE TYPE ${type.name} AS (\n${type.fields
+          .map((f) => `\t${f.name} ${f.type}`)
+          .join("\n")}\n);`
+      );
+    } else {
+      return `${
+        type.comment === "" ? "" : `/**\n${type.comment}\n*/\n`
+      }CREATE TYPE ${type.name} AS (\n${type.fields
+        .map((f) => `\t${f.name} ${f.type}`)
+        .join("\n")}\n);`;
+    }
+  })}\n${diagram.tables
+    .map(
+      (table) =>
+        `${table.comment === "" ? "" : `/**\n${table.comment}\n*/\n`}${
+          table.fields.filter((f) => f.type === "ENUM" || f.type === "SET")
+            .length > 0
+            ? `${table.fields
+                .filter((f) => f.type === "ENUM" || f.type === "SET")
+                .map(
+                  (f) =>
+                    `CREATE TYPE "${f.name}_t" AS ENUM (${f.values
+                      .map((v) => `'${v}'`)
+                      .join(", ")});\n\n`,
+                )}`
+            : ""
+        }CREATE TABLE "${table.name}" (\n${table.fields
+          .map(
+            (field) =>
+              `${field.comment === "" ? "" : `\t-- ${field.comment}\n`}\t"${
+                field.name
+              }" ${field.type}${field.notNull ? " NOT NULL" : ""}${
+                field.default !== ""
+                  ? ` DEFAULT ${parseDefault(field, diagram.database)}`
+                  : ""
+              }${
+                field.check === "" ||
+                !dbToTypes[diagram.database][field.type].hasCheck
+                  ? ""
+                  : ` CHECK(${field.check})`
+              }`,
+          )
+          .join(",\n")}${
+          table.fields.filter((f) => f.primary).length > 0
+            ? `,\n\tPRIMARY KEY(${table.fields
+                .filter((f) => f.primary)
+                .map((f) => `"${f.name}"`)
+                .join(", ")})`
+            : ""
+        }\n);\n${
+          table.indices.length > 0
+            ? `${table.indices.map(
+                (i) =>
+                  `\nCREATE ${i.unique ? "UNIQUE " : ""}INDEX "${
+                    i.name
+                  }"\nON "${table.name}" (${i.fields
+                    .map((f) => `"${f}"`)
+                    .join(", ")});`,
+              )}`
+            : ""
+        }`,
+    )
+    .join("\n")}\n${diagram.references
+    .map(
+      (r) =>
+        `ALTER TABLE "${diagram.tables[r.startTableId].name}"\nADD FOREIGN KEY("${
+          diagram.tables[r.startTableId].fields[r.startFieldId].name
+        }") REFERENCES "${diagram.tables[r.endTableId].name}"("${
+          diagram.tables[r.endTableId].fields[r.endFieldId].name
+        }")\nON UPDATE ${r.updateConstraint.toUpperCase()} ON DELETE ${r.deleteConstraint.toUpperCase()};`,
+    )
+    .join("\n")}`;
+}

src/utils/importSQL/index.js

@@ -6,6 +6,7 @@ import {
 } from "../../data/constants";
 import { fromMariaDB } from "./mariadb";
 import { fromMySQL } from "./mysql";
+import { fromPostgres } from "./postgres";
 import { fromSQLite } from "./sqlite";
 
 export function importSQL(ast, toDb = DB.MYSQL, diagramDb = DB.GENERIC) {
@@ -18,7 +19,7 @@ export function importSQL(ast, toDb = DB.MYSQL, diagramDb = DB.GENERIC) {
       diagram = fromMySQL(ast, diagramDb);
       break;
     case DB.POSTGRES:
-      diagram = { tables: [], relationships: [] };
+      diagram = fromPostgres(ast, diagramDb);
       break;
     case DB.MARIADB:
       diagram = fromMariaDB(ast, diagramDb);

src/utils/importSQL/postgres.js

@@ -0,0 +1,245 @@
+import { Cardinality, DB } from "../../data/constants";
+import { dbToTypes } from "../../data/datatypes";
+import { buildSQLFromAST } from "./shared";
+
+const affinity = {
+  [DB.POSTGRES]: new Proxy(
+    { INT: "INTEGER" },
+    { get: (target, prop) => (prop in target ? target[prop] : "BLOB") },
+  ),
+  [DB.GENERIC]: new Proxy(
+    {
+      INT: "INTEGER",
+      MEDIUMINT: "INTEGER",
+      BIT: "BOOLEAN",
+    },
+    { get: (target, prop) => (prop in target ? target[prop] : "BLOB") },
+  ),
+};
+
+export function fromPostgres(ast, diagramDb = DB.GENERIC) {
+  const tables = [];
+  const relationships = [];
+
+  ast.forEach((e) => {
+    if (e.type === "create") {
+      if (e.keyword === "table") {
+        const table = {};
+        table.name = e.table[0].table;
+        table.comment = "";
+        table.color = "#175e7a";
+        table.fields = [];
+        table.indices = [];
+        table.id = tables.length;
+        e.create_definitions.forEach((d) => {
+          if (d.resource === "column") {
+            const field = {};
+            field.name = d.column.column.expr.value;
+
+            let type = d.definition.dataType;
+            if (!dbToTypes[diagramDb][type]) {
+              type = affinity[diagramDb][type];
+            }
+            field.type = type;
+
+            if (d.definition.expr && d.definition.expr.type === "expr_list") {
+              field.values = d.definition.expr.value.map((v) => v.value);
+            }
+            field.comment = "";
+            field.unique = false;
+            if (d.unique) field.unique = true;
+            field.increment = false;
+            if (d.auto_increment) field.increment = true;
+            field.notNull = false;
+            if (d.nullable) field.notNull = true;
+            field.primary = false;
+            if (d.primary_key) field.primary = true;
+            field.default = "";
+            if (d.default_val) {
+              let defaultValue = "";
+              if (d.default_val.value.type === "function") {
+                defaultValue = d.default_val.value.name.name[0].value;
+                if (d.default_val.value.args) {
+                  defaultValue +=
+                    "(" +
+                    d.default_val.value.args.value
+                      .map((v) => {
+                        if (
+                          v.type === "single_quote_string" ||
+                          v.type === "double_quote_string"
+                        )
+                          return "'" + v.value + "'";
+                        return v.value;
+                      })
+                      .join(", ") +
+                    ")";
+                }
+              } else if (d.default_val.value.type === "null") {
+                defaultValue = "NULL";
+              } else {
+                defaultValue = d.default_val.value.value.toString();
+              }
+              field.default = defaultValue;
+            }
+            if (d.definition["length"]) {
+              if (d.definition.scale) {
+                field.size = d.definition["length"] + "," + d.definition.scale;
+              } else {
+                field.size = d.definition["length"];
+              }
+            }
+            field.check = "";
+            if (d.check) {
+              field.check = buildSQLFromAST(d.check.definition[0]);
+            }
+
+            table.fields.push(field);
+          } else if (d.resource === "constraint") {
+            if (d.constraint_type === "primary key") {
+              d.definition.forEach((c) => {
+                table.fields.forEach((f) => {
+                  if (f.name === c.column && !f.primary) {
+                    f.primary = true;
+                  }
+                });
+              });
+            } else if (d.constraint_type === "FOREIGN KEY") {
+              const relationship = {};
+              const startTableId = table.id;
+              const startTable = e.table[0].table;
+              const startField = d.definition[0].column.expr.value;
+              const endTable = d.reference_definition.table[0].table;
+              const endField =
+                d.reference_definition.definition[0].column.expr.value;
+
+              const endTableId = tables.findIndex((t) => t.name === endTable);
+              if (endTableId === -1) return;
+
+              const endFieldId = tables[endTableId].fields.findIndex(
+                (f) => f.name === endField,
+              );
+              if (endField === -1) return;
+
+              const startFieldId = table.fields.findIndex(
+                (f) => f.name === startField,
+              );
+              if (startFieldId === -1) return;
+
+              relationship.name = startTable + "_" + startField + "_fk";
+              relationship.startTableId = startTableId;
+              relationship.endTableId = endTableId;
+              relationship.endFieldId = endFieldId;
+              relationship.startFieldId = startFieldId;
+              let updateConstraint = "No action";
+              let deleteConstraint = "No action";
+              d.reference_definition.on_action.forEach((c) => {
+                if (c.type === "on update") {
+                  updateConstraint = c.value.value;
+                  updateConstraint =
+                    updateConstraint[0].toUpperCase() +
+                    updateConstraint.substring(1);
+                } else if (c.type === "on delete") {
+                  deleteConstraint = c.value.value;
+                  deleteConstraint =
+                    deleteConstraint[0].toUpperCase() +
+                    deleteConstraint.substring(1);
+                }
+              });
+
+              relationship.updateConstraint = updateConstraint;
+              relationship.deleteConstraint = deleteConstraint;
+              relationship.cardinality = Cardinality.ONE_TO_ONE;
+              relationships.push(relationship);
+            }
+          }
+        });
+        table.fields.forEach((f, j) => {
+          f.id = j;
+        });
+        tables.push(table);
+      } else if (e.keyword === "index") {
+        const index = {};
+        index.name = e.index;
+        index.unique = false;
+        if (e.index_type === "unique") index.unique = true;
+        index.fields = [];
+        e.index_columns.forEach((f) => index.fields.push(f.column));
+
+        let found = -1;
+        tables.forEach((t, i) => {
+          if (found !== -1) return;
+          if (t.name === e.table.table) {
+            t.indices.push(index);
+            found = i;
+          }
+        });
+
+        if (found !== -1) tables[found].indices.forEach((i, j) => (i.id = j));
+      }
+    } else if (e.type === "alter") {
+      e.expr.forEach((expr) => {
+        if (
+          expr.action === "add" &&
+          expr.create_definitions.constraint_type === "FOREIGN KEY"
+        ) {
+          const relationship = {};
+          const startTable = e.table[0].table;
+          const startField = expr.create_definitions.definition[0].column;
+          const endTable =
+            expr.create_definitions.reference_definition.table[0].table;
+          const endField =
+            expr.create_definitions.reference_definition.definition[0].column;
+          let updateConstraint = "No action";
+          let deleteConstraint = "No action";
+          expr.create_definitions.reference_definition.on_action.forEach(
+            (c) => {
+              if (c.type === "on update") {
+                updateConstraint = c.value.value;
+                updateConstraint =
+                  updateConstraint[0].toUpperCase() +
+                  updateConstraint.substring(1);
+              } else if (c.type === "on delete") {
+                deleteConstraint = c.value.value;
+                deleteConstraint =
+                  deleteConstraint[0].toUpperCase() +
+                  deleteConstraint.substring(1);
+              }
+            },
+          );
+
+          const startTableId = tables.findIndex((t) => t.name === startTable);
+          if (startTable === -1) return;
+
+          const endTableId = tables.findIndex((t) => t.name === endTable);
+          if (endTableId === -1) return;
+
+          const endFieldId = tables[endTableId].fields.findIndex(
+            (f) => f.name === endField,
+          );
+          if (endField === -1) return;
+
+          const startFieldId = tables[startTableId].fields.findIndex(
+            (f) => f.name === startField,
+          );
+          if (startFieldId === -1) return;
+
+          relationship.name = startTable + "_" + startField + "_fk";
+          relationship.startTableId = startTableId;
+          relationship.startFieldId = startFieldId;
+          relationship.endTableId = endTableId;
+          relationship.endFieldId = endFieldId;
+          relationship.updateConstraint = updateConstraint;
+          relationship.deleteConstraint = deleteConstraint;
+          relationship.cardinality = Cardinality.ONE_TO_ONE;
+          relationships.push(relationship);
+
+          relationships.forEach((r, i) => (r.id = i));
+        }
+      });
+    }
+  });
+
+  relationships.forEach((r, i) => (r.id = i));
+
+  return { tables, relationships };
+}