@kaelio/ktx 0.5.0 → 0.6.0

package/dist/clack.d.ts

@@ -1,3 +1,11 @@
+import type { KtxCliIo } from './cli-runtime.js';
+export interface RailBufferedSource {
+    stdoutText(): string;
+    stderrText(): string;
+}
+export declare function errorMessage(error: unknown): string;
+export declare function writePrefixedLines(write: (chunk: string) => void, output: string): void;
+export declare function flushPrefixedBufferedCommandOutput(io: KtxCliIo, buffered: RailBufferedSource): void;
 export interface KtxCliSpinner {
     start(message: string): void;
     message(message: string): void;

package/dist/clack.js

@@ -1,5 +1,19 @@
 import { cancel, confirm, isCancel, log, spinner } from '@clack/prompts';
 const ESC = String.fromCharCode(0x1b);
+export function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export function writePrefixedLines(write, output) {
+    for (const line of output.split(/\r?\n/)) {
+        if (line.length > 0) {
+            write(`│  ${line}\n`);
+        }
+    }
+}
+export function flushPrefixedBufferedCommandOutput(io, buffered) {
+    writePrefixedLines((chunk) => io.stdout.write(chunk), buffered.stdoutText());
+    writePrefixedLines((chunk) => io.stderr.write(chunk), buffered.stderrText());
+}
 class KtxCliPromptCancelledError extends Error {
     constructor(message = 'Operation cancelled.') {
         super(message);

package/dist/connection.js

@@ -4,6 +4,7 @@ import { NotionClient } from './context/ingest/adapters/notion/notion-client.js'
 import { createLocalLookerCredentialResolver } from './context/ingest/adapters/looker/local-looker.adapter.js';
 import { metabaseRuntimeConfigFromLocalConnection } from './context/ingest/adapters/metabase/local-metabase.adapter.js';
 import { testRepoConnection } from './context/ingest/repo-fetch.js';
+import { getDriverRegistration } from './context/connections/drivers.js';
 import { parseNotionConnectionConfig, resolveNotionConnectionAuthToken } from './context/connections/notion-config.js';
 import { resolveKtxConfigReference } from './context/core/config-reference.js';
 import { loadKtxProject } from './context/project/project.js';
@@ -159,15 +160,7 @@ async function testConnectionByDriver(project, connectionId, deps) {
         const result = await testGitRepoConnection(project, connectionId, driver, deps.testRepoConnection ?? testRepoConnection);
         return { driver, detailKey: 'Repo', detailValue: result.repoUrl };
     }
-    if (driver === 'sqlite' ||
-        driver === 'sqlite3' ||
-        driver === 'postgres' ||
-        driver === 'postgresql' ||
-        driver === 'mysql' ||
-        driver === 'clickhouse' ||
-        driver === 'sqlserver' ||
-        driver === 'bigquery' ||
-        driver === 'snowflake') {
+    if (getDriverRegistration(driver)) {
         const result = await testNativeConnection(project, connectionId, deps.createScanConnector ?? createKtxCliScanConnector);
         return { driver: result.driver, detailKey: 'Status', detailValue: 'ok' };
     }

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

@@ -96,6 +96,11 @@ export interface KtxBigQueryScanConnectorOptions {
     maxBytesBilled?: number | string;
     queryTimeoutMs?: number;
 }
+/** @internal */
+export declare function prepareBigQueryReadOnlyQuery(sql: string, params?: Record<string, unknown>): {
+    sql: string;
+    params?: Record<string, unknown>;
+};
 export declare function isKtxBigQueryConnectionConfig(connection: KtxBigQueryConnectionConfig | undefined): connection is KtxBigQueryConnectionConfig;
 /** @internal */
 export declare function bigQueryConnectionConfigFromConfig(input: {
@@ -131,7 +136,7 @@ export declare class KtxBigQueryScanConnector implements KtxScanConnector {
     getTableRowCount(tableName: string, datasetId?: string): Promise<number>;
     qTableName(table: Pick<KtxTableRef, 'name'> & Partial<Pick<KtxTableRef, 'catalog' | 'db'>>): string;
     quoteIdentifier(identifier: string): string;
-    listDatasets(): Promise<string[]>;
+    listSchemas(): Promise<string[]>;
     listTables(datasetIds?: string[]): Promise<KtxTableListEntry[]>;
     cleanup(): Promise<void>;
     private getClient;

package/dist/connectors/bigquery/connector.js

@@ -1,12 +1,13 @@
 import { BigQuery } from '@google-cloud/bigquery';
 import { normalizeBigQueryProjectId, normalizeBigQueryRegion } from '../../context/connections/bigquery-identifiers.js';
+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 { readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { resolve } from 'node:path';
-import { KtxBigQueryDialect } from './dialect.js';
 class DefaultBigQueryClientFactory {
     createClient(input) {
         const client = new BigQuery(input);
@@ -79,6 +80,14 @@ function firstNumber(value) {
     const numberValue = Number(value);
     return Number.isFinite(numberValue) ? numberValue : null;
 }
+function isDeniedError(error) {
+    if (!error || typeof error !== 'object') {
+        return false;
+    }
+    const candidate = error;
+    return (candidate.code === 403 ||
+        candidate.errors?.some((item) => item.reason === 'accessDenied' || item.reason === 'notFound') === true);
+}
 function normalizeValue(value) {
     if (value === null || value === undefined) {
         return null;
@@ -97,6 +106,19 @@ function normalizeValue(value) {
     }
     return value;
 }
+/** @internal */
+export function prepareBigQueryReadOnlyQuery(sql, params) {
+    if (!params) {
+        return { sql, params: undefined };
+    }
+    let processedSql = sql;
+    const processedParams = {};
+    for (const [key, value] of Object.entries(params)) {
+        processedSql = processedSql.replace(new RegExp(`:${key}\\b`, 'g'), `@${key}`);
+        processedParams[key] = value;
+    }
+    return { sql: processedSql, params: Object.keys(processedParams).length > 0 ? processedParams : undefined };
+}
 export function isKtxBigQueryConnectionConfig(connection) {
     return String(connection?.driver ?? '').toLowerCase() === 'bigquery';
 }
@@ -138,7 +160,7 @@ export class KtxBigQueryScanConnector {
     now;
     maxBytesBilled;
     queryTimeoutMs;
-    dialect = new KtxBigQueryDialect();
+    dialect = getDialectForDriver('bigquery');
     client = null;
     constructor(options) {
         this.connectionId = options.connectionId;
@@ -170,11 +192,12 @@ export class KtxBigQueryScanConnector {
         this.assertConnection(input.connectionId);
         const tables = [];
         const datasetIds = this.requireDatasetIdsForScan();
+        const snapshotWarnings = [];
         for (const datasetId of datasetIds) {
             const scopedNames = input.tableScope
                 ? scopedTableNames(input.tableScope, { catalog: this.resolved.projectId, db: datasetId })
                 : null;
-            tables.push(...(await this.introspectDataset(datasetId, scopedNames)));
+            tables.push(...(await this.introspectDataset(datasetId, scopedNames, snapshotWarnings)));
         }
         return {
             connectionId: this.connectionId,
@@ -188,6 +211,7 @@ export class KtxBigQueryScanConnector {
                 total_columns: tables.reduce((sum, table) => sum + table.columns.length, 0),
             },
             tables,
+            warnings: snapshotWarnings,
         };
     }
     async sampleTable(input, _ctx) {
@@ -206,7 +230,7 @@ export class KtxBigQueryScanConnector {
     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 = prepareBigQueryReadOnlyQuery(limitedSql, input.params);
         const result = await this.query(prepared.sql, prepared.params);
         return { ...result, rowCount: result.rows.length };
     }
@@ -230,7 +254,7 @@ export class KtxBigQueryScanConnector {
         if (!datasetId) {
             return 0;
         }
-        const tables = await this.introspectDataset(datasetId, null);
+        const tables = await this.introspectDataset(datasetId, null, []);
         return tables.find((table) => table.name === tableName)?.estimatedRows ?? 0;
     }
     qTableName(table) {
@@ -239,7 +263,7 @@ export class KtxBigQueryScanConnector {
     quoteIdentifier(identifier) {
         return this.dialect.quoteIdentifier(identifier);
     }
-    async listDatasets() {
+    async listSchemas() {
         const [datasets] = await this.getClient().getDatasets();
         return datasets.map((dataset) => dataset.id).filter((id) => Boolean(id));
     }
@@ -261,6 +285,7 @@ export class KtxBigQueryScanConnector {
     ORDER BY table_schema, table_name
     `, params);
         return rows.map((row) => ({
+            catalog: this.resolved.projectId,
             schema: row.table_schema,
             name: row.table_name,
             kind: row.table_type === 'VIEW' || row.table_type === 'MATERIALIZED VIEW'
@@ -316,14 +341,18 @@ export class KtxBigQueryScanConnector {
         const rows = await this.queryRaw(sql);
         return firstNumber(rows[0]?.[header]);
     }
-    async introspectDataset(datasetId, scopedNames) {
+    async introspectDataset(datasetId, scopedNames, snapshotWarnings) {
         if (scopedNames && scopedNames.length === 0)
             return [];
         const dataset = this.getClient().dataset(datasetId);
         const [tableRefs] = await dataset.getTables();
         const scopeSet = scopedNames ? new Set(scopedNames) : null;
         const filteredTableRefs = scopeSet ? tableRefs.filter((tableRef) => scopeSet.has(tableRef.id ?? '')) : tableRefs;
-        const primaryKeys = await this.primaryKeys(datasetId);
+        const primaryKeysResult = await tryConstraintQuery({ schema: datasetId, kind: 'primary_key', isDeniedError }, () => this.primaryKeys(datasetId));
+        const primaryKeys = primaryKeysResult.ok ? primaryKeysResult.value : new Map();
+        if (!primaryKeysResult.ok) {
+            snapshotWarnings.push(primaryKeysResult.warning);
+        }
         const tables = [];
         for (const tableRef of filteredTableRefs) {
             const tableName = tableRef.id || '';

package/dist/connectors/bigquery/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 BigQueryTableNameRef = Pick<KtxTableRef, 'name'> & Partial<Pick<KtxTableRef, 'catalog' | 'db'>>;
-export declare class KtxBigQueryDialect {
-    readonly type = "bigquery";
+/** @internal */
+export declare class KtxBigQueryDialect implements KtxDialect {
+    readonly type: "bigquery";
     private readonly typeMappings;
     quoteIdentifier(identifier: string): string;
     formatTableName(table: BigQueryTableNameRef): string;
+    formatDisplayRef(table: BigQueryTableNameRef): 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;
+    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/bigquery/dialect.js

@@ -1,3 +1,5 @@
+import { columnDisplayPartCount, formatDialectDisplayRef, formatDialectTableName, limitOffsetClause, parseDialectDisplayRef, } from '../../context/connections/dialect-helpers.js';
+/** @internal */
 export class KtxBigQueryDialect {
     type = 'bigquery';
     typeMappings = {
@@ -20,13 +22,16 @@ export class KtxBigQueryDialect {
         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) {
         const fieldType = nativeType.toUpperCase().trim();
@@ -80,18 +85,6 @@ export class KtxBigQueryDialect {
         const quotedColumn = this.quoteIdentifier(columnName);
         return `SELECT ${quotedColumn} FROM ${tableName} WHERE ${quotedColumn} IS NOT NULL AND TRIM(CAST(${quotedColumn} AS STRING)) != '' ORDER BY RAND() LIMIT ${limit}`;
     }
-    prepareQuery(sql, params) {
-        if (!params) {
-            return { sql, params: undefined };
-        }
-        let processedSql = sql;
-        const processedParams = {};
-        for (const [key, value] of Object.entries(params)) {
-            processedSql = processedSql.replace(new RegExp(`:${key}\\b`, 'g'), `@${key}`);
-            processedParams[key] = value;
-        }
-        return { sql: processedSql, params: Object.keys(processedParams).length > 0 ? processedParams : undefined };
-    }
     getRandomSampleFilter(samplePct) {
         if (samplePct <= 0 || samplePct >= 1) {
             return '';
@@ -105,7 +98,10 @@ export class KtxBigQueryDialect {
         return `TABLESAMPLE SYSTEM (${samplePct * 100} PERCENT)`;
     }
     getLimitOffsetClause(limit, offset) {
-        return offset !== undefined && offset > 0 ? `LIMIT ${limit} OFFSET ${offset}` : `LIMIT ${limit}`;
+        return limitOffsetClause(limit, offset);
+    }
+    getTopClause(_limit) {
+        return '';
     }
     getNullCountExpression(column) {
         return `COUNTIF(${column} IS NULL)`;
@@ -113,6 +109,15 @@ export class KtxBigQueryDialect {
     getDistinctCountExpression(column) {
         return `APPROX_COUNT_DISTINCT(${column})`;
     }
+    textLengthExpression(columnSql) {
+        return `LENGTH(CAST(${columnSql} AS STRING))`;
+    }
+    castToText(columnSql) {
+        return `CAST(${columnSql} AS STRING)`;
+    }
+    getSampleValueAggregation(innerSql) {
+        return `(SELECT STRING_AGG(CAST(value AS STRING), '\\u001F') FROM (${innerSql}) AS relationship_profile_values)`;
+    }
     generateCardinalitySampleQuery(tableName, columnName, sampleSize) {
         return `
       WITH sampled AS (
@@ -150,29 +155,4 @@ export class KtxBigQueryDialect {
       FROM sampled
     `;
     }
-    getTimeTruncExpression(column, granularity, timezone) {
-        const bigQueryGranularity = granularity.toUpperCase();
-        if (timezone) {
-            return `DATE_TRUNC(DATETIME(${column}, '${timezone}'), ${bigQueryGranularity})`;
-        }
-        return `DATE_TRUNC(${column}, ${bigQueryGranularity})`;
-    }
-    getCustomTimeTruncExpression(column, interval, origin, timezone) {
-        const col = timezone ? `DATETIME(${column}, '${timezone}')` : column;
-        const [rawAmount, rawUnit] = interval.split(' ');
-        let diffUnit = rawUnit.toUpperCase();
-        let amount = Number(rawAmount);
-        let addUnit = diffUnit;
-        if (diffUnit === 'WEEK') {
-            diffUnit = 'DAY';
-            amount = amount * 7;
-            addUnit = 'DAY';
-        }
-        const originExpr = origin ? `TIMESTAMP '${origin}'` : `TIMESTAMP '1970-01-01'`;
-        return `TIMESTAMP_ADD(${originExpr}, INTERVAL CAST(FLOOR(TIMESTAMP_DIFF(${col}, ${originExpr}, ${diffUnit}) / ${amount}) * ${amount} AS INT64) ${addUnit})`;
-    }
-    parseIntervalToSql(interval) {
-        const [amount, unit] = interval.split(' ');
-        return `INTERVAL ${amount} ${unit.toUpperCase()}`;
-    }
 }

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

@@ -68,6 +68,11 @@ export interface KtxClickHouseColumnDistinctValuesResult {
     values: string[] | null;
     cardinality: number;
 }
+/** @internal */
+export declare function prepareClickHouseReadOnlyQuery(sql: string, params?: Record<string, unknown>): {
+    sql: string;
+    params?: Record<string, unknown>;
+};
 export declare function isKtxClickHouseConnectionConfig(connection: KtxClickHouseConnectionConfig | undefined): connection is KtxClickHouseConnectionConfig;
 /** @internal */
 export declare function clickHouseClientConfigFromConfig(input: {

package/dist/connectors/clickhouse/connector.js

@@ -1,4 +1,5 @@
 import { createClient } from '@clickhouse/client';
+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 { scopedTableNames } from '../../context/scan/table-ref.js';
@@ -6,7 +7,6 @@ import { readFileSync } from 'node:fs';
 import { Agent as HttpsAgent } from 'node:https';
 import { homedir } from 'node:os';
 import { resolve } from 'node:path';
-import { KtxClickHouseDialect } from './dialect.js';
 class DefaultClickHouseClientFactory {
     createClient(config) {
         return createClient(config);
@@ -62,6 +62,38 @@ function configuredClickHouseDatabases(connection, fallbackDatabase) {
 function clickHouseTableKey(database, table) {
     return `${database}.${table}`;
 }
+function inferClickHouseQueryParamType(value) {
+    if (value === null || value === undefined) {
+        return 'String';
+    }
+    if (typeof value === 'boolean') {
+        return 'Bool';
+    }
+    if (typeof value === 'number') {
+        return Number.isInteger(value) ? 'Int64' : 'Float64';
+    }
+    if (value instanceof Date) {
+        return 'DateTime';
+    }
+    return 'String';
+}
+/** @internal */
+export function prepareClickHouseReadOnlyQuery(sql, params) {
+    if (!params) {
+        return { sql, params: undefined };
+    }
+    let parameterizedQuery = sql;
+    const queryParams = {};
+    const sortedKeys = Object.keys(params).sort((a, b) => b.length - a.length);
+    for (const key of sortedKeys) {
+        const placeholder = `:${key}`;
+        if (parameterizedQuery.includes(placeholder)) {
+            parameterizedQuery = parameterizedQuery.replace(new RegExp(`:${key}\\b`, 'g'), `{${key}:${inferClickHouseQueryParamType(params[key])}}`);
+            queryParams[key] = params[key];
+        }
+    }
+    return { sql: parameterizedQuery, params: Object.keys(queryParams).length > 0 ? queryParams : undefined };
+}
 export function isKtxClickHouseConnectionConfig(connection) {
     return String(connection?.driver ?? '').toLowerCase() === 'clickhouse';
 }
@@ -108,7 +140,7 @@ export class KtxClickHouseScanConnector {
     clientFactory;
     endpointResolver;
     now;
-    dialect = new KtxClickHouseDialect();
+    dialect = getDialectForDriver('clickhouse');
     client = null;
     resolvedEndpoint = null;
     constructor(options) {
@@ -237,7 +269,7 @@ export class KtxClickHouseScanConnector {
     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 = prepareClickHouseReadOnlyQuery(limitedSql, input.params);
         const result = await this.query(prepared.sql, prepared.params);
         return { ...result, rowCount: result.rows.length };
     }
@@ -298,6 +330,7 @@ export class KtxClickHouseScanConnector {
       ORDER BY database, name
       `, { schemas: filterSchemas });
         return rows.map((row) => ({
+            catalog: null,
             schema: row.database,
             name: row.name,
             kind: row.engine === 'View' || row.engine === 'MaterializedView' ? 'view' : 'table',

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

@@ -1,33 +1,32 @@
+import type { KtxDialect } from '../../context/connections/dialects.js';
 import type { KtxSchemaDimensionType, KtxTableRef } from '../../context/scan/types.js';
 type ClickHouseTableNameRef = Pick<KtxTableRef, 'name'> & Partial<Pick<KtxTableRef, 'catalog' | 'db'>>;
-export declare class KtxClickHouseDialect {
-    readonly type = "clickhouse";
+/** @internal */
+export declare class KtxClickHouseDialect implements KtxDialect {
+    readonly type: "clickhouse";
     private readonly typeMappings;
     quoteIdentifier(identifier: string): string;
     formatTableName(table: ClickHouseTableNameRef): string;
+    formatDisplayRef(table: ClickHouseTableNameRef): 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;
+    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;
     private unwrapClickHouseType;
-    private inferClickHouseType;
-    private toClickHouseDateDiffUnit;
-    private intervalToSeconds;
 }
 export {};

package/dist/connectors/clickhouse/dialect.js

@@ -1,3 +1,5 @@
+import { columnDisplayPartCount, formatDialectDisplayRef, formatDialectTableName, limitOffsetClause, parseDialectDisplayRef, } from '../../context/connections/dialect-helpers.js';
+/** @internal */
 export class KtxClickHouseDialect {
     type = 'clickhouse';
     typeMappings = {
@@ -38,9 +40,16 @@ export class KtxClickHouseDialect {
         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;
@@ -80,22 +89,6 @@ export class KtxClickHouseDialect {
         const quotedColumn = this.quoteIdentifier(columnName);
         return `SELECT ${quotedColumn} FROM ${tableName} WHERE ${quotedColumn} IS NOT NULL AND trim(toString(${quotedColumn})) != '' LIMIT ${limit}`;
     }
-    prepareQuery(sql, params) {
-        if (!params) {
-            return { sql, params: undefined };
-        }
-        let parameterizedQuery = sql;
-        const queryParams = {};
-        const sortedKeys = Object.keys(params).sort((a, b) => b.length - a.length);
-        for (const key of sortedKeys) {
-            const placeholder = `:${key}`;
-            if (parameterizedQuery.includes(placeholder)) {
-                parameterizedQuery = parameterizedQuery.replace(new RegExp(`:${key}\\b`, 'g'), `{${key}:${this.inferClickHouseType(params[key])}}`);
-                queryParams[key] = params[key];
-            }
-        }
-        return { sql: parameterizedQuery, params: queryParams };
-    }
     getRandomSampleFilter(samplePct) {
         if (samplePct <= 0 || samplePct >= 1) {
             return '';
@@ -106,7 +99,10 @@ export class KtxClickHouseDialect {
         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 `countIf(${column} IS NULL)`;
@@ -114,6 +110,15 @@ export class KtxClickHouseDialect {
     getDistinctCountExpression(column) {
         return `COUNT(DISTINCT ${column})`;
     }
+    textLengthExpression(columnSql) {
+        return `length(toString(${columnSql}))`;
+    }
+    castToText(columnSql) {
+        return `toString(${columnSql})`;
+    }
+    getSampleValueAggregation(innerSql) {
+        return `(SELECT arrayStringConcat(groupArray(toString(value)), '\\x1F') FROM (${innerSql}) AS relationship_profile_values)`;
+    }
     generateCardinalitySampleQuery(tableName, columnName, sampleSize) {
         return `
       SELECT COUNT(DISTINCT val) AS cardinality
@@ -149,88 +154,8 @@ export class KtxClickHouseDialect {
       )
     `;
     }
-    getTimeTruncExpression(column, granularity, timezone) {
-        const tz = timezone ? `, '${timezone}'` : '';
-        switch (granularity) {
-            case 'day':
-                return `toStartOfDay(${column}${tz})`;
-            case 'week':
-                return `toStartOfWeek(${column}, 1${tz})`;
-            case 'month':
-                return `toStartOfMonth(${column}${tz})`;
-            case 'quarter':
-                return `toStartOfQuarter(${column}${tz})`;
-            case 'year':
-                return `toStartOfYear(${column}${tz})`;
-        }
-    }
-    getCustomTimeTruncExpression(column, interval, origin, timezone) {
-        const col = timezone ? `toTimezone(${column}, '${timezone}')` : column;
-        const [rawAmount, rawUnit] = interval.split(' ');
-        const amount = Number(rawAmount);
-        const unit = rawUnit.toLowerCase();
-        const originExpr = origin ? `toDateTime('${origin}')` : "toDateTime('1970-01-01')";
-        const calendarUnit = this.toClickHouseDateDiffUnit(unit);
-        if (calendarUnit) {
-            return `dateAdd(${calendarUnit}, intDiv(dateDiff(${calendarUnit}, ${originExpr}, ${col}), ${amount}) * ${amount}, ${originExpr})`;
-        }
-        const seconds = this.intervalToSeconds(amount, unit);
-        return `addSeconds(${originExpr}, intDiv(toUInt64(dateDiff('second', ${originExpr}, ${col})), ${seconds}) * ${seconds})`;
-    }
-    parseIntervalToSql(interval) {
-        const [amount, unit] = interval.split(' ');
-        return `INTERVAL ${amount} ${unit.toUpperCase()}`;
-    }
     unwrapClickHouseType(value, wrapper) {
         const prefix = `${wrapper}(`;
         return value.startsWith(prefix) && value.endsWith(')') ? value.slice(prefix.length, -1) : value;
     }
-    inferClickHouseType(value) {
-        if (value === null || value === undefined) {
-            return 'String';
-        }
-        if (typeof value === 'boolean') {
-            return 'Bool';
-        }
-        if (typeof value === 'number') {
-            return Number.isInteger(value) ? 'Int64' : 'Float64';
-        }
-        if (value instanceof Date) {
-            return 'DateTime';
-        }
-        return 'String';
-    }
-    toClickHouseDateDiffUnit(unit) {
-        if (unit === 'month' || unit === 'months') {
-            return "'month'";
-        }
-        if (unit === 'quarter' || unit === 'quarters') {
-            return "'quarter'";
-        }
-        if (unit === 'year' || unit === 'years') {
-            return "'year'";
-        }
-        return null;
-    }
-    intervalToSeconds(amount, unit) {
-        switch (unit) {
-            case 'second':
-            case 'seconds':
-                return amount;
-            case 'minute':
-            case 'minutes':
-                return amount * 60;
-            case 'hour':
-            case 'hours':
-                return amount * 3600;
-            case 'day':
-            case 'days':
-                return amount * 86400;
-            case 'week':
-            case 'weeks':
-                return amount * 604800;
-            default:
-                return amount * 86400;
-        }
-    }
 }