@kaelio/ktx 0.5.0 → 0.7.0

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

@@ -1,5 +1,5 @@
 import { type FieldPacket, type RowDataPacket } from 'mysql2/promise';
-import { type KtxColumnSampleInput, type KtxColumnSampleResult, type KtxColumnStatsInput, type KtxColumnStatsResult, type KtxQueryResult, type KtxReadOnlyQueryInput, type KtxScanConnector, type KtxScanContext, type KtxScanInput, type KtxTableListEntry, 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 KtxMysqlConnectionConfig {
     driver?: string;
     host?: string;
@@ -13,6 +13,7 @@ export interface KtxMysqlConnectionConfig {
     ssl?: boolean | {
         rejectUnauthorized?: boolean;
     };
+    maxConnections?: number;
     [key: string]: unknown;
 }
 export interface KtxMysqlPoolConfig {
@@ -70,6 +71,11 @@ export interface KtxMysqlColumnDistinctValuesResult {
     values: string[] | null;
     cardinality: number;
 }
+/** @internal */
+export declare function prepareMysqlReadOnlyQuery(sql: string, params?: Record<string, unknown>): {
+    sql: string;
+    params?: unknown[];
+};
 export declare function isKtxMysqlConnectionConfig(connection: KtxMysqlConnectionConfig | undefined): connection is KtxMysqlConnectionConfig;
 /** @internal */
 export declare function mysqlConnectionPoolConfigFromConfig(input: {

package/dist/connectors/mysql/connector.js

@@ -2,10 +2,11 @@ import mysql from 'mysql2/promise';
 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 { constraintDiscoveryWarning, tryConstraintQuery, } from '../../context/scan/constraint-discovery.js';
 import { scopedTableNames } from '../../context/scan/table-ref.js';
-import { KtxMysqlDialect } from './dialect.js';
+import { createKtxConnectorCapabilities, } from '../../context/scan/types.js';
 class DefaultMysqlPoolFactory {
     createPool(config) {
         return mysql.createPool(config);
@@ -30,6 +31,17 @@ function resolveStringReference(value, env) {
 function maybeNumber(value) {
     return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
 }
+function positiveIntegerConfigValue(input) {
+    const value = input.connection[input.key];
+    if (value === undefined) {
+        return input.defaultValue;
+    }
+    const numberValue = Number(value);
+    if (!Number.isInteger(numberValue) || numberValue < 1) {
+        throw new Error(`connections.${input.connectionId}.${String(input.key)} must be a positive integer`);
+    }
+    return numberValue;
+}
 function parseMysqlUrl(url) {
     const parsed = new URL(url);
     const sslParam = parsed.searchParams.get('ssl') ?? parsed.searchParams.get('sslmode');
@@ -89,12 +101,41 @@ function primaryKeyMap(rows, fallbackDatabase) {
     }
     return grouped;
 }
+function isDeniedError(error) {
+    if (!error || typeof error !== 'object') {
+        return false;
+    }
+    const code = error.code;
+    return (code === 'ER_TABLEACCESS_DENIED_ERROR' ||
+        code === 'ER_SPECIFIC_ACCESS_DENIED_ERROR' ||
+        code === 'ER_DBACCESS_DENIED_ERROR');
+}
+function pushConstraintWarnings(warnings, schemas, kind) {
+    for (const schema of schemas) {
+        warnings.push(constraintDiscoveryWarning({ schema, kind }));
+    }
+}
 function queryParams(params) {
     if (!params) {
         return undefined;
     }
     return Array.isArray(params) ? params : Object.values(params);
 }
+/** @internal */
+export function prepareMysqlReadOnlyQuery(sql, params) {
+    if (!params) {
+        return { sql, params: undefined };
+    }
+    const values = [];
+    const parameterizedQuery = sql.replace(/:([A-Za-z_][A-Za-z0-9_]*)\b/g, (placeholder, key) => {
+        if (!(key in params)) {
+            return placeholder;
+        }
+        values.push(params[key]);
+        return '?';
+    });
+    return { sql: parameterizedQuery, params: values };
+}
 export function isKtxMysqlConnectionConfig(connection) {
     return String(connection?.driver ?? '').toLowerCase() === 'mysql';
 }
@@ -111,6 +152,12 @@ export function mysqlConnectionPoolConfigFromConfig(input) {
     const host = stringConfigValue(merged, 'host', env);
     const database = stringConfigValue(merged, 'database', env);
     const user = stringConfigValue(merged, 'username', env) ?? stringConfigValue(merged, 'user', env);
+    const maxConnections = positiveIntegerConfigValue({
+        connection: merged,
+        key: 'maxConnections',
+        connectionId: input.connectionId,
+        defaultValue: 10,
+    });
     if (!host) {
         throw new Error(`Native MySQL connector requires connections.${input.connectionId}.host or url`);
     }
@@ -127,7 +174,7 @@ export function mysqlConnectionPoolConfigFromConfig(input) {
         database,
         user,
         password: stringConfigValue(merged, 'password', env),
-        connectionLimit: 10,
+        connectionLimit: maxConnections,
         waitForConnections: true,
         ...(ssl ? { ssl: { rejectUnauthorized: ssl.rejectUnauthorized ?? false } } : {}),
     };
@@ -150,7 +197,7 @@ export class KtxMysqlScanConnector {
     poolFactory;
     endpointResolver;
     now;
-    dialect = new KtxMysqlDialect();
+    dialect = getDialectForDriver('mysql');
     pool = null;
     resolvedEndpoint = null;
     constructor(options) {
@@ -178,6 +225,7 @@ export class KtxMysqlScanConnector {
     async introspect(input, _ctx) {
         this.assertConnection(input.connectionId);
         const databases = configuredMysqlSchemas(this.connection, this.poolConfig.database);
+        const snapshotWarnings = [];
         const placeholders = databases.map(() => '?').join(', ');
         let allScopedTables = null;
         if (input.tableScope) {
@@ -205,22 +253,30 @@ export class KtxMysqlScanConnector {
       WHERE TABLE_SCHEMA IN (${placeholders}) ${tableNameClause}
       ORDER BY TABLE_SCHEMA, TABLE_NAME, ORDINAL_POSITION
       `, [...databases, ...tableNameParams]);
-        const primaryKeys = await this.queryRaw(`
+        const primaryKeysResult = await tryConstraintQuery({ schema: databases[0] ?? this.poolConfig.database, kind: 'primary_key', isDeniedError }, () => this.queryRaw(`
       SELECT TABLE_SCHEMA, TABLE_NAME, COLUMN_NAME
       FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE
       WHERE TABLE_SCHEMA IN (${placeholders})
         AND CONSTRAINT_NAME = 'PRIMARY'
         ${tableNameClause}
       ORDER BY TABLE_SCHEMA, TABLE_NAME, ORDINAL_POSITION
-      `, [...databases, ...tableNameParams]);
-        const foreignKeys = await this.queryRaw(`
+      `, [...databases, ...tableNameParams]));
+        const primaryKeys = primaryKeysResult.ok ? primaryKeysResult.value : [];
+        if (!primaryKeysResult.ok) {
+            pushConstraintWarnings(snapshotWarnings, databases, 'primary_key');
+        }
+        const foreignKeysResult = await tryConstraintQuery({ schema: databases[0] ?? this.poolConfig.database, kind: 'foreign_key', isDeniedError }, () => this.queryRaw(`
       SELECT TABLE_SCHEMA, TABLE_NAME, COLUMN_NAME, REFERENCED_TABLE_NAME, REFERENCED_COLUMN_NAME, CONSTRAINT_NAME
       FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE
       WHERE TABLE_SCHEMA IN (${placeholders})
         AND REFERENCED_TABLE_NAME IS NOT NULL
         ${tableNameClause}
       ORDER BY TABLE_SCHEMA, TABLE_NAME, COLUMN_NAME
-      `, [...databases, ...tableNameParams]);
+      `, [...databases, ...tableNameParams]));
+        const foreignKeys = foreignKeysResult.ok ? foreignKeysResult.value : [];
+        if (!foreignKeysResult.ok) {
+            pushConstraintWarnings(snapshotWarnings, databases, 'foreign_key');
+        }
         const columnsByTable = groupByTable(columns, this.poolConfig.database);
         const primaryKeysByTable = primaryKeyMap(primaryKeys, this.poolConfig.database);
         const foreignKeysByTable = groupByTable(foreignKeys, this.poolConfig.database);
@@ -238,6 +294,7 @@ export class KtxMysqlScanConnector {
                 total_columns: schemaTables.reduce((sum, table) => sum + table.columns.length, 0),
             },
             tables: schemaTables,
+            warnings: snapshotWarnings,
         };
     }
     emptySnapshot(databases) {
@@ -275,7 +332,7 @@ export class KtxMysqlScanConnector {
         const limitedSql = limitSqlForExecution(assertReadOnlySql(input.sql), input.maxRows);
         const prepared = Array.isArray(input.params)
             ? { sql: limitedSql, params: input.params }
-            : this.dialect.prepareQuery(limitedSql, input.params);
+            : prepareMysqlReadOnlyQuery(limitedSql, input.params);
         const result = await this.query(prepared.sql, prepared.params);
         return { ...result, rowCount: result.rows.length };
     }
@@ -332,6 +389,7 @@ export class KtxMysqlScanConnector {
       ORDER BY TABLE_SCHEMA, TABLE_NAME
       `, filterSchemas);
         return rows.map((row) => ({
+            catalog: null,
             schema: row.TABLE_SCHEMA,
             name: row.TABLE_NAME,
             kind: row.TABLE_TYPE === 'VIEW' ? 'view' : 'table',

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

@@ -1,3 +1,5 @@
+import { columnDisplayPartCount, formatDialectDisplayRef, formatDialectTableName, limitOffsetClause, parseDialectDisplayRef, } from '../../context/connections/dialect-helpers.js';
+/** @internal */
 export class KtxMysqlDialect {
     type = 'mysql';
     typeMappings = {
@@ -34,9 +36,16 @@ export class KtxMysqlDialect {
         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;
@@ -76,20 +85,6 @@ export class KtxMysqlDialect {
         const quotedColumn = this.quoteIdentifier(columnName);
         return `SELECT ${quotedColumn} FROM ${tableName} WHERE ${quotedColumn} IS NOT NULL AND TRIM(CAST(${quotedColumn} AS CHAR)) != '' LIMIT ${limit}`;
     }
-    prepareQuery(sql, params) {
-        if (!params) {
-            return { sql, params: undefined };
-        }
-        const values = [];
-        const parameterizedQuery = sql.replace(/:([A-Za-z_][A-Za-z0-9_]*)\b/g, (placeholder, key) => {
-            if (!(key in params)) {
-                return placeholder;
-            }
-            values.push(params[key]);
-            return '?';
-        });
-        return { sql: parameterizedQuery, params: values };
-    }
     getRandomSampleFilter(samplePct) {
         if (samplePct <= 0 || samplePct >= 1) {
             return '';
@@ -100,7 +95,10 @@ export class KtxMysqlDialect {
         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)`;
@@ -108,6 +106,15 @@ export class KtxMysqlDialect {
     getDistinctCountExpression(column) {
         return `COUNT(DISTINCT ${column})`;
     }
+    textLengthExpression(columnSql) {
+        return `CHAR_LENGTH(CAST(${columnSql} AS CHAR))`;
+    }
+    castToText(columnSql) {
+        return `CAST(${columnSql} AS CHAR)`;
+    }
+    getSampleValueAggregation(innerSql) {
+        return `(SELECT GROUP_CONCAT(CAST(value AS CHAR) SEPARATOR CHAR(31)) FROM (${innerSql}) AS relationship_profile_values)`;
+    }
     generateCardinalitySampleQuery(tableName, columnName, sampleSize) {
         return `
       SELECT COUNT(DISTINCT val) AS cardinality
@@ -143,29 +150,4 @@ export class KtxMysqlDialect {
       ) AS sampled
     `;
     }
-    getTimeTruncExpression(column, granularity, timezone) {
-        const col = timezone ? `CONVERT_TZ(${column}, '+00:00', '${timezone}')` : column;
-        switch (granularity) {
-            case 'day':
-                return `DATE(${col})`;
-            case 'week':
-                return `DATE(${col} - INTERVAL WEEKDAY(${col}) DAY)`;
-            case 'month':
-                return `DATE_FORMAT(${col}, '%Y-%m-01')`;
-            case 'quarter':
-                return `MAKEDATE(YEAR(${col}), 1) + INTERVAL (QUARTER(${col}) - 1) QUARTER`;
-            case 'year':
-                return `DATE_FORMAT(${col}, '%Y-01-01')`;
-        }
-    }
-    getCustomTimeTruncExpression(column, interval, origin, timezone) {
-        const col = timezone ? `CONVERT_TZ(${column}, '+00:00', '${timezone}')` : column;
-        const [amount, unit] = interval.split(' ');
-        const originExpr = origin ? `'${origin}'` : `'1970-01-01'`;
-        return `DATE_ADD(${originExpr}, INTERVAL FLOOR(TIMESTAMPDIFF(${unit.toUpperCase()}, ${originExpr}, ${col}) / ${amount}) * ${amount} ${unit.toUpperCase()})`;
-    }
-    parseIntervalToSql(interval) {
-        const [amount, unit] = interval.split(' ');
-        return `INTERVAL ${amount} ${unit.toUpperCase()}`;
-    }
 }

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

@@ -14,6 +14,7 @@ export interface KtxPostgresConnectionConfig {
     sslmode?: string;
     sslMode?: string;
     rejectUnauthorized?: boolean;
+    maxConnections?: number;
     [key: string]: unknown;
 }
 export interface KtxPostgresPoolConfig {
@@ -89,6 +90,11 @@ export interface KtxPostgresTableSampleResult extends KtxTableSampleResult {
     headerTypes?: string[];
 }
 type PostgresTableRef = Pick<KtxTableRef, 'name'> & Partial<Pick<KtxTableRef, 'catalog' | 'db'>>;
+/** @internal */
+export declare function preparePostgresReadOnlyQuery(sql: string, params?: Record<string, unknown>): {
+    sql: string;
+    params?: unknown[];
+};
 export declare function isKtxPostgresConnectionConfig(connection: KtxPostgresConnectionConfig | undefined): connection is KtxPostgresConnectionConfig;
 /** @internal */
 export declare function postgresPoolConfigFromConfig(input: {

package/dist/connectors/postgres/connector.js

@@ -1,11 +1,12 @@
 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 { Pool } from 'pg';
-import { KtxPostgresDialect } from './dialect.js';
 const PG_OID_TYPE_MAP = {
     16: 'boolean',
     20: 'bigint',
@@ -40,6 +41,25 @@ function groupByTable(rows) {
     }
     return grouped;
 }
+/** @internal */
+export function preparePostgresReadOnlyQuery(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 };
+}
 function primaryKeyMap(rows) {
     const grouped = new Map();
     for (const row of rows) {
@@ -49,6 +69,13 @@ function primaryKeyMap(rows) {
     }
     return grouped;
 }
+function isDeniedError(error) {
+    if (!error || typeof error !== 'object') {
+        return false;
+    }
+    const code = error.code;
+    return code === '42501' || code === '42P01';
+}
 function queryRows(result) {
     const headers = (result.fields ?? []).map((field) => field.name);
     return result.rows.map((row) => headers.map((header) => row[header]));
@@ -75,6 +102,17 @@ function resolveStringReference(value, env) {
 function numberValue(value) {
     return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
 }
+function positiveIntegerConfigValue(input) {
+    const value = input.connection[input.key];
+    if (value === undefined) {
+        return input.defaultValue;
+    }
+    const numberValue = Number(value);
+    if (!Number.isInteger(numberValue) || numberValue < 1) {
+        throw new Error(`connections.${input.connectionId}.${String(input.key)} must be a positive integer`);
+    }
+    return numberValue;
+}
 function parsePostgresUrl(url) {
     const parsed = new URL(url);
     const sslmode = parsed.searchParams.get('sslmode') ?? undefined;
@@ -103,7 +141,7 @@ function searchPathSchemasFromConnection(connection) {
 }
 export function isKtxPostgresConnectionConfig(connection) {
     const driver = String(connection?.driver ?? '').toLowerCase();
-    return driver === 'postgres' || driver === 'postgresql';
+    return driver === 'postgres';
 }
 /** @internal */
 export function postgresPoolConfigFromConfig(input) {
@@ -120,6 +158,12 @@ export function postgresPoolConfigFromConfig(input) {
     const user = stringConfigValue(merged, 'username', env) ?? stringConfigValue(merged, 'user', env);
     const password = stringConfigValue(merged, 'password', env);
     const sslmode = normalizedSslMode(merged);
+    const maxConnections = positiveIntegerConfigValue({
+        connection: merged,
+        key: 'maxConnections',
+        connectionId: input.connectionId,
+        defaultValue: 10,
+    });
     if (!referencedUrl && !host) {
         throw new Error(`Native PostgreSQL connector requires connections.${input.connectionId}.host or url`);
     }
@@ -130,7 +174,7 @@ export function postgresPoolConfigFromConfig(input) {
         throw new Error(`Native PostgreSQL connector requires connections.${input.connectionId}.username, user, or url`);
     }
     const config = {
-        max: 10,
+        max: maxConnections,
         idleTimeoutMillis: 30_000,
         connectionTimeoutMillis: 10_000,
         ...(referencedUrl && sslmode !== 'prefer' && sslmode !== 'disable'
@@ -164,7 +208,7 @@ export class KtxPostgresScanConnector {
     poolFactory;
     endpointResolver;
     now;
-    dialect = new KtxPostgresDialect();
+    dialect = getDialectForDriver('postgres');
     pool = null;
     lastIdlePoolError = null;
     resolvedEndpoint = null;
@@ -194,11 +238,12 @@ export class KtxPostgresScanConnector {
         this.assertConnection(input.connectionId);
         const schemas = schemasFromConnection(this.connection);
         const allTables = [];
+        const snapshotWarnings = [];
         for (const schema of schemas) {
             const scopedNames = input.tableScope ? scopedTableNames(input.tableScope, { catalog: null, db: schema }) : null;
             if (scopedNames && scopedNames.length === 0)
                 continue;
-            const tables = await this.loadSchemaTables(schema, scopedNames);
+            const tables = await this.loadSchemaTables(schema, scopedNames, snapshotWarnings);
             allTables.push(...tables);
         }
         return {
@@ -214,6 +259,7 @@ export class KtxPostgresScanConnector {
                 total_columns: allTables.reduce((sum, table) => sum + table.columns.length, 0),
             },
             tables: allTables,
+            warnings: snapshotWarnings,
         };
     }
     async sampleTable(input, _ctx) {
@@ -244,7 +290,7 @@ export class KtxPostgresScanConnector {
         const limitedSql = limitSqlForExecution(assertReadOnlySql(input.sql), input.maxRows);
         const prepared = Array.isArray(input.params)
             ? { sql: limitedSql, params: input.params }
-            : this.dialect.prepareQuery(limitedSql, input.params);
+            : preparePostgresReadOnlyQuery(limitedSql, input.params);
         const result = await this.query(prepared.sql, prepared.params);
         return { ...result, rowCount: result.rows.length };
     }
@@ -321,6 +367,7 @@ export class KtxPostgresScanConnector {
       ORDER BY n.nspname, c.relname
       `, [filterSchemas]);
         return rows.map((row) => ({
+            catalog: null,
             schema: row.schema_name,
             name: row.table_name,
             kind: row.table_kind === 'v' ? 'view' : 'table',
@@ -336,7 +383,7 @@ export class KtxPostgresScanConnector {
             this.resolvedEndpoint = null;
         }
     }
-    async loadSchemaTables(schema, scopedNames) {
+    async loadSchemaTables(schema, scopedNames, snapshotWarnings) {
         if (scopedNames && scopedNames.length === 0)
             return [];
         const pgCatalogScopeClause = scopedNames ? 'AND c.relname = ANY($2)' : '';
@@ -376,7 +423,7 @@ export class KtxPostgresScanConnector {
         ${pgCatalogScopeClause}
       ORDER BY c.relname, a.attnum
       `, [schema, ...scopeValues]);
-        const primaryKeys = await this.queryRaw(`
+        const primaryKeysResult = await tryConstraintQuery({ schema, kind: 'primary_key', isDeniedError }, () => this.queryRaw(`
       SELECT tc.table_name, kcu.column_name
       FROM information_schema.table_constraints tc
       JOIN information_schema.key_column_usage kcu
@@ -386,8 +433,12 @@ export class KtxPostgresScanConnector {
         AND tc.table_schema = $1
         ${tableConstraintScopeClause}
       ORDER BY tc.table_name, kcu.ordinal_position
-      `, [schema, ...scopeValues]);
-        const foreignKeys = await this.queryRaw(`
+      `, [schema, ...scopeValues]));
+        const primaryKeys = primaryKeysResult.ok ? primaryKeysResult.value : [];
+        if (!primaryKeysResult.ok) {
+            snapshotWarnings.push(primaryKeysResult.warning);
+        }
+        const foreignKeysResult = await tryConstraintQuery({ schema, kind: 'foreign_key', isDeniedError }, () => this.queryRaw(`
       SELECT
         tc.table_name,
         kcu.column_name,
@@ -406,7 +457,11 @@ export class KtxPostgresScanConnector {
         AND tc.table_schema = $1
         ${tableConstraintScopeClause}
       ORDER BY tc.table_name, kcu.column_name
-      `, [schema, ...scopeValues]);
+      `, [schema, ...scopeValues]));
+        const foreignKeys = foreignKeysResult.ok ? foreignKeysResult.value : [];
+        if (!foreignKeysResult.ok) {
+            snapshotWarnings.push(foreignKeysResult.warning);
+        }
         const columnsByTable = groupByTable(columns);
         const primaryKeysByTable = primaryKeyMap(primaryKeys);
         const foreignKeysByTable = groupByTable(foreignKeys);

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