ts-prorm-orm 1.1.0

package/dist/dialects/query-stream-helper.js

@@ -0,0 +1,152 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPaginatedPageQuery = buildPaginatedPageQuery;
+exports.createPaginatedQueryStream = createPaginatedQueryStream;
+exports.createOracleQueryStream = createOracleQueryStream;
+const stream_1 = require("stream");
+/** Strips a single trailing `;` (and surrounding whitespace) so the query is safe to wrap as a subquery. */
+function stripTrailingSemicolon(sql) {
+    return sql.trim().replace(/;\s*$/, '');
+}
+/**
+ * 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.
+ */
+function buildPaginatedPageQuery(dialect, sql, limit, offset) {
+    const inner = stripTrailingSemicolon(sql);
+    const pageClause = dialect.buildLimitOffset(limit, offset);
+    return `SELECT * FROM (${inner}) AS __prorm_stream_page ${pageClause}`;
+}
+/**
+ * Core pull-based streaming loop shared by every fallback implementation.
+ * `fetchPage(limit, offset)` is called once per page, only after the
+ * previous page has been fully drained by the consumer (real backpressure,
+ * not read-ahead buffering) — it must return the raw rows for that page.
+ */
+function createPageDrivenStream(fetchPage, options) {
+    const batchSize = options?.batchSize || 1000;
+    const highWaterMark = options?.highWaterMark || 1000;
+    let offset = 0;
+    let buffer = [];
+    let bufferIndex = 0;
+    let exhausted = false;
+    let fetching = false;
+    const stream = new stream_1.Readable({
+        objectMode: true,
+        highWaterMark,
+        read() {
+            pump();
+        },
+    });
+    function pushRow(row) {
+        if (options?.mapToModel && options?.model) {
+            const instance = new options.model();
+            Object.assign(instance, row);
+            return stream.push(instance);
+        }
+        return stream.push(row);
+    }
+    function pump() {
+        if (fetching)
+            return;
+        // Drain whatever is already buffered first.
+        while (bufferIndex < buffer.length) {
+            const canContinue = pushRow(buffer[bufferIndex]);
+            bufferIndex++;
+            if (!canContinue)
+                return; // consumer applied backpressure; resume on next read()
+        }
+        if (exhausted) {
+            stream.push(null);
+            return;
+        }
+        fetching = true;
+        fetchPage(batchSize, offset)
+            .then((rows) => {
+            fetching = false;
+            buffer = rows;
+            bufferIndex = 0;
+            offset += rows.length;
+            if (rows.length < batchSize) {
+                exhausted = true;
+            }
+            if (rows.length === 0) {
+                stream.push(null);
+                return;
+            }
+            pump();
+        })
+            .catch((error) => {
+            fetching = false;
+            stream.destroy(error instanceof Error ? error : new Error(String(error)));
+        });
+    }
+    return stream;
+}
+/**
+ * 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).
+ */
+function createPaginatedQueryStream(dialect, sql, options) {
+    if (!sql || !sql.trim()) {
+        const stream = new stream_1.Readable({ objectMode: true, read() { } });
+        process.nextTick(() => stream.destroy(new Error('queryStream: sql must be a non-empty string')));
+        return stream;
+    }
+    return createPageDrivenStream(async (limit, offset) => {
+        const pageSql = buildPaginatedPageQuery(dialect, sql, limit, offset);
+        const result = await dialect.query(pageSql, options?.transaction ? { transaction: options.transaction } : undefined);
+        return result.rows || [];
+    }, options);
+}
+/**
+ * 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
+ */
+function createOracleQueryStream(dialect, sql, options) {
+    if (!sql || !sql.trim()) {
+        const stream = new stream_1.Readable({ objectMode: true, read() { } });
+        process.nextTick(() => stream.destroy(new Error('queryStream: sql must be a non-empty string')));
+        return stream;
+    }
+    const inner = stripTrailingSemicolon(sql);
+    return createPageDrivenStream(async (limit, offset) => {
+        const upperBound = offset + limit;
+        const pageSql = `SELECT * FROM (SELECT __prorm_inner.*, ROWNUM __prorm_rnum FROM (${inner}) __prorm_inner ` +
+            `WHERE ROWNUM <= ${upperBound}) WHERE __prorm_rnum > ${offset}`;
+        const result = await dialect.query(pageSql, options?.transaction ? { transaction: options.transaction } : undefined);
+        // Strip the synthetic __prorm_rnum column so callers see only real columns.
+        return (result.rows || []).map(({ __prorm_rnum, ...row }) => row);
+    }, options);
+}

package/dist/dialects/questdb/index.js

@@ -0,0 +1,433 @@
+"use strict";
+/**
+ * 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/
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuestDBDialect = void 0;
+exports.createQuestDBDialect = createQuestDBDialect;
+const index_1 = require("../postgres/index");
+const prorm_1 = require("../../prorm");
+/**
+ * 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.
+ */
+class QuestDBDialect extends index_1.PostgresDialect {
+    constructor(config = {}) {
+        // QuestDB's PostgreSQL-wire (pgwire) port defaults to 8812.
+        super({ port: 8812, ...config });
+        this.name = 'questdb';
+    }
+    /**
+     * 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.
+     */
+    buildQuestColumnSql(columnName, definition) {
+        const dt = definition.type;
+        const isSymbol = definition.symbol === true ||
+            (typeof dt === 'object' && dt !== null && dt.key === 'SYMBOL') ||
+            (typeof definition.type === 'string' && definition.type.toUpperCase() === 'SYMBOL');
+        let typeSql;
+        if (isSymbol) {
+            typeSql = 'SYMBOL';
+            if (definition.symbolCapacity) {
+                typeSql += ` CAPACITY ${definition.symbolCapacity}`;
+            }
+            if (definition.symbolCache) {
+                typeSql += ' CACHE';
+            }
+        }
+        else {
+            typeSql = this.getDataTypeSql(definition.type);
+        }
+        // Note: PRIMARY KEY / UNIQUE / FOREIGN KEY / NOT NULL / DEFAULT are
+        // intentionally NOT emitted — QuestDB's CREATE TABLE grammar has no such
+        // column constraints.
+        return `${this.escapeId(columnName)} ${typeSql}`;
+    }
+    /**
+     * 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, columns, options) {
+        const columnDefs = [];
+        for (const [columnName, definition] of Object.entries(columns)) {
+            columnDefs.push(this.buildQuestColumnSql(columnName, definition));
+        }
+        let sql = 'CREATE TABLE';
+        if (options?.ifNotExists) {
+            sql += ' IF NOT EXISTS';
+        }
+        sql += ` ${this.escapeId(tableName)} (${columnDefs.join(', ')})`;
+        // Designated timestamp + time partitioning. QuestDB only partitions tables
+        // that declare a designated timestamp, so PARTITION BY is emitted inside
+        // the timestamp branch.
+        if (options?.timestamp) {
+            sql += ` TIMESTAMP(${this.escapeId(options.timestamp)})`;
+            const unit = options.partitionBy ?? 'NONE';
+            sql += ` PARTITION BY ${unit}`;
+            // WAL / BYPASS WAL applies to partitioned tables.
+            if (options.wal === true) {
+                sql += ' WAL';
+            }
+            else if (options.wal === false) {
+                sql += ' BYPASS WAL';
+            }
+            // DEDUP requires a designated timestamp (and a WAL table).
+            if (options.dedupUpsertKeys && options.dedupUpsertKeys.length > 0) {
+                const keys = options.dedupUpsertKeys.map((k) => this.escapeId(k)).join(', ');
+                sql += ` DEDUP UPSERT KEYS(${keys})`;
+            }
+        }
+        return sql;
+    }
+    /**
+     * 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()`.
+     */
+    async createTable(tableName, columns, options) {
+        const sql = this.buildCreateTableSQL(tableName, columns, options);
+        await this.query(sql);
+    }
+    /**
+     * 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) {
+        // String shorthand types (e.g. 'BIGINT', 'DATETIME') — normalize the
+        // common cross-dialect names to QuestDB equivalents.
+        if (typeof dataType === 'string') {
+            const up = dataType.toUpperCase();
+            if (/^DATETIME(\(\d+\))?$/.test(up) || up === 'TIMESTAMP' || up === 'DATE' || up === 'TIME') {
+                return 'TIMESTAMP';
+            }
+            if (up === 'BIGINT')
+                return 'LONG';
+            if (up === 'INTEGER' || up === 'INT')
+                return 'INT';
+            if (up === 'DOUBLE' || up === 'DOUBLE PRECISION' || up === 'DECIMAL' || up === 'NUMERIC') {
+                return 'DOUBLE';
+            }
+            if (up === 'REAL')
+                return 'FLOAT';
+            if (up === 'TEXT' || up === 'VARCHAR' || up === 'CHAR' || up === 'STRING')
+                return 'STRING';
+            if (up === 'SYMBOL')
+                return 'SYMBOL';
+            if (up === 'BOOL' || up === 'BOOLEAN')
+                return 'BOOLEAN';
+            return dataType;
+        }
+        if (!dataType || typeof dataType !== 'object') {
+            return 'STRING';
+        }
+        const dt = dataType;
+        switch (dt.key) {
+            case 'INTEGER':
+                return 'INT';
+            case 'BIGINT':
+                return 'LONG';
+            case 'FLOAT':
+                return 'FLOAT';
+            case 'DOUBLE':
+            case 'DECIMAL':
+                return 'DOUBLE';
+            case 'BOOLEAN':
+                return 'BOOLEAN';
+            case 'STRING':
+            case 'TEXT':
+            case 'CHAR':
+                return 'STRING';
+            case 'SYMBOL':
+                return 'SYMBOL';
+            case 'DATE':
+            case 'DATEONLY':
+            case 'TIME':
+                return 'TIMESTAMP';
+            case 'UUID':
+                return 'UUID';
+            case 'BLOB':
+                return 'BINARY';
+            case 'JSON':
+            case 'JSONB':
+                // QuestDB has no native JSON type; store as STRING.
+                return 'STRING';
+            default:
+                // Fall back to the PostgreSQL mapping for anything QuestDB shares.
+                return super.getDataTypeSql(dataType);
+        }
+    }
+    // ===========================================================================
+    // Pagination
+    // ===========================================================================
+    /**
+     * 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, offset) {
+        const hasLimit = limit !== undefined && limit !== null;
+        const hasOffset = offset !== undefined && offset !== null;
+        if (hasLimit && hasOffset) {
+            const lo = Number(offset);
+            const hi = lo + Number(limit);
+            return ` LIMIT ${lo}, ${hi}`;
+        }
+        if (hasLimit) {
+            return ` LIMIT ${Number(limit)}`;
+        }
+        // Offset-only has no direct QuestDB form (an upper bound is required for
+        // `LIMIT lo, hi`), so nothing is emitted. Callers needing a lower bound
+        // without an explicit page size should pass an explicit `limit`.
+        return '';
+    }
+    // ===========================================================================
+    // DML — INSERT / UPSERT / UPDATE / DELETE
+    // ===========================================================================
+    /**
+     * 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, values, _options) {
+        const columns = Object.keys(values);
+        const processedValues = [];
+        const placeholders = [];
+        let paramIndex = 1;
+        for (const value of Object.values(values)) {
+            if (value instanceof prorm_1.Literal) {
+                placeholders.push(value.val);
+            }
+            else {
+                placeholders.push(`$${paramIndex}`);
+                processedValues.push(value);
+                paramIndex++;
+            }
+        }
+        const sql = `INSERT INTO ${this.escapeId(tableName)} ` +
+            `(${columns.map((c) => this.escapeId(c)).join(', ')}) ` +
+            `VALUES (${placeholders.join(', ')})`;
+        return { sql, values: processedValues };
+    }
+    /**
+     * 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, values, _options) {
+        return this.buildInsertQuery(tableName, values);
+    }
+    /**
+     * 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, values, where, _options) {
+        const setClauses = [];
+        const queryValues = [];
+        let paramIndex = 1;
+        for (const [key, value] of Object.entries(values)) {
+            if (value instanceof prorm_1.Literal) {
+                setClauses.push(`${this.escapeId(key)} = ${value.val}`);
+            }
+            else {
+                setClauses.push(`${this.escapeId(key)} = $${paramIndex}`);
+                queryValues.push(value);
+                paramIndex++;
+            }
+        }
+        const whereClause = this.buildWhereClause(where);
+        let sql = `UPDATE ${this.escapeId(tableName)} SET ${setClauses.join(', ')}`;
+        if (whereClause.sql) {
+            sql += ` WHERE ${whereClause.sql}`;
+        }
+        return { sql, values: [...queryValues, ...whereClause.values] };
+    }
+    /**
+     * 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, _where, options) {
+        if (options?.truncate) {
+            return { sql: `TRUNCATE TABLE ${this.escapeId(tableName)}`, values: [] };
+        }
+        throw new Error('QuestDB does not support row-level DELETE. Remove data by dropping ' +
+            'time partitions (ALTER TABLE ... DROP PARTITION ...) or truncating ' +
+            'the table (pass { truncate: true }).');
+    }
+    // ===========================================================================
+    // DDL — columns, indexes, rename, unsupported constraints
+    // ===========================================================================
+    /**
+     * 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, columnName, definition) {
+        return `ALTER TABLE ${this.escapeId(tableName)} ADD COLUMN ${this.buildQuestColumnSql(columnName, definition)}`;
+    }
+    /**
+     * Add a column. Overridden so QuestDB's constraint-free `ADD COLUMN` grammar
+     * (and SYMBOL support) is used rather than the inherited Postgres one.
+     */
+    async addColumn(tableName, columnName, definition) {
+        await this.query(this.buildAddColumnSQL(tableName, columnName, definition));
+    }
+    /**
+     * 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, column, capacity) {
+        let sql = `ALTER TABLE ${this.escapeId(tableName)} ALTER COLUMN ${this.escapeId(column)} ADD INDEX`;
+        if (capacity) {
+            sql += ` CAPACITY ${capacity}`;
+        }
+        return sql;
+    }
+    /**
+     * Pure builder for dropping a QuestDB SYMBOL index:
+     * `ALTER TABLE t ALTER COLUMN col DROP INDEX`.
+     */
+    buildDropIndexSQL(tableName, column) {
+        return `ALTER TABLE ${this.escapeId(tableName)} ALTER COLUMN ${this.escapeId(column)} DROP INDEX`;
+    }
+    /**
+     * 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.
+     */
+    async addIndex(tableName, _indexName, fields = [], options) {
+        for (const field of fields) {
+            await this.query(this.buildAddIndexSQL(tableName, field, options?.capacity));
+        }
+    }
+    /**
+     * Create an index (SYMBOL-column index) from an {@link IndexDefinition}.
+     */
+    async createIndex(tableName, indexDef) {
+        for (const field of indexDef.fields || []) {
+            await this.query(this.buildAddIndexSQL(tableName, field, indexDef.capacity));
+        }
+    }
+    /**
+     * Remove an index. QuestDB drops the index off the SYMBOL column, so the
+     * `indexName` argument is interpreted as the column name.
+     */
+    async removeIndex(tableName, columnName) {
+        await this.query(this.buildDropIndexSQL(tableName, columnName));
+    }
+    async dropIndex(tableName, columnName, _options) {
+        await this.query(this.buildDropIndexSQL(tableName, columnName));
+    }
+    /**
+     * 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, newName) {
+        return `RENAME TABLE ${this.escapeId(oldName)} TO ${this.escapeId(newName)}`;
+    }
+    async renameTable(oldName, newName) {
+        await this.query(this.buildRenameTableSQL(oldName, newName));
+    }
+    // ---------------------------------------------------------------------------
+    // Unsupported relational constraints. QuestDB has no PRIMARY KEY / FOREIGN
+    // KEY / UNIQUE / CHECK constraints, so these fail loudly rather than emitting
+    // SQL the engine cannot parse.
+    // ---------------------------------------------------------------------------
+    async addForeignKey() {
+        throw new Error('QuestDB does not support FOREIGN KEY constraints.');
+    }
+    async addConstraint() {
+        throw new Error('QuestDB does not support table constraints (PRIMARY KEY / FOREIGN KEY / ' +
+            'UNIQUE / CHECK). Use DEDUP UPSERT KEYS on CREATE TABLE for row de-duplication.');
+    }
+    async createConstraint(_tableName, _constraintDef) {
+        throw new Error('QuestDB does not support table constraints (PRIMARY KEY / FOREIGN KEY / ' +
+            'UNIQUE / CHECK). Use DEDUP UPSERT KEYS on CREATE TABLE for row de-duplication.');
+    }
+}
+exports.QuestDBDialect = QuestDBDialect;
+/**
+ * Create a new QuestDB dialect instance.
+ */
+function createQuestDBDialect(options) {
+    return new QuestDBDialect(options || {});
+}
+exports.default = QuestDBDialect;