@kaelio/ktx 0.5.0 → 0.7.0

package/dist/connectors/sqlserver/connector.js

@@ -1,11 +1,12 @@
 import { assertReadOnlySql } from '../../context/connections/read-only-sql.js';
-import { createKtxConnectorCapabilities } from '../../context/scan/types.js';
+import { getDialectForDriver } from '../../context/connections/dialects.js';
+import { tryConstraintQuery } from '../../context/scan/constraint-discovery.js';
 import { scopedTableNames } from '../../context/scan/table-ref.js';
+import { createKtxConnectorCapabilities, } from '../../context/scan/types.js';
 import { readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { resolve } from 'node:path';
 import sql from 'mssql';
-import { KtxSqlServerDialect } from './dialect.js';
 function sqlTypeDeclaration(type) {
     if (typeof type === 'function') {
         try {
@@ -40,6 +41,17 @@ function tableScopeSql(scopedNames, columnExpression) {
     });
     return { clause: `AND ${columnExpression} IN (${placeholders.join(', ')})`, params };
 }
+/** @internal */
+export function prepareSqlServerReadOnlyQuery(sql, params) {
+    if (!params) {
+        return { sql, params: undefined };
+    }
+    let parameterizedQuery = sql;
+    for (const key of Object.keys(params)) {
+        parameterizedQuery = parameterizedQuery.replace(new RegExp(`:${key}\\b`, 'g'), `@${key}`);
+    }
+    return { sql: parameterizedQuery, params };
+}
 class DefaultSqlServerPoolFactory {
     async createPool(config) {
         const pool = await new sql.ConnectionPool(config).connect();
@@ -92,6 +104,17 @@ function parseSqlServerUrl(url) {
 function maybeNumber(value) {
     return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
 }
+function positiveIntegerConfigValue(input) {
+    const value = input.connection[input.key];
+    if (value === undefined) {
+        return input.defaultValue;
+    }
+    const numberValue = Number(value);
+    if (!Number.isInteger(numberValue) || numberValue < 1) {
+        throw new Error(`connections.${input.connectionId}.${String(input.key)} must be a positive integer`);
+    }
+    return numberValue;
+}
 function schemaNames(connection, env) {
     if (Array.isArray(connection.schemas) && connection.schemas.length > 0) {
         return connection.schemas.filter((schema) => schema.trim().length > 0).map((schema) => resolveStringReference(schema, env));
@@ -111,6 +134,13 @@ function firstNumber(value) {
     const numberValue = Number(value);
     return Number.isFinite(numberValue) ? numberValue : null;
 }
+function isDeniedError(error) {
+    if (!error || typeof error !== 'object') {
+        return false;
+    }
+    const number = error.number;
+    return number === 229 || number === 230 || number === 297;
+}
 function limitSqlForSqlServerExecution(sqlText, maxRows) {
     const trimmed = assertReadOnlySql(sqlText).replace(/;+\s*$/, '');
     if (!maxRows) {
@@ -137,6 +167,12 @@ export function sqlServerConnectionPoolConfigFromConfig(input) {
     const server = stringConfigValue(merged, 'host', env);
     const database = stringConfigValue(merged, 'database', env);
     const user = stringConfigValue(merged, 'username', env) ?? stringConfigValue(merged, 'user', env);
+    const maxConnections = positiveIntegerConfigValue({
+        connection: merged,
+        key: 'maxConnections',
+        connectionId: input.connectionId,
+        defaultValue: 10,
+    });
     if (!server) {
         throw new Error(`Native SQL Server connector requires connections.${input.connectionId}.host or url`);
     }
@@ -153,7 +189,7 @@ export function sqlServerConnectionPoolConfigFromConfig(input) {
         user,
         password: stringConfigValue(merged, 'password', env),
         options: { encrypt: true, trustServerCertificate: merged.trustServerCertificate ?? true },
-        pool: { max: 10, min: 0, idleTimeoutMillis: 30000 },
+        pool: { max: maxConnections, min: 0, idleTimeoutMillis: 30000 },
     };
 }
 export class KtxSqlServerScanConnector {
@@ -175,7 +211,7 @@ export class KtxSqlServerScanConnector {
     poolFactory;
     endpointResolver;
     now;
-    dialect = new KtxSqlServerDialect();
+    dialect = getDialectForDriver('sqlserver');
     pool = null;
     resolvedEndpoint = null;
     constructor(options) {
@@ -205,11 +241,12 @@ export class KtxSqlServerScanConnector {
     async introspect(input, _ctx) {
         this.assertConnection(input.connectionId);
         const tables = [];
+        const snapshotWarnings = [];
         for (const schemaName of this.schemas) {
             const scopedNames = input.tableScope
                 ? scopedTableNames(input.tableScope, { catalog: this.poolConfig.database, db: schemaName })
                 : null;
-            tables.push(...(await this.introspectSchema(schemaName, scopedNames)));
+            tables.push(...(await this.introspectSchema(schemaName, scopedNames, snapshotWarnings)));
         }
         return {
             connectionId: this.connectionId,
@@ -224,6 +261,7 @@ export class KtxSqlServerScanConnector {
                 total_columns: tables.reduce((sum, table) => sum + table.columns.length, 0),
             },
             tables,
+            warnings: snapshotWarnings,
         };
     }
     async sampleTable(input, _ctx) {
@@ -243,7 +281,7 @@ export class KtxSqlServerScanConnector {
     async executeReadOnly(input, _ctx) {
         this.assertConnection(input.connectionId);
         const limitedSql = limitSqlForSqlServerExecution(input.sql, input.maxRows);
-        const prepared = this.dialect.prepareQuery(limitedSql, input.params);
+        const prepared = prepareSqlServerReadOnlyQuery(limitedSql, input.params);
         const result = await this.query(prepared.sql, prepared.params);
         return { ...result, rowCount: result.rows.length };
     }
@@ -314,6 +352,7 @@ export class KtxSqlServerScanConnector {
       ORDER BY s.name, o.name
       `, params);
         return rows.map((row) => ({
+            catalog: this.poolConfig.database,
             schema: row.schema_name,
             name: row.table_name,
             kind: row.table_type === 'VIEW' ? 'view' : 'table',
@@ -329,7 +368,7 @@ export class KtxSqlServerScanConnector {
             this.resolvedEndpoint = null;
         }
     }
-    async introspectSchema(schemaName, scopedNames) {
+    async introspectSchema(schemaName, scopedNames, snapshotWarnings) {
         if (scopedNames && scopedNames.length === 0)
             return [];
         const tableScope = tableScopeSql(scopedNames, 'TABLE_NAME');
@@ -350,8 +389,16 @@ export class KtxSqlServerScanConnector {
       `, { schemaName, ...tableScope.params });
         const tableComments = await this.tableComments(schemaName, scopedNames);
         const columnComments = await this.columnComments(schemaName, scopedNames);
-        const primaryKeys = await this.primaryKeys(schemaName, scopedNames);
-        const foreignKeys = await this.foreignKeys(schemaName, scopedNames);
+        const primaryKeysResult = await tryConstraintQuery({ schema: schemaName, kind: 'primary_key', isDeniedError }, () => this.primaryKeys(schemaName, scopedNames));
+        const foreignKeysResult = await tryConstraintQuery({ schema: schemaName, kind: 'foreign_key', isDeniedError }, () => this.foreignKeys(schemaName, scopedNames));
+        const primaryKeys = primaryKeysResult.ok ? primaryKeysResult.value : new Map();
+        const foreignKeys = foreignKeysResult.ok ? foreignKeysResult.value : [];
+        if (!primaryKeysResult.ok) {
+            snapshotWarnings.push(primaryKeysResult.warning);
+        }
+        if (!foreignKeysResult.ok) {
+            snapshotWarnings.push(foreignKeysResult.warning);
+        }
         const rowCounts = await this.rowCounts(schemaName, scopedNames);
         const columnsByTable = groupByTable(columns);
         const foreignKeysByTable = groupByTable(foreignKeys);

package/dist/connectors/sqlserver/dialect.d.ts

@@ -1,30 +1,31 @@
+import type { KtxDialect } from '../../context/connections/dialects.js';
 import type { KtxSchemaDimensionType, KtxTableRef } from '../../context/scan/types.js';
 type SqlServerTableNameRef = Pick<KtxTableRef, 'name'> & Partial<Pick<KtxTableRef, 'catalog' | 'db'>>;
-export declare class KtxSqlServerDialect {
-    readonly type = "sqlserver";
+/** @internal */
+export declare class KtxSqlServerDialect implements KtxDialect {
+    readonly type: "sqlserver";
     private readonly typeMappings;
     quoteIdentifier(identifier: string): string;
     formatTableName(table: SqlServerTableNameRef): string;
+    formatDisplayRef(table: SqlServerTableNameRef): string;
+    parseDisplayRef(display: string): KtxTableRef | null;
+    columnDisplayTablePartCount(): 1 | 2 | 3;
     mapDataType(nativeType: string): string;
     mapToDimensionType(nativeType: string): KtxSchemaDimensionType;
     generateSampleQuery(tableName: string, limit: number, columns?: string[]): string;
     generateColumnSampleQuery(tableName: string, columnName: string, limit: number): string;
-    prepareQuery(sql: string, params?: Record<string, unknown>): {
-        sql: string;
-        params?: Record<string, unknown>;
-    };
     getRandomSampleFilter(samplePct: number): string;
     getTableSampleClause(samplePct: number): string;
-    getLimitOffsetClause(limit: number, offset?: number): string;
+    getLimitOffsetClause(_limit: number, _offset?: number): string;
     getTopClause(limit: number): string;
     getNullCountExpression(column: string): string;
     getDistinctCountExpression(column: string): string;
+    textLengthExpression(columnSql: string): string;
+    castToText(columnSql: string): string;
+    getSampleValueAggregation(innerSql: string): string;
     generateCardinalitySampleQuery(tableName: string, columnName: string, sampleSize: number): string;
     generateDistinctValuesQuery(tableName: string, columnName: string, limit: number): string;
     generateColumnStatisticsQuery(_schemaName: string, _tableName: string): string | null;
     generateRandomizedCardinalitySampleQuery(tableName: string, columnName: string, sampleSize: number): string;
-    getTimeTruncExpression(column: string, granularity: 'day' | 'week' | 'month' | 'quarter' | 'year', timezone?: string): string;
-    getCustomTimeTruncExpression(column: string, interval: string, origin?: string, timezone?: string): string;
-    parseIntervalToSql(interval: string): string;
 }
 export {};

package/dist/connectors/sqlserver/dialect.js

@@ -1,3 +1,5 @@
+import { columnDisplayPartCount, formatDialectDisplayRef, formatDialectTableName, parseDialectDisplayRef, safeSqlLimit, } from '../../context/connections/dialect-helpers.js';
+/** @internal */
 export class KtxSqlServerDialect {
     type = 'sqlserver';
     typeMappings = {
@@ -32,9 +34,16 @@ export class KtxSqlServerDialect {
         return `[${identifier.replace(/\]/g, ']]')}]`;
     }
     formatTableName(table) {
-        return table.db
-            ? `${this.quoteIdentifier(table.db)}.${this.quoteIdentifier(table.name)}`
-            : this.quoteIdentifier(table.name);
+        return formatDialectTableName(table, this.quoteIdentifier.bind(this), 'three-part');
+    }
+    formatDisplayRef(table) {
+        return formatDialectDisplayRef(table, 'three-part');
+    }
+    parseDisplayRef(display) {
+        return parseDialectDisplayRef(display, 'three-part');
+    }
+    columnDisplayTablePartCount() {
+        return columnDisplayPartCount('three-part');
     }
     mapDataType(nativeType) {
         return nativeType;
@@ -71,16 +80,6 @@ export class KtxSqlServerDialect {
         const quotedColumn = this.quoteIdentifier(columnName);
         return `SELECT TOP ${limit} ${quotedColumn} FROM ${tableName} WHERE ${quotedColumn} IS NOT NULL AND LTRIM(RTRIM(CAST(${quotedColumn} AS NVARCHAR(MAX)))) != ''`;
     }
-    prepareQuery(sql, params) {
-        if (!params) {
-            return { sql, params: undefined };
-        }
-        let parameterizedQuery = sql;
-        for (const key of Object.keys(params)) {
-            parameterizedQuery = parameterizedQuery.replace(new RegExp(`:${key}\\b`, 'g'), `@${key}`);
-        }
-        return { sql: parameterizedQuery, params };
-    }
     getRandomSampleFilter(samplePct) {
         if (samplePct <= 0 || samplePct >= 1) {
             return '';
@@ -93,11 +92,11 @@ export class KtxSqlServerDialect {
         }
         return `TABLESAMPLE (${samplePct * 100} PERCENT)`;
     }
-    getLimitOffsetClause(limit, offset) {
-        return offset !== undefined && offset > 0 ? `OFFSET ${offset} ROWS FETCH NEXT ${limit} ROWS ONLY` : '';
+    getLimitOffsetClause(_limit, _offset) {
+        return '';
     }
     getTopClause(limit) {
-        return `TOP ${limit}`;
+        return `TOP (${safeSqlLimit(limit)})`;
     }
     getNullCountExpression(column) {
         return `SUM(CASE WHEN ${column} IS NULL THEN 1 ELSE 0 END)`;
@@ -105,6 +104,15 @@ export class KtxSqlServerDialect {
     getDistinctCountExpression(column) {
         return `COUNT(DISTINCT ${column})`;
     }
+    textLengthExpression(columnSql) {
+        return `LEN(CAST(${columnSql} AS NVARCHAR(MAX)))`;
+    }
+    castToText(columnSql) {
+        return `CAST(${columnSql} AS NVARCHAR(MAX))`;
+    }
+    getSampleValueAggregation(innerSql) {
+        return `(SELECT STRING_AGG(CAST(value AS NVARCHAR(MAX)), CHAR(31)) FROM (${innerSql}) AS relationship_profile_values)`;
+    }
     generateCardinalitySampleQuery(tableName, columnName, sampleSize) {
         return `
       WITH sampled AS (
@@ -142,28 +150,4 @@ export class KtxSqlServerDialect {
       FROM sampled
     `;
     }
-    getTimeTruncExpression(column, granularity, timezone) {
-        const col = timezone ? `${column} AT TIME ZONE 'UTC' AT TIME ZONE '${timezone}'` : column;
-        switch (granularity) {
-            case 'day':
-                return `CAST(${col} AS DATE)`;
-            case 'week':
-                return `DATEADD(WEEK, DATEDIFF(WEEK, 0, ${col}), 0)`;
-            case 'month':
-                return `DATEFROMPARTS(YEAR(${col}), MONTH(${col}), 1)`;
-            case 'quarter':
-                return `DATEFROMPARTS(YEAR(${col}), (DATEPART(QUARTER, ${col}) - 1) * 3 + 1, 1)`;
-            case 'year':
-                return `DATEFROMPARTS(YEAR(${col}), 1, 1)`;
-        }
-    }
-    getCustomTimeTruncExpression(column, interval, origin, timezone) {
-        const col = timezone ? `${column} AT TIME ZONE 'UTC' AT TIME ZONE '${timezone}'` : column;
-        const [amount, unit] = interval.split(' ');
-        const originExpr = origin ? `'${origin}'` : `'1970-01-01'`;
-        return `DATEADD(${unit}, (DATEDIFF(${unit}, ${originExpr}, ${col}) / ${amount}) * ${amount}, ${originExpr})`;
-    }
-    parseIntervalToSql(interval) {
-        return `'${interval}'`;
-    }
 }

package/dist/context/connections/connection-type.d.ts

@@ -1,12 +1,12 @@
 import { z } from 'zod';
 export declare const connectionTypeSchema: z.ZodEnum<{
-    POSTGRESQL: "POSTGRESQL";
     BIGQUERY: "BIGQUERY";
     SNOWFLAKE: "SNOWFLAKE";
     MYSQL: "MYSQL";
     SQLSERVER: "SQLSERVER";
     SQLITE: "SQLITE";
     CLICKHOUSE: "CLICKHOUSE";
+    POSTGRESQL: "POSTGRESQL";
     CENTRALREACH: "CENTRALREACH";
     EPIC: "EPIC";
     CERNER: "CERNER";

package/dist/context/connections/dialect-helpers.d.ts

@@ -0,0 +1,9 @@
+import type { KtxTableRef } from '../scan/types.js';
+export type KtxDialectIdentifierShape = 'ansi' | 'sqlite' | 'three-part';
+export type KtxDialectTableRef = Pick<KtxTableRef, 'name'> & Partial<Pick<KtxTableRef, 'catalog' | 'db'>>;
+export declare function safeSqlLimit(limit: number): number;
+export declare function formatDialectTableName(table: KtxDialectTableRef, quoteIdentifier: (identifier: string) => string, shape: KtxDialectIdentifierShape): string;
+export declare function formatDialectDisplayRef(table: KtxDialectTableRef, shape: KtxDialectIdentifierShape): string;
+export declare function parseDialectDisplayRef(display: string, shape: KtxDialectIdentifierShape): KtxTableRef | null;
+export declare function columnDisplayPartCount(shape: KtxDialectIdentifierShape): 1 | 2 | 3;
+export declare function limitOffsetClause(limit: number, offset?: number): string;

package/dist/context/connections/dialect-helpers.js

@@ -0,0 +1,67 @@
+export function safeSqlLimit(limit) {
+    return Math.max(1, Math.floor(limit));
+}
+function safeSqlOffset(offset) {
+    if (offset === undefined) {
+        return null;
+    }
+    const normalized = Math.floor(offset);
+    return normalized > 0 ? normalized : null;
+}
+function cleanIdentifierPart(part) {
+    return part.trim().replace(/^["'`\[]|["'`\]]$/g, '');
+}
+function splitDisplay(display) {
+    return display.trim().split('.').map(cleanIdentifierPart).filter(Boolean);
+}
+function tableParts(table, shape) {
+    if (shape === 'sqlite') {
+        return [table.name];
+    }
+    return [table.catalog ?? null, table.db ?? null, table.name].filter((part) => Boolean(part));
+}
+function acceptedDisplayPartCounts(shape) {
+    if (shape === 'sqlite') {
+        return [1];
+    }
+    if (shape === 'three-part') {
+        return [3];
+    }
+    return [2, 3];
+}
+export function formatDialectTableName(table, quoteIdentifier, shape) {
+    return tableParts(table, shape).map(quoteIdentifier).join('.');
+}
+export function formatDialectDisplayRef(table, shape) {
+    return tableParts(table, shape).join('.');
+}
+export function parseDialectDisplayRef(display, shape) {
+    const parts = splitDisplay(display);
+    if (!acceptedDisplayPartCounts(shape).includes(parts.length)) {
+        return null;
+    }
+    if (parts.length === 1) {
+        return { catalog: null, db: null, name: parts[0] };
+    }
+    if (parts.length === 2) {
+        return { catalog: null, db: parts[0], name: parts[1] };
+    }
+    if (parts.length === 3) {
+        return { catalog: parts[0], db: parts[1], name: parts[2] };
+    }
+    return null;
+}
+export function columnDisplayPartCount(shape) {
+    if (shape === 'sqlite') {
+        return 1;
+    }
+    if (shape === 'three-part') {
+        return 3;
+    }
+    return 2;
+}
+export function limitOffsetClause(limit, offset) {
+    const safeLimit = safeSqlLimit(limit);
+    const safeOffset = safeSqlOffset(offset);
+    return safeOffset === null ? `LIMIT ${safeLimit}` : `LIMIT ${safeLimit} OFFSET ${safeOffset}`;
+}

package/dist/context/connections/dialects.d.ts

@@ -1,10 +1,28 @@
-import type { KtxSchemaDimensionType, KtxTableRef } from '../scan/types.js';
-type SupportedDriver = 'postgres' | 'postgresql' | 'mysql' | 'sqlserver' | 'snowflake' | 'bigquery' | 'clickhouse' | 'sqlite' | 'sqlite3';
+import type { KtxConnectionDriver, KtxSchemaDimensionType, KtxTableRef } from '../scan/types.js';
+import type { KtxDialectTableRef } from './dialect-helpers.js';
 export interface KtxDialect {
-    readonly type: SupportedDriver;
+    readonly type: KtxConnectionDriver;
     quoteIdentifier(identifier: string): string;
-    formatTableName(table: KtxTableRef): string;
+    formatTableName(table: KtxDialectTableRef): string;
+    formatDisplayRef(table: KtxDialectTableRef): string;
+    parseDisplayRef(display: string): KtxTableRef | null;
+    columnDisplayTablePartCount(): 1 | 2 | 3;
+    getLimitOffsetClause(limit: number, offset?: number): string;
+    getTopClause(limit: number): string;
+    getRandomSampleFilter(samplePct: number): string;
+    getTableSampleClause(samplePct: number): string;
+    generateSampleQuery(tableName: string, limit: number, columns?: string[]): string;
+    generateColumnSampleQuery(tableName: string, columnName: string, limit: number): string;
+    getSampleValueAggregation(innerSql: string): string;
+    generateCardinalitySampleQuery(tableName: string, columnName: string, sampleSize: number): string;
+    generateRandomizedCardinalitySampleQuery(tableName: string, columnName: string, sampleSize: number): string;
+    generateDistinctValuesQuery(tableName: string, columnName: string, limit: number): string;
+    generateColumnStatisticsQuery(schemaName: string, tableName: string): string | null;
+    getNullCountExpression(column: string): string;
+    getDistinctCountExpression(column: string): string;
+    textLengthExpression(columnSql: string): string;
+    castToText(columnSql: string): string;
     mapToDimensionType(nativeType: string): KtxSchemaDimensionType;
+    mapDataType(nativeType: string): string;
 }
 export declare function getDialectForDriver(driver: string): KtxDialect;
-export {};

package/dist/context/connections/dialects.js

@@ -1,71 +1,33 @@
+import { KtxBigQueryDialect } from '../../connectors/bigquery/dialect.js';
+import { KtxClickHouseDialect } from '../../connectors/clickhouse/dialect.js';
+import { KtxMysqlDialect } from '../../connectors/mysql/dialect.js';
+import { KtxPostgresDialect } from '../../connectors/postgres/dialect.js';
+import { KtxSqliteDialect } from '../../connectors/sqlite/dialect.js';
+import { KtxSnowflakeDialect } from '../../connectors/snowflake/dialect.js';
+import { KtxSqlServerDialect } from '../../connectors/sqlserver/dialect.js';
 const supportedDrivers = [
     'bigquery',
     'clickhouse',
     'mysql',
     'postgres',
-    'postgresql',
     'sqlite',
-    'sqlite3',
     'snowflake',
     'sqlserver',
 ];
-function doubleQuoted(identifier) {
-    return `"${identifier.replace(/"/g, '""')}"`;
-}
-function backtickQuoted(identifier) {
-    return `\`${identifier.replace(/`/g, '``')}\``;
-}
-function bigQueryQuoted(identifier) {
-    return `\`${identifier.replace(/`/g, '\\`')}\``;
-}
-function bracketQuoted(identifier) {
-    return `[${identifier.replace(/\]/g, ']]')}]`;
-}
-function inferDimensionType(nativeType) {
-    const normalized = nativeType.toLowerCase().trim();
-    if (normalized.includes('date') || normalized.includes('time')) {
-        return 'time';
-    }
-    if (normalized.includes('int') ||
-        normalized.includes('num') ||
-        normalized.includes('dec') ||
-        normalized.includes('float') ||
-        normalized.includes('double') ||
-        normalized.includes('real')) {
-        return 'number';
-    }
-    if (normalized.includes('bool') || normalized === 'bit') {
-        return 'boolean';
-    }
-    return 'string';
-}
-function formatWithParts(table, quote, sqlite = false) {
-    const parts = sqlite ? [table.name] : [table.catalog, table.db, table.name].filter((part) => !!part);
-    return parts.map(quote).join('.');
-}
-function createDialect(type, quote, sqlite = false) {
-    return {
-        type,
-        quoteIdentifier: quote,
-        formatTableName: (table) => formatWithParts(table, quote, sqlite),
-        mapToDimensionType: inferDimensionType,
-    };
-}
-const dialects = {
-    postgres: createDialect('postgres', doubleQuoted),
-    postgresql: createDialect('postgresql', doubleQuoted),
-    mysql: createDialect('mysql', backtickQuoted),
-    clickhouse: createDialect('clickhouse', backtickQuoted),
-    sqlite: createDialect('sqlite', doubleQuoted, true),
-    sqlite3: createDialect('sqlite3', doubleQuoted, true),
-    snowflake: createDialect('snowflake', doubleQuoted),
-    bigquery: createDialect('bigquery', bigQueryQuoted),
-    sqlserver: createDialect('sqlserver', bracketQuoted),
+const dialectFactories = {
+    bigquery: () => new KtxBigQueryDialect(),
+    clickhouse: () => new KtxClickHouseDialect(),
+    mysql: () => new KtxMysqlDialect(),
+    postgres: () => new KtxPostgresDialect(),
+    sqlite: () => new KtxSqliteDialect(),
+    snowflake: () => new KtxSnowflakeDialect(),
+    sqlserver: () => new KtxSqlServerDialect(),
 };
 export function getDialectForDriver(driver) {
     const normalized = driver.toLowerCase().trim();
-    if (normalized in dialects) {
-        return dialects[normalized];
+    const factory = dialectFactories[normalized];
+    if (factory) {
+        return factory();
     }
     throw new Error(`Unsupported warehouse driver "${driver}". Supported drivers: ${supportedDrivers.join(', ')}`);
 }

package/dist/context/connections/drivers.d.ts

@@ -0,0 +1,23 @@
+import type { KtxConnectionDriver, KtxScanConnector } from '../scan/types.js';
+/** @internal */
+export type KtxScopeConfigKey = 'dataset_ids' | 'databases' | 'schemas' | 'schema_names';
+/** @internal */
+export interface KtxDriverConnectorModule {
+    isConnectionConfig(connection: unknown): boolean;
+    createScanConnector(args: {
+        connectionId: string;
+        connection: unknown;
+        projectDir: string;
+    }): KtxScanConnector;
+}
+export interface KtxDriverRegistration {
+    readonly driver: KtxConnectionDriver;
+    readonly scopeConfigKey: KtxScopeConfigKey | null;
+    readonly hasHistoricSqlReader: boolean;
+    readonly hasLocalQueryExecutor: boolean;
+    load(): Promise<KtxDriverConnectorModule>;
+}
+/** @internal */
+export declare const driverRegistrations: Record<KtxConnectionDriver, KtxDriverRegistration>;
+export declare function getDriverRegistration(driver: string): KtxDriverRegistration | undefined;
+export declare function listSupportedDrivers(): KtxConnectionDriver[];