@dbml/core 6.1.0 → 6.2.0-alpha.0

package/README.md

@@ -160,13 +160,13 @@ For more detailed documentation on each SQL parser, see the individual parser RE
 | Feature | PostgreSQL | MySQL | MSSQL | Oracle | Snowflake |
 |---------|------------|-------|-------|--------|-----------|
 | Basic `INSERT` ... VALUES | ✓ | ✓ | ✓ | ✓ | ✗ |
-| Multi-row `INSERT` | ✓ | ✓ | ✓ | — | ✓ |
+| Multi-row `INSERT` | ✓ | ✓ | ✓ | ✓ | ✓ |
 | `INSERT` ... SELECT | ✗ | ✗ | ✗ | ✗ | ✗ |
 | `INSERT` ... with returned rows (`RETURNING`, `OUTPUT`) | ◐ | — | ◐ | ◐ | — |
 | `INSERT` ... ON CONFLICT/DUPLICATE KEY | ◐ | ◐ | — | — | — |
 
 **Notes:**
-- **Oracle**: Uses `INSERT ALL` syntax for multi-row inserts (not supported)
+- **Oracle**: Multi-row inserts use `INSERT ALL ... SELECT * FROM dual` syntax, which is fully supported.
 
 ---
 

package/lib/export/DbmlExporter.js

@@ -227,7 +227,7 @@ var DbmlExporter = /*#__PURE__*/function () {
         if ((0, _utils.shouldPrintSchema)(schema, model)) tableName = "\"".concat(schema.name, "\".\"").concat(table.name, "\"");
 
         // Include alias if present
-        var aliasStr = table.alias ? " as ".concat((0, _parse.addQuoteIfNeeded)(table.alias)) : '';
+        var aliasStr = table.alias ? " as ".concat((0, _parse.addDoubleQuoteIfNeeded)(table.alias)) : '';
         var fieldStr = tableContent.fieldContents.map(function (field) {
           return "  ".concat(field, "\n");
         }).join('');
@@ -342,6 +342,57 @@ var DbmlExporter = /*#__PURE__*/function () {
         return result ? "".concat(result, "\n").concat(stickyNote) : stickyNote;
       }, '');
     }
+  }, {
+    key: "exportRecords",
+    value: function exportRecords(model) {
+      var records = model.records;
+      if (!records || (0, _lodash.isEmpty)(records)) {
+        return '';
+      }
+
+      // Group records by schemaName and tableName
+      var recordGroups = (0, _lodash.groupBy)(Object.values(records), function (record) {
+        return "".concat(record.schemaName || '', ".").concat(record.tableName);
+      });
+
+      // Process each group
+      var recordStrs = Object.values(recordGroups).map(function (groupRecords) {
+        var _groupRecords$ = groupRecords[0],
+          schemaName = _groupRecords$.schemaName,
+          tableName = _groupRecords$.tableName;
+
+        // Build table reference
+        var tableRef = schemaName ? "".concat((0, _parse.addDoubleQuoteIfNeeded)(schemaName), ".").concat((0, _parse.addDoubleQuoteIfNeeded)(tableName)) : (0, _parse.addDoubleQuoteIfNeeded)(tableName);
+
+        // Collect all unique columns in order
+        var allColumns = _toConsumableArray(new Set(groupRecords.flatMap(function (r) {
+          return r.columns;
+        })));
+        var columnList = allColumns.map(_parse.addDoubleQuoteIfNeeded).join(', ');
+
+        // Merge all rows
+        var allRows = groupRecords.flatMap(function (record) {
+          var allColumnIndexes = allColumns.map(function (col) {
+            return record.columns.indexOf(col);
+          });
+          return record.values.map(function (row) {
+            return allColumnIndexes.map(function (colIdx) {
+              return colIdx === -1 ? {
+                value: null,
+                type: 'expression'
+              } : row[colIdx];
+            });
+          });
+        });
+
+        // Build data rows
+        var rowStrs = allRows.map(function (row) {
+          return "  ".concat(row.map(_parse.formatRecordValue).join(', '));
+        });
+        return "Records ".concat(tableRef, "(").concat(columnList, ") {\n").concat(rowStrs.join('\n'), "\n}\n");
+      });
+      return recordStrs.join('\n');
+    }
   }, {
     key: "export",
     value: function _export(model) {
@@ -359,6 +410,7 @@ var DbmlExporter = /*#__PURE__*/function () {
         if (!(0, _lodash.isEmpty)(refIds)) elementStrs.push(DbmlExporter.exportRefs(refIds, model));
       });
       if (!(0, _lodash.isEmpty)(model.notes)) elementStrs.push(DbmlExporter.exportStickyNotes(model));
+      if (!(0, _lodash.isEmpty)(model.records)) elementStrs.push(DbmlExporter.exportRecords(model));
 
       // all elements already end with 1 '\n', so join('\n') to separate them with 1 blank line
       return elementStrs.join('\n');

package/lib/export/MysqlExporter.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports["default"] = void 0;
 var _lodash = _interopRequireDefault(require("lodash"));
 var _utils = require("./utils");
+var _parse = require("@dbml/parse");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
 function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
 function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
@@ -24,6 +25,46 @@ var MySQLExporter = /*#__PURE__*/function () {
     _classCallCheck(this, MySQLExporter);
   }
   return _createClass(MySQLExporter, null, [{
+    key: "exportRecords",
+    value: function exportRecords(model) {
+      var records = Object.values(model.records || {});
+      if (_lodash["default"].isEmpty(records)) {
+        return [];
+      }
+      var insertStatements = records.map(function (record) {
+        var schemaName = record.schemaName,
+          tableName = record.tableName,
+          columns = record.columns,
+          values = record.values;
+
+        // Build the table reference with schema if present
+        var tableRef = schemaName ? "`".concat(schemaName, "`.`").concat(tableName, "`") : "`".concat(tableName, "`");
+
+        // Build the column list
+        var columnList = columns.length > 0 ? "(`".concat(columns.join('`, `'), "`)") : '';
+
+        // Value formatter for MySQL
+        var formatValue = function formatValue(val) {
+          if (val.value === null) return 'NULL';
+          if (val.type === 'expression') return val.value;
+          if ((0, _parse.isNumericType)(val.type)) return val.value;
+          if ((0, _parse.isBooleanType)(val.type)) return String(val.value).toUpperCase() === 'TRUE' ? 'TRUE' : 'FALSE';
+          if ((0, _parse.isStringType)(val.type) || (0, _parse.isBinaryType)(val.type) || (0, _parse.isDateTimeType)(val.type)) return "'".concat(val.value.replace(/'/g, "''").replace(/\\/g, '\\\\'), "'");
+          // Unknown type - use CAST
+          return "CAST('".concat(val.value.replace(/'/g, "''").replace(/\\/g, '\\\\'), "' AS ").concat(val.type, ")");
+        };
+
+        // Build the VALUES clause
+        var valueRows = values.map(function (row) {
+          var valueStrs = row.map(formatValue);
+          return "(".concat(valueStrs.join(', '), ")");
+        });
+        var valuesClause = valueRows.join(',\n  ');
+        return "INSERT INTO ".concat(tableRef, " ").concat(columnList, "\nVALUES\n  ").concat(valuesClause, ";");
+      });
+      return insertStatements;
+    }
+  }, {
     key: "getFieldLines",
     value: function getFieldLines(tableId, model) {
       var table = model.tables[tableId];
@@ -337,7 +378,12 @@ var MySQLExporter = /*#__PURE__*/function () {
         comments: [],
         refs: []
       });
-      var res = _lodash["default"].concat(statements.schemas, statements.enums, statements.tables, statements.indexes, statements.comments, statements.refs).join('\n');
+
+      // Export INSERT statements
+      // Note: MySQL does not support DEFERRED constraints, so foreign key checks are disabled
+      var insertStatements = MySQLExporter.exportRecords(model);
+      var recordsSection = !_lodash["default"].isEmpty(insertStatements) ? ['-- Disable foreign key checks for INSERT', 'SET FOREIGN_KEY_CHECKS = 0;', ''].concat(_toConsumableArray(insertStatements), ['', '-- Re-enable foreign key checks', 'SET FOREIGN_KEY_CHECKS = 1;']) : [];
+      var res = _lodash["default"].concat(statements.schemas, statements.enums, statements.tables, statements.indexes, statements.comments, statements.refs, recordsSection).join('\n');
       return res;
     }
   }]);

package/lib/export/OracleExporter.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports["default"] = void 0;
 var _lodash = _interopRequireDefault(require("lodash"));
 var _utils = require("./utils");
+var _parse = require("@dbml/parse");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
 function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
 function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
@@ -27,6 +28,50 @@ var OracleExporter = /*#__PURE__*/function () {
     _classCallCheck(this, OracleExporter);
   }
   return _createClass(OracleExporter, null, [{
+    key: "exportRecords",
+    value: function exportRecords(model) {
+      var records = Object.values(model.records || {});
+      if (_lodash["default"].isEmpty(records)) {
+        return [];
+      }
+      var insertStatements = records.map(function (record) {
+        var schemaName = record.schemaName,
+          tableName = record.tableName,
+          columns = record.columns,
+          values = record.values;
+
+        // Build the table reference with schema if present
+        var tableRef = schemaName ? "\"".concat(schemaName, "\".\"").concat(tableName, "\"") : "\"".concat(tableName, "\"");
+
+        // Build the column list
+        var columnList = columns.length > 0 ? "(\"".concat(columns.join('", "'), "\")") : '';
+        var formatValue = function formatValue(val) {
+          if (val.value === null) return 'NULL';
+          if (val.type === 'expression') return val.value;
+          if ((0, _parse.isNumericType)(val.type)) return val.value;
+          if ((0, _parse.isBooleanType)(val.type)) return String(val.value).toUpperCase() === 'TRUE' ? '1' : '0';
+          if ((0, _parse.isStringType)(val.type) || (0, _parse.isDateTimeType)(val.type)) return "'".concat(val.value.replace(/'/g, "''"), "'");
+          if ((0, _parse.isBinaryType)(val.type)) return "HEXTORAW('".concat(val.value, "')");
+          // Unknown type - use CAST
+          return "CAST('".concat(val.value.replace(/'/g, "''"), "' AS ").concat(val.type, ")");
+        };
+
+        // Build the INSERT ALL statement for multiple rows
+        if (values.length > 1) {
+          var intoStatements = values.map(function (row) {
+            var valueStrs = row.map(formatValue);
+            return "  INTO ".concat(tableRef, " ").concat(columnList, " VALUES (").concat(valueStrs.join(', '), ")");
+          });
+          return "INSERT ALL\n".concat(intoStatements.join('\n'), "\nSELECT * FROM dual;");
+        }
+
+        // Single row INSERT
+        var valueStrs = values[0].map(formatValue);
+        return "INSERT INTO ".concat(tableRef, " ").concat(columnList, "\nVALUES (").concat(valueStrs.join(', '), ");");
+      });
+      return insertStatements;
+    }
+  }, {
     key: "buildSchemaToTableNameSetMap",
     value: function buildSchemaToTableNameSetMap(model) {
       var schemaToTableNameSetMap = new Map();
@@ -225,7 +270,7 @@ var OracleExporter = /*#__PURE__*/function () {
     key: "buildForeignKeyManyToMany",
     value: function buildForeignKeyManyToMany(foreignEndpointTableName, foreignEndpointFields, refEndpointTableName, refEndpointFieldsString) {
       var foreignEndpointFieldsString = _toConsumableArray(foreignEndpointFields.keys()).join('`, `');
-      var line = "ALTER TABLE ".concat(foreignEndpointTableName, " ADD FOREIGN KEY (\"").concat(foreignEndpointFieldsString, "\") REFERENCES ").concat(refEndpointTableName, " ").concat(refEndpointFieldsString, ";\n");
+      var line = "ALTER TABLE ".concat(foreignEndpointTableName, " ADD FOREIGN KEY (\"").concat(foreignEndpointFieldsString, "\") REFERENCES ").concat(refEndpointTableName, " ").concat(refEndpointFieldsString, " DEFERRABLE INITIALLY IMMEDIATE;\n");
       return line;
     }
   }, {
@@ -269,7 +314,7 @@ var OracleExporter = /*#__PURE__*/function () {
           if (ref.onDelete) {
             line += " ON DELETE ".concat(ref.onDelete.toUpperCase());
           }
-          line += ';\n';
+          line += ' DEFERRABLE INITIALLY IMMEDIATE;\n';
           result.refs.push(line);
           return;
         }
@@ -482,7 +527,11 @@ var OracleExporter = /*#__PURE__*/function () {
         referenceGrants: [],
         refs: []
       });
-      var res = _lodash["default"].concat(statements.schemas, statements.tables, statements.indexes, statements.comments, statements.referenceGrants, statements.refs).join('\n');
+
+      // Export INSERT statements with constraint checking disabled
+      var insertStatements = this.exportRecords(model);
+      var recordsSection = !_lodash["default"].isEmpty(insertStatements) ? ['-- Disable constraint checking for INSERT', 'SET CONSTRAINTS ALL DEFERRED;', ''].concat(_toConsumableArray(insertStatements), ['', 'COMMIT;']) : [];
+      var res = _lodash["default"].concat(statements.schemas, statements.tables, statements.indexes, statements.comments, statements.referenceGrants, statements.refs, recordsSection).join('\n');
       return res;
     }
   }]);

package/lib/export/PostgresExporter.js

@@ -7,6 +7,7 @@ exports["default"] = void 0;
 var _lodash = _interopRequireDefault(require("lodash"));
 var _utils = require("./utils");
 var _utils2 = require("../model_structure/utils");
+var _parse = require("@dbml/parse");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
 function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
 function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
@@ -66,6 +67,53 @@ var PostgresExporter = /*#__PURE__*/function () {
     _classCallCheck(this, PostgresExporter);
   }
   return _createClass(PostgresExporter, null, [{
+    key: "exportRecords",
+    value: function exportRecords(model) {
+      var records = Object.values(model.records || {});
+      if (_lodash["default"].isEmpty(records)) {
+        return [];
+      }
+      var insertStatements = records.map(function (record) {
+        var schemaName = record.schemaName,
+          tableName = record.tableName,
+          columns = record.columns,
+          values = record.values;
+
+        // Skip if no values
+        if (!values || values.length === 0) {
+          return null;
+        }
+
+        // Build the table reference with schema if present
+        var tableRef = schemaName ? "\"".concat(schemaName, "\".\"").concat(tableName, "\"") : "\"".concat(tableName, "\"");
+
+        // Build the column list
+        var columnList = columns.length > 0 ? "(".concat(columns.map(function (col) {
+          return "\"".concat(col, "\"");
+        }).join(', '), ")") : '';
+
+        // Value formatter for PostgreSQL
+        var formatValue = function formatValue(val) {
+          if (val.value === null) return 'NULL';
+          if (val.type === 'expression') return val.value;
+          if ((0, _parse.isNumericType)(val.type)) return val.value;
+          if ((0, _parse.isBooleanType)(val.type)) return String(val.value).toUpperCase() === 'TRUE' ? 'TRUE' : 'FALSE';
+          if ((0, _parse.isStringType)(val.type) || (0, _parse.isDateTimeType)(val.type) || (0, _parse.isBinaryType)(val.type)) return "'".concat(String(val.value).replace(/'/g, "''"), "'");
+          // Unknown type - use CAST
+          return "CAST('".concat(String(val.value).replace(/'/g, "''"), "' AS ").concat(val.type, ")");
+        };
+
+        // Build the VALUES clause
+        var valueRows = values.map(function (row) {
+          var valueStrs = row.map(formatValue);
+          return "(".concat(valueStrs.join(', '), ")");
+        });
+        var valuesClause = valueRows.join(',\n  ');
+        return "INSERT INTO ".concat(tableRef, " ").concat(columnList, "\nVALUES\n  ").concat(valuesClause, ";");
+      }).filter(Boolean);
+      return insertStatements;
+    }
+  }, {
     key: "exportEnums",
     value: function exportEnums(enumIds, model) {
       return enumIds.map(function (enumId) {
@@ -451,7 +499,11 @@ var PostgresExporter = /*#__PURE__*/function () {
         }
         return prevStatements;
       }, schemaEnumStatements);
-      var res = _lodash["default"].concat(statements.schemas, statements.enums, statements.tables, statements.indexes, statements.comments, statements.refs).join('\n');
+
+      // Export INSERT statements with constraint checking disabled
+      var insertStatements = PostgresExporter.exportRecords(model);
+      var recordsSection = !_lodash["default"].isEmpty(insertStatements) ? ['-- Disable constraint checking for INSERT', 'BEGIN;', 'SET session_replication_role = replica;', ''].concat(_toConsumableArray(insertStatements), ['', 'SET session_replication_role = DEFAULT;', 'COMMIT;']) : [];
+      var res = _lodash["default"].concat(statements.schemas, statements.enums, statements.tables, statements.indexes, statements.comments, statements.refs, recordsSection).join('\n');
       return res;
     }
   }]);

package/lib/export/SqlServerExporter.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports["default"] = void 0;
 var _lodash = _interopRequireDefault(require("lodash"));
 var _utils = require("./utils");
+var _parse = require("@dbml/parse");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
 function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
 function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
@@ -24,6 +25,47 @@ var SqlServerExporter = /*#__PURE__*/function () {
     _classCallCheck(this, SqlServerExporter);
   }
   return _createClass(SqlServerExporter, null, [{
+    key: "exportRecords",
+    value: function exportRecords(model) {
+      var records = Object.values(model.records || {});
+      if (_lodash["default"].isEmpty(records)) {
+        return [];
+      }
+      var insertStatements = records.map(function (record) {
+        var schemaName = record.schemaName,
+          tableName = record.tableName,
+          columns = record.columns,
+          values = record.values;
+
+        // Build the table reference with schema if present
+        var tableRef = schemaName ? "[".concat(schemaName, "].[").concat(tableName, "]") : "[".concat(tableName, "]");
+
+        // Build the column list
+        var columnList = columns.length > 0 ? "([".concat(columns.join('], ['), "])") : '';
+
+        // Value formatter for SQL Server
+        var formatValue = function formatValue(val) {
+          if (val.value === null) return 'NULL';
+          if (val.type === 'expression') return val.value;
+          if ((0, _parse.isNumericType)(val.type)) return val.value;
+          if ((0, _parse.isBooleanType)(val.type)) return String(val.value).toUpperCase() === 'TRUE' ? '1' : '0';
+          if ((0, _parse.isStringType)(val.type) || (0, _parse.isDateTimeType)(val.type)) return "'".concat(val.value.replace(/'/g, "''"), "'");
+          if ((0, _parse.isBinaryType)(val.type)) return "0x".concat(val.value); // SQL Server binary as hex
+          // Unknown type - use CAST
+          return "CAST('".concat(val.value.replace(/'/g, "''"), "' AS ").concat(val.type, ")");
+        };
+
+        // Build the VALUES clause
+        var valueRows = values.map(function (row) {
+          var valueStrs = row.map(formatValue);
+          return "(".concat(valueStrs.join(', '), ")");
+        });
+        var valuesClause = valueRows.join(',\n  ');
+        return "INSERT INTO ".concat(tableRef, " ").concat(columnList, "\nVALUES\n  ").concat(valuesClause, ";\nGO");
+      });
+      return insertStatements;
+    }
+  }, {
     key: "getFieldLines",
     value: function getFieldLines(tableId, model) {
       var table = model.tables[tableId];
@@ -364,7 +406,12 @@ var SqlServerExporter = /*#__PURE__*/function () {
         comments: [],
         refs: []
       });
-      var res = _lodash["default"].concat(statements.schemas, statements.enums, statements.tables, statements.indexes, statements.comments, statements.refs).join('\n');
+
+      // Export INSERT statements
+      // Note: SQL Server does not support DEFERRED constraints, so constraint checks are disabled
+      var insertStatements = SqlServerExporter.exportRecords(model);
+      var recordsSection = !_lodash["default"].isEmpty(insertStatements) ? ['-- Disable constraint checks for INSERT', 'EXEC sp_MSforeachtable "ALTER TABLE ? NOCHECK CONSTRAINT all";', 'GO', ''].concat(_toConsumableArray(insertStatements), ['', '-- Re-enable constraint checks', 'EXEC sp_MSforeachtable "ALTER TABLE ? WITH CHECK CHECK CONSTRAINT all";', 'GO']) : [];
+      var res = _lodash["default"].concat(statements.schemas, statements.enums, statements.tables, statements.indexes, statements.comments, statements.refs, recordsSection).join('\n');
       return res;
     }
   }]);

package/lib/index.js

@@ -21,30 +21,132 @@ Object.defineProperty(exports, "Parser", {
     return _Parser["default"];
   }
 });
+Object.defineProperty(exports, "SqlDialect", {
+  enumerable: true,
+  get: function get() {
+    return _parse.SqlDialect;
+  }
+});
 Object.defineProperty(exports, "VERSION", {
   enumerable: true,
   get: function get() {
     return _version.VERSION;
   }
 });
+Object.defineProperty(exports, "addDoubleQuoteIfNeeded", {
+  enumerable: true,
+  get: function get() {
+    return _parse.addDoubleQuoteIfNeeded;
+  }
+});
 Object.defineProperty(exports, "exporter", {
   enumerable: true,
   get: function get() {
     return _export["default"];
   }
 });
+Object.defineProperty(exports, "formatRecordValue", {
+  enumerable: true,
+  get: function get() {
+    return _parse.formatRecordValue;
+  }
+});
 Object.defineProperty(exports, "importer", {
   enumerable: true,
   get: function get() {
     return _import["default"];
   }
 });
+Object.defineProperty(exports, "isBinaryType", {
+  enumerable: true,
+  get: function get() {
+    return _parse.isBinaryType;
+  }
+});
+Object.defineProperty(exports, "isBooleanType", {
+  enumerable: true,
+  get: function get() {
+    return _parse.isBooleanType;
+  }
+});
+Object.defineProperty(exports, "isDateTimeType", {
+  enumerable: true,
+  get: function get() {
+    return _parse.isDateTimeType;
+  }
+});
+Object.defineProperty(exports, "isFloatType", {
+  enumerable: true,
+  get: function get() {
+    return _parse.isFloatType;
+  }
+});
+Object.defineProperty(exports, "isIntegerType", {
+  enumerable: true,
+  get: function get() {
+    return _parse.isIntegerType;
+  }
+});
+Object.defineProperty(exports, "isNumericType", {
+  enumerable: true,
+  get: function get() {
+    return _parse.isNumericType;
+  }
+});
+Object.defineProperty(exports, "isSerialType", {
+  enumerable: true,
+  get: function get() {
+    return _parse.isSerialType;
+  }
+});
+Object.defineProperty(exports, "isStringType", {
+  enumerable: true,
+  get: function get() {
+    return _parse.isStringType;
+  }
+});
 Object.defineProperty(exports, "renameTable", {
   enumerable: true,
   get: function get() {
     return _transform.renameTable;
   }
 });
+Object.defineProperty(exports, "tryExtractBoolean", {
+  enumerable: true,
+  get: function get() {
+    return _parse.tryExtractBoolean;
+  }
+});
+Object.defineProperty(exports, "tryExtractDateTime", {
+  enumerable: true,
+  get: function get() {
+    return _parse.tryExtractDateTime;
+  }
+});
+Object.defineProperty(exports, "tryExtractEnum", {
+  enumerable: true,
+  get: function get() {
+    return _parse.tryExtractEnum;
+  }
+});
+Object.defineProperty(exports, "tryExtractInteger", {
+  enumerable: true,
+  get: function get() {
+    return _parse.tryExtractInteger;
+  }
+});
+Object.defineProperty(exports, "tryExtractNumeric", {
+  enumerable: true,
+  get: function get() {
+    return _parse.tryExtractNumeric;
+  }
+});
+Object.defineProperty(exports, "tryExtractString", {
+  enumerable: true,
+  get: function get() {
+    return _parse.tryExtractString;
+  }
+});
 var _ModelExporter = _interopRequireDefault(require("./export/ModelExporter"));
 var _Parser = _interopRequireDefault(require("./parse/Parser"));
 var _error = require("./parse/error");
@@ -52,4 +154,5 @@ var _import = _interopRequireDefault(require("./import"));
 var _export = _interopRequireDefault(require("./export"));
 var _transform = require("./transform");
 var _version = require("./utils/version");
+var _parse = require("@dbml/parse");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }

package/lib/parse/ANTLR/ASTGeneration/mssql/MssqlASTGen.js

@@ -37,6 +37,7 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
 function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
 function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
 var ADD_DESCRIPTION_FUNCTION_NAME = 'sp_addextendedproperty';
+var DEFAULT_SCHEMA = 'dbo';
 var getSchemaAndTableName = function getSchemaAndTableName(names) {
   var tableName = (0, _lodash.last)(names);
   var schemaName = names.length > 1 ? (0, _lodash.nth)(names, -2) : undefined;
@@ -138,13 +139,23 @@ var MssqlASTGen = exports["default"] = /*#__PURE__*/function (_TSqlParserVisitor
     };
     return _this;
   }
-
-  // tsql_file
-  //   : batch* EOF
-  //   | execute_body_batch go_statement* EOF
-  //   ;
   _inherits(MssqlASTGen, _TSqlParserVisitor);
   return _createClass(MssqlASTGen, [{
+    key: "findTable",
+    value: function findTable(schemaName, tableName) {
+      var realSchemaName = schemaName || DEFAULT_SCHEMA;
+      var table = this.data.tables.find(function (t) {
+        var targetSchemaName = t.schemaName || DEFAULT_SCHEMA;
+        return targetSchemaName === realSchemaName && t.name === tableName;
+      });
+      return table;
+    }
+
+    // tsql_file
+    //   : batch* EOF
+    //   | execute_body_batch go_statement* EOF
+    //   ;
+  }, {
     key: "visitTsql_file",
     value: function visitTsql_file(ctx) {
       var _this2 = this;
@@ -219,6 +230,7 @@ var MssqlASTGen = exports["default"] = /*#__PURE__*/function (_TSqlParserVisitor
   }, {
     key: "visitInsert_statement",
     value: function visitInsert_statement(ctx) {
+      var _this$findTable;
       // [ 'users' ]
       // [ 'test', 'users' ]
       // [ 'db', 'test', 'users' ]
@@ -228,7 +240,9 @@ var MssqlASTGen = exports["default"] = /*#__PURE__*/function (_TSqlParserVisitor
       var names = ctx.ddl_object().accept(this);
       var tableName = (0, _lodash.last)(names);
       var schemaName = names.length > 1 ? (0, _lodash.nth)(names, -2) : undefined;
-      var columns = ctx.insert_column_name_list() ? ctx.insert_column_name_list().accept(this) : [];
+      var columns = ctx.insert_column_name_list() ? ctx.insert_column_name_list().accept(this) : ((_this$findTable = this.findTable(schemaName, tableName)) === null || _this$findTable === void 0 ? void 0 : _this$findTable.fields.map(function (field) {
+        return field.name;
+      })) || [];
       var values = ctx.insert_statement_value().accept(this);
       var record = new _AST.TableRecord({
         tableName: tableName,
@@ -1335,7 +1349,7 @@ var MssqlASTGen = exports["default"] = /*#__PURE__*/function (_TSqlParserVisitor
         // https://learn.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-addextendedproperty-transact-sql?view=sql-server-ver16#----level0type
         var level0Type = argsObj.level0type.toLowerCase();
         if (!level0Type.includes('schema')) return;
-        var schemaName = argsObj.level0name !== 'dbo' ? argsObj.level0name : undefined;
+        var schemaName = argsObj.level0name !== DEFAULT_SCHEMA ? argsObj.level0name : undefined;
         var level1Type = argsObj.level1type.toLowerCase();
         var tableName = level1Type.includes('table') ? argsObj.level1name : null;
         var table = this.data.tables.find(function (t) {

package/lib/parse/ANTLR/ASTGeneration/mysql/MySQLASTGen.js

@@ -1226,12 +1226,15 @@ var MySQLASTGen = exports["default"] = /*#__PURE__*/function (_MySQLParserVisito
   }, {
     key: "visitInsertStatement",
     value: function visitInsertStatement(ctx) {
+      var _this$findTable;
       var names = ctx.tableName().accept(this);
       var tableName = (0, _lodash.last)(names);
       var schemaName = names.length > 1 ? names[names.length - 2] : undefined;
 
-      // insert without specified columns
-      var columns = ctx.fullColumnNameList() ? ctx.fullColumnNameList().accept(this) : [];
+      // Get explicit columns if specified, otherwise lookup table definition
+      var columns = ctx.fullColumnNameList() ? ctx.fullColumnNameList().accept(this) : ((_this$findTable = this.findTable(schemaName, tableName)) === null || _this$findTable === void 0 ? void 0 : _this$findTable.fields.map(function (field) {
+        return field.name;
+      })) || [];
       var values = ctx.insertStatementValue().accept(this);
       var record = new _AST.TableRecord({
         schemaName: schemaName,

package/lib/parse/ANTLR/ASTGeneration/oraclesql/OracleSQLASTGen.js

@@ -989,13 +989,15 @@ var OracleSqlASTGen = exports["default"] = /*#__PURE__*/function (_OracleSqlPars
     }
 
     // insert_statement
-    //   : INSERT (single_table_insert | <other rules>)
+    //   : INSERT (single_table_insert | multi_table_insert)
     //   ;
   }, {
     key: "visitInsert_statement",
     value: function visitInsert_statement(ctx) {
       if (ctx.single_table_insert()) {
         ctx.single_table_insert().accept(this);
+      } else if (ctx.multi_table_insert()) {
+        ctx.multi_table_insert().accept(this);
       }
     }
 
@@ -1022,18 +1024,97 @@ var OracleSqlASTGen = exports["default"] = /*#__PURE__*/function (_OracleSqlPars
       }
     }
 
+    // multi_table_insert
+    //   : (ALL multi_table_element+ | conditional_insert_clause) select_statement
+    //   ;
+  }, {
+    key: "visitMulti_table_insert",
+    value: function visitMulti_table_insert(ctx) {
+      var _this14 = this;
+      if (!ctx.multi_table_element()) {
+        // conditional_insert_clause is not supported yet
+        return;
+      }
+
+      // Collect all insert elements from INSERT ALL statement
+      var elements = ctx.multi_table_element().map(function (element) {
+        return element.accept(_this14);
+      }).filter(Boolean);
+
+      // Group elements by table, schema, and columns to combine multiple rows into single records
+      var recordsMap = new Map();
+      elements.forEach(function (element) {
+        var tableName = element.tableName,
+          schemaName = element.schemaName,
+          columns = element.columns,
+          values = element.values;
+        var key = "".concat(schemaName || '', ".").concat(tableName, ".").concat(columns.join(','));
+        if (recordsMap.has(key)) {
+          var _recordsMap$get$value;
+          // Same table and columns - append values to existing record
+          (_recordsMap$get$value = recordsMap.get(key).values).push.apply(_recordsMap$get$value, _toConsumableArray(values));
+        } else {
+          // New combination - create new record entry
+          recordsMap.set(key, {
+            tableName: tableName,
+            schemaName: schemaName,
+            columns: columns,
+            values: values
+          });
+        }
+      });
+
+      // Create TableRecord objects for each unique table/column combination
+      recordsMap.forEach(function (recordData) {
+        var record = new _AST.TableRecord({
+          schemaName: recordData.schemaName,
+          tableName: recordData.tableName,
+          columns: recordData.columns,
+          values: recordData.values
+        });
+        _this14.data.records.push(record);
+      });
+    }
+
+    // multi_table_element
+    //   : insert_into_clause values_clause? error_logging_clause?
+    //   ;
+  }, {
+    key: "visitMulti_table_element",
+    value: function visitMulti_table_element(ctx) {
+      var _ctx$values_clause;
+      var intoClause = ctx.insert_into_clause().accept(this);
+      var valuesClause = (_ctx$values_clause = ctx.values_clause()) === null || _ctx$values_clause === void 0 ? void 0 : _ctx$values_clause.accept(this);
+      if (intoClause && valuesClause) {
+        var tableName = intoClause.tableName,
+          schemaName = intoClause.schemaName,
+          columns = intoClause.columns;
+        var values = valuesClause.values;
+        return {
+          tableName: tableName,
+          schemaName: schemaName,
+          columns: columns,
+          values: values
+        };
+      }
+      return null;
+    }
+
     // insert_into_clause
     //   : INTO general_table_ref paren_column_list?
     //   ;
   }, {
     key: "visitInsert_into_clause",
     value: function visitInsert_into_clause(ctx) {
+      var _findTable;
       var names = ctx.general_table_ref().accept(this);
       var tableName = (0, _lodash.last)(names);
       var schemaName = names.length > 1 ? names[names.length - 2] : undefined;
       var columns = ctx.paren_column_list() ? ctx.paren_column_list().accept(this).map(function (c) {
         return (0, _lodash.last)(c);
-      }) : [];
+      }) : (_findTable = findTable(this.data.tables, schemaName, tableName)) === null || _findTable === void 0 ? void 0 : _findTable.fields.map(function (field) {
+        return field.name;
+      });
       return {
         tableName: tableName,
         schemaName: schemaName,
@@ -1078,9 +1159,9 @@ var OracleSqlASTGen = exports["default"] = /*#__PURE__*/function (_OracleSqlPars
   }, {
     key: "visitExpressions_",
     value: function visitExpressions_(ctx) {
-      var _this14 = this;
+      var _this15 = this;
       return ctx.expression().map(function (e) {
-        return e.accept(_this14);
+        return e.accept(_this15);
       });
     }
   }, {

package/lib/parse/ANTLR/ASTGeneration/oraclesql/README.md

@@ -177,13 +177,13 @@ This module provides SQL parsing capabilities for Oracle databases, enabling con
 | Feature | Status | Notes |
 |---------|---------|-------|
 | Basic `INSERT` ... VALUES | ✓ | `INSERT INTO t (col) VALUES (1)` |
-| Multi-row `INSERT` | — | Oracle uses `INSERT ALL` syntax |
+| Multi-row `INSERT` | ✓ | Supported via `INSERT ALL` syntax |
 | `INSERT` ... SELECT | ✗ | Subquery as data source |
 | WITH clause (CTE) | ✗ | CTE before `INSERT` |
 | Target table alias | ✗ | `INSERT INTO t alias ...` |
 | `INSERT` ... RETURNING | ◐ | Returns inserted rows - clause is ignored |
-| `INSERT ALL` (multi-table insert) | ✗ | Oracle-specific multi-table insert |
-| Conditional `INSERT` (WHEN/FIRST/ALL) | ✗ | Oracle syntax for conditional inserts |
+| `INSERT ALL` (multi-table insert) | ✓ | Oracle-specific multi-table insert - fully supported |
+| Conditional `INSERT` (WHEN/FIRST/ALL) | ◐ | Conditional inserts with WHEN clauses not yet supported |
 | `INSERT` OVERWRITE | — | Snowflake/Hive syntax - not valid in Oracle |
 
 ---
@@ -243,7 +243,7 @@ This module provides SQL parsing capabilities for Oracle databases, enabling con
 ## Known Limitations
 
 - **`ON UPDATE` for `FOREIGN KEY`**: Oracle does not support `ON UPDATE` actions for foreign keys; only `ON DELETE` is available
-- **Multi-row `INSERT`**: Oracle uses `INSERT ALL` syntax which is not currently supported
+- **Conditional `INSERT ALL`**: Basic `INSERT ALL` is fully supported, but conditional inserts with WHEN/FIRST clauses are not yet supported
 - **DDL modification statements**: `DROP TABLE`, `DROP INDEX`, `ALTER INDEX` not supported
 - **`INSERT` ... SELECT**: Subqueries in `INSERT` statements not supported
 - **`CREATE VIEW`**: View definitions are not parsed
@@ -257,5 +257,5 @@ This module provides SQL parsing capabilities for Oracle databases, enabling con
 3. **Function-based Indexes**: Oracle's function-based indexes (e.g., `CREATE INDEX ON t (UPPER(col))`) are fully supported
 4. **`ON DELETE` Only**: Oracle foreign keys only support `ON DELETE` actions (`CASCADE`, `SET NULL`, `NO ACTION`). There is no `ON UPDATE` support
 5. **Comments**: Use `COMMENT ON TABLE/COLUMN` statements. These are separate DDL statements, not inline with `CREATE TABLE`
-6. **No Multi-row `INSERT`**: Oracle uses `INSERT ALL ... SELECT` syntax for multi-row inserts, which differs from other databases
+6. **`INSERT ALL` Support**: Oracle's `INSERT ALL ... SELECT * FROM dual` syntax for multi-row and multi-table inserts is fully supported. Rows with the same table and columns are automatically grouped together. Conditional inserts with WHEN clauses are not yet supported
 7. **`VARCHAR2`**: Oracle uses `VARCHAR2` (not `VARCHAR`) as the standard variable-length string type

package/lib/parse/ANTLR/ASTGeneration/postgres/PostgresASTGen.js

@@ -1230,6 +1230,16 @@ var PostgresASTGen = exports["default"] = /*#__PURE__*/function (_PostgreSQLPars
       var _ctx$insert_rest$acce = ctx.insert_rest().accept(this),
         columns = _ctx$insert_rest$acce.columns,
         values = _ctx$insert_rest$acce.values;
+
+      // When no columns are specified, lookup table and use all its columns
+      if (columns.length === 0) {
+        var table = findTable(this.data.tables, schemaName, tableName);
+        if (table && table.fields) {
+          columns = table.fields.map(function (field) {
+            return field.name;
+          });
+        }
+      }
       var record = new _AST.TableRecord({
         schemaName: schemaName,
         tableName: tableName,

package/lib/parse/ANTLR/ASTGeneration/snowflake/SnowflakeASTGen.js

@@ -33,6 +33,7 @@ function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.
 function _getPrototypeOf(t) { return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, _getPrototypeOf(t); }
 function _inherits(t, e) { if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function"); t.prototype = Object.create(e && e.prototype, { constructor: { value: t, writable: !0, configurable: !0 } }), Object.defineProperty(t, "prototype", { writable: !1 }), e && _setPrototypeOf(t, e); }
 function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
+var DEFAULT_SCHEMA = 'public';
 var sanitizeComment = function sanitizeComment(stringContext) {
   return (0, _helpers.getOriginalText)(stringContext).replace(/''/g, "'").slice(1, -1);
 };
@@ -48,14 +49,25 @@ var SnowflakeASTGen = exports["default"] = /*#__PURE__*/function (_SnowflakePars
       enums: [],
       tableGroups: [],
       aliases: [],
-      project: {}
+      project: {},
+      records: []
     };
     return _this;
   }
-
-  // batch? EOF
   _inherits(SnowflakeASTGen, _SnowflakeParserVisit);
   return _createClass(SnowflakeASTGen, [{
+    key: "findTable",
+    value: function findTable(schemaName, tableName) {
+      var realSchemaName = schemaName || DEFAULT_SCHEMA;
+      var table = this.data.tables.find(function (t) {
+        var targetSchemaName = t.schemaName || DEFAULT_SCHEMA;
+        return targetSchemaName === realSchemaName && t.name === tableName;
+      });
+      return table;
+    }
+
+    // batch? EOF
+  }, {
     key: "visitSnowflake_file",
     value: function visitSnowflake_file(ctx) {
       var _ctx$batch;
@@ -79,6 +91,8 @@ var SnowflakeASTGen = exports["default"] = /*#__PURE__*/function (_SnowflakePars
     value: function visitSql_command(ctx) {
       if (ctx.ddl_command()) {
         ctx.ddl_command().accept(this);
+      } else if (ctx.dml_command()) {
+        ctx.dml_command().accept(this);
       }
     }
 
@@ -93,6 +107,22 @@ var SnowflakeASTGen = exports["default"] = /*#__PURE__*/function (_SnowflakePars
       }
     }
 
+    // dml_command
+    //   : query_statement
+    //   | insert_statement
+    //   | insert_multi_table_statement
+    //   | update_statement
+    //   | delete_statement
+    //   | merge_statement
+    //   ;
+  }, {
+    key: "visitDml_command",
+    value: function visitDml_command(ctx) {
+      if (ctx.insert_statement()) {
+        ctx.insert_statement().accept(this);
+      }
+    }
+
     // check SnowflakeParser.g4 line 1442
   }, {
     key: "visitCreate_command",
@@ -171,7 +201,7 @@ var SnowflakeASTGen = exports["default"] = /*#__PURE__*/function (_SnowflakePars
         var field = fieldData.field,
           inlineRefs = fieldData.inlineRefs;
         if (((_field$type$type_name = field.type.type_name) === null || _field$type$type_name === void 0 ? void 0 : _field$type$type_name.toLowerCase()) === 'enum') {
-          var _values = field.type.args.map(function (arg) {
+          var values = field.type.args.map(function (arg) {
             var newValue = arg.replace(/'|"|`/g, '').trim();
             return {
               name: newValue
@@ -180,7 +210,7 @@ var SnowflakeASTGen = exports["default"] = /*#__PURE__*/function (_SnowflakePars
           var _enum = new _AST.Enum({
             name: "".concat(tableName, "_").concat(field.name, "_enum"),
             schemaName: schemaName,
-            values: _values
+            values: values
           });
           field.type.type_name = _enum.name;
           field.type.schemaName = _enum.schemaName;
@@ -743,5 +773,60 @@ var SnowflakeASTGen = exports["default"] = /*#__PURE__*/function (_SnowflakePars
       }
       return null;
     }
+
+    // insert_statement
+    //   : INSERT OVERWRITE? INTO object_name column_list_in_parentheses? (
+    //       values_builder
+    //       | query_statement
+    //   )
+    //   ;
+  }, {
+    key: "visitInsert_statement",
+    value: function visitInsert_statement(ctx) {
+      var _this$findTable;
+      var _ctx$object_name$acce7 = ctx.object_name().accept(this),
+        _ctx$object_name$acce8 = _slicedToArray(_ctx$object_name$acce7, 3),
+        databaseName = _ctx$object_name$acce8[0],
+        schemaName = _ctx$object_name$acce8[1],
+        tableName = _ctx$object_name$acce8[2];
+      var columns = ctx.column_list_in_parentheses() ? ctx.column_list_in_parentheses().accept(this) : ((_this$findTable = this.findTable(schemaName, tableName)) === null || _this$findTable === void 0 ? void 0 : _this$findTable.fields.map(function (field) {
+        return field.name;
+      })) || [];
+
+      // Only handle values_builder, not query_statement
+      var values = ctx.values_builder() ? ctx.values_builder().accept(this) : [];
+      var record = new _AST.TableRecord({
+        schemaName: schemaName,
+        tableName: tableName,
+        columns: columns,
+        values: values
+      });
+      this.data.records.push(record);
+    }
+
+    // values_builder
+    //   : VALUES '(' expr_list ')' (COMMA '(' expr_list ')')?
+    //   ;
+  }, {
+    key: "visitValues_builder",
+    value: function visitValues_builder(ctx) {
+      var _this0 = this;
+      return ctx.expr_list().map(function (exprList) {
+        var rowValues = exprList.accept(_this0);
+        return (0, _lodash.flattenDepth)(rowValues, 1);
+      });
+    }
+
+    // expr_list
+    //   : expr (COMMA expr)*
+    //   ;
+  }, {
+    key: "visitExpr_list",
+    value: function visitExpr_list(ctx) {
+      var _this1 = this;
+      return ctx.expr().map(function (expr) {
+        return expr.accept(_this1);
+      });
+    }
   }]);
 }(_SnowflakeParserVisitor["default"]);

package/lib/parse/ANTLR/parsers/mysql/MySqlLexerBase.js

@@ -45,7 +45,7 @@ var MySqlLexerBase = exports["default"] = /*#__PURE__*/function (_antlr4$Lexer)
     key: "nextToken",
     value: function nextToken() {
       // See the comment above HIGH_PRIORITY_MODE in the Lexer grammar G4 file
-      this.mode(MySqlLexerBase.DEFAULT_MODE); // always start in DEFAULT_MODE, which will automatically switch to high priority mode
+      this.setMode(MySqlLexerBase.DEFAULT_MODE); // always start in DEFAULT_MODE, which will automatically switch to high priority mode
       return _superPropGet(MySqlLexerBase, "nextToken", this, 3)([]);
     }
   }]);

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@dbml/core",
-  "version": "6.1.0",
+  "version": "6.2.0-alpha.0",
   "description": "> TODO: description",
   "author": "Holistics <dev@holistics.io>",
   "license": "Apache-2.0",
@@ -36,7 +36,7 @@
     "lint:fix": "eslint --fix ."
   },
   "dependencies": {
-    "@dbml/parse": "^6.1.0",
+    "@dbml/parse": "^6.2.0-alpha.0",
     "antlr4": "^4.13.1",
     "lodash": "^4.17.15",
     "parsimmon": "^1.13.0",
@@ -63,7 +63,7 @@
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.46.3"
   },
-  "gitHead": "4897a3e1f59dd9eed89ee4a9f945b4e740e9bc0a",
+  "gitHead": "00865dc46e1cbab39233ad010c6b5e120131476c",
   "engines": {
     "node": ">=16"
   }

package/types/export/index.d.ts

@@ -1,4 +1,5 @@
 import { ExportFormatOption } from './ModelExporter';
+import { RecordValueType } from '../model_structure/database';
 
 declare function _export(str: string, format: ExportFormatOption): string;
 declare const _default: {

package/types/index.d.ts

@@ -2,8 +2,16 @@ import ModelExporter from './export/ModelExporter';
 import Parser from './parse/Parser';
 import importer from './import';
 import exporter from './export';
-import { renameTable } from './transform';
-export { renameTable, importer, exporter, ModelExporter, Parser };
+import {
+  renameTable,
+} from './transform';
+export {
+  renameTable,
+  importer,
+  exporter,
+  ModelExporter,
+  Parser,
+};
 export { CompilerDiagnostic, CompilerError as CompilerDiagnostics, EditorPosition, ErrorCode, WarningLevel, } from './parse/error';
 
 // Export normalized types
@@ -43,3 +51,23 @@ export type {
     NormalizedRecords,
     RawSchema,
 } from './model_structure';
+export { RecordValueType, RecordValue } from './model_structure/database';
+export {
+  SqlDialect,
+  isIntegerType,
+  isFloatType,
+  isNumericType,
+  isBooleanType,
+  isStringType,
+  isBinaryType,
+  isDateTimeType,
+  isSerialType,
+  tryExtractBoolean,
+  tryExtractNumeric,
+  tryExtractInteger,
+  tryExtractString,
+  tryExtractDateTime,
+  tryExtractEnum,
+  addDoubleQuoteIfNeeded,
+  formatRecordValue,
+} from '@dbml/parse';

package/types/model_structure/database.d.ts

@@ -19,13 +19,20 @@ export interface Project {
     name: string;
 }
 
-interface RawTableRecord {
+export type RecordValueType = 'string' | 'bool' | 'integer' | 'real' | 'date' | 'time' | 'datetime' | string;
+
+export interface RecordValue {
+    value: any;
+    type: RecordValueType;
+}
+
+export interface RawTableRecord {
     schemaName: string | undefined;
     tableName: string;
     columns: string[];
     values: {
         value: any;
-        type: string;
+        type: RecordValueType;
     }[][];
 }
 

package/types/model_structure/endpoint.d.ts

@@ -3,6 +3,16 @@ import Field from './field';
 import Ref from './ref';
 import DbState from './dbState';
 import { NormalizedModel } from './database';
+import { Token } from 'antlr4';
+
+export interface RawEndpoint {
+    schemaName: string | null;
+    tableName: string;
+    fieldNames: string[];
+    relation: '1' | '*';
+    token: Token;
+}
+
 declare class Endpoint extends Element {
     relation: any;
     schemaName: string;

package/types/model_structure/stickyNote.d.ts

@@ -2,13 +2,15 @@ import Element, { Token } from './element';
 import Database from './database';
 import DbState from './dbState';
 import { NormalizedModel } from './database';
-interface RawStickyNote {
+
+export interface RawStickyNote {
     name: string;
     content: string;
     database: Database;
     token: Token;
     headerColor: string;
 }
+
 declare class StickyNote extends Element {
     name: string;
     content: string;