ts-prorm-orm 1.1.0

package/dist/dialects/tidb/index.js

@@ -0,0 +1,377 @@
+"use strict";
+/**
+ * TiDB dialect implementation for the TypeScript ORM
+ *
+ * TiDB is MySQL-wire-protocol compatible: it speaks the MySQL client/server
+ * protocol and understands (almost all of) MySQL's SQL grammar, so this
+ * dialect extends {@link MySQLDialect} and reuses MySQL's `mysql2` driver
+ * verbatim (connection pooling, escaping, query execution, streaming, most
+ * DDL/DML builders). Only the genuine TiDB grammar differences are overridden
+ * or added here.
+ *
+ * Differences from plain MySQL implemented in this dialect:
+ *
+ * - **Dialect identity**: `name` is `'tidb'` (the wire `library` stays
+ *   `'mysql2'` since that's the actual driver in use).
+ * - **Default port 4000**: TiDB's default SQL port is 4000, not MySQL's 3306.
+ *   The constructor injects it as a default that the caller can still override.
+ * - **AUTO_RANDOM primary keys**: TiDB offers `AUTO_RANDOM` as an alternative
+ *   to `AUTO_INCREMENT` for (BIGINT) primary keys. It scatters generated IDs
+ *   across the key space to avoid the write hot-spotting that a monotonic
+ *   `AUTO_INCREMENT` key causes on a range-partitioned distributed store. A
+ *   column flag (`autoRandom: true` or `autoRandom: <shardBits>`) emits
+ *   `AUTO_RANDOM` / `AUTO_RANDOM(n)` instead of `AUTO_INCREMENT`.
+ * - **SHARD_ROW_ID_BITS / PRE_SPLIT_REGIONS**: TiDB table options (for tables
+ *   without an integer PK) that shard the implicit `_tidb_rowid` and
+ *   pre-split the table into multiple regions up front to spread write load.
+ *   Both are supported as CREATE TABLE options and are not valid MySQL syntax.
+ * - **SPLIT TABLE**: TiDB-only statement to pre-split a table/index's key
+ *   range into N regions (`SPLIT TABLE t BETWEEN (...) AND (...) REGIONS n`).
+ *   Not standard MySQL, so it's exposed as a dedicated helper.
+ * - **Storage engines**: TiDB parses but effectively ignores MySQL
+ *   storage-engine clauses such as `ENGINE=InnoDB` (all TiDB tables live in
+ *   its distributed KV store / TiKV; there is no per-table pluggable engine).
+ *   The `engine` table option is still emitted for MySQL source compatibility,
+ *   but has no effect on TiDB — documented here so callers don't rely on it.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TiDBDialect = void 0;
+exports.createTiDBDialect = createTiDBDialect;
+const index_1 = require("../mysql/index");
+/**
+ * TiDB dialect. MySQL-wire-compatible; reuses the `mysql2` driver via
+ * {@link MySQLDialect}. See the file header for the full list of differences.
+ */
+class TiDBDialect extends index_1.MySQLDialect {
+    constructor(config = {}) {
+        // TiDB's default SQL port is 4000 (MySQL's is 3306). Inject it as a
+        // default that an explicit `config.port` still overrides.
+        super({ port: 4000, ...config });
+        this.name = 'tidb';
+    }
+    /**
+     * Build the column-definition SQL fragment for a single column, with TiDB's
+     * `AUTO_RANDOM` support. MySQL's own column builder is `private`, so this
+     * dialect implements its own (covering the same common flags) rather than
+     * reusing it.
+     */
+    buildColumnSql(columnName, definition) {
+        let sql = `${this.escapeId(columnName)} ${this.getDataTypeSql(definition.type)}`;
+        if (definition.charset) {
+            sql += ` CHARACTER SET ${this.escapeId(definition.charset)}`;
+        }
+        if (definition.collate) {
+            sql += ` COLLATE ${this.escapeId(definition.collate)}`;
+        }
+        if (definition.allowNull === false) {
+            sql += ' NOT NULL';
+        }
+        if (definition.defaultValue !== undefined) {
+            sql += ` DEFAULT ${this.formatDefaultValue(definition.defaultValue)}`;
+        }
+        if (definition.invisible) {
+            sql += ' INVISIBLE';
+        }
+        if (definition.primaryKey) {
+            sql += ' PRIMARY KEY';
+        }
+        // AUTO_RANDOM is TiDB's alternative to AUTO_INCREMENT and wins when both
+        // are specified. `autoRandom: <number>` emits `AUTO_RANDOM(n)`.
+        if (definition.autoRandom !== undefined && definition.autoRandom !== false) {
+            const shardBits = typeof definition.autoRandom === 'number' ? `(${definition.autoRandom})` : '';
+            sql += ` AUTO_RANDOM${shardBits}`;
+        }
+        else if (definition.autoIncrement) {
+            sql += ' AUTO_INCREMENT';
+        }
+        if (definition.unique) {
+            if (typeof definition.unique === 'string') {
+                sql += ` UNIQUE KEY ${this.escapeId(definition.unique)}`;
+            }
+            else {
+                sql += ' UNIQUE';
+            }
+        }
+        if (definition.references) {
+            const refField = definition.references.field;
+            const refFieldSql = Array.isArray(refField)
+                ? `(${refField.map((f) => this.escapeId(f)).join(', ')})`
+                : `(${this.escapeId(refField)})`;
+            sql += ` REFERENCES ${this.escapeId(definition.references.table)}${refFieldSql}`;
+            if (definition.references.onDelete) {
+                sql += ` ON DELETE ${definition.references.onDelete}`;
+            }
+            if (definition.references.onUpdate) {
+                sql += ` ON UPDATE ${definition.references.onUpdate}`;
+            }
+        }
+        if (definition.comment) {
+            sql += ` COMMENT '${this.escapeSqlString(definition.comment)}'`;
+        }
+        return sql;
+    }
+    /** Escape single quotes/backslashes for embedding a string literal. */
+    escapeSqlString(str) {
+        return str.replace(/'/g, "''").replace(/\\/g, '\\\\');
+    }
+    /** Render a column DEFAULT value. */
+    formatDefaultValue(value) {
+        if (value === null) {
+            return 'NULL';
+        }
+        if (typeof value === 'string') {
+            if (value.toUpperCase().includes('CURRENT_') || value.toUpperCase() === 'NULL') {
+                return value;
+            }
+            return `'${this.escapeSqlString(value)}'`;
+        }
+        if (typeof value === 'number' || typeof value === 'boolean') {
+            return String(value);
+        }
+        if (typeof value === 'object' &&
+            value !== null &&
+            typeof value.toDefaultValue === 'function') {
+            return value.toDefaultValue();
+        }
+        return `'${this.escapeSqlString(String(value))}'`;
+    }
+    /**
+     * Build a TiDB `CREATE TABLE` statement, supporting `AUTO_RANDOM` primary
+     * keys and the `SHARD_ROW_ID_BITS` / `PRE_SPLIT_REGIONS` table options.
+     * Pure/synchronous — returns the SQL string without executing it.
+     */
+    buildCreateTableSql(tableName, columns, options) {
+        const columnDefs = Object.entries(columns).map(([name, def]) => this.buildColumnSql(name, def));
+        let sql = 'CREATE TABLE';
+        if (options?.ifNotExists) {
+            sql += ' IF NOT EXISTS';
+        }
+        sql += ` ${this.escapeId(tableName)} (${columnDefs.join(', ')})`;
+        // ENGINE is parsed but ignored by TiDB (no per-table pluggable engine —
+        // everything lives in TiKV). Emitted only for MySQL source compatibility.
+        if (options?.engine) {
+            sql += ` ENGINE=${options.engine}`;
+        }
+        if (options?.charset) {
+            sql += ` DEFAULT CHARSET=${options.charset}`;
+        }
+        if (options?.collate) {
+            sql += ` COLLATE ${options.collate}`;
+        }
+        if (options?.comment) {
+            sql += ` COMMENT='${this.escapeSqlString(options.comment)}'`;
+        }
+        // TiDB-specific table options (not valid MySQL syntax).
+        if (options?.shardRowIdBits !== undefined) {
+            sql += ` SHARD_ROW_ID_BITS = ${options.shardRowIdBits}`;
+        }
+        if (options?.preSplitRegions !== undefined) {
+            sql += ` PRE_SPLIT_REGIONS = ${options.preSplitRegions}`;
+        }
+        return sql;
+    }
+    /**
+     * Create a table using TiDB grammar (AUTO_RANDOM, SHARD_ROW_ID_BITS,
+     * PRE_SPLIT_REGIONS). Overrides the MySQL implementation, whose private
+     * column builder cannot emit `AUTO_RANDOM`.
+     */
+    async createTable(tableName, columns, options) {
+        const sql = this.buildCreateTableSql(tableName, columns, options);
+        await this.query(sql);
+    }
+    // ==========================================================================
+    // Upsert (ON DUPLICATE KEY UPDATE) — TiDB compatibility override
+    //
+    // MySQL 8.0.19 introduced the row-alias INSERT form
+    //   `INSERT INTO t (...) VALUES (...) AS new_vals
+    //      ON DUPLICATE KEY UPDATE col = new_vals.col`
+    // and the base MySQLDialect emits exactly that (because the older
+    // `VALUES(col)` function form is deprecated in MySQL 8.0.20+).
+    //
+    // TiDB does NOT support that row-alias syntax in the INSERT statement — a
+    // real TiDB server rejects `INSERT ... VALUES (...) AS alias ...` with a
+    // parse error. TiDB *does* fully support the classic `VALUES(col)` function
+    // form inside ON DUPLICATE KEY UPDATE (across all TiDB versions), so we
+    // override the two upsert builders to emit that form instead. It is the
+    // TiDB-compatible way to express the same "insert or update" semantics.
+    // ==========================================================================
+    /**
+     * Build an INSERT query. Identical to the MySQL builder except that when
+     * `options.upsert` is set, the `ON DUPLICATE KEY UPDATE` clause uses the
+     * TiDB-compatible `VALUES(col)` function form rather than MySQL 8.0.19's
+     * row-alias (`AS new_vals`) form, which TiDB rejects.
+     */
+    buildInsertQuery(tableName, values, options) {
+        const base = super.buildInsertQuery(tableName, values, { ...options, upsert: false });
+        if (!options?.upsert) {
+            return base;
+        }
+        const columns = Object.keys(values);
+        const updateFields = options.updateOnDuplicate && options.updateOnDuplicate.length > 0
+            ? options.updateOnDuplicate
+            : columns;
+        const updateClause = updateFields
+            .map((c) => `${this.escapeId(c)} = VALUES(${this.escapeId(c)})`)
+            .join(', ');
+        return {
+            sql: `${base.sql} ON DUPLICATE KEY UPDATE ${updateClause}`,
+            values: base.values,
+        };
+    }
+    /**
+     * Build an UPSERT query using TiDB-compatible `ON DUPLICATE KEY UPDATE col =
+     * VALUES(col)` syntax (the base MySQL dialect emits the row-alias form that
+     * TiDB does not accept). TiDB, like MySQL, has no `RETURNING` clause.
+     */
+    buildUpsertQuery(tableName, values, options) {
+        if (options?.returning) {
+            throw new Error('TiDB does not support the RETURNING clause. Re-fetch the row after the upsert instead.');
+        }
+        const base = super.buildInsertQuery(tableName, values);
+        const columns = Object.keys(values);
+        const updateFields = options?.updateOnDuplicate && options.updateOnDuplicate.length > 0
+            ? options.updateOnDuplicate
+            : columns;
+        const updateClause = updateFields
+            .map((c) => `${this.escapeId(c)} = VALUES(${this.escapeId(c)})`)
+            .join(', ');
+        return {
+            sql: `${base.sql} ON DUPLICATE KEY UPDATE ${updateClause}`,
+            values: base.values,
+        };
+    }
+    // ==========================================================================
+    // Data-type mapping — reject types TiDB does not implement
+    // ==========================================================================
+    /**
+     * Map an ORM {@link DataType} to TiDB column SQL. Delegates to the MySQL
+     * mapping for everything TiDB shares, but rejects the spatial/GIS types up
+     * front: TiDB implements no spatial data types (GEOMETRY, POINT, POLYGON,
+     * …), so emitting them would produce a `CREATE TABLE` that a real TiDB
+     * server rejects. Failing here gives a clear, actionable error instead of
+     * an opaque server-side parse error.
+     */
+    getDataTypeSql(dataType) {
+        if (dataType && typeof dataType === 'object') {
+            const key = dataType.key;
+            const spatial = new Set([
+                'GEOMETRY',
+                'GEOGRAPHY',
+                'POINT',
+                'LINESTRING',
+                'POLYGON',
+                'MULTIPOINT',
+                'MULTILINESTRING',
+                'MULTIPOLYGON',
+                'GEOMETRYCOLLECTION',
+            ]);
+            if (key && spatial.has(key)) {
+                throw new Error(`TiDB does not support spatial/GIS data types (got '${key}'). ` +
+                    'Store the geometry as JSON/TEXT or a pair of numeric columns instead.');
+            }
+        }
+        return super.getDataTypeSql(dataType);
+    }
+    // ==========================================================================
+    // Constraints — TiDB supports ALTER TABLE ADD/DROP CONSTRAINT
+    //
+    // The base MySQLDialect throws "addConstraint is not supported in MySQL",
+    // but TiDB fully supports altering a table to add a PRIMARY KEY / UNIQUE /
+    // FOREIGN KEY / CHECK constraint and to drop it again, so implement them.
+    // ==========================================================================
+    /**
+     * Build an `ALTER TABLE ... ADD CONSTRAINT` statement (synchronous).
+     */
+    buildAddConstraintSql(tableName, options) {
+        const namePart = options.name ? `CONSTRAINT ${this.escapeId(options.name)} ` : '';
+        const fieldList = (options.fields || []).map((f) => this.escapeId(f)).join(', ');
+        const prefix = `ALTER TABLE ${this.escapeId(tableName)} ADD ${namePart}`;
+        switch (options.type) {
+            case 'PRIMARY KEY':
+                return `${prefix}PRIMARY KEY (${fieldList})`;
+            case 'UNIQUE':
+                return `${prefix}UNIQUE (${fieldList})`;
+            case 'CHECK':
+                return `${prefix}CHECK (${options.check ?? ''})`;
+            case 'FOREIGN KEY': {
+                if (!options.references) {
+                    throw new Error('FOREIGN KEY constraint requires a `references` target.');
+                }
+                const refFields = options.references.fields.map((f) => this.escapeId(f)).join(', ');
+                return `${prefix}FOREIGN KEY (${fieldList}) REFERENCES ${this.escapeId(options.references.table)} (${refFields})`;
+            }
+            default:
+                throw new Error(`Unsupported constraint type: ${String(options.type)}`);
+        }
+    }
+    /**
+     * Build an `ALTER TABLE ... DROP ...` statement for a constraint
+     * (synchronous). TiDB (like MySQL) drops each constraint kind with a
+     * different clause, so the caller passes the constraint `type`; when omitted
+     * a generic `DROP CONSTRAINT` (valid for CHECK constraints) is emitted.
+     */
+    buildDropConstraintSql(tableName, constraintName, type) {
+        const t = this.escapeId(tableName);
+        switch (type) {
+            case 'PRIMARY KEY':
+                return `ALTER TABLE ${t} DROP PRIMARY KEY`;
+            case 'FOREIGN KEY':
+                return `ALTER TABLE ${t} DROP FOREIGN KEY ${this.escapeId(constraintName)}`;
+            case 'UNIQUE':
+                return `ALTER TABLE ${t} DROP INDEX ${this.escapeId(constraintName)}`;
+            case 'CHECK':
+                return `ALTER TABLE ${t} DROP CHECK ${this.escapeId(constraintName)}`;
+            default:
+                return `ALTER TABLE ${t} DROP CONSTRAINT ${this.escapeId(constraintName)}`;
+        }
+    }
+    /**
+     * Add a constraint to an existing table (TiDB supports this; MySQL base
+     * throws). Executes {@link buildAddConstraintSql}.
+     */
+    async addConstraint(tableName, options) {
+        await this.query(this.buildAddConstraintSql(tableName, options));
+    }
+    /**
+     * Drop a constraint from a table by name. Emits a generic
+     * `ALTER TABLE ... DROP CONSTRAINT name` (valid on TiDB for CHECK
+     * constraints); for foreign keys / unique keys / primary keys use
+     * {@link buildDropConstraintSql} with an explicit `type`.
+     */
+    async removeConstraint(tableName, constraintName) {
+        await this.query(this.buildDropConstraintSql(tableName, constraintName));
+    }
+    /**
+     * Build a TiDB `SPLIT TABLE` statement. This pre-splits a table's (or an
+     * index's) key range into `regions` regions, distributing write load before
+     * data arrives. Not standard MySQL. Pure/synchronous.
+     *
+     * @example
+     * // SPLIT TABLE `t` BETWEEN (0) AND (1000000) REGIONS 16
+     * dialect.buildSplitTableSql('t', { between: [0, 1000000], regions: 16 });
+     */
+    buildSplitTableSql(tableName, options) {
+        const bound = (value) => {
+            const parts = Array.isArray(value) ? value : [value];
+            return `(${parts.map((v) => this.escape(v)).join(', ')})`;
+        };
+        const target = options.index
+            ? `${this.escapeId(tableName)} INDEX ${this.escapeId(options.index)}`
+            : this.escapeId(tableName);
+        const [lower, upper] = options.between;
+        return `SPLIT TABLE ${target} BETWEEN ${bound(lower)} AND ${bound(upper)} REGIONS ${options.regions}`;
+    }
+    /**
+     * Execute a {@link buildSplitTableSql} statement.
+     */
+    async splitTable(tableName, options) {
+        await this.query(this.buildSplitTableSql(tableName, options));
+    }
+}
+exports.TiDBDialect = TiDBDialect;
+/**
+ * Convenience factory mirroring `createMySQLDialect`.
+ */
+function createTiDBDialect(options = {}) {
+    return new TiDBDialect(options);
+}

package/dist/dialects/timescaledb/index.js

@@ -0,0 +1,164 @@
+"use strict";
+/**
+ * TimescaleDB dialect implementation for the TypeScript ORM
+ *
+ * TimescaleDB is not a separate database engine — it is a PostgreSQL extension
+ * (`CREATE EXTENSION timescaledb`) that layers time-series capabilities on top
+ * of a stock PostgreSQL server. Because of that, this dialect extends
+ * `PostgresDialect` and reuses the exact same `pg` driver, wire protocol, and
+ * default port (5432). Everything PostgreSQL can do, TimescaleDB can do; this
+ * subclass only adds thin SQL builders for TimescaleDB-specific features.
+ *
+ * TimescaleDB-specific helpers (pure, synchronous SQL builders — they return
+ * the SQL string so callers can run it through the inherited `query()`):
+ *
+ *  - `createExtensionSQL()`        → `CREATE EXTENSION IF NOT EXISTS timescaledb`
+ *  - `createHypertable()`          → `SELECT create_hypertable(...)`
+ *  - `addCompressionPolicy()`      → `SELECT add_compression_policy(...)`
+ *  - `addRetentionPolicy()`        → `SELECT add_retention_policy(...)`
+ *  - `createContinuousAggregate()` → `CREATE MATERIALIZED VIEW ... WITH (timescaledb.continuous) AS ...`
+ *  - `enableCompression()`         → `ALTER TABLE ... SET (timescaledb.compress, ...)`
+ *
+ * @see https://docs.timescale.com/
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimescaleDBDialect = void 0;
+exports.createTimescaleDBDialect = createTimescaleDBDialect;
+const index_1 = require("../postgres/index");
+/**
+ * TimescaleDB dialect — a PostgreSQL dialect (reusing the `pg` driver on the
+ * standard port 5432) extended with time-series helpers backed by the
+ * `timescaledb` extension.
+ */
+class TimescaleDBDialect extends index_1.PostgresDialect {
+    constructor(config = {}) {
+        // TimescaleDB runs inside PostgreSQL, so it uses PostgreSQL's default port
+        // (5432). Let callers override it, but default to 5432.
+        super({ port: 5432, ...config });
+        // Override the inherited `name = 'postgres'` so the ORM identifies this as
+        // its own dialect. `library` stays `'pg'` (inherited) since TimescaleDB
+        // speaks the PostgreSQL wire protocol through the same driver. The base
+        // types `name` as the string literal `'postgres'`, so the override is cast
+        // to that literal type (the runtime value is still `'timescaledb'`) to
+        // satisfy the property-override compatibility check without editing the base.
+        this.name = 'timescaledb';
+    }
+    /**
+     * Build the SQL that enables the TimescaleDB extension on the current
+     * database. Overrides the base `createExtension()` idea with a dedicated,
+     * synchronous SQL builder specifically for `timescaledb`.
+     *
+     * @param extensionName - Extension to enable. Defaults to `'timescaledb'`.
+     * @returns `CREATE EXTENSION IF NOT EXISTS timescaledb`
+     */
+    createExtensionSQL(extensionName = 'timescaledb') {
+        return `CREATE EXTENSION IF NOT EXISTS ${this.escapeId(extensionName)}`;
+    }
+    /**
+     * Format a TimescaleDB interval argument. Time-based hypertables use a
+     * PostgreSQL interval literal (`INTERVAL '7 days'`); integer-based
+     * hypertables use a bare integer (e.g. `86400000`). A number is emitted
+     * as a raw integer with no `INTERVAL` keyword; a string is wrapped in a
+     * safely-escaped `INTERVAL '...'` literal.
+     */
+    formatInterval(value) {
+        if (typeof value === 'number') {
+            return String(value);
+        }
+        return `INTERVAL ${this.escape(value)}`;
+    }
+    /**
+     * Build a `SELECT create_hypertable(...)` statement that converts a regular
+     * table into a TimescaleDB hypertable partitioned on a time column.
+     *
+     * @param table - Table to convert.
+     * @param timeColumn - The time/timestamp column to partition on.
+     * @param opts - Chunk interval and other options.
+     * @returns e.g. `SELECT create_hypertable('conditions', 'time', chunk_time_interval => INTERVAL '7 days')`
+     */
+    createHypertable(table, timeColumn, opts) {
+        const interval = opts?.chunkTimeInterval ?? '7 days';
+        const args = [
+            this.escape(table),
+            this.escape(timeColumn),
+            `chunk_time_interval => ${this.formatInterval(interval)}`,
+        ];
+        if (opts?.ifNotExists) {
+            args.push('if_not_exists => TRUE');
+        }
+        if (opts?.migrateData) {
+            args.push('migrate_data => TRUE');
+        }
+        return `SELECT create_hypertable(${args.join(', ')})`;
+    }
+    /**
+     * Build a `SELECT add_compression_policy(...)` statement that schedules
+     * automatic compression of chunks older than the given interval. The table
+     * must have compression enabled first (see {@link enableCompression}).
+     *
+     * @param table - Hypertable to add the policy to.
+     * @param olderThan - Age threshold. A string is a PostgreSQL interval literal
+     *   (e.g. `'30 days'`); a number is a raw integer threshold for hypertables
+     *   partitioned on an integer time column.
+     * @returns e.g. `SELECT add_compression_policy('conditions', INTERVAL '30 days')`
+     */
+    addCompressionPolicy(table, olderThan) {
+        return `SELECT add_compression_policy(${this.escape(table)}, ${this.formatInterval(olderThan)})`;
+    }
+    /**
+     * Build a `SELECT add_retention_policy(...)` statement that schedules
+     * automatic dropping of chunks older than the given interval.
+     *
+     * @param table - Hypertable to add the policy to.
+     * @param olderThan - Age threshold. A string is a PostgreSQL interval literal
+     *   (e.g. `'90 days'`); a number is a raw integer threshold for hypertables
+     *   partitioned on an integer time column.
+     * @returns e.g. `SELECT add_retention_policy('conditions', INTERVAL '90 days')`
+     */
+    addRetentionPolicy(table, olderThan) {
+        return `SELECT add_retention_policy(${this.escape(table)}, ${this.formatInterval(olderThan)})`;
+    }
+    /**
+     * Build a `CREATE MATERIALIZED VIEW ... WITH (timescaledb.continuous) AS ...`
+     * statement for a continuous aggregate — a TimescaleDB materialized view that
+     * is incrementally and automatically refreshed as new data arrives.
+     *
+     * @param viewName - Name of the continuous aggregate view to create.
+     * @param query - The `SELECT` query (typically using `time_bucket(...)`) that defines the aggregate.
+     * @returns e.g. `CREATE MATERIALIZED VIEW "daily_avg" WITH (timescaledb.continuous) AS SELECT ...`
+     */
+    createContinuousAggregate(viewName, query) {
+        return `CREATE MATERIALIZED VIEW ${this.escapeId(viewName)} WITH (timescaledb.continuous) AS ${query}`;
+    }
+    /**
+     * Build an `ALTER TABLE ... SET (timescaledb.compress, ...)` statement that
+     * enables native compression on a hypertable and optionally configures the
+     * segment-by / order-by columns.
+     *
+     * @param table - Hypertable to enable compression on.
+     * @param opts - Segment-by and order-by column configuration.
+     * @returns e.g. `ALTER TABLE "conditions" SET (timescaledb.compress, timescaledb.compress_segmentby = 'device_id')`
+     */
+    enableCompression(table, opts) {
+        const settings = ['timescaledb.compress'];
+        if (opts?.segmentBy !== undefined) {
+            const segmentBy = Array.isArray(opts.segmentBy)
+                ? opts.segmentBy.join(', ')
+                : opts.segmentBy;
+            settings.push(`timescaledb.compress_segmentby = ${this.escape(segmentBy)}`);
+        }
+        if (opts?.orderBy !== undefined) {
+            const orderBy = Array.isArray(opts.orderBy) ? opts.orderBy.join(', ') : opts.orderBy;
+            settings.push(`timescaledb.compress_orderby = ${this.escape(orderBy)}`);
+        }
+        return `ALTER TABLE ${this.quoteTable(table)} SET (${settings.join(', ')})`;
+    }
+}
+exports.TimescaleDBDialect = TimescaleDBDialect;
+/**
+ * Create a new TimescaleDB dialect instance.
+ */
+function createTimescaleDBDialect(options) {
+    return new TimescaleDBDialect(options || {});
+}
+exports.default = TimescaleDBDialect;