@kaelio/ktx 0.5.0 → 0.7.0

package/dist/context/scan/constraint-discovery.js

@@ -0,0 +1,23 @@
+export function constraintDiscoveryWarning(input) {
+    return {
+        code: 'constraint_discovery_unauthorized',
+        message: `Skipped ${input.kind === 'primary_key' ? 'primary-key' : 'foreign-key'} ` +
+            `discovery in ${input.schema} (insufficient grants on system catalogs)`,
+        recoverable: true,
+        metadata: { schema: input.schema, kind: input.kind },
+    };
+}
+export async function tryConstraintQuery(ctx, fn) {
+    try {
+        return { ok: true, value: await fn() };
+    }
+    catch (error) {
+        if (!ctx.isDeniedError(error)) {
+            throw error;
+        }
+        return {
+            ok: false,
+            warning: constraintDiscoveryWarning({ schema: ctx.schema, kind: ctx.kind }),
+        };
+    }
+}

package/dist/context/scan/enabled-tables.d.ts

@@ -1,4 +1,5 @@
 import { type KtxTableRefKey } from './table-ref.js';
+import type { KtxTableRef } from './types.js';
 /**
  * Parses the `enabled_tables` field on a connection into a scope of
  * fully-qualified table refs. Returns `null` when the field is absent or
@@ -6,11 +7,9 @@ import { type KtxTableRefKey } from './table-ref.js';
  *
  * Accepted entry forms:
  *   "catalog.db.name"  — fully qualified
- *   "db.name"          — schema-qualified (catalog = null; legacy / Postgres-shape)
+ *   "db.name"          — schema-qualified (catalog = null)
  *   "name"             — bare (catalog = db = null; SQLite-shape)
- *   { catalog?, db?, name }  — escape hatch for identifiers containing dots
- *
- * The setup wizard writes the fully-qualified form going forward; the lenient
- * parser keeps existing project configs working.
  */
 export declare function resolveEnabledTables(connection: Record<string, unknown> | undefined): ReadonlySet<KtxTableRefKey> | null;
+/** @internal */
+export declare function parseDottedTableEntry(value: string): KtxTableRef | null;

package/dist/context/scan/enabled-tables.js

@@ -6,12 +6,8 @@ import { tableRefSet } from './table-ref.js';
  *
  * Accepted entry forms:
  *   "catalog.db.name"  — fully qualified
- *   "db.name"          — schema-qualified (catalog = null; legacy / Postgres-shape)
+ *   "db.name"          — schema-qualified (catalog = null)
  *   "name"             — bare (catalog = db = null; SQLite-shape)
- *   { catalog?, db?, name }  — escape hatch for identifiers containing dots
- *
- * The setup wizard writes the fully-qualified form going forward; the lenient
- * parser keeps existing project configs working.
  */
 export function resolveEnabledTables(connection) {
     const raw = connection?.enabled_tables;
@@ -29,22 +25,12 @@ export function resolveEnabledTables(connection) {
 }
 function parseEnabledTableEntry(value) {
     if (typeof value === 'string') {
-        return parseDottedEntry(value);
-    }
-    if (value && typeof value === 'object' && !Array.isArray(value)) {
-        const entry = value;
-        const name = typeof entry.name === 'string' ? entry.name : null;
-        if (!name)
-            return null;
-        return {
-            catalog: typeof entry.catalog === 'string' ? entry.catalog : null,
-            db: typeof entry.db === 'string' ? entry.db : null,
-            name,
-        };
+        return parseDottedTableEntry(value);
     }
     return null;
 }
-function parseDottedEntry(value) {
+/** @internal */
+export function parseDottedTableEntry(value) {
     const trimmed = value.trim();
     if (trimmed.length === 0)
         return null;

package/dist/context/scan/entity-details.js

@@ -1,3 +1,4 @@
+import { getDialectForDriver } from '../connections/dialects.js';
 import { readLocalScanStructuralSnapshot } from './local-structural-artifacts.js';
 function normalize(value) {
     return (value ?? '').toLowerCase();
@@ -7,50 +8,18 @@ function refsEqual(left, right) {
         normalize(left.db) === normalize(right.db) &&
         normalize(left.name) === normalize(right.name));
 }
-function cleanIdentifierPart(part) {
-    return part.trim().replace(/^["'`\[]|["'`\]]$/g, '');
-}
-function splitDisplay(display) {
-    return display
-        .trim()
-        .split('.')
-        .map(cleanIdentifierPart)
-        .filter(Boolean);
-}
-function displayForTable(driver, table) {
-    if (driver === 'sqlite') {
-        return table.name;
-    }
-    return [table.catalog, table.db, table.name].filter((part) => Boolean(part)).join('.');
-}
 function tableRef(table) {
     return { catalog: table.catalog, db: table.db, name: table.name };
 }
-function candidateList(driver, tables) {
+function candidateList(dialect, tables) {
     return tables
         .map((table) => ({
         tableRef: tableRef(table),
-        display: displayForTable(driver, table),
+        display: dialect.formatDisplayRef(table),
     }))
         .sort((left, right) => left.display.localeCompare(right.display));
 }
-function parseDisplayRef(driver, display) {
-    const parts = splitDisplay(display);
-    if (driver === 'sqlite') {
-        return parts.length === 1 ? { catalog: null, db: null, name: parts[0] } : null;
-    }
-    if (driver === 'bigquery' || driver === 'snowflake' || driver === 'sqlserver') {
-        return parts.length === 3 ? { catalog: parts[0], db: parts[1], name: parts[2] } : null;
-    }
-    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;
-}
-function resolveTable(snapshot, input) {
+function resolveTable(snapshot, input, dialect) {
     if (typeof input !== 'string') {
         const table = snapshot.tables.find((candidate) => refsEqual(candidate, input)) ?? null;
         return table
@@ -59,12 +28,12 @@ function resolveTable(snapshot, input) {
                 table: null,
                 error: {
                     code: 'table_not_found',
-                    message: `Table not found in latest scan: ${displayForTable(snapshot.driver, input)}`,
-                    candidates: candidateList(snapshot.driver, snapshot.tables),
+                    message: `Table not found in latest scan: ${dialect.formatDisplayRef(input)}`,
+                    candidates: candidateList(dialect, snapshot.tables),
                 },
             };
     }
-    const parsed = parseDisplayRef(snapshot.driver, input);
+    const parsed = dialect.parseDisplayRef(input);
     if (parsed) {
         const table = snapshot.tables.find((candidate) => refsEqual(candidate, parsed)) ?? null;
         return table
@@ -74,7 +43,7 @@ function resolveTable(snapshot, input) {
                 error: {
                     code: 'table_not_found',
                     message: `Table not found in latest scan: ${input}`,
-                    candidates: candidateList(snapshot.driver, snapshot.tables),
+                    candidates: candidateList(dialect, snapshot.tables),
                 },
             };
     }
@@ -88,7 +57,7 @@ function resolveTable(snapshot, input) {
             error: {
                 code: 'ambiguous_table',
                 message: `Table name "${input}" is ambiguous across schemas/catalogs; pass a structured table ref.`,
-                candidates: candidateList(snapshot.driver, byName),
+                candidates: candidateList(dialect, byName),
             },
         };
     }
@@ -97,7 +66,7 @@ function resolveTable(snapshot, input) {
         error: {
             code: 'table_not_found',
             message: `Table not found in latest scan: ${input}`,
-            candidates: candidateList(snapshot.driver, snapshot.tables),
+            candidates: candidateList(dialect, snapshot.tables),
         },
     };
 }
@@ -164,9 +133,10 @@ export function createKtxEntityDetailsService(project) {
                 };
             }
             const info = snapshotInfo(scan.report, scan.snapshot);
+            const dialect = getDialectForDriver(scan.snapshot.driver);
             const results = [];
             for (const entity of input.entities) {
-                const resolved = resolveTable(scan.snapshot, entity.table);
+                const resolved = resolveTable(scan.snapshot, entity.table, dialect);
                 if (!resolved.table) {
                     results.push({
                         ok: false,
@@ -191,7 +161,7 @@ export function createKtxEntityDetailsService(project) {
                         snapshot: info,
                         error: {
                             code: 'column_not_found',
-                            message: `Column(s) not found on ${displayForTable(scan.snapshot.driver, resolved.table)}: ${missing.join(', ')}`,
+                            message: `Column(s) not found on ${dialect.formatDisplayRef(resolved.table)}: ${missing.join(', ')}`,
                             candidates: resolved.table.columns.map((column) => column.name),
                         },
                     });
@@ -201,7 +171,7 @@ export function createKtxEntityDetailsService(project) {
                     ok: true,
                     connectionId: input.connectionId,
                     tableRef: tableRef(resolved.table),
-                    display: displayForTable(scan.snapshot.driver, resolved.table),
+                    display: dialect.formatDisplayRef(resolved.table),
                     kind: resolved.table.kind,
                     comment: resolved.table.comment,
                     estimatedRows: resolved.table.estimatedRows,

package/dist/context/scan/local-enrichment.js

@@ -1,4 +1,5 @@
 import pLimit from 'p-limit';
+import { getDialectForDriver } from '../connections/dialects.js';
 import { buildDefaultKtxProjectConfig } from '../project/config.js';
 import { KtxDescriptionGenerator } from './description-generation.js';
 import { buildKtxColumnEmbeddingText } from './embedding-text.js';
@@ -35,6 +36,11 @@ function targetMatchesForeignKey(table, foreignKey) {
         (foreignKey.toCatalog === null || table.ref.catalog === foreignKey.toCatalog) &&
         (foreignKey.toDb === null || table.ref.db === foreignKey.toDb));
 }
+function assertConnectorDriverMatchesSnapshot(input) {
+    if (input.connector.driver !== input.snapshot.driver) {
+        throw new Error(`ktx scan connector driver "${input.connector.driver}" does not match snapshot driver "${input.snapshot.driver}" for connection "${input.connectionId}"`);
+    }
+}
 function formalRelationshipsFromSnapshot(snapshot, tables) {
     const tableById = new Map(tables.map((table) => [table.id, table]));
     const relationships = [];
@@ -319,6 +325,12 @@ export async function runLocalScanEnrichment(input) {
             detectRelationships: input.detectRelationships,
         }, input.context));
     await progress?.update(0.05, `Loaded schema snapshot with ${snapshot.tables.length} tables`);
+    assertConnectorDriverMatchesSnapshot({
+        connector: input.connector,
+        snapshot,
+        connectionId: input.connectionId,
+    });
+    const dialect = getDialectForDriver(snapshot.driver);
     const now = input.now ?? (() => new Date());
     const state = completedKtxScanEnrichmentStateSummary();
     const syncId = input.syncId ?? input.context.runId;
@@ -420,7 +432,7 @@ export async function runLocalScanEnrichment(input) {
                 await relationshipProgress?.update(0, 'Detecting relationships');
                 const detection = await discoverKtxRelationships({
                     connectionId: input.connectionId,
-                    driver: snapshot.driver,
+                    dialect,
                     connector: input.connector,
                     schema,
                     context: input.context,

package/dist/context/scan/local-scan.js

@@ -42,17 +42,15 @@ const LOCAL_AUTHOR_EMAIL = 'ktx@example.com';
 function normalizeDriver(driver) {
     const normalized = (driver ?? '').toLowerCase();
     if (normalized === 'postgres' ||
-        normalized === 'postgresql' ||
         normalized === 'sqlite' ||
-        normalized === 'sqlite3' ||
         normalized === 'mysql' ||
         normalized === 'clickhouse' ||
         normalized === 'sqlserver' ||
         normalized === 'bigquery' ||
         normalized === 'snowflake') {
-        return normalized === 'sqlite3' ? 'sqlite' : normalized;
+        return normalized;
     }
-    throw new Error(`Standalone ktx scan supports postgres/postgresql/sqlite/mysql/clickhouse/sqlserver/bigquery/snowflake in this phase, received "${driver ?? 'unknown'}"`);
+    throw new Error(`Standalone ktx scan supports postgres/sqlite/mysql/clickhouse/sqlserver/bigquery/snowflake in this phase, received "${driver ?? 'unknown'}"`);
 }
 function tablePathCount(paths) {
     return paths.filter((path) => path.startsWith('tables/') && path.endsWith('.json')).length;
@@ -311,6 +309,9 @@ export async function runLocalScan(options) {
                 extractedAtFallback: report.createdAt,
             });
             enrichmentSnapshot = rawSnapshot;
+            if (rawSnapshot.warnings?.length) {
+                report.warnings.push(...rawSnapshot.warnings);
+            }
             const manifestArtifacts = await writeLocalScanManifestShards({
                 project: options.project,
                 connectionId: options.connectionId,

package/dist/context/scan/local-structural-artifacts.js

@@ -4,6 +4,55 @@ function isRecord(value) {
 function metadataRecord(value) {
     return isRecord(value) ? value : {};
 }
+const scanWarningCodes = new Set([
+    'connector_capability_missing',
+    'sampling_failed',
+    'statistics_failed',
+    'llm_unavailable',
+    'embedding_unavailable',
+    'scan_enrichment_backend_not_configured',
+    'relationship_validation_failed',
+    'relationship_llm_invalid_reference',
+    'relationship_llm_proposal_failed',
+    'credential_redacted',
+    'enrichment_failed',
+    'description_fallback_used',
+    'constraint_discovery_unauthorized',
+]);
+function parseWarning(rawWarning, path) {
+    if (!isRecord(rawWarning) ||
+        typeof rawWarning.code !== 'string' ||
+        !scanWarningCodes.has(rawWarning.code) ||
+        typeof rawWarning.message !== 'string' ||
+        typeof rawWarning.recoverable !== 'boolean') {
+        throw new Error(`Invalid KTX schema warning artifact: ${path}`);
+    }
+    return {
+        code: rawWarning.code,
+        message: rawWarning.message,
+        recoverable: rawWarning.recoverable,
+        ...(typeof rawWarning.table === 'string' ? { table: rawWarning.table } : {}),
+        ...(typeof rawWarning.column === 'string' ? { column: rawWarning.column } : {}),
+        ...(isRecord(rawWarning.metadata) ? { metadata: rawWarning.metadata } : {}),
+    };
+}
+async function readWarnings(input) {
+    const path = `${input.rawSourcesDir}/warnings.json`;
+    try {
+        const warningRaw = await input.project.fileStore.readFile(path);
+        const parsed = JSON.parse(warningRaw.content);
+        if (!isRecord(parsed) || !Array.isArray(parsed.warnings)) {
+            throw new Error(`Invalid KTX schema warnings artifact: ${path}`);
+        }
+        return parsed.warnings.map((warning) => parseWarning(warning, path));
+    }
+    catch (error) {
+        if (error instanceof Error && /not found|ENOENT|no such file/i.test(error.message)) {
+            return [];
+        }
+        throw error;
+    }
+}
 function optionalStringOrNull(value) {
     if (value === undefined) {
         return undefined;
@@ -75,6 +124,7 @@ export async function readLocalScanStructuralSnapshot(input) {
         const tableRaw = await input.project.fileStore.readFile(path);
         tables.push(parseTable(tableRaw.content, path));
     }
+    const warnings = await readWarnings(input);
     return {
         connectionId: typeof connection.connectionId === 'string' ? connection.connectionId : input.connectionId,
         driver: input.driver,
@@ -82,5 +132,6 @@ export async function readLocalScanStructuralSnapshot(input) {
         scope: isRecord(connection.scope) ? connection.scope : {},
         metadata: metadataRecord(connection.metadata),
         tables,
+        warnings,
     };
 }

package/dist/context/scan/relationship-benchmarks.js

@@ -6,6 +6,7 @@ import { gunzipSync } from 'node:zlib';
 import Database from 'better-sqlite3';
 import YAML from 'yaml';
 import { z } from 'zod';
+import { getDialectForDriver } from '../connections/dialects.js';
 import { snapshotToKtxEnrichedSchema } from './local-enrichment.js';
 import { generateKtxRelationshipDiscoveryCandidates, mergeKtxRelationshipDiscoveryCandidates, } from './relationship-candidates.js';
 import { proposeKtxRelationshipCandidatesWithLlm } from './relationship-llm-proposal.js';
@@ -318,6 +319,7 @@ export function ktxRelationshipBenchmarkDetectorWithLlm(llmRuntime) {
             const formalLinks = formalMetadata.accepted.map((relationship) => relationshipToBenchmarkLink(relationship));
             const acceptedKeys = new Set(formalLinks.map(fkKey));
             const sqliteDataAvailable = Boolean(input.dataPath && input.snapshot.driver === 'sqlite');
+            const dialect = getDialectForDriver(input.snapshot.driver);
             const profilingExecutor = sqliteDataAvailable && input.mode !== 'profiling_disabled'
                 ? new KtxRelationshipBenchmarkSqliteExecutor(input.dataPath)
                 : null;
@@ -330,7 +332,7 @@ export function ktxRelationshipBenchmarkDetectorWithLlm(llmRuntime) {
                 })
                 : await profileKtxRelationshipSchema({
                     connectionId: input.snapshot.connectionId,
-                    driver: input.snapshot.driver,
+                    dialect,
                     schema: input.schema,
                     executor: profilingExecutor,
                     ctx: { runId: `relationship-benchmark:${input.fixtureId}:${input.mode}:profile` },
@@ -358,7 +360,7 @@ export function ktxRelationshipBenchmarkDetectorWithLlm(llmRuntime) {
                     : Math.max(0, input.validationBudget - profiles.queryCount);
             const validatedBroadCandidates = await validateKtxRelationshipDiscoveryCandidates({
                 connectionId: input.snapshot.connectionId,
-                driver: input.snapshot.driver,
+                dialect,
                 candidates,
                 profiles,
                 executor: validationExecutor,
@@ -374,7 +376,7 @@ export function ktxRelationshipBenchmarkDetectorWithLlm(llmRuntime) {
                 input.mode !== 'validation_disabled'
                 ? await discoverKtxCompositeRelationships({
                     connectionId: input.snapshot.connectionId,
-                    driver: input.snapshot.driver,
+                    dialect,
                     schema: input.schema,
                     profiles,
                     executor: validationExecutor,
@@ -445,6 +447,7 @@ export function currentKtxRelationshipBenchmarkDetector() {
             const formalLinks = formalMetadata.accepted.map((relationship) => relationshipToBenchmarkLink(relationship));
             const acceptedKeys = new Set(formalLinks.map(fkKey));
             const sqliteDataAvailable = Boolean(input.dataPath && input.snapshot.driver === 'sqlite');
+            const dialect = getDialectForDriver(input.snapshot.driver);
             const profilingExecutor = sqliteDataAvailable && input.mode !== 'profiling_disabled'
                 ? new KtxRelationshipBenchmarkSqliteExecutor(input.dataPath)
                 : null;
@@ -457,7 +460,7 @@ export function currentKtxRelationshipBenchmarkDetector() {
                 })
                 : await profileKtxRelationshipSchema({
                     connectionId: input.snapshot.connectionId,
-                    driver: input.snapshot.driver,
+                    dialect,
                     schema: input.schema,
                     executor: profilingExecutor,
                     ctx: { runId: `relationship-benchmark:${input.fixtureId}:${input.mode}:profile` },
@@ -473,7 +476,7 @@ export function currentKtxRelationshipBenchmarkDetector() {
                     : Math.max(0, input.validationBudget - profiles.queryCount);
             const validatedBroadCandidates = await validateKtxRelationshipDiscoveryCandidates({
                 connectionId: input.snapshot.connectionId,
-                driver: input.snapshot.driver,
+                dialect,
                 candidates: broadRelationshipCandidates,
                 profiles,
                 executor: validationExecutor,
@@ -489,7 +492,7 @@ export function currentKtxRelationshipBenchmarkDetector() {
                 input.mode !== 'validation_disabled'
                 ? await discoverKtxCompositeRelationships({
                     connectionId: input.snapshot.connectionId,
-                    driver: input.snapshot.driver,
+                    dialect,
                     schema: input.schema,
                     profiles,
                     executor: validationExecutor,

package/dist/context/scan/relationship-composite-candidates.d.ts

@@ -1,6 +1,7 @@
+import type { KtxDialect } from '../connections/dialects.js';
 import type { KtxEnrichedSchema, KtxRelationshipType } from './enrichment-types.js';
 import { type KtxRelationshipProfileArtifact, type KtxRelationshipReadOnlyExecutor } from './relationship-profiling.js';
-import type { KtxConnectionDriver, KtxScanContext, KtxTableRef } from './types.js';
+import type { KtxScanContext, KtxTableRef } from './types.js';
 type KtxCompositeRelationshipStatus = 'accepted' | 'review' | 'rejected';
 interface KtxCompositeRelationshipTupleEndpoint {
     tableId: string;
@@ -46,7 +47,7 @@ export interface KtxCompositeRelationshipCandidate {
 }
 export interface DiscoverKtxCompositeRelationshipsInput {
     connectionId: string;
-    driver: KtxConnectionDriver;
+    dialect: KtxDialect;
     schema: KtxEnrichedSchema;
     profiles: KtxRelationshipProfileArtifact;
     executor: KtxRelationshipReadOnlyExecutor | null;

package/dist/context/scan/relationship-composite-candidates.js

@@ -1,4 +1,3 @@
-import { formatKtxRelationshipTableRef, quoteKtxRelationshipIdentifier, } from './relationship-profiling.js';
 const KEY_NAME_PARTS = new Set(['id', 'key', 'code', 'number', 'num', 'line', 'warehouse', 'account', 'order']);
 const DEFAULT_MAX_COMPOSITE_WIDTH = 3;
 const DEFAULT_MAX_COLUMNS_PER_TABLE = 8;
@@ -113,51 +112,40 @@ function numberAt(result, header) {
     }
     return 0;
 }
-function topSql(driver, limit) {
-    if (driver === 'sqlserver') {
-        return ` TOP (${Math.max(1, Math.floor(limit))})`;
-    }
-    return '';
-}
-function limitSql(driver, limit) {
-    if (driver === 'sqlserver') {
-        return '';
-    }
-    return ` LIMIT ${Math.max(1, Math.floor(limit))}`;
+function sqlSuffix(fragment) {
+    return fragment ? ` ${fragment}` : '';
 }
-function aliasedTupleSelect(driver, columns) {
-    return columns
-        .map((column, index) => `${quoteKtxRelationshipIdentifier(driver, column)} AS c${index}`)
-        .join(', ');
+function aliasedTupleSelect(dialect, columns) {
+    return columns.map((column, index) => `${dialect.quoteIdentifier(column)} AS c${index}`).join(', ');
 }
-function nonNullPredicate(driver, columns) {
-    return columns.map((column) => `${quoteKtxRelationshipIdentifier(driver, column)} IS NOT NULL`).join(' AND ');
+function nonNullPredicate(dialect, columns) {
+    return columns.map((column) => `${dialect.quoteIdentifier(column)} IS NOT NULL`).join(' AND ');
 }
 function tupleEquality(columns) {
     return Array.from({ length: columns }, (_, index) => `child_values.c${index} = parent_values.c${index}`).join(' AND ');
 }
 function buildTupleDistinctSql(input) {
-    const tableSql = formatKtxRelationshipTableRef(input.driver, input.table);
+    const tableSql = input.dialect.formatTableName(input.table);
     return [
         'WITH tuple_values AS (',
-        `SELECT DISTINCT ${aliasedTupleSelect(input.driver, input.columns)} FROM ${tableSql}`,
-        `WHERE ${nonNullPredicate(input.driver, input.columns)}`,
+        `SELECT DISTINCT ${aliasedTupleSelect(input.dialect, input.columns)} FROM ${tableSql}`,
+        `WHERE ${nonNullPredicate(input.dialect, input.columns)}`,
         ')',
         'SELECT COUNT(*) AS distinct_count FROM tuple_values',
     ].join(' ');
 }
 function buildCompositeCoverageSql(input) {
-    const childTableSql = formatKtxRelationshipTableRef(input.driver, input.childTable);
-    const parentTableSql = formatKtxRelationshipTableRef(input.driver, input.parentTable);
-    const top = topSql(input.driver, input.maxDistinctSourceValues);
-    const limit = limitSql(input.driver, input.maxDistinctSourceValues);
+    const childTableSql = input.dialect.formatTableName(input.childTable);
+    const parentTableSql = input.dialect.formatTableName(input.parentTable);
+    const top = input.dialect.getTopClause(input.maxDistinctSourceValues);
+    const limit = sqlSuffix(input.dialect.getLimitOffsetClause(input.maxDistinctSourceValues));
     return [
         'WITH child_values AS (',
-        `SELECT DISTINCT${top} ${aliasedTupleSelect(input.driver, input.childColumns)} FROM ${childTableSql}`,
-        `WHERE ${nonNullPredicate(input.driver, input.childColumns)}${limit}`,
+        `SELECT DISTINCT${top ? ` ${top}` : ''} ${aliasedTupleSelect(input.dialect, input.childColumns)} FROM ${childTableSql}`,
+        `WHERE ${nonNullPredicate(input.dialect, input.childColumns)}${limit}`,
         '), parent_values AS (',
-        `SELECT DISTINCT ${aliasedTupleSelect(input.driver, input.parentColumns)} FROM ${parentTableSql}`,
-        `WHERE ${nonNullPredicate(input.driver, input.parentColumns)}`,
+        `SELECT DISTINCT ${aliasedTupleSelect(input.dialect, input.parentColumns)} FROM ${parentTableSql}`,
+        `WHERE ${nonNullPredicate(input.dialect, input.parentColumns)}`,
         ')',
         'SELECT',
         '(SELECT COUNT(*) FROM child_values) AS child_distinct,',
@@ -216,7 +204,7 @@ async function detectCompositePrimaryKeys(input) {
             const result = await input.executor.executeReadOnly({
                 connectionId: input.connectionId,
                 sql: buildTupleDistinctSql({
-                    driver: input.driver,
+                    dialect: input.dialect,
                     table: input.table.ref,
                     columns: columnNames,
                 }),
@@ -268,7 +256,7 @@ async function validateCompositeRelationship(input) {
     const result = await input.executor.executeReadOnly({
         connectionId: input.connectionId,
         sql: buildCompositeCoverageSql({
-            driver: input.driver,
+            dialect: input.dialect,
             childTable: input.sourceTable.ref,
             childColumns: input.sourceColumns.map((column) => column.name),
             parentTable: input.targetTable.ref,
@@ -356,7 +344,7 @@ export async function discoverKtxCompositeRelationships(input) {
     for (const table of tables) {
         const result = await detectCompositePrimaryKeys({
             connectionId: input.connectionId,
-            driver: input.driver,
+            dialect: input.dialect,
             table,
             profiles: input.profiles,
             executor: input.executor,
@@ -396,7 +384,7 @@ export async function discoverKtxCompositeRelationships(input) {
             }
             const result = await validateCompositeRelationship({
                 connectionId: input.connectionId,
-                driver: input.driver,
+                dialect: input.dialect,
                 sourceTable,
                 sourceColumns,
                 targetKey,

package/dist/context/scan/relationship-discovery.d.ts

@@ -1,13 +1,14 @@
 import type { KtxLlmRuntimePort } from '../../context/llm/runtime-port.js';
+import type { KtxDialect } from '../connections/dialects.js';
 import type { KtxScanRelationshipConfig } from '../project/config.js';
 import type { KtxEnrichedSchema, KtxRelationshipUpdate } from './enrichment-types.js';
 import { type KtxCompositeRelationshipCandidate } from './relationship-composite-candidates.js';
 import { type KtxResolvedRelationshipDiscoveryCandidate } from './relationship-graph-resolver.js';
 import { type KtxRelationshipProfileArtifact } from './relationship-profiling.js';
-import type { KtxConnectionDriver, KtxScanConnector, KtxScanContext, KtxScanEnrichmentSummary, KtxScanRelationshipSummary, KtxScanWarning } from './types.js';
+import type { KtxScanConnector, KtxScanContext, KtxScanEnrichmentSummary, KtxScanRelationshipSummary, KtxScanWarning } from './types.js';
 export interface DiscoverKtxRelationshipsInput {
     connectionId: string;
-    driver: KtxConnectionDriver;
+    dialect: KtxDialect;
     connector: KtxScanConnector;
     schema: KtxEnrichedSchema;
     context: KtxScanContext;

package/dist/context/scan/relationship-discovery.js

@@ -68,7 +68,7 @@ async function detectCompositeRelationships(input) {
     try {
         const compositeDetection = await discoverKtxCompositeRelationships({
             connectionId: input.connectionId,
-            driver: input.driver,
+            dialect: input.dialect,
             schema: input.schema,
             profiles: input.profile,
             executor: input.executor,
@@ -143,7 +143,7 @@ export async function discoverKtxRelationships(input) {
     const profileCache = createKtxRelationshipProfileCache();
     const profile = await profileKtxRelationshipSchema({
         connectionId: input.connectionId,
-        driver: input.driver,
+        dialect: input.dialect,
         schema: input.schema,
         executor,
         ctx: input.context,
@@ -173,7 +173,7 @@ export async function discoverKtxRelationships(input) {
     warnings.push(...llmProposalResult.warnings);
     const validated = await validateKtxRelationshipDiscoveryCandidates({
         connectionId: input.connectionId,
-        driver: input.driver,
+        dialect: input.dialect,
         candidates,
         profiles: profile,
         executor,
@@ -199,7 +199,7 @@ export async function discoverKtxRelationships(input) {
     });
     const compositeRelationships = await detectCompositeRelationships({
         connectionId: input.connectionId,
-        driver: input.driver,
+        dialect: input.dialect,
         schema: input.schema,
         profile,
         executor,

package/dist/context/scan/relationship-profiling.d.ts

@@ -1,3 +1,4 @@
+import type { KtxDialect } from '../connections/dialects.js';
 import type { KtxEnrichedSchema } from './enrichment-types.js';
 import type { KtxConnectionDriver, KtxQueryResult, KtxReadOnlyQueryInput, KtxScanContext, KtxTableRef } from './types.js';
 export interface KtxRelationshipReadOnlyExecutor {
@@ -41,7 +42,7 @@ export interface KtxRelationshipProfileCache {
 }
 export interface ProfileKtxRelationshipSchemaInput {
     connectionId: string;
-    driver: KtxConnectionDriver;
+    dialect: KtxDialect;
     schema: KtxEnrichedSchema;
     executor: KtxRelationshipReadOnlyExecutor | null;
     ctx: KtxScanContext;
@@ -51,7 +52,5 @@ export interface ProfileKtxRelationshipSchemaInput {
     cache?: KtxRelationshipProfileCache;
 }
 export declare function createKtxRelationshipProfileCache(): KtxRelationshipProfileCache;
-export declare function quoteKtxRelationshipIdentifier(driver: KtxConnectionDriver, identifier: string): string;
-export declare function formatKtxRelationshipTableRef(driver: KtxConnectionDriver, table: KtxTableRef): string;
 export declare function profileKtxRelationshipSchema(input: ProfileKtxRelationshipSchemaInput): Promise<KtxRelationshipProfileArtifact>;
 export {};