@kaelio/ktx 0.4.1 → 0.6.0

package/dist/connectors/mysql/connector.js

@@ -0,0 +1,494 @@
+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 { constraintDiscoveryWarning, tryConstraintQuery, } from '../../context/scan/constraint-discovery.js';
+import { scopedTableNames } from '../../context/scan/table-ref.js';
+import { createKtxConnectorCapabilities, } from '../../context/scan/types.js';
+class DefaultMysqlPoolFactory {
+    createPool(config) {
+        return mysql.createPool(config);
+    }
+}
+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:')) {
+        const envName = value.slice('env:'.length);
+        return env[envName] ?? '';
+    }
+    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 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');
+    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,
+        ssl: sslParam === 'true' || sslParam === 'required',
+    };
+}
+function cleanMySqlTableComment(comment) {
+    if (!comment) {
+        return null;
+    }
+    if (comment.startsWith('InnoDB free:')) {
+        const semiIndex = comment.indexOf(';');
+        if (semiIndex === -1) {
+            return null;
+        }
+        const userComment = comment.slice(semiIndex + 1).trim();
+        return userComment || null;
+    }
+    return comment;
+}
+function configuredMysqlSchemas(connection, fallbackDatabase) {
+    if (Array.isArray(connection.schemas) && connection.schemas.length > 0) {
+        const selected = connection.schemas
+            .filter((schema) => typeof schema === 'string' && schema.trim().length > 0)
+            .map((schema) => schema.trim());
+        if (selected.length > 0) {
+            return [...new Set(selected)];
+        }
+    }
+    return [fallbackDatabase];
+}
+function mysqlTableKey(schema, table) {
+    return `${schema}.${table}`;
+}
+function groupByTable(rows, fallbackDatabase) {
+    const grouped = new Map();
+    for (const row of rows) {
+        const tableRows = grouped.get(mysqlTableKey(row.TABLE_SCHEMA ?? fallbackDatabase, row.TABLE_NAME)) ?? [];
+        tableRows.push(row);
+        grouped.set(mysqlTableKey(row.TABLE_SCHEMA ?? fallbackDatabase, row.TABLE_NAME), tableRows);
+    }
+    return grouped;
+}
+function primaryKeyMap(rows, fallbackDatabase) {
+    const grouped = new Map();
+    for (const row of rows) {
+        const key = mysqlTableKey(row.TABLE_SCHEMA ?? fallbackDatabase, row.TABLE_NAME);
+        const columns = grouped.get(key) ?? new Set();
+        columns.add(row.COLUMN_NAME);
+        grouped.set(key, columns);
+    }
+    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';
+}
+/** @internal */
+export function mysqlConnectionPoolConfigFromConfig(input) {
+    const inputDriver = input.connection?.driver ?? 'unknown';
+    if (!isKtxMysqlConnectionConfig(input.connection)) {
+        throw new Error(`Native MySQL connector cannot run driver "${inputDriver}"`);
+    }
+    const env = input.env ?? process.env;
+    const referencedUrl = stringConfigValue(input.connection, 'url', env);
+    const urlConfig = referencedUrl ? parseMysqlUrl(referencedUrl) : {};
+    const merged = { ...urlConfig, ...input.connection };
+    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`);
+    }
+    if (!database) {
+        throw new Error(`Native MySQL connector requires connections.${input.connectionId}.database or url`);
+    }
+    if (!user) {
+        throw new Error(`Native MySQL connector requires connections.${input.connectionId}.username, user, or url`);
+    }
+    const ssl = merged.ssl === true ? { rejectUnauthorized: false } : typeof merged.ssl === 'object' ? merged.ssl : undefined;
+    return {
+        host,
+        port: maybeNumber(merged.port) ?? 3306,
+        database,
+        user,
+        password: stringConfigValue(merged, 'password', env),
+        connectionLimit: maxConnections,
+        waitForConnections: true,
+        ...(ssl ? { ssl: { rejectUnauthorized: ssl.rejectUnauthorized ?? false } } : {}),
+    };
+}
+export class KtxMysqlScanConnector {
+    id;
+    driver = 'mysql';
+    capabilities = createKtxConnectorCapabilities({
+        tableSampling: true,
+        columnSampling: true,
+        columnStats: false,
+        readOnlySql: true,
+        nestedAnalysis: true,
+        formalForeignKeys: true,
+        estimatedRowCounts: true,
+    });
+    connectionId;
+    connection;
+    poolConfig;
+    poolFactory;
+    endpointResolver;
+    now;
+    dialect = getDialectForDriver('mysql');
+    pool = null;
+    resolvedEndpoint = null;
+    constructor(options) {
+        this.connectionId = options.connectionId;
+        this.connection = options.connection ?? {};
+        this.poolConfig = mysqlConnectionPoolConfigFromConfig({
+            connectionId: options.connectionId,
+            connection: options.connection,
+            env: options.env,
+        });
+        this.poolFactory = options.poolFactory ?? new DefaultMysqlPoolFactory();
+        this.endpointResolver = options.endpointResolver;
+        this.now = options.now ?? (() => new Date());
+        this.id = `mysql:${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 databases = configuredMysqlSchemas(this.connection, this.poolConfig.database);
+        const snapshotWarnings = [];
+        const placeholders = databases.map(() => '?').join(', ');
+        let allScopedTables = null;
+        if (input.tableScope) {
+            allScopedTables = [];
+            for (const database of databases) {
+                allScopedTables.push(...scopedTableNames(input.tableScope, { catalog: null, db: database }));
+            }
+            if (allScopedTables.length === 0) {
+                return this.emptySnapshot(databases);
+            }
+        }
+        const tableNameClause = allScopedTables
+            ? `AND TABLE_NAME IN (${allScopedTables.map(() => '?').join(', ')})`
+            : '';
+        const tableNameParams = allScopedTables ?? [];
+        const tables = await this.queryRaw(`
+      SELECT TABLE_SCHEMA, TABLE_NAME, TABLE_TYPE, TABLE_COMMENT, TABLE_ROWS
+      FROM INFORMATION_SCHEMA.TABLES
+      WHERE TABLE_SCHEMA IN (${placeholders}) AND TABLE_TYPE IN ('BASE TABLE', 'VIEW') ${tableNameClause}
+      ORDER BY TABLE_SCHEMA, TABLE_NAME
+      `, [...databases, ...tableNameParams]);
+        const columns = await this.queryRaw(`
+      SELECT TABLE_SCHEMA, TABLE_NAME, COLUMN_NAME, DATA_TYPE, IS_NULLABLE, COLUMN_COMMENT
+      FROM INFORMATION_SCHEMA.COLUMNS
+      WHERE TABLE_SCHEMA IN (${placeholders}) ${tableNameClause}
+      ORDER BY TABLE_SCHEMA, TABLE_NAME, ORDINAL_POSITION
+      `, [...databases, ...tableNameParams]);
+        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 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]));
+        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);
+        const schemaTables = tables.map((table) => this.toSchemaTable(table.TABLE_SCHEMA ?? this.poolConfig.database, table, columnsByTable.get(mysqlTableKey(table.TABLE_SCHEMA ?? this.poolConfig.database, table.TABLE_NAME)) ?? [], primaryKeysByTable, foreignKeysByTable));
+        return {
+            connectionId: this.connectionId,
+            driver: 'mysql',
+            extractedAt: this.now().toISOString(),
+            scope: { schemas: databases },
+            metadata: {
+                database: this.poolConfig.database,
+                schemas: databases,
+                host: this.poolConfig.host,
+                table_count: schemaTables.length,
+                total_columns: schemaTables.reduce((sum, table) => sum + table.columns.length, 0),
+            },
+            tables: schemaTables,
+            warnings: snapshotWarnings,
+        };
+    }
+    emptySnapshot(databases) {
+        return {
+            connectionId: this.connectionId,
+            driver: 'mysql',
+            extractedAt: this.now().toISOString(),
+            scope: { schemas: databases },
+            metadata: {
+                database: this.poolConfig.database,
+                schemas: databases,
+                host: this.poolConfig.host,
+                table_count: 0,
+                total_columns: 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, 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 = limitSqlForExecution(assertReadOnlySql(input.sql), input.maxRows);
+        const prepared = Array.isArray(input.params)
+            ? { sql: limitedSql, params: input.params }
+            : prepareMysqlReadOnlyQuery(limitedSql, input.params);
+        const result = await this.query(prepared.sql, prepared.params);
+        return { ...result, rowCount: result.rows.length };
+    }
+    async getColumnDistinctValues(table, columnName, options) {
+        const sampleSize = options.sampleSize ?? 10000;
+        const tableName = this.qTableName(table);
+        const quotedColumn = this.dialect.quoteIdentifier(columnName);
+        const cardinalityRows = await this.queryRaw(this.dialect.generateCardinalitySampleQuery(tableName, quotedColumn, sampleSize));
+        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) {
+        const rows = await this.queryRaw(`SELECT COUNT(*) AS count FROM ${this.dialect.quoteIdentifier(tableName)}`);
+        return Number(rows[0]?.count ?? 0);
+    }
+    qTableName(table) {
+        return this.dialect.formatTableName(table);
+    }
+    quoteIdentifier(identifier) {
+        return this.dialect.quoteIdentifier(identifier);
+    }
+    async listSchemas() {
+        const rows = await this.queryRaw(`
+      SELECT SCHEMA_NAME
+      FROM INFORMATION_SCHEMA.SCHEMATA
+      WHERE SCHEMA_NAME NOT IN ('information_schema', 'mysql', 'performance_schema', 'sys')
+      ORDER BY SCHEMA_NAME
+    `);
+        return rows.map((row) => row.SCHEMA_NAME);
+    }
+    async listTables(schemas) {
+        const filterSchemas = schemas ?? (await this.listSchemas());
+        if (filterSchemas.length === 0)
+            return [];
+        const placeholders = filterSchemas.map(() => '?').join(', ');
+        const rows = await this.queryRaw(`
+      SELECT TABLE_SCHEMA, TABLE_NAME, TABLE_TYPE
+      FROM INFORMATION_SCHEMA.TABLES
+      WHERE TABLE_SCHEMA IN (${placeholders})
+        AND TABLE_TYPE IN ('BASE TABLE', 'VIEW')
+      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',
+        }));
+    }
+    async cleanup() {
+        if (this.pool) {
+            await this.pool.end();
+            this.pool = null;
+        }
+        if (this.resolvedEndpoint?.close) {
+            await this.resolvedEndpoint.close();
+            this.resolvedEndpoint = null;
+        }
+    }
+    toSchemaTable(database, table, columns, primaryKeysByTable, foreignKeysByTable) {
+        const tableName = table.TABLE_NAME;
+        const kind = table.TABLE_TYPE === 'VIEW' ? 'view' : 'table';
+        const estimatedRows = kind === 'view' ? null : Number(table.TABLE_ROWS ?? 0);
+        return {
+            catalog: null,
+            db: database,
+            name: tableName,
+            kind,
+            comment: cleanMySqlTableComment(table.TABLE_COMMENT),
+            estimatedRows: Number.isFinite(estimatedRows) ? estimatedRows : null,
+            columns: columns.map((column) => this.toSchemaColumn(column, primaryKeysByTable.get(mysqlTableKey(database, tableName)) ?? new Set())),
+            foreignKeys: (foreignKeysByTable.get(mysqlTableKey(database, tableName)) ?? []).map((row) => this.toSchemaForeignKey(database, row)),
+        };
+    }
+    toSchemaColumn(column, primaryKeys) {
+        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: column.COLUMN_COMMENT || null,
+        };
+    }
+    toSchemaForeignKey(database, row) {
+        return {
+            fromColumn: row.COLUMN_NAME,
+            toCatalog: null,
+            toDb: database,
+            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.host,
+                    port: config.port,
+                    connection: this.connection,
+                });
+                config.host = this.resolvedEndpoint.host;
+                config.port = this.resolvedEndpoint.port;
+            }
+            this.pool = this.poolFactory.createPool(config);
+        }
+        return this.pool;
+    }
+    async queryRaw(sql, params) {
+        const pool = await this.poolForQuery();
+        const connection = await pool.getConnection();
+        try {
+            const [rows] = await connection.query(sql, params);
+            return rows;
+        }
+        finally {
+            connection.release();
+        }
+    }
+    async query(sql, params) {
+        const pool = await this.poolForQuery();
+        const connection = await pool.getConnection();
+        try {
+            const [rows, fields] = await connection.query(assertReadOnlySql(sql), queryParams(params));
+            const headers = fields.map((field) => field.name);
+            const headerTypes = fields.map((field) => String(field.type ?? 'unknown'));
+            return {
+                headers,
+                headerTypes,
+                rows: rows.map((row) => headers.map((header) => row[header])),
+                totalRows: rows.length,
+            };
+        }
+        finally {
+            connection.release();
+        }
+    }
+    assertConnection(connectionId) {
+        if (connectionId !== this.connectionId) {
+            throw new Error(`KTX MySQL connector ${this.id} cannot serve connection ${connectionId}`);
+        }
+    }
+}

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

@@ -0,0 +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'>>;
+/** @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;
+    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;
+}
+export {};

package/dist/connectors/mysql/dialect.js

@@ -0,0 +1,153 @@
+import { columnDisplayPartCount, formatDialectDisplayRef, formatDialectTableName, limitOffsetClause, parseDialectDisplayRef, } from '../../context/connections/dialect-helpers.js';
+/** @internal */
+export class KtxMysqlDialect {
+    type = 'mysql';
+    typeMappings = {
+        datetime: 'time',
+        timestamp: 'time',
+        date: 'time',
+        time: 'time',
+        year: 'time',
+        tinyint: 'number',
+        smallint: 'number',
+        mediumint: 'number',
+        int: 'number',
+        integer: 'number',
+        bigint: 'number',
+        decimal: 'number',
+        numeric: 'number',
+        float: 'number',
+        double: 'number',
+        real: 'number',
+        varchar: 'string',
+        char: 'string',
+        text: 'string',
+        tinytext: 'string',
+        mediumtext: 'string',
+        longtext: 'string',
+        enum: 'string',
+        set: 'string',
+        json: 'string',
+        bit: 'boolean',
+        bool: 'boolean',
+        boolean: 'boolean',
+    };
+    quoteIdentifier(identifier) {
+        return `\`${identifier.replace(/`/g, '``')}\``;
+    }
+    formatTableName(table) {
+        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;
+    }
+    mapToDimensionType(nativeType) {
+        if (!nativeType) {
+            return 'string';
+        }
+        const lower = nativeType.toLowerCase().trim();
+        if (lower.includes('tinyint(1)')) {
+            return 'boolean';
+        }
+        const normalized = lower.includes('(') ? lower.split('(')[0] : lower;
+        if (this.typeMappings[normalized]) {
+            return this.typeMappings[normalized];
+        }
+        if (normalized.includes('time') || normalized.includes('date')) {
+            return 'time';
+        }
+        if (normalized.includes('int') ||
+            normalized.includes('num') ||
+            normalized.includes('dec') ||
+            normalized.includes('float') ||
+            normalized.includes('double')) {
+            return 'number';
+        }
+        if (normalized.includes('bit') || normalized === 'bool' || normalized === 'boolean') {
+            return 'boolean';
+        }
+        return 'string';
+    }
+    generateSampleQuery(tableName, limit, columns) {
+        const columnList = columns && columns.length > 0 ? columns.map((column) => this.quoteIdentifier(column)).join(', ') : '*';
+        return `SELECT ${columnList} FROM ${tableName} LIMIT ${limit}`;
+    }
+    generateColumnSampleQuery(tableName, columnName, limit) {
+        const quotedColumn = this.quoteIdentifier(columnName);
+        return `SELECT ${quotedColumn} FROM ${tableName} WHERE ${quotedColumn} IS NOT NULL AND TRIM(CAST(${quotedColumn} AS CHAR)) != '' LIMIT ${limit}`;
+    }
+    getRandomSampleFilter(samplePct) {
+        if (samplePct <= 0 || samplePct >= 1) {
+            return '';
+        }
+        return `RAND() < ${samplePct}`;
+    }
+    getTableSampleClause(_samplePct) {
+        return '';
+    }
+    getLimitOffsetClause(limit, offset) {
+        return limitOffsetClause(limit, offset);
+    }
+    getTopClause(_limit) {
+        return '';
+    }
+    getNullCountExpression(column) {
+        return `SUM(CASE WHEN ${column} IS NULL THEN 1 ELSE 0 END)`;
+    }
+    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
+      FROM (
+        SELECT ${columnName} AS val
+        FROM ${tableName}
+        WHERE ${columnName} IS NOT NULL
+        LIMIT ${sampleSize}
+      ) AS sampled
+    `;
+    }
+    generateDistinctValuesQuery(tableName, columnName, limit) {
+        return `
+      SELECT DISTINCT CAST(${columnName} AS CHAR) AS val
+      FROM ${tableName}
+      WHERE ${columnName} IS NOT NULL
+      ORDER BY val
+      LIMIT ${limit}
+    `;
+    }
+    generateColumnStatisticsQuery(_schemaName, _tableName) {
+        return null;
+    }
+    generateRandomizedCardinalitySampleQuery(tableName, columnName, sampleSize) {
+        return `
+      SELECT COUNT(DISTINCT val) AS cardinality
+      FROM (
+        SELECT ${columnName} AS val
+        FROM ${tableName}
+        WHERE ${columnName} IS NOT NULL
+        ORDER BY RAND()
+        LIMIT ${sampleSize}
+      ) AS sampled
+    `;
+    }
+}

package/dist/connectors/mysql/live-database-introspection.d.ts

@@ -0,0 +1,11 @@
+import type { LiveDatabaseIntrospectionPort } from '../../context/ingest/adapters/live-database/types.js';
+import type { KtxProjectConnectionConfig } from '../../context/project/config.js';
+import { type KtxMysqlEndpointResolver, type KtxMysqlPoolFactory } from './connector.js';
+interface CreateMysqlLiveDatabaseIntrospectionOptions {
+    connections: Record<string, KtxProjectConnectionConfig>;
+    poolFactory?: KtxMysqlPoolFactory;
+    endpointResolver?: KtxMysqlEndpointResolver;
+    now?: () => Date;
+}
+export declare function createMysqlLiveDatabaseIntrospection(options: CreateMysqlLiveDatabaseIntrospectionOptions): LiveDatabaseIntrospectionPort;
+export {};