metal-orm 1.0.46 → 1.0.48

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

@@ -1,16 +1,20 @@
 import { SchemaIntrospector, IntrospectOptions } from './types.js';
-import { queryRows, shouldIncludeTable } from './utils.js';
+import { shouldIncludeTable } from './utils.js';
 import { DatabaseSchema, DatabaseTable, DatabaseIndex } from '../schema-types.js';
-import { ReferentialAction } from '../../../schema/column-types.js';
-import { DbExecutor } from '../../execution/db-executor.js';
+import type { IntrospectContext } from './context.js';
+import { runSelectNode } from './run-select.js';
+import type { SelectQueryNode, TableNode } from '../../ast/query.js';
+import type { ColumnNode } from '../../ast/expression-nodes.js';
+import { eq, notLike, and, valueToOperand } from '../../ast/expression-builders.js';
+import { fnTable } from '../../ast/builders.js';
+import type { ReferentialAction } from '../../../schema/column-types.js';
 
-/** Row type for SQLite table list from sqlite_master. */
 type SqliteTableRow = {
   name: string;
 };
 
-/** Row type for SQLite table column information from PRAGMA table_info. */
 type SqliteTableInfoRow = {
+  cid: number;
   name: string;
   type: string;
   notnull: number;
@@ -18,31 +22,28 @@ type SqliteTableInfoRow = {
   pk: number;
 };
 
-/** Row type for SQLite foreign key information from PRAGMA foreign_key_list. */
 type SqliteForeignKeyRow = {
+  id: number;
+  seq: number;
   table: string;
   from: string;
   to: string;
-  on_delete: string | null;
   on_update: string | null;
+  on_delete: string | null;
 };
 
-/** Row type for SQLite index list from PRAGMA index_list. */
 type SqliteIndexListRow = {
+  seq: number;
   name: string;
   unique: number;
 };
 
-/** Row type for SQLite index column information from PRAGMA index_info. */
 type SqliteIndexInfoRow = {
+  seqno: number;
+  cid: number;
   name: string;
 };
 
-/**
- * Converts a SQLite referential action string to a ReferentialAction enum value.
- * @param value - The string value from SQLite pragma (e.g., 'CASCADE', 'SET NULL').
- * @returns The corresponding ReferentialAction enum value, or undefined if the value is invalid or null.
- */
 const toReferentialAction = (value: string | null | undefined): ReferentialAction | undefined => {
   if (!value) return undefined;
   const normalized = value.toUpperCase();
@@ -58,53 +59,101 @@ const toReferentialAction = (value: string | null | undefined): ReferentialActio
   return undefined;
 };
 
-/**
- * Escapes single quotes in a string for safe inclusion in SQL queries.
- * @param name - The string to escape.
- * @returns The escaped string with single quotes doubled.
- */
-const escapeSingleQuotes = (name: string) => name.replace(/'/g, "''");
+const columnNode = (table: string, name: string, alias?: string): ColumnNode => ({
+  type: 'Column',
+  table,
+  name,
+  alias
+});
+
+const buildPragmaQuery = (
+  name: string,
+  table: string,
+  alias: string,
+  columnAliases: string[]
+): SelectQueryNode => ({
+  type: 'SelectQuery',
+  from: fnTable(name, [valueToOperand(table)], alias, { columnAliases }),
+  columns: columnAliases.map(column => columnNode(alias, column)),
+  joins: []
+});
+
+const runPragma = async <T>(
+  name: string,
+  table: string,
+  alias: string,
+  columnAliases: string[],
+  ctx: IntrospectContext
+): Promise<T[]> => {
+  const query = buildPragmaQuery(name, table, alias, columnAliases);
+  return (await runSelectNode<T>(query, ctx)) as T[];
+};
 
-/** SQLite schema introspector. */
 export const sqliteIntrospector: SchemaIntrospector = {
-  /**
-   * Introspects the SQLite database schema by querying sqlite_master and various PRAGMAs.
-   * @param ctx - The database execution context containing the DbExecutor.
-   * @param options - Options controlling which tables and schemas to include.
-   * @returns A promise that resolves to the introspected DatabaseSchema.
-   */
-  async introspect(ctx: { executor: DbExecutor }, options: IntrospectOptions): Promise<DatabaseSchema> {
+  async introspect(ctx: IntrospectContext, options: IntrospectOptions): Promise<DatabaseSchema> {
+    const alias = 'sqlite_master';
+    const tablesQuery: SelectQueryNode = {
+      type: 'SelectQuery',
+      from: { type: 'Table', name: 'sqlite_master' } as TableNode,
+      columns: [columnNode(alias, 'name')],
+      joins: [],
+      where: and(
+        eq(columnNode(alias, 'type'), 'table'),
+        notLike(columnNode(alias, 'name'), 'sqlite_%')
+      )
+    };
+
+    const tableRows = (await runSelectNode<SqliteTableRow>(tablesQuery, ctx)) as SqliteTableRow[];
     const tables: DatabaseTable[] = [];
-    const tableRows = (await queryRows(
-      ctx.executor,
-      `SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%';`
-    )) as SqliteTableRow[];
 
     for (const row of tableRows) {
-      const name = row.name;
-      if (!shouldIncludeTable(name, options)) continue;
-      const table: DatabaseTable = { name, columns: [], primaryKey: [], indexes: [] };
-
-      const cols = (await queryRows(ctx.executor, `PRAGMA table_info('${escapeSingleQuotes(name)}');`)) as SqliteTableInfoRow[];
-      cols.forEach(c => {
-        table.columns.push({
-          name: c.name,
-          type: c.type,
-          notNull: c.notnull === 1,
-          default: c.dflt_value ?? undefined,
+      const tableName = row.name;
+      if (!shouldIncludeTable(tableName, options)) continue;
+
+      const tableInfo = await runPragma<SqliteTableInfoRow>(
+        'pragma_table_info',
+        tableName,
+        'ti',
+        ['cid', 'name', 'type', 'notnull', 'dflt_value', 'pk'],
+        ctx
+      );
+
+      const foreignKeys = await runPragma<SqliteForeignKeyRow>(
+        'pragma_foreign_key_list',
+        tableName,
+        'fk',
+        ['id', 'seq', 'table', 'from', 'to', 'on_update', 'on_delete', 'match'],
+        ctx
+      );
+
+      const indexList = await runPragma<SqliteIndexListRow>(
+        'pragma_index_list',
+        tableName,
+        'idx',
+        ['seq', 'name', 'unique'],
+        ctx
+      );
+
+      const tableEntry: DatabaseTable = { name: tableName, columns: [], primaryKey: [], indexes: [] };
+
+      tableInfo.forEach(info => {
+        tableEntry.columns.push({
+          name: info.name,
+          type: info.type,
+          notNull: info.notnull === 1,
+          default: info.dflt_value ?? undefined,
           autoIncrement: false
         });
-        if (c.pk && c.pk > 0) {
-          table.primaryKey = table.primaryKey || [];
-          table.primaryKey.push(c.name);
+        if (info.pk && info.pk > 0) {
+          tableEntry.primaryKey = tableEntry.primaryKey || [];
+          tableEntry.primaryKey.push(info.name);
         }
       });
 
-      const fkRows = (await queryRows(ctx.executor, `PRAGMA foreign_key_list('${escapeSingleQuotes(name)}');`)) as SqliteForeignKeyRow[];
-      fkRows.forEach(fk => {
-        const col = table.columns.find(c => c.name === fk.from);
-        if (col) {
-          col.references = {
+      foreignKeys.forEach(fk => {
+        const column = tableEntry.columns.find(col => col.name === fk.from);
+        if (column) {
+          column.references = {
             table: fk.table,
             column: fk.to,
             onDelete: toReferentialAction(fk.on_delete),
@@ -113,22 +162,26 @@ export const sqliteIntrospector: SchemaIntrospector = {
         }
       });
 
-      const idxList = (await queryRows(ctx.executor, `PRAGMA index_list('${escapeSingleQuotes(name)}');`)) as SqliteIndexListRow[];
-      for (const idx of idxList) {
-        const idxName = idx.name;
-        const columnsInfo = (await queryRows(ctx.executor, `PRAGMA index_info('${escapeSingleQuotes(idxName)}');`)) as SqliteIndexInfoRow[];
+      for (const idx of indexList) {
+        if (!idx.name) continue;
+        const indexColumns = await runPragma<SqliteIndexInfoRow>(
+          'pragma_index_info',
+          idx.name,
+          'info',
+          ['seqno', 'cid', 'name'],
+          ctx
+        );
         const idxEntry: DatabaseIndex = {
-          name: idxName,
-          columns: columnsInfo.map(ci => ({ column: ci.name })),
+          name: idx.name,
+          columns: indexColumns.map(col => ({ column: col.name })),
           unique: idx.unique === 1
         };
-        table.indexes!.push(idxEntry);
+        tableEntry.indexes!.push(idxEntry);
       }
 
-      tables.push(table);
+      tables.push(tableEntry);
     }
 
     return { tables };
   }
 };
-

package/src/core/ddl/schema-types.ts

@@ -19,6 +19,7 @@ export interface DatabaseColumn {
   generated?: 'always' | 'byDefault';
   unique?: boolean | string;
   references?: ForeignKeyReference;
+  comment?: string;
   check?: string;
 }
 
@@ -44,10 +45,10 @@ export interface DatabaseTable {
   primaryKey?: string[];
   indexes?: DatabaseIndex[];
   checks?: DatabaseCheck[];
+  comment?: string;
 }
 
 /** Represents the overall database schema. */
 export interface DatabaseSchema {
   tables: DatabaseTable[];
 }
-

package/src/core/dialect/abstract.ts

@@ -21,10 +21,11 @@ import {
   JsonPathNode,
   ScalarSubqueryNode,
   CaseExpressionNode,
+  CastExpressionNode,
   WindowFunctionNode,
   BetweenExpressionNode,
-  AliasRefNode,
   ArithmeticExpressionNode,
+  AliasRefNode,
   isOperandNode
 } from '../ast/expression.js';
 import { DialectName } from '../sql/sql.js';
@@ -476,6 +477,11 @@ export abstract class Dialect
       return parts.join(' ');
     });
 
+    this.registerOperandCompiler('Cast', (node: CastExpressionNode, ctx) => {
+      const value = this.compileOperand(node.expression, ctx);
+      return `CAST(${value} AS ${node.castType})`;
+    });
+
     this.registerOperandCompiler('WindowFunction', (node: WindowFunctionNode, ctx) => {
       let result = `${node.name}(`;
       if (node.args.length > 0) {
@@ -507,6 +513,11 @@ export abstract class Dialect
 
       return result;
     });
+    this.registerOperandCompiler('ArithmeticExpression', (node: ArithmeticExpressionNode, ctx) => {
+      const left = this.compileOperand(node.left, ctx);
+      const right = this.compileOperand(node.right, ctx);
+      return `(${left} ${node.operator} ${right})`;
+    });
   }
 
   // Default fallback, should be overridden by dialects if supported

package/src/core/dialect/mssql/index.ts

@@ -105,16 +105,10 @@ export class SqlServerDialect extends SqlDialectBase {
 
   private compileSelectCoreForMssql(ast: SelectQueryNode, ctx: CompilerContext): string {
     const columns = ast.columns.map(c => {
-      let expr = '';
-      if (c.type === 'Function') {
-        expr = this.compileOperand(c, ctx);
-      } else if (c.type === 'Column') {
-        expr = `${this.quoteIdentifier(c.table)}.${this.quoteIdentifier(c.name)}`;
-      } else if (c.type === 'ScalarSubquery') {
-        expr = this.compileOperand(c, ctx);
-      } else if (c.type === 'WindowFunction') {
-        expr = this.compileOperand(c, ctx);
-      }
+      // Default to full operand compilation for all projection node types (Function, Column, Cast, Case, Window, etc)
+      const expr = c.type === 'Column'
+        ? `${this.quoteIdentifier(c.table)}.${this.quoteIdentifier(c.name)}`
+        : this.compileOperand(c as unknown as import('../../ast/expression.js').OperandNode, ctx);
 
       if (c.alias) {
         if (c.alias.includes('(')) return c.alias;

package/src/query-builder/query-ast-service.ts

@@ -15,6 +15,7 @@ import {
   ExpressionNode,
   FunctionNode,
   CaseExpressionNode,
+  CastExpressionNode,
   WindowFunctionNode,
   ScalarSubqueryNode,
   and,
@@ -57,7 +58,7 @@ export class QueryAstService {
    * @returns Column selection result with updated state and added columns
    */
   select(
-    columns: Record<string, ColumnDef | FunctionNode | CaseExpressionNode | WindowFunctionNode>
+    columns: Record<string, ColumnDef | FunctionNode | CaseExpressionNode | CastExpressionNode | WindowFunctionNode>
   ): ColumnSelectionResult {
     const existingAliases = new Set(
       this.state.ast.columns.map(c => (c as ColumnNode).alias || (c as ColumnNode).name)
@@ -69,7 +70,7 @@ export class QueryAstService {
       if (existingAliases.has(alias)) return acc;
 
       if (isExpressionSelectionNode(val)) {
-        acc.push({ ...(val as FunctionNode | CaseExpressionNode | WindowFunctionNode), alias } as ProjectionNode);
+        acc.push({ ...(val as FunctionNode | CaseExpressionNode | CastExpressionNode | WindowFunctionNode), alias } as ProjectionNode);
         return acc;
       }
 
@@ -284,4 +285,3 @@ export class QueryAstService {
   }
 
 }
-

package/src/query-builder/select-query-state.ts

@@ -14,6 +14,7 @@ import {
   FunctionNode,
   ScalarSubqueryNode,
   CaseExpressionNode,
+  CastExpressionNode,
   WindowFunctionNode
 } from '../core/ast/expression.js';
 import { JoinNode } from '../core/ast/join.js';
@@ -26,6 +27,7 @@ export type ProjectionNode =
   | FunctionNode
   | ScalarSubqueryNode
   | CaseExpressionNode
+  | CastExpressionNode
   | WindowFunctionNode;
 
 /**