@kaelio/ktx 0.15.0 → 0.16.0

package/dist/commands/setup-commands.js

@@ -26,6 +26,7 @@ function llmBackend(value) {
 }
 function databaseDriver(value) {
     if (value === 'sqlite' ||
+        value === 'duckdb' ||
         value === 'postgres' ||
         value === 'mysql' ||
         value === 'clickhouse' ||

package/dist/connection-drivers.d.ts

@@ -1,5 +1,5 @@
 import type { KtxProjectConnectionConfig } from './context/project/config.js';
 /** @internal Canonical SQL-warehouse driver ids; the dialect-notes coverage test derives its required coverage from this set. */
-export declare const KTX_DATABASE_DRIVER_IDS: readonly ["sqlite", "postgres", "mysql", "clickhouse", "sqlserver", "bigquery", "snowflake"];
+export declare const KTX_DATABASE_DRIVER_IDS: readonly ["sqlite", "duckdb", "postgres", "mysql", "clickhouse", "sqlserver", "bigquery", "snowflake", "athena"];
 export declare function normalizeConnectionDriver(connection: KtxProjectConnectionConfig): string;
 export declare function isDatabaseDriver(driver: string): boolean;

package/dist/connection-drivers.js

@@ -1,12 +1,14 @@
 /** @internal Canonical SQL-warehouse driver ids; the dialect-notes coverage test derives its required coverage from this set. */
 export const KTX_DATABASE_DRIVER_IDS = [
     'sqlite',
+    'duckdb',
     'postgres',
     'mysql',
     'clickhouse',
     'sqlserver',
     'bigquery',
     'snowflake',
+    'athena',
 ];
 // mongodb is a database driver but has no SQL dialect, so it sits outside the
 // dialect-notes coverage set above.

package/dist/connection.js

@@ -22,6 +22,7 @@ import { formatErrorDetail, scrubErrorClass } from './telemetry/scrubber.js';
 profileMark('module:connection');
 const SUPPORTED_TEST_DRIVERS = [
     'sqlite',
+    'duckdb',
     'postgres',
     'mysql',
     'clickhouse',

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

@@ -0,0 +1,160 @@
+import { type KtxConnectorTestResult, 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 KtxAthenaConnectionConfig {
+    driver?: string;
+    region?: string;
+    s3_staging_dir?: string;
+    workgroup?: string;
+    catalog?: string;
+    database?: string;
+    databases?: string[];
+    [key: string]: unknown;
+}
+export interface KtxAthenaResolvedConnectionConfig {
+    region: string;
+    s3StagingDir: string;
+    workgroup: string;
+    catalog: string;
+    database: string | undefined;
+    databases: string[];
+}
+interface KtxAthenaQueryExecutionStatus {
+    State?: string;
+    StateChangeReason?: string;
+}
+interface KtxAthenaQueryExecution {
+    Status?: KtxAthenaQueryExecutionStatus;
+}
+interface KtxAthenaColumnInfo {
+    Name?: string;
+    Type?: string;
+}
+interface KtxAthenaDatum {
+    VarCharValue?: string;
+}
+interface KtxAthenaRow {
+    Data?: KtxAthenaDatum[];
+}
+interface KtxAthenaResultSet {
+    Rows?: KtxAthenaRow[];
+    ResultSetMetadata?: {
+        ColumnInfo?: KtxAthenaColumnInfo[];
+    };
+}
+/** @internal */
+export interface KtxAthenaClient {
+    startQueryExecution(input: {
+        QueryString: string;
+        ResultConfiguration: {
+            OutputLocation: string;
+        };
+        WorkGroup: string;
+        QueryExecutionContext?: {
+            Database?: string;
+            Catalog?: string;
+        };
+    }): Promise<{
+        QueryExecutionId?: string;
+    }>;
+    getQueryExecution(input: {
+        QueryExecutionId: string;
+    }): Promise<{
+        QueryExecution?: KtxAthenaQueryExecution;
+    }>;
+    getQueryResults(input: {
+        QueryExecutionId: string;
+        NextToken?: string;
+    }): Promise<{
+        ResultSet?: KtxAthenaResultSet;
+        NextToken?: string;
+    }>;
+}
+interface KtxGlueColumnDef {
+    Name?: string;
+    Type?: string;
+    Comment?: string;
+}
+interface KtxGlueStorageDescriptor {
+    Columns?: KtxGlueColumnDef[];
+}
+/** @internal */
+export interface KtxGlueTable {
+    Name?: string;
+    TableType?: string;
+    StorageDescriptor?: KtxGlueStorageDescriptor;
+    PartitionKeys?: KtxGlueColumnDef[];
+    Description?: string;
+    Parameters?: Record<string, string>;
+}
+/** @internal */
+export interface KtxGlueClient {
+    getDatabases(input: {
+        CatalogId?: string;
+        NextToken?: string;
+    }): Promise<{
+        DatabaseList?: Array<{
+            Name?: string;
+        }>;
+        NextToken?: string;
+    }>;
+    getTables(input: {
+        DatabaseName: string;
+        CatalogId?: string;
+        NextToken?: string;
+    }): Promise<{
+        TableList?: KtxGlueTable[];
+        NextToken?: string;
+    }>;
+}
+export interface KtxAthenaClientFactory {
+    createAthenaClient(region: string): KtxAthenaClient;
+    createGlueClient(region: string): KtxGlueClient;
+}
+export declare function isKtxAthenaConnectionConfig(connection: unknown): connection is KtxAthenaConnectionConfig;
+/** @internal */
+export declare function athenaConnectionConfigFromConfig(input: {
+    connectionId: string;
+    connection: KtxAthenaConnectionConfig | undefined;
+    env?: NodeJS.ProcessEnv;
+}): KtxAthenaResolvedConnectionConfig;
+export interface KtxAthenaScanConnectorOptions {
+    connectionId: string;
+    connection: KtxAthenaConnectionConfig | undefined;
+    clientFactory?: KtxAthenaClientFactory;
+    env?: NodeJS.ProcessEnv;
+    now?: () => Date;
+}
+export declare class KtxAthenaScanConnector implements KtxScanConnector {
+    readonly id: string;
+    readonly driver: "athena";
+    readonly capabilities: import("../../context/scan/types.js").KtxConnectorCapabilities;
+    private readonly connectionId;
+    private readonly resolved;
+    private readonly clientFactory;
+    private readonly now;
+    private readonly dialect;
+    private athenaClient;
+    private glueClient;
+    constructor(options: KtxAthenaScanConnectorOptions);
+    testConnection(): Promise<KtxConnectorTestResult>;
+    introspect(input: KtxScanInput, _ctx: KtxScanContext): Promise<KtxSchemaSnapshot>;
+    sampleTable(input: KtxTableSampleInput, _ctx: KtxScanContext): Promise<KtxTableSampleResult & {
+        headerTypes?: string[];
+    }>;
+    sampleColumn(input: KtxColumnSampleInput, _ctx: KtxScanContext): Promise<KtxColumnSampleResult>;
+    columnStats(_input: KtxColumnStatsInput, _ctx: KtxScanContext): Promise<KtxColumnStatsResult | null>;
+    executeReadOnly(input: KtxReadOnlyQueryInput, _ctx: KtxScanContext): Promise<KtxQueryResult>;
+    listSchemas(): Promise<string[]>;
+    listTables(databases?: string[]): Promise<KtxTableListEntry[]>;
+    cleanup(): Promise<void>;
+    qTableName(table: Pick<KtxTableRef, 'name'> & Partial<Pick<KtxTableRef, 'catalog' | 'db'>>): string;
+    private getAthenaClient;
+    private getGlueClient;
+    private listDatabasesPaginated;
+    private listGlueTablesPaginated;
+    private introspectDatabase;
+    private toSchemaColumns;
+    private query;
+    private waitForQueryCompletion;
+    private assertConnection;
+}
+export {};

package/dist/connectors/athena/connector.js

@@ -0,0 +1,378 @@
+import { AthenaClient, StartQueryExecutionCommand, GetQueryExecutionCommand, GetQueryResultsCommand } from '@aws-sdk/client-athena';
+import { GlueClient, GetDatabasesCommand, GetTablesCommand } from '@aws-sdk/client-glue';
+import { getSqlDialectForDriver } from '../../context/connections/dialects.js';
+import { assertReadOnlySql, limitSqlForExecution } from '../../context/connections/read-only-sql.js';
+import { connectorTestFailure, createKtxConnectorCapabilities, } from '../../context/scan/types.js';
+import { scopedTableNames } from '../../context/scan/table-ref.js';
+import { resolveStringReference } from '../shared/string-reference.js';
+class DefaultAthenaClientFactory {
+    createAthenaClient(region) {
+        const client = new AthenaClient({ region });
+        return {
+            startQueryExecution: async (input) => {
+                const result = await client.send(new StartQueryExecutionCommand({
+                    QueryString: input.QueryString,
+                    ResultConfiguration: { OutputLocation: input.ResultConfiguration.OutputLocation },
+                    WorkGroup: input.WorkGroup,
+                    QueryExecutionContext: input.QueryExecutionContext,
+                }));
+                return { QueryExecutionId: result.QueryExecutionId };
+            },
+            getQueryExecution: async (input) => {
+                const result = await client.send(new GetQueryExecutionCommand({ QueryExecutionId: input.QueryExecutionId }));
+                return {
+                    QueryExecution: result.QueryExecution
+                        ? {
+                            Status: {
+                                State: result.QueryExecution.Status?.State,
+                                StateChangeReason: result.QueryExecution.Status?.StateChangeReason,
+                            },
+                        }
+                        : undefined,
+                };
+            },
+            getQueryResults: async (input) => {
+                const result = await client.send(new GetQueryResultsCommand({ QueryExecutionId: input.QueryExecutionId, NextToken: input.NextToken }));
+                return {
+                    ResultSet: result.ResultSet,
+                    NextToken: result.NextToken,
+                };
+            },
+        };
+    }
+    createGlueClient(region) {
+        const client = new GlueClient({ region });
+        return {
+            getDatabases: async (input) => {
+                const result = await client.send(new GetDatabasesCommand({ CatalogId: input.CatalogId, NextToken: input.NextToken }));
+                return {
+                    DatabaseList: result.DatabaseList?.map((db) => ({ Name: db.Name })),
+                    NextToken: result.NextToken,
+                };
+            },
+            getTables: async (input) => {
+                const result = await client.send(new GetTablesCommand({ DatabaseName: input.DatabaseName, CatalogId: input.CatalogId, NextToken: input.NextToken }));
+                return {
+                    TableList: result.TableList,
+                    NextToken: result.NextToken,
+                };
+            },
+        };
+    }
+}
+function stringConfigValue(connection, key, env) {
+    const value = connection?.[key];
+    if (typeof value !== 'string' || value.trim().length === 0)
+        return undefined;
+    // Resolve before checking emptiness: an unset `env:` reference resolves to '',
+    // which must become undefined so `?? default` applies instead of keeping ''.
+    const resolved = resolveStringReference(value.trim(), env).trim();
+    return resolved.length > 0 ? resolved : undefined;
+}
+function configuredAthenaDatabases(connection) {
+    if (!Array.isArray(connection.databases))
+        return [];
+    const selected = connection.databases
+        .filter((database) => typeof database === 'string' && database.trim().length > 0)
+        .map((database) => database.trim());
+    return [...new Set(selected)];
+}
+export function isKtxAthenaConnectionConfig(connection) {
+    return (typeof connection === 'object' &&
+        connection !== null &&
+        String(connection.driver ?? '').toLowerCase() === 'athena');
+}
+/** @internal */
+export function athenaConnectionConfigFromConfig(input) {
+    const inputDriver = input.connection?.driver ?? 'unknown';
+    if (!isKtxAthenaConnectionConfig(input.connection)) {
+        throw new Error(`Native Athena connector cannot run driver "${String(inputDriver)}"`);
+    }
+    const env = input.env ?? process.env;
+    const region = stringConfigValue(input.connection, 'region', env);
+    if (!region) {
+        throw new Error(`Native Athena connector requires connections.${input.connectionId}.region`);
+    }
+    const s3StagingDir = stringConfigValue(input.connection, 's3_staging_dir', env);
+    if (!s3StagingDir) {
+        throw new Error(`Native Athena connector requires connections.${input.connectionId}.s3_staging_dir`);
+    }
+    return {
+        region,
+        s3StagingDir,
+        workgroup: stringConfigValue(input.connection, 'workgroup', env) ?? 'primary',
+        catalog: stringConfigValue(input.connection, 'catalog', env) ?? 'AwsDataCatalog',
+        database: stringConfigValue(input.connection, 'database', env),
+        databases: configuredAthenaDatabases(input.connection),
+    };
+}
+function glueTableKind(tableType) {
+    const t = String(tableType ?? '').toUpperCase();
+    if (t === 'VIRTUAL_VIEW')
+        return 'view';
+    return 'table';
+}
+const POLL_INTERVAL_MS = 250;
+const QUERY_TIMEOUT_MS = 5 * 60 * 1000;
+export class KtxAthenaScanConnector {
+    id;
+    driver = 'athena';
+    capabilities = createKtxConnectorCapabilities({
+        tableSampling: true,
+        columnSampling: true,
+        columnStats: false,
+        readOnlySql: true,
+        nestedAnalysis: false,
+        formalForeignKeys: false,
+        estimatedRowCounts: false,
+    });
+    connectionId;
+    resolved;
+    clientFactory;
+    now;
+    dialect = getSqlDialectForDriver('athena');
+    athenaClient = null;
+    glueClient = null;
+    constructor(options) {
+        this.connectionId = options.connectionId;
+        this.resolved = athenaConnectionConfigFromConfig({
+            connectionId: options.connectionId,
+            connection: options.connection,
+            env: options.env,
+        });
+        this.clientFactory = options.clientFactory ?? new DefaultAthenaClientFactory();
+        this.now = options.now ?? (() => new Date());
+        this.id = `athena:${options.connectionId}`;
+    }
+    async testConnection() {
+        try {
+            await this.listDatabasesPaginated({ maxResults: 1 });
+            return { success: true };
+        }
+        catch (error) {
+            return connectorTestFailure(error);
+        }
+    }
+    async introspect(input, _ctx) {
+        this.assertConnection(input.connectionId);
+        // Honor the configured `databases` scope (written by `ktx setup`); fall back
+        // to every Glue database only when the scope is unset.
+        const databases = this.resolved.databases.length > 0 ? this.resolved.databases : await this.listDatabasesPaginated({});
+        const tables = [];
+        for (const database of databases) {
+            const scopedNames = input.tableScope
+                ? scopedTableNames(input.tableScope, { catalog: this.resolved.catalog, db: database })
+                : null;
+            tables.push(...(await this.introspectDatabase(database, scopedNames)));
+        }
+        return {
+            connectionId: this.connectionId,
+            driver: 'athena',
+            extractedAt: this.now().toISOString(),
+            scope: { catalogs: [this.resolved.catalog], datasets: databases },
+            metadata: {
+                catalog: this.resolved.catalog,
+                databases,
+                table_count: tables.length,
+                total_columns: tables.reduce((sum, t) => sum + t.columns.length, 0),
+            },
+            tables,
+            warnings: [],
+        };
+    }
+    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));
+        return {
+            values: result.rows.filter((row) => row.length > 0 && row[0] !== null).map((row) => row[0]),
+            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 result = await this.query(limitedSql);
+        return { ...result, rowCount: result.rows.length };
+    }
+    async listSchemas() {
+        return this.listDatabasesPaginated({});
+    }
+    async listTables(databases) {
+        const targetDatabases = databases && databases.length > 0 ? databases : await this.listDatabasesPaginated({});
+        const entries = [];
+        for (const database of targetDatabases) {
+            const glueTables = await this.listGlueTablesPaginated(database);
+            for (const t of glueTables) {
+                if (!t.Name)
+                    continue;
+                entries.push({
+                    catalog: this.resolved.catalog,
+                    schema: database,
+                    name: t.Name,
+                    kind: glueTableKind(t.TableType),
+                });
+            }
+        }
+        return entries;
+    }
+    async cleanup() {
+        this.athenaClient = null;
+        this.glueClient = null;
+    }
+    qTableName(table) {
+        return this.dialect.formatTableName(table);
+    }
+    getAthenaClient() {
+        if (!this.athenaClient) {
+            this.athenaClient = this.clientFactory.createAthenaClient(this.resolved.region);
+        }
+        return this.athenaClient;
+    }
+    getGlueClient() {
+        if (!this.glueClient) {
+            this.glueClient = this.clientFactory.createGlueClient(this.resolved.region);
+        }
+        return this.glueClient;
+    }
+    async listDatabasesPaginated(opts) {
+        const names = [];
+        let nextToken;
+        do {
+            const result = await this.getGlueClient().getDatabases({ NextToken: nextToken });
+            for (const db of result.DatabaseList ?? []) {
+                if (db.Name)
+                    names.push(db.Name);
+                if (opts.maxResults && names.length >= opts.maxResults)
+                    return names;
+            }
+            nextToken = result.NextToken;
+        } while (nextToken);
+        return names;
+    }
+    async listGlueTablesPaginated(database) {
+        const tables = [];
+        let nextToken;
+        do {
+            const result = await this.getGlueClient().getTables({ DatabaseName: database, NextToken: nextToken });
+            tables.push(...(result.TableList ?? []));
+            nextToken = result.NextToken;
+        } while (nextToken);
+        return tables;
+    }
+    async introspectDatabase(database, scopedNames) {
+        if (scopedNames && scopedNames.length === 0)
+            return [];
+        const glueTables = await this.listGlueTablesPaginated(database);
+        const scopeSet = scopedNames ? new Set(scopedNames) : null;
+        return glueTables
+            .filter((t) => Boolean(t.Name) && (!scopeSet || scopeSet.has(t.Name)))
+            .map((t) => ({
+            catalog: this.resolved.catalog,
+            db: database,
+            name: t.Name,
+            kind: glueTableKind(t.TableType),
+            comment: t.Description ?? null,
+            estimatedRows: null,
+            columns: this.toSchemaColumns(t),
+            foreignKeys: [],
+        }));
+    }
+    toSchemaColumns(table) {
+        const columns = [...(table.StorageDescriptor?.Columns ?? []), ...(table.PartitionKeys ?? [])];
+        return columns
+            .filter((col) => Boolean(col.Name))
+            .map((col) => {
+            const nativeType = String(col.Type ?? 'string').toLowerCase();
+            return {
+                name: col.Name,
+                nativeType,
+                normalizedType: this.dialect.mapDataType(nativeType),
+                dimensionType: this.dialect.mapToDimensionType(nativeType),
+                nullable: true,
+                primaryKey: false,
+                comment: col.Comment ?? null,
+            };
+        });
+    }
+    async query(sql) {
+        const athena = this.getAthenaClient();
+        const { QueryExecutionId } = await athena.startQueryExecution({
+            QueryString: sql,
+            ResultConfiguration: { OutputLocation: this.resolved.s3StagingDir },
+            WorkGroup: this.resolved.workgroup,
+            ...(this.resolved.database || this.resolved.catalog
+                ? {
+                    QueryExecutionContext: {
+                        ...(this.resolved.database ? { Database: this.resolved.database } : {}),
+                        ...(this.resolved.catalog ? { Catalog: this.resolved.catalog } : {}),
+                    },
+                }
+                : {}),
+        });
+        if (!QueryExecutionId) {
+            throw new Error('Athena did not return a QueryExecutionId');
+        }
+        await this.waitForQueryCompletion(athena, QueryExecutionId);
+        const rows = [];
+        let headers = [];
+        let headerTypes = [];
+        let nextToken;
+        let firstPage = true;
+        do {
+            const result = await athena.getQueryResults({ QueryExecutionId, NextToken: nextToken });
+            const resultSet = result.ResultSet;
+            if (firstPage) {
+                const columnInfo = resultSet?.ResultSetMetadata?.ColumnInfo ?? [];
+                headers = columnInfo.map((col) => col.Name ?? '');
+                headerTypes = columnInfo.map((col) => String(col.Type ?? 'varchar').toUpperCase());
+                firstPage = false;
+            }
+            const pageRows = resultSet?.Rows ?? [];
+            // Athena includes the header row as the first row of the first page — skip it.
+            const dataRows = nextToken === undefined ? pageRows.slice(1) : pageRows;
+            for (const row of dataRows) {
+                rows.push((row.Data ?? []).map((d) => d.VarCharValue ?? null));
+            }
+            nextToken = result.NextToken;
+        } while (nextToken);
+        return {
+            headers,
+            headerTypes: headerTypes.length > 0 ? headerTypes : undefined,
+            rows,
+            totalRows: rows.length,
+            rowCount: rows.length,
+        };
+    }
+    async waitForQueryCompletion(athena, queryExecutionId) {
+        const terminalStates = new Set(['SUCCEEDED', 'FAILED', 'CANCELLED']);
+        const deadline = this.now().getTime() + QUERY_TIMEOUT_MS;
+        for (;;) {
+            const { QueryExecution } = await athena.getQueryExecution({ QueryExecutionId: queryExecutionId });
+            const state = QueryExecution?.Status?.State ?? '';
+            if (state === 'SUCCEEDED')
+                return;
+            if (terminalStates.has(state)) {
+                const reason = QueryExecution?.Status?.StateChangeReason ?? state;
+                throw new Error(`Athena query ${state}: ${reason}`);
+            }
+            if (this.now().getTime() >= deadline) {
+                throw new Error(`Athena query ${queryExecutionId} timed out after ${QUERY_TIMEOUT_MS / 1000}s`);
+            }
+            await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+        }
+    }
+    assertConnection(connectionId) {
+        if (connectionId !== this.connectionId) {
+            throw new Error(`Athena connector ${this.connectionId} cannot scan connection ${connectionId}`);
+        }
+    }
+}

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

@@ -0,0 +1,31 @@
+import type { KtxSqlDialect } from '../../context/connections/dialects.js';
+import type { KtxSchemaDimensionType, KtxTableRef } from '../../context/scan/types.js';
+type AthenaTableNameRef = Pick<KtxTableRef, 'name'> & Partial<Pick<KtxTableRef, 'catalog' | 'db'>>;
+/** @internal */
+export declare class KtxAthenaDialect implements KtxSqlDialect {
+    readonly type: "athena";
+    private readonly dimensionTypeMappings;
+    quoteIdentifier(identifier: string): string;
+    formatTableName(table: AthenaTableNameRef): string;
+    formatDisplayRef(table: AthenaTableNameRef): 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;
+    generateCardinalitySampleQuery(tableName: string, columnName: string, sampleSize: number): string;
+    generateRandomizedCardinalitySampleQuery(tableName: string, columnName: string, sampleSize: number): string;
+    generateDistinctValuesQuery(tableName: string, columnName: string, limit: number): string;
+    generateColumnStatisticsQuery(_schemaName: string, _tableName: string): string | null;
+    getNullCountExpression(column: string): string;
+    getDistinctCountExpression(column: string): string;
+    textLengthExpression(columnSql: string): string;
+    castToText(columnSql: string): string;
+    getSampleValueAggregation(innerSql: string): string;
+    getLimitOffsetClause(limit: number, offset?: number): string;
+    getTopClause(_limit: number): string;
+    getTableSampleClause(_samplePct: number): string;
+    getRandomSampleFilter(samplePct: number): string;
+}
+export {};