@kaelio/ktx 0.4.1 → 0.5.0

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

@@ -0,0 +1,139 @@
+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 KtxSqlServerConnectionConfig {
+    driver?: string;
+    host?: string;
+    port?: number;
+    database?: string;
+    username?: string;
+    user?: string;
+    password?: string;
+    url?: string;
+    schema?: string;
+    schemas?: string[];
+    trustServerCertificate?: boolean;
+    [key: string]: unknown;
+}
+export interface KtxSqlServerPoolConfig {
+    server: string;
+    port: number;
+    database: string;
+    user: string;
+    password?: string;
+    options: {
+        encrypt: true;
+        trustServerCertificate: boolean;
+    };
+    pool: {
+        max: number;
+        min: number;
+        idleTimeoutMillis: number;
+    };
+}
+/** @internal */
+export interface KtxSqlServerQueryResult {
+    recordset?: Array<Record<string, unknown>> & {
+        columns?: Record<string, {
+            type?: {
+                declaration?: string;
+            };
+        }>;
+    };
+}
+interface KtxSqlServerRequest {
+    input(name: string, value: unknown): KtxSqlServerRequest;
+    query(query: string): Promise<KtxSqlServerQueryResult>;
+}
+export interface KtxSqlServerPool {
+    request(): KtxSqlServerRequest;
+    close(): Promise<void>;
+}
+export interface KtxSqlServerPoolFactory {
+    createPool(config: KtxSqlServerPoolConfig): Promise<KtxSqlServerPool>;
+}
+interface KtxSqlServerResolvedEndpoint {
+    host: string;
+    port: number;
+    close?: () => Promise<void>;
+}
+export interface KtxSqlServerEndpointResolver {
+    resolve(input: {
+        host: string;
+        port: number;
+        connection: KtxSqlServerConnectionConfig;
+    }): Promise<KtxSqlServerResolvedEndpoint>;
+}
+export interface KtxSqlServerScanConnectorOptions {
+    connectionId: string;
+    connection: KtxSqlServerConnectionConfig | undefined;
+    poolFactory?: KtxSqlServerPoolFactory;
+    endpointResolver?: KtxSqlServerEndpointResolver;
+    env?: NodeJS.ProcessEnv;
+    now?: () => Date;
+}
+export interface KtxSqlServerReadOnlyQueryInput extends KtxReadOnlyQueryInput {
+    params?: Record<string, unknown>;
+}
+export interface KtxSqlServerColumnDistinctValuesOptions {
+    maxCardinality: number;
+    limit: number;
+    sampleSize?: number;
+}
+export interface KtxSqlServerColumnDistinctValuesResult {
+    values: string[] | null;
+    cardinality: number;
+}
+interface KtxSqlServerTableSampleResult extends KtxTableSampleResult {
+    headerTypes?: string[];
+}
+export declare function isKtxSqlServerConnectionConfig(connection: KtxSqlServerConnectionConfig | undefined): connection is KtxSqlServerConnectionConfig;
+/** @internal */
+export declare function sqlServerConnectionPoolConfigFromConfig(input: {
+    connectionId: string;
+    connection: KtxSqlServerConnectionConfig | undefined;
+    env?: NodeJS.ProcessEnv;
+}): KtxSqlServerPoolConfig;
+export declare class KtxSqlServerScanConnector implements KtxScanConnector {
+    readonly id: string;
+    readonly driver: "sqlserver";
+    readonly capabilities: import("../../context/scan/types.js").KtxConnectorCapabilities;
+    private readonly connectionId;
+    private readonly connection;
+    private readonly poolConfig;
+    private readonly schemas;
+    private readonly poolFactory;
+    private readonly endpointResolver?;
+    private readonly now;
+    private readonly dialect;
+    private pool;
+    private resolvedEndpoint;
+    constructor(options: KtxSqlServerScanConnectorOptions);
+    testConnection(): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    introspect(input: KtxScanInput, _ctx: KtxScanContext): Promise<KtxSchemaSnapshot>;
+    sampleTable(input: KtxTableSampleInput, _ctx: KtxScanContext): Promise<KtxSqlServerTableSampleResult>;
+    sampleColumn(input: KtxColumnSampleInput, _ctx: KtxScanContext): Promise<KtxColumnSampleResult>;
+    columnStats(_input: KtxColumnStatsInput, _ctx: KtxScanContext): Promise<KtxColumnStatsResult | null>;
+    executeReadOnly(input: KtxSqlServerReadOnlyQueryInput, _ctx: KtxScanContext): Promise<KtxQueryResult>;
+    getColumnDistinctValues(table: KtxTableRef, columnName: string, options: KtxSqlServerColumnDistinctValuesOptions): Promise<KtxSqlServerColumnDistinctValuesResult | null>;
+    getTableRowCount(tableName: string, schemaName?: string): Promise<number>;
+    qTableName(table: Pick<KtxTableRef, 'name'> & Partial<Pick<KtxTableRef, 'catalog' | 'db'>>): string;
+    quoteIdentifier(identifier: string): string;
+    listSchemas(): Promise<string[]>;
+    listTables(schemas?: string[]): Promise<KtxTableListEntry[]>;
+    cleanup(): Promise<void>;
+    private introspectSchema;
+    private tableComments;
+    private columnComments;
+    private primaryKeys;
+    private foreignKeys;
+    private rowCounts;
+    private toSchemaColumn;
+    private toSchemaForeignKey;
+    private poolForQuery;
+    private queryRaw;
+    private query;
+    private assertConnection;
+}
+export {};

package/dist/connectors/sqlserver/connector.js

@@ -0,0 +1,534 @@
+import { assertReadOnlySql } from '../../context/connections/read-only-sql.js';
+import { createKtxConnectorCapabilities } from '../../context/scan/types.js';
+import { scopedTableNames } from '../../context/scan/table-ref.js';
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { resolve } from 'node:path';
+import sql from 'mssql';
+import { KtxSqlServerDialect } from './dialect.js';
+function sqlTypeDeclaration(type) {
+    if (typeof type === 'function') {
+        try {
+            return sqlTypeDeclaration(type());
+        }
+        catch {
+            return 'unknown';
+        }
+    }
+    if (typeof type === 'object' && type !== null && 'declaration' in type) {
+        const declaration = type.declaration;
+        return typeof declaration === 'string' ? declaration : 'unknown';
+    }
+    return 'unknown';
+}
+function sqlRecordset(rows, columns) {
+    const recordset = [...(rows ?? [])];
+    recordset.columns = Object.fromEntries(Object.entries(columns ?? {}).map(([name, metadata]) => [
+        name,
+        { type: { declaration: sqlTypeDeclaration(metadata.type) } },
+    ]));
+    return recordset;
+}
+function tableScopeSql(scopedNames, columnExpression) {
+    if (!scopedNames)
+        return { clause: '', params: {} };
+    const params = {};
+    const placeholders = scopedNames.map((name, index) => {
+        const key = `table_${index}`;
+        params[key] = name;
+        return `@${key}`;
+    });
+    return { clause: `AND ${columnExpression} IN (${placeholders.join(', ')})`, params };
+}
+class DefaultSqlServerPoolFactory {
+    async createPool(config) {
+        const pool = await new sql.ConnectionPool(config).connect();
+        return {
+            request() {
+                const request = pool.request();
+                return {
+                    input(name, value) {
+                        request.input(name, value);
+                        return this;
+                    },
+                    async query(query) {
+                        const result = await request.query(query);
+                        return {
+                            recordset: sqlRecordset(result.recordset, result.recordset?.columns),
+                        };
+                    },
+                };
+            },
+            close: () => pool.close(),
+        };
+    }
+}
+function stringConfigValue(connection, key, env) {
+    const value = connection?.[key];
+    return typeof value === 'string' && value.trim().length > 0 ? resolveStringReference(value.trim(), env) : undefined;
+}
+function resolveStringReference(value, env) {
+    if (value.startsWith('env:')) {
+        return env[value.slice('env:'.length)] ?? '';
+    }
+    if (value.startsWith('file:')) {
+        const rawPath = value.slice('file:'.length);
+        const path = rawPath.startsWith('~') ? resolve(homedir(), rawPath.slice(1)) : rawPath;
+        return readFileSync(path, 'utf-8').trim();
+    }
+    return value;
+}
+function parseSqlServerUrl(url) {
+    const parsed = new URL(url);
+    return {
+        host: parsed.hostname,
+        port: parsed.port ? Number(parsed.port) : undefined,
+        database: parsed.pathname.replace(/^\/+/, '') || undefined,
+        username: parsed.username ? decodeURIComponent(parsed.username) : undefined,
+        password: parsed.password ? decodeURIComponent(parsed.password) : undefined,
+        trustServerCertificate: parsed.searchParams.get('trustServerCertificate') === 'true',
+    };
+}
+function maybeNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function schemaNames(connection, env) {
+    if (Array.isArray(connection.schemas) && connection.schemas.length > 0) {
+        return connection.schemas.filter((schema) => schema.trim().length > 0).map((schema) => resolveStringReference(schema, env));
+    }
+    return [stringConfigValue(connection, 'schema', env) ?? 'dbo'];
+}
+function groupByTable(rows) {
+    const grouped = new Map();
+    for (const row of rows) {
+        const values = grouped.get(row.table_name) ?? [];
+        values.push(row);
+        grouped.set(row.table_name, values);
+    }
+    return grouped;
+}
+function firstNumber(value) {
+    const numberValue = Number(value);
+    return Number.isFinite(numberValue) ? numberValue : null;
+}
+function limitSqlForSqlServerExecution(sqlText, maxRows) {
+    const trimmed = assertReadOnlySql(sqlText).replace(/;+\s*$/, '');
+    if (!maxRows) {
+        return trimmed;
+    }
+    if (!Number.isInteger(maxRows) || maxRows <= 0) {
+        throw new Error('maxRows must be a positive integer.');
+    }
+    return `SELECT TOP ${maxRows} * FROM (${trimmed}) AS ktx_query_result`;
+}
+export function isKtxSqlServerConnectionConfig(connection) {
+    return String(connection?.driver ?? '').toLowerCase() === 'sqlserver';
+}
+/** @internal */
+export function sqlServerConnectionPoolConfigFromConfig(input) {
+    const inputDriver = input.connection?.driver ?? 'unknown';
+    if (!isKtxSqlServerConnectionConfig(input.connection)) {
+        throw new Error(`Native SQL Server connector cannot run driver "${inputDriver}"`);
+    }
+    const env = input.env ?? process.env;
+    const referencedUrl = stringConfigValue(input.connection, 'url', env);
+    const urlConfig = referencedUrl ? parseSqlServerUrl(referencedUrl) : {};
+    const merged = { ...urlConfig, ...input.connection };
+    const server = stringConfigValue(merged, 'host', env);
+    const database = stringConfigValue(merged, 'database', env);
+    const user = stringConfigValue(merged, 'username', env) ?? stringConfigValue(merged, 'user', env);
+    if (!server) {
+        throw new Error(`Native SQL Server connector requires connections.${input.connectionId}.host or url`);
+    }
+    if (!database) {
+        throw new Error(`Native SQL Server connector requires connections.${input.connectionId}.database or url`);
+    }
+    if (!user) {
+        throw new Error(`Native SQL Server connector requires connections.${input.connectionId}.username, user, or url`);
+    }
+    return {
+        server,
+        port: maybeNumber(merged.port) ?? 1433,
+        database,
+        user,
+        password: stringConfigValue(merged, 'password', env),
+        options: { encrypt: true, trustServerCertificate: merged.trustServerCertificate ?? true },
+        pool: { max: 10, min: 0, idleTimeoutMillis: 30000 },
+    };
+}
+export class KtxSqlServerScanConnector {
+    id;
+    driver = 'sqlserver';
+    capabilities = createKtxConnectorCapabilities({
+        tableSampling: true,
+        columnSampling: true,
+        columnStats: false,
+        readOnlySql: true,
+        nestedAnalysis: false,
+        formalForeignKeys: true,
+        estimatedRowCounts: true,
+    });
+    connectionId;
+    connection;
+    poolConfig;
+    schemas;
+    poolFactory;
+    endpointResolver;
+    now;
+    dialect = new KtxSqlServerDialect();
+    pool = null;
+    resolvedEndpoint = null;
+    constructor(options) {
+        this.connectionId = options.connectionId;
+        this.connection = options.connection ?? {};
+        const env = options.env ?? process.env;
+        this.poolConfig = sqlServerConnectionPoolConfigFromConfig({
+            connectionId: options.connectionId,
+            connection: options.connection,
+            env,
+        });
+        this.schemas = schemaNames(this.connection, env);
+        this.poolFactory = options.poolFactory ?? new DefaultSqlServerPoolFactory();
+        this.endpointResolver = options.endpointResolver;
+        this.now = options.now ?? (() => new Date());
+        this.id = `sqlserver:${options.connectionId}`;
+    }
+    async testConnection() {
+        try {
+            await this.query('SELECT 1');
+            return { success: true };
+        }
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    async introspect(input, _ctx) {
+        this.assertConnection(input.connectionId);
+        const tables = [];
+        for (const schemaName of this.schemas) {
+            const scopedNames = input.tableScope
+                ? scopedTableNames(input.tableScope, { catalog: this.poolConfig.database, db: schemaName })
+                : null;
+            tables.push(...(await this.introspectSchema(schemaName, scopedNames)));
+        }
+        return {
+            connectionId: this.connectionId,
+            driver: 'sqlserver',
+            extractedAt: this.now().toISOString(),
+            scope: { catalogs: [this.poolConfig.database], schemas: this.schemas },
+            metadata: {
+                database: this.poolConfig.database,
+                schemas: this.schemas,
+                host: this.poolConfig.server,
+                table_count: tables.length,
+                total_columns: tables.reduce((sum, table) => sum + table.columns.length, 0),
+            },
+            tables,
+        };
+    }
+    async sampleTable(input, _ctx) {
+        this.assertConnection(input.connectionId);
+        const result = await this.query(this.dialect.generateSampleQuery(this.qTableName(input.table), input.limit, input.columns));
+        return { headers: result.headers, headerTypes: result.headerTypes, rows: result.rows, totalRows: result.totalRows };
+    }
+    async sampleColumn(input, _ctx) {
+        this.assertConnection(input.connectionId);
+        const result = await this.query(this.dialect.generateColumnSampleQuery(this.qTableName(input.table), input.column, input.limit));
+        const values = result.rows.filter((row) => row.length > 0 && row[0] !== null).map((row) => row[0]);
+        return { values, nullCount: null, distinctCount: null };
+    }
+    async columnStats(_input, _ctx) {
+        return null;
+    }
+    async executeReadOnly(input, _ctx) {
+        this.assertConnection(input.connectionId);
+        const limitedSql = limitSqlForSqlServerExecution(input.sql, input.maxRows);
+        const prepared = this.dialect.prepareQuery(limitedSql, input.params);
+        const result = await this.query(prepared.sql, prepared.params);
+        return { ...result, rowCount: result.rows.length };
+    }
+    async getColumnDistinctValues(table, columnName, options) {
+        const tableName = this.qTableName(table);
+        const quotedColumn = this.dialect.quoteIdentifier(columnName);
+        const cardinalityRows = await this.queryRaw(this.dialect.generateCardinalitySampleQuery(tableName, quotedColumn, options.sampleSize ?? 10000));
+        const cardinality = Number(cardinalityRows[0]?.cardinality);
+        if (Number.isNaN(cardinality)) {
+            return null;
+        }
+        if (cardinality === 0) {
+            return { values: [], cardinality: 0 };
+        }
+        if (cardinality > options.maxCardinality) {
+            return { values: null, cardinality };
+        }
+        const valuesRows = await this.queryRaw(this.dialect.generateDistinctValuesQuery(tableName, quotedColumn, options.limit));
+        return { values: valuesRows.filter((row) => row.val !== null).map((row) => String(row.val)), cardinality };
+    }
+    async getTableRowCount(tableName, schemaName = this.schemas[0] ?? 'dbo') {
+        const rows = await this.queryRaw(`
+      SELECT SUM(p.rows) AS row_count
+      FROM sys.tables t
+      INNER JOIN sys.partitions p ON t.object_id = p.object_id
+      INNER JOIN sys.schemas s ON t.schema_id = s.schema_id
+      WHERE s.name = @schemaName
+        AND t.name = @tableName
+        AND p.index_id IN (0, 1)
+      `, { schemaName, tableName });
+        return firstNumber(rows[0]?.row_count) ?? 0;
+    }
+    qTableName(table) {
+        return this.dialect.formatTableName(table);
+    }
+    quoteIdentifier(identifier) {
+        return this.dialect.quoteIdentifier(identifier);
+    }
+    async listSchemas() {
+        const rows = await this.queryRaw(`
+      SELECT s.name AS schema_name
+      FROM sys.schemas s
+      WHERE s.name NOT IN (
+        'INFORMATION_SCHEMA', 'sys', 'guest',
+        'db_owner', 'db_accessadmin', 'db_securityadmin', 'db_ddladmin',
+        'db_backupoperator', 'db_datareader', 'db_datawriter',
+        'db_denydatareader', 'db_denydatawriter'
+      )
+      ORDER BY s.name
+    `);
+        return rows.map((row) => row.schema_name);
+    }
+    async listTables(schemas) {
+        const filterSchemas = schemas ?? (await this.listSchemas());
+        if (filterSchemas.length === 0)
+            return [];
+        const params = {};
+        const placeholders = filterSchemas.map((s, i) => {
+            params[`schema${i}`] = s;
+            return `@schema${i}`;
+        });
+        const rows = await this.queryRaw(`
+      SELECT s.name AS schema_name, o.name AS table_name, o.type_desc AS table_type
+      FROM sys.objects o
+      JOIN sys.schemas s ON o.schema_id = s.schema_id
+      WHERE o.type IN ('U', 'V')
+        AND s.name IN (${placeholders.join(', ')})
+      ORDER BY s.name, o.name
+      `, params);
+        return rows.map((row) => ({
+            schema: row.schema_name,
+            name: row.table_name,
+            kind: row.table_type === 'VIEW' ? 'view' : 'table',
+        }));
+    }
+    async cleanup() {
+        if (this.pool) {
+            await this.pool.close();
+            this.pool = null;
+        }
+        if (this.resolvedEndpoint?.close) {
+            await this.resolvedEndpoint.close();
+            this.resolvedEndpoint = null;
+        }
+    }
+    async introspectSchema(schemaName, scopedNames) {
+        if (scopedNames && scopedNames.length === 0)
+            return [];
+        const tableScope = tableScopeSql(scopedNames, 'TABLE_NAME');
+        const tables = await this.queryRaw(`
+      SELECT TABLE_NAME AS table_name, TABLE_TYPE AS table_type
+      FROM INFORMATION_SCHEMA.TABLES
+      WHERE TABLE_SCHEMA = @schemaName
+        AND TABLE_TYPE IN ('BASE TABLE', 'VIEW')
+        ${tableScope.clause}
+      ORDER BY TABLE_NAME
+      `, { schemaName, ...tableScope.params });
+        const columns = await this.queryRaw(`
+      SELECT TABLE_NAME AS table_name, COLUMN_NAME AS column_name, DATA_TYPE AS data_type, IS_NULLABLE AS is_nullable
+      FROM INFORMATION_SCHEMA.COLUMNS
+      WHERE TABLE_SCHEMA = @schemaName
+        ${tableScope.clause}
+      ORDER BY TABLE_NAME, ORDINAL_POSITION
+      `, { schemaName, ...tableScope.params });
+        const tableComments = await this.tableComments(schemaName, scopedNames);
+        const columnComments = await this.columnComments(schemaName, scopedNames);
+        const primaryKeys = await this.primaryKeys(schemaName, scopedNames);
+        const foreignKeys = await this.foreignKeys(schemaName, scopedNames);
+        const rowCounts = await this.rowCounts(schemaName, scopedNames);
+        const columnsByTable = groupByTable(columns);
+        const foreignKeysByTable = groupByTable(foreignKeys);
+        return tables.map((table) => ({
+            catalog: this.poolConfig.database,
+            db: schemaName,
+            name: table.table_name,
+            kind: table.table_type === 'VIEW' ? 'view' : 'table',
+            comment: tableComments.get(table.table_name) ?? null,
+            estimatedRows: table.table_type === 'VIEW' ? null : rowCounts.get(table.table_name) ?? 0,
+            columns: (columnsByTable.get(table.table_name) ?? []).map((column) => this.toSchemaColumn(column, primaryKeys.get(table.table_name) ?? new Set(), columnComments)),
+            foreignKeys: (foreignKeysByTable.get(table.table_name) ?? []).map((row) => this.toSchemaForeignKey(row)),
+        }));
+    }
+    async tableComments(schemaName, scopedNames) {
+        const tableScope = tableScopeSql(scopedNames, 'o.name');
+        const rows = await this.queryRaw(`
+      SELECT o.name AS table_name, CAST(ep.value AS NVARCHAR(MAX)) AS table_comment
+      FROM sys.objects o
+      INNER JOIN sys.schemas s ON o.schema_id = s.schema_id
+      INNER JOIN sys.extended_properties ep ON ep.major_id = o.object_id
+        AND ep.minor_id = 0
+        AND ep.name = 'MS_Description'
+      WHERE s.name = @schemaName
+        AND o.type IN ('U', 'V')
+        ${tableScope.clause}
+      `, { schemaName, ...tableScope.params });
+        return new Map(rows.map((row) => [row.table_name, row.table_comment]));
+    }
+    async columnComments(schemaName, scopedNames) {
+        const tableScope = tableScopeSql(scopedNames, 'o.name');
+        const rows = await this.queryRaw(`
+      SELECT o.name AS table_name, c.name AS column_name, CAST(ep.value AS NVARCHAR(MAX)) AS column_comment
+      FROM sys.columns c
+      INNER JOIN sys.objects o ON c.object_id = o.object_id
+      INNER JOIN sys.schemas s ON o.schema_id = s.schema_id
+      INNER JOIN sys.extended_properties ep ON ep.major_id = c.object_id
+        AND ep.minor_id = c.column_id
+        AND ep.name = 'MS_Description'
+      WHERE s.name = @schemaName
+        AND o.type IN ('U', 'V')
+        ${tableScope.clause}
+      `, { schemaName, ...tableScope.params });
+        return new Map(rows.map((row) => [`${row.table_name}.${row.column_name}`, row.column_comment]));
+    }
+    async primaryKeys(schemaName, scopedNames) {
+        const tableScope = tableScopeSql(scopedNames, 'tc.TABLE_NAME');
+        const rows = await this.queryRaw(`
+      SELECT tc.TABLE_NAME AS table_name, kcu.COLUMN_NAME AS column_name
+      FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc
+      JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE kcu
+        ON tc.CONSTRAINT_NAME = kcu.CONSTRAINT_NAME
+        AND tc.TABLE_SCHEMA = kcu.TABLE_SCHEMA
+      WHERE tc.CONSTRAINT_TYPE = 'PRIMARY KEY'
+        AND tc.TABLE_SCHEMA = @schemaName
+        ${tableScope.clause}
+      ORDER BY tc.TABLE_NAME, kcu.ORDINAL_POSITION
+      `, { schemaName, ...tableScope.params });
+        const grouped = new Map();
+        for (const row of rows) {
+            const columns = grouped.get(row.table_name) ?? new Set();
+            columns.add(row.column_name);
+            grouped.set(row.table_name, columns);
+        }
+        return grouped;
+    }
+    async foreignKeys(schemaName, scopedNames) {
+        const tableScope = tableScopeSql(scopedNames, 'fk.TABLE_NAME');
+        return this.queryRaw(`
+      SELECT
+        fk.TABLE_NAME AS table_name,
+        fk.COLUMN_NAME AS column_name,
+        pk.TABLE_SCHEMA AS referenced_table_schema,
+        pk.TABLE_NAME AS referenced_table_name,
+        pk.COLUMN_NAME AS referenced_column_name,
+        fk.CONSTRAINT_NAME AS constraint_name
+      FROM INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS rc
+      JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE fk
+        ON fk.CONSTRAINT_CATALOG = rc.CONSTRAINT_CATALOG
+        AND fk.CONSTRAINT_SCHEMA = rc.CONSTRAINT_SCHEMA
+        AND fk.CONSTRAINT_NAME = rc.CONSTRAINT_NAME
+      JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE pk
+        ON pk.CONSTRAINT_CATALOG = rc.UNIQUE_CONSTRAINT_CATALOG
+        AND pk.CONSTRAINT_SCHEMA = rc.UNIQUE_CONSTRAINT_SCHEMA
+        AND pk.CONSTRAINT_NAME = rc.UNIQUE_CONSTRAINT_NAME
+        AND pk.ORDINAL_POSITION = fk.ORDINAL_POSITION
+      WHERE fk.TABLE_SCHEMA = @schemaName
+        ${tableScope.clause}
+      ORDER BY fk.TABLE_NAME, fk.COLUMN_NAME
+      `, { schemaName, ...tableScope.params });
+    }
+    async rowCounts(schemaName, scopedNames) {
+        const tableScope = tableScopeSql(scopedNames, 't.name');
+        const rows = await this.queryRaw(`
+      SELECT t.name AS table_name, SUM(p.rows) AS row_count
+      FROM sys.tables t
+      INNER JOIN sys.partitions p ON t.object_id = p.object_id
+      INNER JOIN sys.schemas s ON t.schema_id = s.schema_id
+      WHERE s.name = @schemaName
+        AND p.index_id IN (0, 1)
+        ${tableScope.clause}
+      GROUP BY t.name
+      `, { schemaName, ...tableScope.params });
+        return new Map(rows.map((row) => [row.table_name, firstNumber(row.row_count) ?? 0]));
+    }
+    toSchemaColumn(column, primaryKeys, comments) {
+        return {
+            name: column.column_name,
+            nativeType: column.data_type,
+            normalizedType: this.dialect.mapDataType(column.data_type),
+            dimensionType: this.dialect.mapToDimensionType(column.data_type),
+            nullable: column.is_nullable === 'YES',
+            primaryKey: primaryKeys.has(column.column_name),
+            comment: comments.get(`${column.table_name}.${column.column_name}`) ?? null,
+        };
+    }
+    toSchemaForeignKey(row) {
+        return {
+            fromColumn: row.column_name,
+            toCatalog: this.poolConfig.database,
+            toDb: row.referenced_table_schema,
+            toTable: row.referenced_table_name,
+            toColumn: row.referenced_column_name,
+            constraintName: row.constraint_name || null,
+        };
+    }
+    async poolForQuery() {
+        if (!this.pool) {
+            const config = { ...this.poolConfig };
+            if (this.endpointResolver) {
+                this.resolvedEndpoint = await this.endpointResolver.resolve({
+                    host: config.server,
+                    port: config.port,
+                    connection: this.connection,
+                });
+                config.server = this.resolvedEndpoint.host;
+                config.port = this.resolvedEndpoint.port;
+            }
+            this.pool = await this.poolFactory.createPool(config);
+        }
+        return this.pool;
+    }
+    async queryRaw(query, params) {
+        const pool = await this.poolForQuery();
+        const request = pool.request();
+        if (params) {
+            for (const [key, value] of Object.entries(params)) {
+                request.input(key, value);
+            }
+        }
+        const result = await request.query(query);
+        return (result.recordset ?? []);
+    }
+    async query(query, params) {
+        const pool = await this.poolForQuery();
+        const request = pool.request();
+        if (params) {
+            for (const [key, value] of Object.entries(params)) {
+                request.input(key, value);
+            }
+        }
+        const result = await request.query(assertReadOnlySql(query));
+        const recordset = result.recordset ?? [];
+        const columnMetadata = recordset.columns ?? {};
+        const metadataHeaders = Object.keys(columnMetadata);
+        const headers = metadataHeaders.length > 0 ? metadataHeaders : Object.keys(recordset[0] ?? {});
+        const headerTypes = headers.map((header) => columnMetadata[header]?.type?.declaration ?? 'unknown');
+        return {
+            headers,
+            headerTypes,
+            rows: recordset.map((row) => headers.map((header) => row[header])),
+            totalRows: recordset.length,
+        };
+    }
+    assertConnection(connectionId) {
+        if (connectionId !== this.connectionId) {
+            throw new Error(`KTX SQL Server connector ${this.id} cannot serve connection ${connectionId}`);
+        }
+    }
+}