@kaelio/ktx 0.5.0 → 0.6.0

package/dist/connectors/postgres/dialect.js

@@ -1,5 +1,7 @@
+import { columnDisplayPartCount, formatDialectDisplayRef, formatDialectTableName, limitOffsetClause, parseDialectDisplayRef, } from '../../context/connections/dialect-helpers.js';
+/** @internal */
 export class KtxPostgresDialect {
-    type = 'postgresql';
+    type = 'postgres';
     typeMappings = {
         timestamp: 'time',
         'timestamp without time zone': 'time',
@@ -38,9 +40,16 @@ export class KtxPostgresDialect {
         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), 'ansi');
+    }
+    formatDisplayRef(table) {
+        return formatDialectDisplayRef(table, 'ansi');
+    }
+    parseDisplayRef(display) {
+        return parseDialectDisplayRef(display, 'ansi');
+    }
+    columnDisplayTablePartCount() {
+        return columnDisplayPartCount('ansi');
     }
     mapDataType(nativeType) {
         return nativeType;
@@ -77,24 +86,6 @@ export class KtxPostgresDialect {
         const quotedColumn = this.quoteIdentifier(columnName);
         return `SELECT ${quotedColumn} FROM ${tableName} WHERE ${quotedColumn} IS NOT NULL AND TRIM(CAST(${quotedColumn} AS TEXT)) != '' LIMIT ${limit}`;
     }
-    prepareQuery(sql, params) {
-        if (!params) {
-            return { sql, params: undefined };
-        }
-        const paramNames = Object.keys(params);
-        const values = new Array(paramNames.length);
-        const paramIndexMap = new Map();
-        paramNames.forEach((name, index) => {
-            paramIndexMap.set(name, index + 1);
-            values[index] = params[name];
-        });
-        const sortedKeys = [...paramNames].sort((a, b) => b.length - a.length);
-        let parameterizedQuery = sql;
-        for (const name of sortedKeys) {
-            parameterizedQuery = parameterizedQuery.replace(new RegExp(`:${name}\\b`, 'g'), `$${paramIndexMap.get(name)}`);
-        }
-        return { sql: parameterizedQuery, params: values };
-    }
     getRandomSampleFilter(samplePct) {
         if (samplePct <= 0 || samplePct >= 1) {
             return '';
@@ -108,7 +99,10 @@ export class KtxPostgresDialect {
         return `TABLESAMPLE SYSTEM (${samplePct * 100})`;
     }
     getLimitOffsetClause(limit, offset) {
-        return offset !== undefined && offset > 0 ? `LIMIT ${limit} OFFSET ${offset}` : `LIMIT ${limit}`;
+        return limitOffsetClause(limit, offset);
+    }
+    getTopClause(_limit) {
+        return '';
     }
     getNullCountExpression(column) {
         return `COUNT(*) FILTER (WHERE ${column} IS NULL)`;
@@ -116,6 +110,15 @@ export class KtxPostgresDialect {
     getDistinctCountExpression(column) {
         return `COUNT(DISTINCT ${column})`;
     }
+    textLengthExpression(columnSql) {
+        return `LENGTH(CAST(${columnSql} AS TEXT))`;
+    }
+    castToText(columnSql) {
+        return `CAST(${columnSql} AS TEXT)`;
+    }
+    getSampleValueAggregation(innerSql) {
+        return `(SELECT STRING_AGG(CAST(value AS TEXT), CHR(31)) FROM (${innerSql}) AS relationship_profile_values)`;
+    }
     generateCardinalitySampleQuery(tableName, columnName, sampleSize) {
         return `
       WITH sampled AS (
@@ -167,16 +170,4 @@ export class KtxPostgresDialect {
       FROM sampled
     `;
     }
-    getTimeTruncExpression(column, granularity, timezone) {
-        const col = timezone ? `(${column} AT TIME ZONE '${timezone.replace(/'/g, "''")}')` : column;
-        return `DATE_TRUNC('${granularity}', ${col})`;
-    }
-    getCustomTimeTruncExpression(column, interval, origin, timezone) {
-        const col = timezone ? `(${column} AT TIME ZONE '${timezone.replace(/'/g, "''")}')` : column;
-        const originExpr = origin ? `TIMESTAMP '${origin.replace(/'/g, "''")}'` : "TIMESTAMP '1970-01-01'";
-        return `${originExpr} + FLOOR(EXTRACT(EPOCH FROM (${col} - ${originExpr})) / EXTRACT(EPOCH FROM INTERVAL '${interval.replace(/'/g, "''")}')) * INTERVAL '${interval.replace(/'/g, "''")}'`;
-    }
-    parseIntervalToSql(interval) {
-        return `INTERVAL '${interval.replace(/'/g, "''")}'`;
-    }
 }

package/dist/connectors/snowflake/connector.d.ts

@@ -1,4 +1,4 @@
-import { type KtxColumnSampleInput, type KtxColumnSampleResult, type KtxColumnStatsInput, type KtxColumnStatsResult, type KtxQueryResult, type KtxReadOnlyQueryInput, type KtxScanConnector, type KtxScanContext, type KtxScanInput, type KtxSchemaSnapshot, type KtxTableRef, type KtxTableSampleInput, type KtxTableListEntry, type KtxTableSampleResult } from '../../context/scan/types.js';
+import { type KtxColumnSampleInput, type KtxColumnSampleResult, type KtxColumnStatsInput, type KtxColumnStatsResult, type KtxQueryResult, type KtxReadOnlyQueryInput, type KtxScanConnector, type KtxScanContext, type KtxScanInput, type KtxSchemaSnapshot, type KtxTableListEntry, type KtxTableRef, type KtxTableSampleInput, type KtxTableSampleResult } from '../../context/scan/types.js';
 export interface KtxSnowflakeConnectionConfig {
     driver?: string;
     authMethod?: 'password' | 'rsa';
@@ -12,7 +12,7 @@ export interface KtxSnowflakeConnectionConfig {
     privateKey?: string;
     passphrase?: string;
     role?: string;
-    maxSessions?: number;
+    maxConnections?: number;
     [key: string]: unknown;
 }
 export interface KtxSnowflakeResolvedConnectionConfig {
@@ -26,7 +26,7 @@ export interface KtxSnowflakeResolvedConnectionConfig {
     privateKey?: string;
     passphrase?: string;
     role?: string;
-    maxSessions: number;
+    maxConnections: number;
 }
 export interface KtxSnowflakeRawColumnMetadata {
     name: string;
@@ -94,6 +94,11 @@ export interface KtxSnowflakeColumnDistinctValuesResult {
     values: string[] | null;
     cardinality: number;
 }
+/** @internal */
+export declare function prepareSnowflakeReadOnlyQuery(sql: string, params?: Record<string, unknown>): {
+    sql: string;
+    params?: unknown[];
+};
 export declare function isKtxSnowflakeConnectionConfig(connection: KtxSnowflakeConnectionConfig | undefined): connection is KtxSnowflakeConnectionConfig;
 /** @internal */
 export declare function snowflakeConnectionConfigFromConfig(input: {

package/dist/connectors/snowflake/connector.js

@@ -2,11 +2,12 @@ import { createPrivateKey } from 'node:crypto';
 import { readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { resolve } from 'node:path';
+import { getDialectForDriver } from '../../context/connections/dialects.js';
 import { assertReadOnlySql, limitSqlForExecution } from '../../context/connections/read-only-sql.js';
-import { createKtxConnectorCapabilities } from '../../context/scan/types.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 snowflake from 'snowflake-sdk';
-import { KtxSnowflakeDialect } from './dialect.js';
 import { assertSafeSnowflakeIdentifier, quoteSnowflakeIdentifier } from './identifiers.js';
 import { configureSnowflakeSdkLogger } from './sdk-logger.js';
 const DATE_TYPES = ['DATE', 'TIMESTAMP', 'TIMESTAMP_LTZ', 'TIMESTAMP_NTZ', 'TIMESTAMP_TZ', 'TIME'];
@@ -49,6 +50,12 @@ function firstNumber(value) {
     const numberValue = Number(value);
     return Number.isFinite(numberValue) ? numberValue : null;
 }
+function isDeniedError(error) {
+    if (error instanceof Error) {
+        return /insufficient privileges|does not exist or not authorized/i.test(error.message);
+    }
+    return false;
+}
 function normalizeSnowflakeValue(value, columnType) {
     if (columnType && DATE_TYPES.some((type) => columnType.toUpperCase().includes(type))) {
         if (typeof value === 'number') {
@@ -83,6 +90,10 @@ function toSnowflakeBind(value) {
 function toSnowflakeBinds(params) {
     return params?.map((value) => toSnowflakeBind(value));
 }
+/** @internal */
+export function prepareSnowflakeReadOnlyQuery(sql, params) {
+    return { sql, params: params ? Object.values(params) : undefined };
+}
 export function isKtxSnowflakeConnectionConfig(connection) {
     return String(connection?.driver ?? '').toLowerCase() === 'snowflake';
 }
@@ -92,6 +103,10 @@ export function snowflakeConnectionConfigFromConfig(input) {
     if (!isKtxSnowflakeConnectionConfig(input.connection)) {
         throw new Error(`Native Snowflake connector cannot run driver "${inputDriver}"`);
     }
+    const staleMaxSessionsKey = 'max' + 'Sessions';
+    if (Object.prototype.hasOwnProperty.call(input.connection, staleMaxSessionsKey)) {
+        throw new Error(`connections.${input.connectionId}.maxSessions has been renamed to maxConnections`);
+    }
     const env = input.env ?? process.env;
     const authMethod = input.connection?.authMethod ?? 'password';
     const account = stringConfigValue(input.connection, 'account', env);
@@ -123,9 +138,9 @@ export function snowflakeConnectionConfigFromConfig(input) {
         database,
         schemas: resolvedSchemas,
         username,
-        maxSessions: positiveIntegerConfigValue({
+        maxConnections: positiveIntegerConfigValue({
             connection: input.connection,
-            key: 'maxSessions',
+            key: 'maxConnections',
             connectionId: input.connectionId,
             defaultValue: 4,
         }),
@@ -184,7 +199,7 @@ class SnowflakeSdkDriver {
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
             if (/timeout/i.test(message) && /pool|acquire/i.test(message)) {
-                throw new Error("Snowflake session pool exhausted after 60s - consider lowering maxSessions or increasing your account's concurrent-statement limit.");
+                throw new Error("Snowflake session pool exhausted after 60s - consider lowering maxConnections or increasing your account's concurrent-statement limit.");
             }
             throw error;
         }
@@ -242,6 +257,7 @@ class SnowflakeSdkDriver {
     ORDER BY TABLE_SCHEMA, TABLE_NAME
     `, [this.resolved.database, ...(schemas ?? [])]);
         return result.rows.map((row) => ({
+            catalog: this.resolved.database,
             schema: String(row[0]),
             name: String(row[1]),
             kind: String(row[2]) === 'VIEW' ? 'view' : 'table',
@@ -273,7 +289,7 @@ class SnowflakeSdkDriver {
         if (!this.pool) {
             this.pool = snowflake.createPool(await this.resolveConnectionOptions(), {
                 min: 0,
-                max: this.resolved.maxSessions,
+                max: this.resolved.maxConnections,
                 evictionRunIntervalMillis: 30_000,
                 acquireTimeoutMillis: 60_000,
             });
@@ -352,7 +368,7 @@ export class KtxSnowflakeScanConnector {
     });
     resolved;
     driverFactory;
-    dialect = new KtxSnowflakeDialect();
+    dialect = getDialectForDriver('snowflake');
     now;
     driverInstance = null;
     constructor(options) {
@@ -371,6 +387,7 @@ export class KtxSnowflakeScanConnector {
     async introspect(input, _ctx) {
         this.assertConnection(input.connectionId);
         const tables = [];
+        const snapshotWarnings = [];
         for (const schemaName of this.resolved.schemas) {
             const scopedNames = input.tableScope
                 ? scopedTableNames(input.tableScope, { catalog: this.resolved.database, db: schemaName })
@@ -378,7 +395,13 @@ export class KtxSnowflakeScanConnector {
             if (scopedNames && scopedNames.length === 0)
                 continue;
             const rawTables = await this.getDriver().getSchemaMetadata(schemaName, scopedNames);
-            const primaryKeys = await this.primaryKeys(rawTables.map((table) => table.name), schemaName);
+            const primaryKeysResult = await tryConstraintQuery({ schema: schemaName, kind: 'primary_key', isDeniedError }, () => this.primaryKeys(rawTables.map((table) => table.name), schemaName));
+            const primaryKeys = primaryKeysResult.ok
+                ? primaryKeysResult.value
+                : new Map(rawTables.map((table) => [table.name, new Set()]));
+            if (!primaryKeysResult.ok) {
+                snapshotWarnings.push(primaryKeysResult.warning);
+            }
             tables.push(...rawTables.map((table) => this.toSchemaTable(table, primaryKeys)));
         }
         return {
@@ -395,6 +418,7 @@ export class KtxSnowflakeScanConnector {
                 total_columns: tables.reduce((sum, table) => sum + table.columns.length, 0),
             },
             tables,
+            warnings: snapshotWarnings,
         };
     }
     async sampleTable(input, _ctx) {
@@ -417,7 +441,7 @@ export class KtxSnowflakeScanConnector {
     async executeReadOnly(input, _ctx) {
         this.assertConnection(input.connectionId);
         const limitedSql = limitSqlForExecution(assertReadOnlySql(input.sql), input.maxRows);
-        const prepared = this.dialect.prepareQuery(limitedSql, input.params);
+        const prepared = prepareSnowflakeReadOnlyQuery(limitedSql, input.params);
         return this.getDriver().query(prepared.sql, prepared.params);
     }
     async getColumnDistinctValues(table, columnName, options) {
@@ -460,6 +484,7 @@ export class KtxSnowflakeScanConnector {
     ORDER BY TABLE_SCHEMA, TABLE_NAME
     `, [this.resolved.database, ...(schemas ?? [])]);
         return result.rows.map((row) => ({
+            catalog: this.resolved.database,
             schema: String(row[0]),
             name: String(row[1]),
             kind: String(row[2]) === 'VIEW' ? 'view' : 'table',
@@ -489,8 +514,7 @@ export class KtxSnowflakeScanConnector {
             return grouped;
         }
         const tableNamePlaceholders = tableNames.map(() => '?').join(', ');
-        try {
-            const result = await this.getDriver().query(`
+        const result = await this.getDriver().query(`
           SELECT tc.TABLE_NAME, kcu.COLUMN_NAME
           FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc
           JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE kcu
@@ -503,15 +527,10 @@ export class KtxSnowflakeScanConnector {
             AND tc.TABLE_NAME IN (${tableNamePlaceholders})
           ORDER BY tc.TABLE_NAME, kcu.ORDINAL_POSITION
         `, [schemaName, this.resolved.database, ...tableNames]);
-            for (const row of result.rows) {
-                const tableName = String(row[0]);
-                const columnName = String(row[1]);
-                grouped.get(tableName)?.add(columnName);
-            }
-        }
-        catch {
-            // INFORMATION_SCHEMA.KEY_COLUMN_USAGE often isn't granted to read-only roles;
-            // continue with empty PK map and let FK inference + profiling carry the slack.
+        for (const row of result.rows) {
+            const tableName = String(row[0]);
+            const columnName = String(row[1]);
+            grouped.get(tableName)?.add(columnName);
         }
         return grouped;
     }

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

@@ -1,29 +1,31 @@
+import type { KtxDialect } from '../../context/connections/dialects.js';
 import type { KtxSchemaDimensionType, KtxTableRef } from '../../context/scan/types.js';
 type SnowflakeTableNameRef = Pick<KtxTableRef, 'name'> & Partial<Pick<KtxTableRef, 'catalog' | 'db'>>;
-export declare class KtxSnowflakeDialect {
-    readonly type = "snowflake";
+/** @internal */
+export declare class KtxSnowflakeDialect implements KtxDialect {
+    readonly type: "snowflake";
     private readonly typeMappings;
     quoteIdentifier(identifier: string): string;
     formatTableName(table: SnowflakeTableNameRef): string;
+    formatDisplayRef(table: SnowflakeTableNameRef): 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?: unknown[];
-    };
     getRandomSampleFilter(samplePct: number): string;
     getTableSampleClause(samplePct: 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/snowflake/dialect.js

@@ -1,3 +1,5 @@
+import { columnDisplayPartCount, formatDialectDisplayRef, formatDialectTableName, limitOffsetClause, parseDialectDisplayRef, } from '../../context/connections/dialect-helpers.js';
+/** @internal */
 export class KtxSnowflakeDialect {
     type = 'snowflake';
     typeMappings = {
@@ -38,13 +40,16 @@ export class KtxSnowflakeDialect {
         return `"${identifier.replace(/"/g, '""')}"`;
     }
     formatTableName(table) {
-        if (table.catalog && table.db) {
-            return `${this.quoteIdentifier(table.catalog)}.${this.quoteIdentifier(table.db)}.${this.quoteIdentifier(table.name)}`;
-        }
-        if (table.db) {
-            return `${this.quoteIdentifier(table.db)}.${this.quoteIdentifier(table.name)}`;
-        }
-        return 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;
@@ -81,9 +86,6 @@ export class KtxSnowflakeDialect {
         const quotedColumn = this.quoteIdentifier(columnName);
         return `SELECT ${quotedColumn} FROM ${tableName} WHERE ${quotedColumn} IS NOT NULL AND TRIM(CAST(${quotedColumn} AS STRING)) != '' LIMIT ${limit}`;
     }
-    prepareQuery(sql, params) {
-        return { sql, params: params ? Object.values(params) : undefined };
-    }
     getRandomSampleFilter(samplePct) {
         if (samplePct <= 0 || samplePct >= 1) {
             return '';
@@ -97,7 +99,10 @@ export class KtxSnowflakeDialect {
         return `SAMPLE (${samplePct * 100})`;
     }
     getLimitOffsetClause(limit, offset) {
-        return offset !== undefined && offset > 0 ? `LIMIT ${limit} OFFSET ${offset}` : `LIMIT ${limit}`;
+        return limitOffsetClause(limit, offset);
+    }
+    getTopClause(_limit) {
+        return '';
     }
     getNullCountExpression(column) {
         return `COUNT_IF(${column} IS NULL)`;
@@ -105,6 +110,15 @@ export class KtxSnowflakeDialect {
     getDistinctCountExpression(column) {
         return `APPROX_COUNT_DISTINCT(${column})`;
     }
+    textLengthExpression(columnSql) {
+        return `LENGTH(CAST(${columnSql} AS TEXT))`;
+    }
+    castToText(columnSql) {
+        return `CAST(${columnSql} AS VARCHAR)`;
+    }
+    getSampleValueAggregation(innerSql) {
+        return `(SELECT LISTAGG(CAST(value AS VARCHAR), '\\x1f') FROM (${innerSql}) AS relationship_profile_values)`;
+    }
     generateCardinalitySampleQuery(tableName, columnName, sampleSize) {
         return `
       WITH sampled AS (
@@ -140,17 +154,4 @@ export class KtxSnowflakeDialect {
       FROM sampled
     `;
     }
-    getTimeTruncExpression(column, granularity, timezone) {
-        const target = timezone ? `CONVERT_TIMEZONE('UTC', '${timezone}', ${column})` : column;
-        return `DATE_TRUNC('${granularity}', ${target})`;
-    }
-    getCustomTimeTruncExpression(column, interval, origin, timezone) {
-        const target = timezone ? `CONVERT_TIMEZONE('UTC', '${timezone}', ${column})` : column;
-        const [amount, unit] = interval.split(' ');
-        const originExpr = origin ? `'${origin}'::TIMESTAMP` : `'1970-01-01'::TIMESTAMP`;
-        return `DATEADD(${unit}, FLOOR(DATEDIFF(${unit}, ${originExpr}, ${target}) / ${amount}) * ${amount}, ${originExpr})`;
-    }
-    parseIntervalToSql(interval) {
-        return `INTERVAL '${interval}'`;
-    }
 }

package/dist/connectors/sqlite/connector.d.ts

@@ -1,4 +1,4 @@
-import { type KtxColumnSampleInput, type KtxColumnSampleResult, type KtxColumnStatsInput, type KtxColumnStatsResult, type KtxQueryResult, type KtxReadOnlyQueryInput, type KtxScanConnector, type KtxScanContext, type KtxScanInput, type KtxSchemaSnapshot, type KtxTableRef, type KtxTableSampleInput, type KtxTableSampleResult } from '../../context/scan/types.js';
+import { type KtxColumnSampleInput, type KtxColumnSampleResult, type KtxColumnStatsInput, type KtxColumnStatsResult, type KtxQueryResult, type KtxReadOnlyQueryInput, type KtxScanConnector, type KtxScanContext, type KtxScanInput, type KtxSchemaSnapshot, type KtxTableListEntry, type KtxTableRef, type KtxTableSampleInput, type KtxTableSampleResult } from '../../context/scan/types.js';
 export interface KtxSqliteConnectionConfig {
     driver?: string;
     path?: string;
@@ -44,6 +44,8 @@ export declare class KtxSqliteScanConnector implements KtxScanConnector {
         error?: string;
     }>;
     introspect(input: KtxScanInput, _ctx: KtxScanContext): Promise<KtxSchemaSnapshot>;
+    listSchemas(): Promise<string[]>;
+    listTables(_schemas?: string[]): Promise<KtxTableListEntry[]>;
     sampleTable(input: KtxTableSampleInput, _ctx: KtxScanContext): Promise<KtxTableSampleResult>;
     sampleColumn(input: KtxColumnSampleInput, _ctx: KtxScanContext): Promise<KtxColumnSampleResult>;
     columnStats(_input: KtxColumnStatsInput, _ctx: KtxScanContext): Promise<KtxColumnStatsResult | null>;

package/dist/connectors/sqlite/connector.js

@@ -3,11 +3,11 @@ import { existsSync, readFileSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { isAbsolute, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { getDialectForDriver } from '../../context/connections/dialects.js';
 import { assertReadOnlySql, limitSqlForExecution } from '../../context/connections/read-only-sql.js';
 import { normalizeQueryRows } from '../../context/connections/query-executor.js';
 import { createKtxConnectorCapabilities } from '../../context/scan/types.js';
 import { scopedTableNames } from '../../context/scan/table-ref.js';
-import { KtxSqliteDialect } from './dialect.js';
 function stringConfigValue(connection, key) {
     const value = connection?.[key];
     return typeof value === 'string' && value.trim().length > 0 ? resolveStringReference(key, value.trim()) : undefined;
@@ -60,7 +60,7 @@ function stripLeadingSqlComments(sql) {
 }
 export function isKtxSqliteConnectionConfig(connection) {
     const driver = String(connection?.driver ?? '').toLowerCase();
-    return driver === 'sqlite' || driver === 'sqlite3';
+    return driver === 'sqlite';
 }
 /** @internal */
 export function sqliteDatabasePathFromConfig(input) {
@@ -89,7 +89,7 @@ export class KtxSqliteScanConnector {
     connectionId;
     dbPath;
     now;
-    dialect = new KtxSqliteDialect();
+    dialect = getDialectForDriver('sqlite');
     db = null;
     constructor(options) {
         this.connectionId = options.connectionId;
@@ -135,6 +135,26 @@ export class KtxSqliteScanConnector {
             tables,
         };
     }
+    async listSchemas() {
+        return [];
+    }
+    async listTables(_schemas) {
+        const rows = this.database()
+            .prepare(`
+      SELECT name, type
+      FROM sqlite_master
+      WHERE type IN ('table', 'view')
+        AND name NOT LIKE 'sqlite_%'
+      ORDER BY name
+      `)
+            .all();
+        return rows.map((row) => ({
+            catalog: null,
+            schema: '',
+            name: row.name,
+            kind: row.type === 'view' ? 'view' : 'table',
+        }));
+    }
     async sampleTable(input, _ctx) {
         this.assertConnection(input.connectionId);
         const result = this.query(this.dialect.generateSampleQuery(this.qTableName(input.table), input.limit, input.columns));

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

@@ -1,29 +1,31 @@
+import type { KtxDialect } from '../../context/connections/dialects.js';
 import type { KtxSchemaDimensionType, KtxTableRef } from '../../context/scan/types.js';
 type SqliteTableNameRef = Pick<KtxTableRef, 'name'> & Partial<Pick<KtxTableRef, 'catalog' | 'db'>>;
-export declare class KtxSqliteDialect {
-    readonly type = "sqlite";
+/** @internal */
+export declare class KtxSqliteDialect implements KtxDialect {
+    readonly type: "sqlite";
     private readonly typeMappings;
     quoteIdentifier(identifier: string): string;
     formatTableName(table: SqliteTableNameRef): string;
+    formatDisplayRef(table: SqliteTableNameRef): 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?: unknown;
-    };
     getRandomSampleFilter(samplePct: number): string;
     getTableSampleClause(_samplePct: 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/sqlite/dialect.js

@@ -1,3 +1,5 @@
+import { columnDisplayPartCount, formatDialectDisplayRef, formatDialectTableName, limitOffsetClause, parseDialectDisplayRef, } from '../../context/connections/dialect-helpers.js';
+/** @internal */
 export class KtxSqliteDialect {
     type = 'sqlite';
     typeMappings = {
@@ -22,7 +24,16 @@ export class KtxSqliteDialect {
         return `"${identifier.replace(/"/g, '""')}"`;
     }
     formatTableName(table) {
-        return this.quoteIdentifier(table.name);
+        return formatDialectTableName(table, this.quoteIdentifier.bind(this), 'sqlite');
+    }
+    formatDisplayRef(table) {
+        return formatDialectDisplayRef(table, 'sqlite');
+    }
+    parseDisplayRef(display) {
+        return parseDialectDisplayRef(display, 'sqlite');
+    }
+    columnDisplayTablePartCount() {
+        return columnDisplayPartCount('sqlite');
     }
     mapDataType(nativeType) {
         return nativeType;
@@ -61,9 +72,6 @@ export class KtxSqliteDialect {
         const quoted = this.quoteIdentifier(columnName);
         return `SELECT ${quoted} FROM ${tableName} WHERE ${quoted} IS NOT NULL AND TRIM(CAST(${quoted} AS TEXT)) != '' LIMIT ${limit}`;
     }
-    prepareQuery(sql, params) {
-        return params ? { sql, params } : { sql };
-    }
     getRandomSampleFilter(samplePct) {
         if (samplePct <= 0 || samplePct >= 1) {
             return '';
@@ -74,7 +82,10 @@ export class KtxSqliteDialect {
         return '';
     }
     getLimitOffsetClause(limit, offset) {
-        return offset !== undefined && offset > 0 ? `LIMIT ${limit} OFFSET ${offset}` : `LIMIT ${limit}`;
+        return limitOffsetClause(limit, offset);
+    }
+    getTopClause(_limit) {
+        return '';
     }
     getNullCountExpression(column) {
         return `SUM(CASE WHEN ${column} IS NULL THEN 1 ELSE 0 END)`;
@@ -82,6 +93,15 @@ export class KtxSqliteDialect {
     getDistinctCountExpression(column) {
         return `COUNT(DISTINCT ${column})`;
     }
+    textLengthExpression(columnSql) {
+        return `LENGTH(CAST(${columnSql} AS TEXT))`;
+    }
+    castToText(columnSql) {
+        return `CAST(${columnSql} AS TEXT)`;
+    }
+    getSampleValueAggregation(innerSql) {
+        return `(SELECT GROUP_CONCAT(CAST(value AS TEXT), char(31)) FROM (${innerSql}) AS relationship_profile_values)`;
+    }
     generateCardinalitySampleQuery(tableName, columnName, sampleSize) {
         return `
       WITH sampled AS (
@@ -119,28 +139,4 @@ export class KtxSqliteDialect {
       FROM sampled
     `;
     }
-    getTimeTruncExpression(column, granularity, _timezone) {
-        switch (granularity) {
-            case 'day':
-                return `DATE(${column})`;
-            case 'week':
-                return `DATE(${column}, 'weekday 0', '-6 days')`;
-            case 'month':
-                return `DATE(${column}, 'start of month')`;
-            case 'quarter':
-                return `DATE(${column}, 'start of month', '-' || ((CAST(STRFTIME('%m', ${column}) AS INTEGER) - 1) % 3) || ' months')`;
-            case 'year':
-                return `DATE(${column}, 'start of year')`;
-        }
-    }
-    getCustomTimeTruncExpression(column, interval, origin, _timezone) {
-        const [amount, unit] = interval.split(' ');
-        const originExpr = origin ? `julianday('${origin}')` : `julianday('1970-01-01')`;
-        const unitDays = unit === 'day' ? 1 : unit === 'week' ? 7 : 30;
-        const intervalDays = Number(amount) * unitDays;
-        return `DATE(julianday('1970-01-01') + (CAST((julianday(${column}) - ${originExpr}) / ${intervalDays} AS INTEGER) * ${intervalDays}))`;
-    }
-    parseIntervalToSql(interval) {
-        return `'${interval}'`;
-    }
 }

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

@@ -11,6 +11,7 @@ export interface KtxSqlServerConnectionConfig {
     schema?: string;
     schemas?: string[];
     trustServerCertificate?: boolean;
+    maxConnections?: number;
     [key: string]: unknown;
 }
 export interface KtxSqlServerPoolConfig {
@@ -85,6 +86,11 @@ export interface KtxSqlServerColumnDistinctValuesResult {
 interface KtxSqlServerTableSampleResult extends KtxTableSampleResult {
     headerTypes?: string[];
 }
+/** @internal */
+export declare function prepareSqlServerReadOnlyQuery(sql: string, params?: Record<string, unknown>): {
+    sql: string;
+    params?: Record<string, unknown>;
+};
 export declare function isKtxSqlServerConnectionConfig(connection: KtxSqlServerConnectionConfig | undefined): connection is KtxSqlServerConnectionConfig;
 /** @internal */
 export declare function sqlServerConnectionPoolConfigFromConfig(input: {