metal-orm 1.0.45 → 1.0.47

package/src/core/ddl/dialects/sqlite-schema-dialect.ts

@@ -1,7 +1,7 @@
 import { BaseSchemaDialect } from './base-schema-dialect.js';
 import { deriveIndexName } from '../naming-strategy.js';
 import { renderIndexColumns, resolvePrimaryKey, createLiteralFormatter } from '../sql-writing.js';
-import { ColumnDef } from '../../../schema/column.js';
+import { ColumnDef, normalizeColumnType, renderTypeWithArgs } from '../../../schema/column-types.js';
 import { IndexDef, TableDef } from '../../../schema/table.js';
 import { ColumnDiff, DatabaseColumn, DatabaseTable } from '../schema-types.js';
 import { DialectName } from '../schema-dialect.js';
@@ -24,52 +24,37 @@ export class SQLiteSchemaDialect extends BaseSchemaDialect {
   }
 
   renderColumnType(column: ColumnDef): string {
-    switch (column.type) {
-      case 'INT':
-      case 'INTEGER':
+    const override = column.dialectTypes?.[this.name] ?? column.dialectTypes?.default;
+    if (override) {
+      return renderTypeWithArgs(override, column.args);
+    }
+
+    const type = normalizeColumnType(column.type);
+    switch (type) {
       case 'int':
       case 'integer':
-      case 'BIGINT':
       case 'bigint':
         return 'INTEGER';
-      case 'BOOLEAN':
       case 'boolean':
         return 'INTEGER';
-      case 'DECIMAL':
       case 'decimal':
-      case 'FLOAT':
       case 'float':
-      case 'DOUBLE':
       case 'double':
         return 'REAL';
-      case 'DATE':
       case 'date':
-      case 'DATETIME':
       case 'datetime':
-      case 'TIMESTAMP':
       case 'timestamp':
-      case 'TIMESTAMPTZ':
       case 'timestamptz':
         return 'TEXT';
-      case 'VARCHAR':
       case 'varchar':
-      case 'TEXT':
       case 'text':
-      case 'JSON':
       case 'json':
-      case 'UUID':
       case 'uuid':
-        return 'TEXT';
-      case 'ENUM':
       case 'enum':
         return 'TEXT';
-      case 'BINARY':
       case 'binary':
-      case 'VARBINARY':
       case 'varbinary':
-      case 'BLOB':
       case 'blob':
-      case 'BYTEA':
       case 'bytea':
         return 'BLOB';
       default:
@@ -134,3 +119,4 @@ export class SQLiteSchemaDialect extends BaseSchemaDialect {
     return `SQLite ALTER COLUMN is not supported; rebuild table ${key} to change column ${column.name}.`;
   }
 }
+

package/src/core/ddl/introspect/catalogs/index.ts

@@ -1,2 +1,5 @@
-/** Re-exports for PostgreSQL catalog definitions. */
+/** Re-exports for supported catalog definitions. */
 export * from './postgres.js';
+export * from './mssql.js';
+export * from './mysql.js';
+export * from './sqlite.js';

package/src/core/ddl/introspect/catalogs/mssql.ts

@@ -0,0 +1,126 @@
+import { defineTable } from '../../../../schema/table.js';
+import { col } from '../../../../schema/column-types.js';
+
+/** Table definitions for SQL Server catalog views used during introspection. */
+export const SysColumns = defineTable(
+  'columns',
+  {
+    object_id: col.int(),
+    name: col.varchar(255),
+    column_id: col.int(),
+    max_length: col.int(),
+    precision: col.int(),
+    scale: col.int(),
+    is_nullable: col.boolean(),
+    is_identity: col.boolean(),
+    default_object_id: col.int(),
+    user_type_id: col.int()
+  },
+  {},
+  undefined,
+  { schema: 'sys' }
+);
+
+export const SysTables = defineTable(
+  'tables',
+  {
+    object_id: col.int(),
+    name: col.varchar(255),
+    schema_id: col.int(),
+    is_ms_shipped: col.boolean()
+  },
+  {},
+  undefined,
+  { schema: 'sys' }
+);
+
+export const SysSchemas = defineTable(
+  'schemas',
+  {
+    schema_id: col.int(),
+    name: col.varchar(255)
+  },
+  {},
+  undefined,
+  { schema: 'sys' }
+);
+
+export const SysTypes = defineTable(
+  'types',
+  {
+    user_type_id: col.int(),
+    name: col.varchar(255)
+  },
+  {},
+  undefined,
+  { schema: 'sys' }
+);
+
+export const SysIndexes = defineTable(
+  'indexes',
+  {
+    object_id: col.int(),
+    index_id: col.int(),
+    name: col.varchar(255),
+    is_primary_key: col.boolean(),
+    is_unique: col.boolean(),
+    has_filter: col.boolean(),
+    filter_definition: col.varchar(1024),
+    is_hypothetical: col.boolean()
+  },
+  {},
+  undefined,
+  { schema: 'sys' }
+);
+
+export const SysIndexColumns = defineTable(
+  'index_columns',
+  {
+    object_id: col.int(),
+    index_id: col.int(),
+    column_id: col.int(),
+    key_ordinal: col.int()
+  },
+  {},
+  undefined,
+  { schema: 'sys' }
+);
+
+export const SysForeignKeys = defineTable(
+  'foreign_keys',
+  {
+    object_id: col.int(),
+    name: col.varchar(255),
+    delete_referential_action_desc: col.varchar(64),
+    update_referential_action_desc: col.varchar(64)
+  },
+  {},
+  undefined,
+  { schema: 'sys' }
+);
+
+export const SysForeignKeyColumns = defineTable(
+  'foreign_key_columns',
+  {
+    constraint_object_id: col.int(),
+    parent_object_id: col.int(),
+    parent_column_id: col.int(),
+    referenced_object_id: col.int(),
+    referenced_column_id: col.int(),
+    constraint_column_id: col.int()
+  },
+  {},
+  undefined,
+  { schema: 'sys' }
+);
+
+export default {
+  SysColumns,
+  SysTables,
+  SysSchemas,
+  SysTypes,
+  SysIndexes,
+  SysIndexColumns,
+  SysForeignKeys,
+  SysForeignKeyColumns
+};

package/src/core/ddl/introspect/catalogs/mysql.ts

@@ -0,0 +1,89 @@
+import { defineTable } from '../../../../schema/table.js';
+import { col } from '../../../../schema/column-types.js';
+
+const INFORMATION_SCHEMA = 'information_schema';
+
+export const InformationSchemaTables = defineTable(
+  'tables',
+  {
+    table_schema: col.varchar(255),
+    table_name: col.varchar(255),
+    table_comment: col.varchar(1024)
+  },
+  {},
+  undefined,
+  { schema: INFORMATION_SCHEMA }
+);
+
+export const InformationSchemaColumns = defineTable(
+  'columns',
+  {
+    table_schema: col.varchar(255),
+    table_name: col.varchar(255),
+    column_name: col.varchar(255),
+    column_type: col.varchar(255),
+    data_type: col.varchar(255),
+    is_nullable: col.varchar(3),
+    column_default: col.varchar(1024),
+    extra: col.varchar(255),
+    column_comment: col.varchar(1024),
+    ordinal_position: col.int()
+  },
+  {},
+  undefined,
+  { schema: INFORMATION_SCHEMA }
+);
+
+export const InformationSchemaKeyColumnUsage = defineTable(
+  'key_column_usage',
+  {
+    constraint_schema: col.varchar(255),
+    constraint_name: col.varchar(255),
+    table_schema: col.varchar(255),
+    table_name: col.varchar(255),
+    column_name: col.varchar(255),
+    ordinal_position: col.int(),
+    referenced_table_schema: col.varchar(255),
+    referenced_table_name: col.varchar(255),
+    referenced_column_name: col.varchar(255)
+  },
+  {},
+  undefined,
+  { schema: INFORMATION_SCHEMA }
+);
+
+export const InformationSchemaReferentialConstraints = defineTable(
+  'referential_constraints',
+  {
+    constraint_schema: col.varchar(255),
+    constraint_name: col.varchar(255),
+    delete_rule: col.varchar(255),
+    update_rule: col.varchar(255)
+  },
+  {},
+  undefined,
+  { schema: INFORMATION_SCHEMA }
+);
+
+export const InformationSchemaStatistics = defineTable(
+  'statistics',
+  {
+    table_schema: col.varchar(255),
+    table_name: col.varchar(255),
+    index_name: col.varchar(255),
+    non_unique: col.int(),
+    column_name: col.varchar(255),
+    seq_in_index: col.int()
+  },
+  {},
+  undefined,
+  { schema: INFORMATION_SCHEMA }
+);
+
+export default {
+  InformationSchemaTables,
+  InformationSchemaColumns,
+  InformationSchemaKeyColumnUsage,
+  InformationSchemaReferentialConstraints,
+  InformationSchemaStatistics
+};

package/src/core/ddl/introspect/catalogs/postgres.ts

@@ -1,5 +1,5 @@
 import { defineTable } from '../../../../schema/table.js';
-import { col } from '../../../../schema/column.js';
+import { col } from '../../../../schema/column-types.js';
 
 /** Table definition for information_schema.columns, providing metadata about table columns. */
 export const PgInformationSchemaColumns = defineTable(
@@ -143,3 +143,4 @@ export default {
   PgIndex,
   PgAttribute
 };
+

package/src/core/ddl/introspect/catalogs/sqlite.ts

@@ -0,0 +1,47 @@
+import { defineTable } from '../../../../schema/table.js';
+import { col } from '../../../../schema/column-types.js';
+
+// SQLite catalogs are limited; most metadata comes from PRAGMAs, but these tables are queryable.
+
+export const SqliteMaster = defineTable(
+  'sqlite_master',
+  {
+    type: col.varchar(255),      // 'table', 'index', 'view', 'trigger'
+    name: col.varchar(255),      // Object name
+    tbl_name: col.varchar(255),  // Table the object belongs to
+    rootpage: col.int(),         // B-tree root page
+    sql: col.varchar(4096)       // Original DDL
+  },
+  {},
+  undefined,
+  { schema: undefined }
+);
+
+export const SqliteSequence = defineTable(
+  'sqlite_sequence',
+  {
+    name: col.varchar(255),  // Table name
+    seq: col.int()           // Last autoincrement value
+  },
+  {},
+  undefined,
+  { schema: undefined }
+);
+
+export const SqliteStat1 = defineTable(
+  'sqlite_stat1',
+  {
+    tbl: col.varchar(255),   // Table name
+    idx: col.varchar(255),   // Index name
+    stat: col.varchar(255)   // Statistics string
+  },
+  {},
+  undefined,
+  { schema: undefined }
+);
+
+export default {
+  SqliteMaster,
+  SqliteSequence,
+  SqliteStat1
+};

package/src/core/ddl/introspect/functions/mssql.ts

@@ -0,0 +1,84 @@
+import { caseWhen, cast, div, eq, inList, valueToOperand, columnOperand, ValueOperandInput } from '../../../ast/expression-builders.js';
+import { isOperandNode } from '../../../ast/expression-nodes.js';
+import type { OperandNode } from '../../../ast/expression.js';
+import type { ColumnRef } from '../../../ast/types.js';
+import { concat, lower } from '../../../functions/text.js';
+
+type OperandInput = OperandNode | ColumnRef | string | number | boolean | null;
+
+const isColumnReference = (value: unknown): value is ColumnRef =>
+  typeof value === 'object' &&
+  value !== null &&
+  !('type' in value) &&
+  'name' in value &&
+  typeof (value as ColumnRef).name === 'string';
+
+const toOperandNode = (value: OperandInput): OperandNode => {
+  if (isOperandNode(value)) return value;
+  if (isColumnReference(value)) return columnOperand(value);
+  return valueToOperand(value as ValueOperandInput);
+};
+
+const fn = (name: string, args: OperandInput[]): OperandNode => ({
+  type: 'Function',
+  name,
+  fn: name,
+  args: args.map(arg => toOperandNode(arg))
+});
+
+const CHAR_TYPES = ['varchar', 'char', 'varbinary', 'binary', 'nvarchar', 'nchar'];
+const DECIMAL_TYPES = ['decimal', 'numeric'];
+
+export const objectDefinition = (objectId: OperandInput): OperandNode => fn('OBJECT_DEFINITION', [objectId]);
+
+export const buildMssqlDataType = (
+  typeName: OperandInput,
+  maxLength: OperandInput,
+  precision: OperandInput,
+  scale: OperandInput
+): OperandNode => {
+  const typeOperand = toOperandNode(typeName);
+  const maxLenOperand = toOperandNode(maxLength);
+  const precisionOperand = toOperandNode(precision);
+  const scaleOperand = toOperandNode(scale);
+  const typeLower = lower(typeOperand);
+
+  const lengthCase = caseWhen(
+    [
+      {
+        when: eq(maxLenOperand, -1),
+        then: 'max'
+      },
+      {
+        when: inList(typeLower, ['nvarchar', 'nchar']),
+        then: cast(div(maxLenOperand, 2), 'varchar(10)')
+      }
+    ],
+    cast(maxLenOperand, 'varchar(10)')
+  );
+
+  const charSuffix = concat('(', lengthCase, ')');
+
+  const decimalSuffix = concat(
+    '(',
+    cast(precisionOperand, 'varchar(10)'),
+    ',',
+    cast(scaleOperand, 'varchar(10)'),
+    ')'
+  );
+
+  const suffix = caseWhen(
+    [
+      { when: inList(typeLower, CHAR_TYPES), then: charSuffix },
+      { when: inList(typeLower, DECIMAL_TYPES), then: decimalSuffix }
+    ],
+    ''
+  );
+
+  return concat(typeLower, suffix);
+};
+
+export default {
+  objectDefinition,
+  buildMssqlDataType
+};