ts-prorm-orm 1.1.0 → 1.2.1

package/dist/dialects/questdb/index.js

@@ -422,6 +422,298 @@ class QuestDBDialect extends index_1.PostgresDialect {
         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.');
     }
+    // ===========================================================================
+    // Column DDL — change column (QuestDB subset)
+    // ===========================================================================
+    /**
+     * 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, columnName, definition) {
+        const isSymbol = definition.symbol === true ||
+            (typeof definition.type === 'string' && definition.type.toUpperCase() === 'SYMBOL');
+        const typeSql = isSymbol ? 'SYMBOL' : this.getDataTypeSql(definition.type);
+        return `ALTER TABLE ${this.escapeId(tableName)} ALTER COLUMN ${this.escapeId(columnName)} TYPE ${typeSql}`;
+    }
+    /**
+     * 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.
+     */
+    async changeColumn(tableName, columnName, definition) {
+        await this.query(this.buildChangeColumnSQL(tableName, columnName, definition));
+    }
+    // ===========================================================================
+    // DEDUP (row de-duplication) — enable / disable on an existing WAL table
+    // ===========================================================================
+    /**
+     * 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, upsertKeys) {
+        const keys = upsertKeys.map((k) => this.escapeId(k)).join(', ');
+        return `ALTER TABLE ${this.escapeId(tableName)} DEDUP ENABLE UPSERT KEYS(${keys})`;
+    }
+    /** Enable DEDUP UPSERT KEYS on an existing table. */
+    async enableDedup(tableName, upsertKeys) {
+        await this.query(this.buildEnableDedupSQL(tableName, upsertKeys));
+    }
+    /** Pure builder for `ALTER TABLE t DEDUP DISABLE`. */
+    buildDisableDedupSQL(tableName) {
+        return `ALTER TABLE ${this.escapeId(tableName)} DEDUP DISABLE`;
+    }
+    /** Disable DEDUP on an existing table. */
+    async disableDedup(tableName) {
+        await this.query(this.buildDisableDedupSQL(tableName));
+    }
+    // ===========================================================================
+    // WAL control
+    // ===========================================================================
+    /** Pure builder for `ALTER TABLE t SET TYPE WAL | BYPASS WAL`. */
+    buildSetWalSQL(tableName, enabled) {
+        return `ALTER TABLE ${this.escapeId(tableName)} SET TYPE ${enabled ? 'WAL' : 'BYPASS WAL'}`;
+    }
+    /** Convert a table between WAL and non-WAL storage. */
+    async setWal(tableName, enabled) {
+        await this.query(this.buildSetWalSQL(tableName, enabled));
+    }
+    /** Pure builder for `ALTER TABLE t RESUME WAL` (resume a suspended WAL table). */
+    buildResumeWalSQL(tableName) {
+        return `ALTER TABLE ${this.escapeId(tableName)} RESUME WAL`;
+    }
+    /** Resume a suspended WAL table. */
+    async resumeWal(tableName) {
+        await this.query(this.buildResumeWalSQL(tableName));
+    }
+    // ===========================================================================
+    // Partition management — the sanctioned path for bulk removal in QuestDB,
+    // which has no row-level DELETE.
+    // ===========================================================================
+    /**
+     * 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, spec) {
+        const base = `ALTER TABLE ${this.escapeId(tableName)} DROP PARTITION`;
+        if (spec.list && spec.list.length > 0) {
+            const list = spec.list.map((v) => this.escape(v)).join(', ');
+            return `${base} LIST ${list}`;
+        }
+        if (spec.where) {
+            return `${base} WHERE ${spec.where}`;
+        }
+        throw new Error('dropPartitions requires either a `list` of partition values or a `where` predicate.');
+    }
+    /** Drop one or more time partitions. */
+    async dropPartitions(tableName, spec) {
+        await this.query(this.buildDropPartitionSQL(tableName, spec));
+    }
+    /**
+     * 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, spec) {
+        const base = `ALTER TABLE ${this.escapeId(tableName)} DETACH PARTITION`;
+        if (spec.list && spec.list.length > 0) {
+            const list = spec.list.map((v) => this.escape(v)).join(', ');
+            return `${base} LIST ${list}`;
+        }
+        if (spec.where) {
+            return `${base} WHERE ${spec.where}`;
+        }
+        throw new Error('detachPartitions requires either a `list` of partition values or a `where` predicate.');
+    }
+    /** Detach one or more time partitions. */
+    async detachPartitions(tableName, spec) {
+        await this.query(this.buildDetachPartitionSQL(tableName, spec));
+    }
+    /**
+     * 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, list) {
+        if (!list || list.length === 0) {
+            throw new Error('attachPartitions requires a non-empty `list` of partition values.');
+        }
+        const values = list.map((v) => this.escape(v)).join(', ');
+        return `ALTER TABLE ${this.escapeId(tableName)} ATTACH PARTITION LIST ${values}`;
+    }
+    /** Attach one or more previously detached time partitions. */
+    async attachPartitions(tableName, list) {
+        await this.query(this.buildAttachPartitionSQL(tableName, list));
+    }
+    /**
+     * 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.
+     */
+    async dropPartition() {
+        throw new Error('QuestDB partitions are not standalone tables. Use ' +
+            'dropPartitions(table, { list } | { where }) to drop time partitions.');
+    }
+    // ===========================================================================
+    // Time-series query builders — SAMPLE BY / LATEST ON
+    // ===========================================================================
+    /**
+     * Build a QuestDB `SAMPLE BY` clause (leading space included) with optional
+     * `FROM`/`TO` bounds, `FILL(...)`, and `ALIGN TO` handling.
+     */
+    buildSampleByClause(opts) {
+        let clause = ` SAMPLE BY ${opts.interval}`;
+        if (opts.from) {
+            clause += ` FROM ${this.escape(opts.from)}`;
+        }
+        if (opts.to) {
+            clause += ` TO ${this.escape(opts.to)}`;
+        }
+        if (opts.fill !== undefined) {
+            const fill = Array.isArray(opts.fill) ? opts.fill.join(', ') : opts.fill;
+            clause += ` FILL(${fill})`;
+        }
+        if (opts.alignTo) {
+            clause += ` ALIGN TO ${opts.alignTo}`;
+            if (opts.alignTo === 'CALENDAR') {
+                if (opts.timeZone) {
+                    clause += ` TIME ZONE ${this.escape(opts.timeZone)}`;
+                }
+                if (opts.offset) {
+                    clause += ` WITH OFFSET ${this.escape(opts.offset)}`;
+                }
+            }
+        }
+        return clause;
+    }
+    /**
+     * 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, partitionBy) {
+        const cols = (Array.isArray(partitionBy) ? partitionBy : [partitionBy])
+            .map((c) => this.escapeId(c))
+            .join(', ');
+        return ` LATEST ON ${this.escapeId(tsColumn)} PARTITION BY ${cols}`;
+    }
+    /**
+     * 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) {
+        const cols = options.attributes && options.attributes.length > 0
+            ? options.attributes.join(', ')
+            : '*';
+        let sql = `SELECT ${cols} FROM ${this.escapeId(options.tableName)}`;
+        const values = [];
+        if (options.where) {
+            const where = this.buildWhereClause(options.where);
+            if (where.sql) {
+                sql += ` WHERE ${where.sql}`;
+                values.push(...where.values);
+            }
+        }
+        if (options.latestOn) {
+            sql += this.buildLatestOnClause(options.latestOn.timestamp, options.latestOn.partitionBy);
+        }
+        if (options.sampleBy) {
+            sql += this.buildSampleByClause(options.sampleBy);
+        }
+        if (options.group) {
+            const group = Array.isArray(options.group) ? options.group : [options.group];
+            sql += ` GROUP BY ${group.map((g) => this.escapeId(g)).join(', ')}`;
+        }
+        if (options.order) {
+            const orderClause = this.buildOrderClause(options.order);
+            if (orderClause) {
+                sql += ` ${orderClause}`;
+            }
+        }
+        sql += this.buildLimitOffset(options.limit, options.offset);
+        return { sql, values };
+    }
+    // ===========================================================================
+    // Metadata / introspection — QuestDB uses its own SHOW commands and meta
+    // functions rather than PostgreSQL's information_schema / pg_catalog, so the
+    // inherited implementations would fail against a QuestDB server.
+    // ===========================================================================
+    /** List all tables via QuestDB's `SHOW TABLES`. */
+    async showTables() {
+        const result = await this.query('SHOW TABLES');
+        return (result.rows || []).map((row) => {
+            const r = row;
+            return (r.table ?? r.name ?? Object.values(r)[0]);
+        });
+    }
+    /**
+     * 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.
+     */
+    async describeTable(tableName) {
+        const result = await this.query(`SHOW COLUMNS FROM ${this.escapeId(tableName)}`);
+        const description = {};
+        for (const row of result.rows || []) {
+            const r = row;
+            const columnName = (r.column ?? r.name);
+            if (!columnName) {
+                continue;
+            }
+            description[columnName] = {
+                type: r.type ?? '',
+                allowNull: true,
+                defaultValue: null,
+                primaryKey: false,
+                autoIncrement: false,
+            };
+        }
+        return description;
+    }
+    /**
+     * 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.
+     */
+    async showIndexes(tableName) {
+        const result = await this.query(`SHOW COLUMNS FROM ${this.escapeId(tableName)}`);
+        return (result.rows || [])
+            .filter((row) => {
+            const indexed = row.indexed;
+            return indexed === true || indexed === 'true';
+        })
+            .map((row) => {
+            const r = row;
+            return {
+                column: r.column ?? r.name,
+                indexed: true,
+                capacity: r.indexBlockCapacity,
+            };
+        });
+    }
+    /**
+     * QuestDB has no relational constraints (PRIMARY KEY / FOREIGN KEY / UNIQUE /
+     * CHECK), so there are never any constraints to report.
+     */
+    async showConstraints() {
+        return [];
+    }
 }
 exports.QuestDBDialect = QuestDBDialect;
 /**