ts-prorm-orm 1.1.0 → 1.2.1

package/dist/dialects/postgres/index.js

@@ -2,16 +2,28 @@
 /**
  * PostgreSQL dialect implementation for the TypeScript ORM
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PostgresTransaction = exports.PostgresDialect = void 0;
 exports.createPostgresDialect = createPostgresDialect;
-const pg_1 = __importDefault(require("pg"));
 const operators_1 = require("../../operators");
+const operators_2 = require("../../operators");
 const prorm_1 = require("../../prorm");
-const { Pool: PgPool, Client: PgClient } = pg_1.default;
+// Lazily-loaded `pg` driver. Required only when a connection is opened, so
+// importing this ORM never loads the pg driver.
+let pgModule = null;
+function loadPg() {
+    if (!pgModule) {
+        try {
+            pgModule = require('pg');
+        }
+        catch (err) {
+            throw new Error("The 'pg' package is required to use the PostgreSQL dialect but could not be loaded. " +
+                'Install it with `npm install pg`. Original error: ' +
+                (err instanceof Error ? err.message : String(err)));
+        }
+    }
+    return pgModule;
+}
 /**
  * Build a PostgreSQL OPTIONS (...) clause from a plain object.
  * Single-quotes each value and escapes existing single-quotes.
@@ -89,7 +101,7 @@ class PostgresDialect {
      */
     async connect() {
         try {
-            this.pool = new PgPool({
+            this.pool = new (loadPg().Pool)({
                 host: this.config.host,
                 port: this.config.port,
                 user: this.config.username,
@@ -158,7 +170,7 @@ class PostgresDialect {
             return this.notifyConnectPromise;
         }
         this.notifyConnectPromise = (async () => {
-            const client = new PgClient({
+            const client = new (loadPg().Client)({
                 host: this.config.host,
                 port: this.config.port,
                 user: this.config.username,
@@ -3270,7 +3282,7 @@ class PostgresDialect {
             const rawCond = condition;
             const cond = { ...rawCond };
             for (const sym of Object.getOwnPropertySymbols(rawCond)) {
-                const strKey = (0, operators_1.operatorToWhereKey)(sym);
+                const strKey = (0, operators_2.operatorToWhereKey)(sym);
                 if (strKey)
                     cond[strKey] = rawCond[sym];
             }
@@ -3308,7 +3320,7 @@ class PostgresDialect {
                     const rawValueObj = value;
                     const valueObj = { ...rawValueObj };
                     for (const sym of Object.getOwnPropertySymbols(rawValueObj)) {
-                        const strKey = (0, operators_1.operatorToWhereKey)(sym);
+                        const strKey = (0, operators_2.operatorToWhereKey)(sym);
                         if (strKey)
                             valueObj[strKey] = rawValueObj[sym];
                     }
@@ -3842,6 +3854,15 @@ class PostgresDialect {
     /**
      * Check if a value is a literal expression (literal('sql'))
      */
+    /**
+     * Render a literal expression, substituting any `bindings` into its `?`
+     * placeholders with dialect-correct escaping. `literalExpr(sql)` with no
+     * bindings is unchanged; `literalExpr('x > ?', [v])` no longer requires the
+     * caller to concatenate the value into the string themselves.
+     */
+    literalSql(expr) {
+        return (0, operators_1.expandLiteralBindings)(expr, (v) => this.escape(v));
+    }
     isLiteralExpression(value) {
         return value !== null && typeof value === 'object' && value.__type === 'literal';
     }
@@ -3885,7 +3906,7 @@ class PostgresDialect {
                         sql = this.escapeId(expr.col);
                     }
                     else if (this.isLiteralExpression(expr)) {
-                        sql = expr.sql;
+                        sql = this.literalSql(expr);
                     }
                     else if (typeof expr === 'string') {
                         // Check if it's a column reference or literal SQL
@@ -3909,7 +3930,7 @@ class PostgresDialect {
                     return this.escapeId(attr.col);
                 }
                 else if (this.isLiteralExpression(attr)) {
-                    return attr.sql;
+                    return this.literalSql(attr);
                 }
                 else if (typeof attr === 'string') {
                     // Plain column name
@@ -3950,7 +3971,7 @@ class PostgresDialect {
                     sql = this.escapeId(expr.col);
                 }
                 else if (this.isLiteralExpression(expr)) {
-                    sql = expr.sql;
+                    sql = this.literalSql(expr);
                 }
                 else if (typeof expr === 'string') {
                     sql = this.escapeId(expr);
@@ -3971,7 +3992,7 @@ class PostgresDialect {
                 return this.escapeId(field.col);
             }
             else if (this.isLiteralExpression(field)) {
-                return field.sql;
+                return this.literalSql(field);
             }
             else if (typeof field === 'string') {
                 if (field.includes('.')) {

package/dist/dialects/query-stream-helper.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Dialect-agnostic fallback implementation of `Dialect.queryStream()`.
+ *
+ * Dialects whose driver exposes a real server-side cursor (postgres, mysql,
+ * cockroachdb) implement `queryStream` natively for true constant-memory
+ * streaming. Every other dialect uses `createPaginatedQueryStream()` here:
+ * it pages through the query via repeated `LIMIT`/`OFFSET`-equivalent
+ * queries (one dialect-appropriate page-clause per round trip, built with
+ * the dialect's own `buildLimitOffset()` by default), instead of loading the
+ * whole result set into memory at once. It's not as fast as a native cursor
+ * for very large result sets — each page is a fresh query — but it's
+ * correct on every dialect that can run a `SELECT * FROM (<sql>) AS alias`
+ * wrapped subquery with a trailing pagination clause, which is effectively
+ * all of them.
+ */
+import { Readable } from 'stream';
+import type { StreamOptions } from '../types';
+/**
+ * Minimal shape this helper needs from a dialect — narrower than the full
+ * `Dialect` interface so it can be unit tested with a stub.
+ */
+export interface StreamableDialect {
+    query(sql: string, options?: any): Promise<{
+        rows: any[];
+    }>;
+    buildLimitOffset(limit?: number | string, offset?: number | string): string;
+}
+/**
+ * Build the SQL for one page of a paginated stream. Exposed separately from
+ * `createPaginatedQueryStream()` so dialects with an unusual pagination
+ * syntax (see `createOracleQueryStream()`) can supply their own page-builder
+ * while still reusing the shared stream/backpressure/model-mapping logic.
+ */
+export declare function buildPaginatedPageQuery(dialect: Pick<StreamableDialect, 'buildLimitOffset'>, sql: string, limit: number, offset: number): string;
+/**
+ * Generic LIMIT/OFFSET-paginated `queryStream` fallback. Suitable for any
+ * dialect whose `buildLimitOffset()` returns a self-sufficient trailing
+ * clause (sqlite, mariadb, redshift, snowflake, clickhouse, duckdb, hana,
+ * spanner, mssql, db2 all qualify — mssql's own `buildLimitOffset` already
+ * injects a no-op `ORDER BY` when none is supplied, so it works unmodified
+ * here).
+ */
+export declare function createPaginatedQueryStream(dialect: StreamableDialect, sql: string, options?: StreamOptions): Readable;
+/**
+ * Oracle-specific streaming. Oracle's `buildLimitOffset()` returns a bare
+ * `WHERE ROWNUM <= n` fragment that only limits the *first* n rows of the
+ * result set — it doesn't skip the first `offset` rows, so wrapping it the
+ * same way as `createPaginatedQueryStream()` would return the same leading
+ * rows on every page instead of paging forward. Rather than depend on that,
+ * this builds the standard "windowed ROWNUM" pagination idiom directly,
+ * which is correct for offset+limit on any Oracle version (no dependency on
+ * 12c's OFFSET/FETCH syntax):
+ *
+ *   SELECT * FROM (
+ *     SELECT a.*, ROWNUM rnum FROM (<sql>) a WHERE ROWNUM <= :offset + :limit
+ *   ) WHERE rnum > :offset
+ */
+export declare function createOracleQueryStream(dialect: Pick<StreamableDialect, 'query'>, sql: string, options?: StreamOptions): Readable;

package/dist/dialects/questdb/index.d.ts

@@ -0,0 +1,430 @@
+/**
+ * QuestDB dialect implementation for the TypeScript ORM
+ *
+ * QuestDB is a high-performance, column-oriented time-series database that
+ * speaks the PostgreSQL wire protocol, so this dialect extends
+ * `PostgresDialect` and reuses the exact same `pg` driver. Everything is
+ * inherited from Postgres except the handful of areas where QuestDB's SQL
+ * dialect genuinely diverges. The notable differences this subclass models:
+ *
+ *  - Default SQL port is 8812 (QuestDB's `pgwire` port), not Postgres's 5432.
+ *
+ *  - Designated timestamp + partitioning. Time-series tables in QuestDB elect
+ *    one `TIMESTAMP` column as the "designated timestamp" and are physically
+ *    partitioned by a time unit:
+ *      `CREATE TABLE t (...) TIMESTAMP(ts) PARTITION BY DAY`
+ *    Supported partition units are `NONE | YEAR | MONTH | DAY | HOUR` (WEEK is
+ *    also accepted by QuestDB but rarely used). These are supplied via the
+ *    table options (`timestamp` + `partitionBy`).
+ *
+ *  - `SYMBOL` type for low-cardinality repeated strings (e.g. ticker symbols,
+ *    device ids). QuestDB stores SYMBOLs as an interned dictionary of ints,
+ *    which is far more compact/faster than STRING for repeated values. Columns
+ *    can opt into `SYMBOL CAPACITY n` (dictionary size hint) and `CACHE`
+ *    (keep the dictionary in memory).
+ *
+ *  - WAL tables. Partitioned tables can be created with a write-ahead log
+ *    (`WAL`, the default in modern QuestDB) or without it (`BYPASS WAL`).
+ *
+ *  - No traditional constraints. QuestDB has NO PRIMARY KEY, NO FOREIGN KEY,
+ *    NO UNIQUE, NO NOT NULL and NO DEFAULT clauses in `CREATE TABLE` — those
+ *    concepts don't exist in the engine, so they are deliberately omitted from
+ *    the generated DDL. Row de-duplication is instead expressed with a
+ *    `DEDUP UPSERT KEYS(...)` clause (WAL tables only), which upserts rows that
+ *    share the given key columns (the designated timestamp must be one of
+ *    them).
+ *
+ *  - Type mapping. QuestDB's type names differ from Postgres's:
+ *      INTEGER -> INT, BIGINT -> LONG, FLOAT -> FLOAT, DOUBLE -> DOUBLE,
+ *      BOOLEAN -> BOOLEAN, STRING/TEXT/CHAR -> STRING, SYMBOL -> SYMBOL,
+ *      DATE/DATETIME/TIME -> TIMESTAMP, BLOB -> BINARY, UUID -> UUID.
+ *
+ * The core DDL builder here (`buildCreateTableSQL`) is a pure, synchronous
+ * function that returns the SQL string, so it can be unit-tested without a
+ * live connection; `createTable()` simply runs it through the inherited
+ * `query()`.
+ *
+ * @see https://questdb.io/docs/
+ */
+import { PostgresDialect, PostgresDialectOptions } from '../postgres/index';
+import { ColumnDefinition, TableOptions, InsertOptions, UpsertQueryOptions, UpdateOptions, DeleteOptions, IndexOptions, IndexDefinition, DropIndexOptions, ConstraintDefinition, TableDescription } from '../dialect';
+import { DataType, WhereOptions, Order } from '../../types';
+/**
+ * The time unit a QuestDB table is partitioned by. `NONE` produces an
+ * unpartitioned table (still allowed to have a designated timestamp).
+ * @see https://questdb.io/docs/concept/partitions/
+ */
+export type QuestDBPartitionUnit = 'NONE' | 'YEAR' | 'MONTH' | 'DAY' | 'HOUR' | 'WEEK';
+/**
+ * QuestDB-specific per-column options layered on top of the shared
+ * {@link ColumnDefinition}. Not part of the cross-dialect column type, so
+ * callers targeting QuestDB pass these alongside the common column definition.
+ */
+export interface QuestDBColumnOptions {
+    /**
+     * Emit this column as a `SYMBOL` (QuestDB's interned low-cardinality string
+     * type) regardless of its declared `type`. Equivalent to using a data type
+     * whose `key` is `'SYMBOL'`.
+     */
+    symbol?: boolean;
+    /** `SYMBOL CAPACITY n` — hint for the expected number of distinct values. */
+    symbolCapacity?: number;
+    /** `CACHE` — keep the symbol dictionary in memory for faster reads. */
+    symbolCache?: boolean;
+}
+/**
+ * QuestDB-specific table options layered on top of the shared
+ * {@link TableOptions}. `partitionBy` is narrowed to QuestDB's time units.
+ */
+export interface QuestDBTableOptions {
+    /**
+     * Name of the column to elect as the table's designated timestamp. Required
+     * for time-partitioned tables and for `DEDUP`. Emits `TIMESTAMP(col)`.
+     */
+    timestamp?: string;
+    /**
+     * Partition unit. Only emitted when a designated {@link timestamp} is set
+     * (QuestDB only partitions tables that have a designated timestamp).
+     * @default 'NONE'
+     */
+    partitionBy?: QuestDBPartitionUnit;
+    /**
+     * Write-ahead-log setting for a partitioned table: `true` -> `WAL`,
+     * `false` -> `BYPASS WAL`. When omitted, QuestDB's server default applies
+     * and no WAL clause is emitted.
+     */
+    wal?: boolean;
+    /**
+     * `DEDUP UPSERT KEYS(...)` columns. When present, QuestDB de-duplicates rows
+     * sharing these key values (WAL tables only). The designated timestamp must
+     * be included in the key set.
+     */
+    dedupUpsertKeys?: string[];
+}
+/**
+ * Options for a QuestDB `SAMPLE BY` time-bucketing clause — the headline
+ * QuestDB time-series aggregation that groups rows into fixed time intervals.
+ * @see https://questdb.io/docs/reference/sql/sample-by/
+ */
+export interface QuestDBSampleByOptions {
+    /** SAMPLE BY interval, e.g. `'5m'`, `'1h'`, `'1d'`, `'30s'`. */
+    interval: string;
+    /**
+     * `FILL(...)` strategy for gaps in the sampled series. Accepts a keyword
+     * (`'NONE' | 'NULL' | 'PREV' | 'LINEAR'`), a constant value, or a list of
+     * per-aggregate strategies/values (e.g. `['NULL', 21.5]`).
+     */
+    fill?: 'NONE' | 'NULL' | 'PREV' | 'LINEAR' | number | Array<number | 'NULL' | 'PREV' | 'LINEAR'>;
+    /** `ALIGN TO CALENDAR` or `ALIGN TO FIRST OBSERVATION`. */
+    alignTo?: 'CALENDAR' | 'FIRST OBSERVATION';
+    /** Time zone for `ALIGN TO CALENDAR`, e.g. `'Europe/London'`. */
+    timeZone?: string;
+    /** Offset for `ALIGN TO CALENDAR`, e.g. `'00:30'`. */
+    offset?: string;
+    /** Lower time bound (`SAMPLE BY ... FROM ts`). */
+    from?: string;
+    /** Upper time bound (`SAMPLE BY ... TO ts`). */
+    to?: string;
+}
+/**
+ * A QuestDB partition selector for partition-level DDL (drop/detach/attach).
+ * QuestDB removes/moves whole time partitions rather than individual rows.
+ * @see https://questdb.io/docs/reference/sql/alter-table-drop-partition/
+ */
+export interface QuestDBPartitionSpec {
+    /**
+     * Explicit partition boundary values, e.g. `['2023-01-01', '2023-01-02']`,
+     * emitting `... PARTITION LIST '2023-01-01', '2023-01-02'`.
+     */
+    list?: string[];
+    /**
+     * A predicate over the designated timestamp, e.g.
+     * `"timestamp < '2023-01-01'"`, emitting `... PARTITION WHERE <predicate>`.
+     * Only valid for DROP (not ATTACH).
+     */
+    where?: string;
+}
+/**
+ * QuestDB dialect class. Extends the PostgreSQL dialect (QuestDB is
+ * PG-wire-compatible) and overrides only the CREATE TABLE DDL and the type
+ * mapping to reflect QuestDB's time-series-specific SQL.
+ */
+export declare class QuestDBDialect extends PostgresDialect {
+    readonly name = "questdb";
+    constructor(config?: PostgresDialectOptions);
+    /**
+     * Build the column fragment for a single column, honouring QuestDB's
+     * `SYMBOL [CAPACITY n] [CACHE]` syntax and deliberately omitting the
+     * PRIMARY KEY / UNIQUE / FOREIGN KEY / NOT NULL / DEFAULT clauses that
+     * QuestDB does not support in CREATE TABLE.
+     */
+    private buildQuestColumnSql;
+    /**
+     * Pure, synchronous builder for a QuestDB `CREATE TABLE` statement. Returns
+     * the SQL string so it can be unit-tested without a database connection.
+     *
+     * Emits, in order:
+     *   CREATE TABLE [IF NOT EXISTS] name (cols...)
+     *     [TIMESTAMP(designated) PARTITION BY UNIT [WAL|BYPASS WAL]]
+     *     [DEDUP UPSERT KEYS(...)]
+     */
+    buildCreateTableSQL(tableName: string, columns: Record<string, ColumnDefinition & QuestDBColumnOptions>, options?: TableOptions & QuestDBTableOptions): string;
+    /**
+     * Create a new table using QuestDB's CREATE TABLE grammar. Delegates SQL
+     * construction to the synchronous {@link buildCreateTableSQL} and runs it
+     * through the inherited `query()`.
+     */
+    createTable(tableName: string, columns: Record<string, ColumnDefinition & QuestDBColumnOptions>, options?: TableOptions & QuestDBTableOptions): Promise<void>;
+    /**
+     * Map an ORM data type to QuestDB's type name. QuestDB's type vocabulary
+     * differs from PostgreSQL's, so this overrides the inherited mapping.
+     * @see https://questdb.io/docs/reference/sql/datatypes/
+     */
+    getDataTypeSql(dataType: DataType): string;
+    /**
+     * Build a QuestDB `LIMIT` clause. QuestDB does NOT support the SQL-standard
+     * `OFFSET` keyword; instead it uses:
+     *   - `LIMIT n`        — first `n` rows (or last `n` when negative).
+     *   - `LIMIT lo, hi`   — rows in the half-open range `(lo, hi]`, which is how
+     *                        an offset is expressed. To skip `offset` rows and
+     *                        return `limit` of them we emit `LIMIT offset, offset+limit`.
+     *
+     * @see https://questdb.io/docs/reference/sql/limit/
+     */
+    buildLimitOffset(limit?: number | string, offset?: number | string): string;
+    /**
+     * Build a QuestDB `INSERT`. QuestDB has **no** `ON CONFLICT` clause (row
+     * de-duplication is configured on the table via `DEDUP UPSERT KEYS(...)` at
+     * `CREATE TABLE` time) and **no** `RETURNING` clause, so both are omitted —
+     * any `upsert`/`conflictFields`/`returning` options are ignored here.
+     */
+    buildInsertQuery(tableName: string, values: Record<string, unknown>, _options?: InsertOptions): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * QuestDB has no `INSERT ... ON CONFLICT DO UPDATE`. The closest concept is a
+     * table-level `DEDUP UPSERT KEYS(...)` declaration, after which a plain
+     * `INSERT` transparently upserts rows sharing the dedup keys. This therefore
+     * emits a bare `INSERT` (no `ON CONFLICT`, no `RETURNING`); `conflictFields`
+     * and `updateOnDuplicate` are ignored because QuestDB resolves conflicts from
+     * the table's DEDUP configuration, not the statement.
+     */
+    buildUpsertQuery(tableName: string, values: Record<string, unknown>, _options?: UpsertQueryOptions): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build a QuestDB `UPDATE`. QuestDB supports `UPDATE t SET ... WHERE ...` but
+     * does NOT support `LIMIT` on updates nor a `RETURNING` clause, so those
+     * options are omitted.
+     * @see https://questdb.io/docs/reference/sql/update/
+     */
+    buildUpdateQuery(tableName: string, values: Record<string, unknown>, where: WhereOptions, _options?: UpdateOptions): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build a QuestDB "delete". IMPORTANT: QuestDB does **not** support
+     * row-level `DELETE`. Bulk removal is done by dropping whole time partitions
+     * (`ALTER TABLE t DROP PARTITION ...`) or emptying the table
+     * (`TRUNCATE TABLE t`). Accordingly:
+     *   - `options.truncate` produces a valid `TRUNCATE TABLE t` statement.
+     *   - Any other call throws, because emitting a `DELETE ... WHERE ...` that
+     *     the server will reject would be misleading. Callers wanting to remove
+     *     a time range should drop the relevant partition(s) via raw SQL / the
+     *     partition APIs instead.
+     * @see https://questdb.io/docs/reference/sql/alter-table-drop-partition/
+     */
+    buildDeleteQuery(tableName: string, _where: WhereOptions, options?: DeleteOptions): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Pure builder for `ALTER TABLE t ADD COLUMN name type` (testable without a
+     * connection). QuestDB supports adding a column but NOT the per-column
+     * constraints (NOT NULL / DEFAULT / PRIMARY KEY / UNIQUE / REFERENCES) that
+     * the Postgres builder would emit, so this reuses the QuestDB column builder.
+     */
+    buildAddColumnSQL(tableName: string, columnName: string, definition: ColumnDefinition & QuestDBColumnOptions): string;
+    /**
+     * Add a column. Overridden so QuestDB's constraint-free `ADD COLUMN` grammar
+     * (and SYMBOL support) is used rather than the inherited Postgres one.
+     */
+    addColumn(tableName: string, columnName: string, definition: ColumnDefinition & QuestDBColumnOptions): Promise<void>;
+    /**
+     * Pure builder for a QuestDB SYMBOL-column index. QuestDB has no
+     * PostgreSQL-style `CREATE INDEX`; indexes exist only on `SYMBOL` columns and
+     * are added via `ALTER TABLE t ALTER COLUMN col ADD INDEX [CAPACITY n]`.
+     * @see https://questdb.io/docs/reference/sql/alter-table-alter-column-add-index/
+     */
+    buildAddIndexSQL(tableName: string, column: string, capacity?: number): string;
+    /**
+     * Pure builder for dropping a QuestDB SYMBOL index:
+     * `ALTER TABLE t ALTER COLUMN col DROP INDEX`.
+     */
+    buildDropIndexSQL(tableName: string, column: string): string;
+    /**
+     * Add an index. In QuestDB an "index" is a SYMBOL-column index, so each field
+     * is indexed with its own `ALTER COLUMN ... ADD INDEX`. The `indexName` and
+     * PG-only options (unique/using/expression/where/include) have no meaning and
+     * are ignored.
+     */
+    addIndex(tableName: string, _indexName: string, fields?: string[], options?: IndexOptions & {
+        capacity?: number;
+    }): Promise<void>;
+    /**
+     * Create an index (SYMBOL-column index) from an {@link IndexDefinition}.
+     */
+    createIndex(tableName: string, indexDef: IndexDefinition & {
+        capacity?: number;
+    }): Promise<void>;
+    /**
+     * Remove an index. QuestDB drops the index off the SYMBOL column, so the
+     * `indexName` argument is interpreted as the column name.
+     */
+    removeIndex(tableName: string, columnName: string): Promise<void>;
+    dropIndex(tableName: string, columnName: string, _options?: DropIndexOptions): Promise<void>;
+    /**
+     * Pure builder for `RENAME TABLE old TO new`. QuestDB renames tables with a
+     * dedicated `RENAME TABLE` statement, NOT `ALTER TABLE ... RENAME TO`.
+     * @see https://questdb.io/docs/reference/sql/rename/
+     */
+    buildRenameTableSQL(oldName: string, newName: string): string;
+    renameTable(oldName: string, newName: string): Promise<void>;
+    addForeignKey(): Promise<void>;
+    addConstraint(): Promise<void>;
+    createConstraint(_tableName: string, _constraintDef: ConstraintDefinition): Promise<void>;
+    /**
+     * Pure builder for QuestDB's narrow column-type alteration:
+     *   `ALTER TABLE t ALTER COLUMN c TYPE <newType>`
+     * QuestDB supports changing a column's type (e.g. SYMBOL <-> VARCHAR/STRING,
+     * widening numerics) but has NO NOT NULL / DEFAULT concept, so any such flags
+     * on the definition are intentionally ignored.
+     * @see https://questdb.io/docs/reference/sql/alter-table-change-column-type/
+     */
+    buildChangeColumnSQL(tableName: string, columnName: string, definition: ColumnDefinition & QuestDBColumnOptions): string;
+    /**
+     * Change a column's type. Overridden so QuestDB's `ALTER COLUMN ... TYPE`
+     * grammar (and SYMBOL support) is used, and so the inherited Postgres
+     * builder's NOT NULL / DEFAULT statements — which QuestDB rejects — are not
+     * emitted.
+     */
+    changeColumn(tableName: string, columnName: string, definition: ColumnDefinition & QuestDBColumnOptions): Promise<void>;
+    /**
+     * Pure builder for `ALTER TABLE t DEDUP ENABLE UPSERT KEYS(...)`. Enables
+     * row de-duplication on an existing WAL table (the designated timestamp must
+     * be one of the keys). This is QuestDB's equivalent of an upsert conflict
+     * target, configured on the table rather than the INSERT statement.
+     * @see https://questdb.io/docs/reference/sql/alter-table-enable-deduplication/
+     */
+    buildEnableDedupSQL(tableName: string, upsertKeys: string[]): string;
+    /** Enable DEDUP UPSERT KEYS on an existing table. */
+    enableDedup(tableName: string, upsertKeys: string[]): Promise<void>;
+    /** Pure builder for `ALTER TABLE t DEDUP DISABLE`. */
+    buildDisableDedupSQL(tableName: string): string;
+    /** Disable DEDUP on an existing table. */
+    disableDedup(tableName: string): Promise<void>;
+    /** Pure builder for `ALTER TABLE t SET TYPE WAL | BYPASS WAL`. */
+    buildSetWalSQL(tableName: string, enabled: boolean): string;
+    /** Convert a table between WAL and non-WAL storage. */
+    setWal(tableName: string, enabled: boolean): Promise<void>;
+    /** Pure builder for `ALTER TABLE t RESUME WAL` (resume a suspended WAL table). */
+    buildResumeWalSQL(tableName: string): string;
+    /** Resume a suspended WAL table. */
+    resumeWal(tableName: string): Promise<void>;
+    /**
+     * Pure builder for `ALTER TABLE t DROP PARTITION LIST ... | WHERE ...`.
+     * QuestDB deletes data by dropping whole time partitions.
+     * @see https://questdb.io/docs/reference/sql/alter-table-drop-partition/
+     */
+    buildDropPartitionSQL(tableName: string, spec: QuestDBPartitionSpec): string;
+    /** Drop one or more time partitions. */
+    dropPartitions(tableName: string, spec: QuestDBPartitionSpec): Promise<void>;
+    /**
+     * Pure builder for `ALTER TABLE t DETACH PARTITION LIST ... | WHERE ...`.
+     * Detaches partitions so they can be archived/moved and later re-attached.
+     * @see https://questdb.io/docs/reference/sql/alter-table-detach-partition/
+     */
+    buildDetachPartitionSQL(tableName: string, spec: QuestDBPartitionSpec): string;
+    /** Detach one or more time partitions. */
+    detachPartitions(tableName: string, spec: QuestDBPartitionSpec): Promise<void>;
+    /**
+     * Pure builder for `ALTER TABLE t ATTACH PARTITION LIST ...`. Re-attaches
+     * previously detached partitions (list form only — WHERE is not valid here).
+     * @see https://questdb.io/docs/reference/sql/alter-table-attach-partition/
+     */
+    buildAttachPartitionSQL(tableName: string, list: string[]): string;
+    /** Attach one or more previously detached time partitions. */
+    attachPartitions(tableName: string, list: string[]): Promise<void>;
+    /**
+     * QuestDB partitions are NOT standalone tables (unlike PostgreSQL declarative
+     * partitions), so the inherited `dropPartition(name)` — which issues
+     * `DROP TABLE name` — does not apply. Fail loudly with guidance to the
+     * QuestDB-correct partition API rather than silently dropping a whole table.
+     */
+    dropPartition(): Promise<void>;
+    /**
+     * Build a QuestDB `SAMPLE BY` clause (leading space included) with optional
+     * `FROM`/`TO` bounds, `FILL(...)`, and `ALIGN TO` handling.
+     */
+    buildSampleByClause(opts: QuestDBSampleByOptions): string;
+    /**
+     * Build a QuestDB `LATEST ON ts PARTITION BY col[, ...]` clause (leading
+     * space included). Returns, per partition, the most recent row by the
+     * designated timestamp.
+     * @see https://questdb.io/docs/reference/sql/latest-on/
+     */
+    buildLatestOnClause(tsColumn: string, partitionBy: string | string[]): string;
+    /**
+     * Build a full QuestDB time-series `SELECT` with `SAMPLE BY` and/or
+     * `LATEST ON` support, which the cross-dialect {@link buildSelectQuery} (and
+     * the shared {@link SelectOptions}) has no representation for. Clause order:
+     *   SELECT ... FROM t [WHERE ...] [LATEST ON ...] [SAMPLE BY ... FILL ... ALIGN]
+     *     [GROUP BY ...] [ORDER BY ...] [LIMIT ...]
+     *
+     * `attributes` are treated as raw column/aggregate expressions (e.g.
+     * `['ts', 'avg(price) AS avg_price']`) so callers can use QuestDB aggregate
+     * functions directly.
+     */
+    buildSampleBySelect(options: {
+        tableName: string;
+        attributes?: string[];
+        where?: WhereOptions;
+        latestOn?: {
+            timestamp: string;
+            partitionBy: string | string[];
+        };
+        sampleBy?: QuestDBSampleByOptions;
+        group?: string | string[];
+        order?: Order;
+        limit?: number | string;
+        offset?: number | string;
+    }): {
+        sql: string;
+        values: unknown[];
+    };
+    /** List all tables via QuestDB's `SHOW TABLES`. */
+    showTables(): Promise<string[]>;
+    /**
+     * Describe a table via `SHOW COLUMNS FROM t`. QuestDB has no NOT NULL /
+     * DEFAULT / auto-increment concepts, so those fields are reported as
+     * permissive defaults.
+     */
+    describeTable(tableName: string): Promise<TableDescription>;
+    /**
+     * Show indexes via `SHOW COLUMNS FROM t`. In QuestDB an "index" exists only
+     * on a SYMBOL column, surfaced by the `indexed` flag of each column.
+     */
+    showIndexes(tableName: string): Promise<any[]>;
+    /**
+     * QuestDB has no relational constraints (PRIMARY KEY / FOREIGN KEY / UNIQUE /
+     * CHECK), so there are never any constraints to report.
+     */
+    showConstraints(): Promise<any[]>;
+}
+/**
+ * Create a new QuestDB dialect instance.
+ */
+export declare function createQuestDBDialect(options?: PostgresDialectOptions): QuestDBDialect;
+export default QuestDBDialect;