ts-prorm-orm 1.1.0

package/dist/dialects/exasol/index.js

@@ -0,0 +1,357 @@
+"use strict";
+/**
+ * Exasol dialect implementation for the TypeScript ORM.
+ *
+ * Exasol is an in-memory, column-oriented, massively-parallel (MPP) analytic
+ * database. Its SQL grammar and wire behavior are close enough to PostgreSQL
+ * that this dialect extends {@link PostgresDialect} and reuses the pg-style
+ * grammar (double-quoted identifiers, `$1` placeholders, `ON CONFLICT`-free
+ * INSERTs, etc.) as its base, overriding only the places where Exasol really
+ * differs. Notable differences from PostgreSQL captured here:
+ *
+ * - Default SQL port is 8563 (not 5432).
+ * - CREATE TABLE supports MPP distribution/partitioning clauses:
+ *     `... DISTRIBUTE BY col1, col2` controls how rows are hash-distributed
+ *     across cluster nodes, and `... PARTITION BY col` controls on-disk
+ *     partitioning within a node. Both are surfaced via table options and
+ *     emitted as trailing clauses.
+ * - No SERIAL / BIGSERIAL. Auto-increment columns use an `IDENTITY` column
+ *   constraint on a numeric (DECIMAL) column instead.
+ * - Type mapping differs: TEXT maps to `VARCHAR(2000000)` (Exasol's max
+ *   VARCHAR width), STRING to `VARCHAR(n)`, integers to `DECIMAL(18,0)`
+ *   (Exasol has no native narrow integer types — everything numeric is a
+ *   DECIMAL), and DECIMAL(p,s)/BOOLEAN/TIMESTAMP map straight through.
+ * - Bulk load/unload uses Exasol's `IMPORT` / `EXPORT` statements against a
+ *   file/connection endpoint rather than PostgreSQL's `COPY`.
+ * - Exasol upper-cases unquoted identifiers (like Oracle). This dialect quotes
+ *   identifiers with double quotes (inherited from PostgresDialect), so the
+ *   ORM's mixed-case names are preserved exactly rather than being folded to
+ *   upper case.
+ * - Exasol has **no `RETURNING` clause** on INSERT/UPDATE/DELETE and **no
+ *   `ON CONFLICT`**. So the write builders inherited from PostgresDialect
+ *   (`buildInsertQuery`, `buildUpdateQuery`, `buildDeleteQuery`,
+ *   `buildUpsertQuery`) are overridden here to strip `RETURNING` and to express
+ *   upserts as a `MERGE INTO ... USING (SELECT ...) ON (...) WHEN MATCHED /
+ *   WHEN NOT MATCHED` statement instead.
+ * - Plain SELECT (WHERE, ORDER BY, GROUP BY / HAVING, JOIN, `LIMIT ... OFFSET`)
+ *   and `buildLimitOffset` are inherited unchanged: Exasol's SELECT grammar
+ *   matches the PostgreSQL forms the base emits, including `LIMIT n OFFSET m`.
+ *
+ * Placeholders: this dialect keeps the PostgreSQL `$n` positional style so it
+ * composes with the rest of the ORM's parameter handling. Exasol's own JDBC/
+ * WebSocket drivers use `?`; a live driver binding would translate accordingly.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExasolDialect = void 0;
+exports.createExasolDialect = createExasolDialect;
+const postgres_1 = require("../postgres");
+const prorm_1 = require("../../prorm");
+/**
+ * Exasol dialect. Extends {@link PostgresDialect}; see the file header for the
+ * list of Exasol-specific behaviors.
+ */
+class ExasolDialect extends postgres_1.PostgresDialect {
+    constructor(config) {
+        // Exasol's default SQL port is 8563 (not Postgres's 5432). Caller-supplied
+        // config still wins over this default.
+        super({ port: 8563, ...config });
+        this.name = 'exasol';
+    }
+    /**
+     * Map an ORM data type to its Exasol SQL type. Overrides the Postgres
+     * mapping for the types that differ on Exasol:
+     *  - TEXT      -> VARCHAR(2000000)  (Exasol's max VARCHAR width; no TEXT type)
+     *  - STRING    -> VARCHAR(n)
+     *  - INTEGER   -> DECIMAL(18,0)     (no SERIAL; IDENTITY is applied separately)
+     *  - BIGINT    -> DECIMAL(36,0)
+     *  - DECIMAL   -> DECIMAL(p,s)
+     *  - BOOLEAN   -> BOOLEAN
+     *  - DATE      -> TIMESTAMP
+     * Everything else delegates to the PostgreSQL mapping.
+     */
+    getDataTypeSql(dataType) {
+        if (typeof dataType === 'string') {
+            // Normalize the cross-dialect DATETIME pseudo-type to TIMESTAMP, matching
+            // the Postgres base behavior.
+            if (/^DATETIME(\(\d+\))?$/i.test(dataType)) {
+                return dataType.replace(/^DATETIME/i, 'TIMESTAMP');
+            }
+            return dataType;
+        }
+        if (!dataType || typeof dataType !== 'object') {
+            return super.getDataTypeSql(dataType);
+        }
+        const dt = dataType;
+        switch (dt.key) {
+            case 'TEXT':
+                // Exasol has no TEXT type; use its maximum-width VARCHAR.
+                return 'VARCHAR(2000000)';
+            case 'STRING':
+                return `VARCHAR(${dt.length || 255})`;
+            case 'CHAR':
+                return `CHAR(${dt.length || 1})`;
+            case 'INTEGER':
+                // No SERIAL on Exasol - auto-increment is handled via IDENTITY in the
+                // column definition, so the base type is a plain numeric DECIMAL.
+                return 'DECIMAL(18,0)';
+            case 'BIGINT':
+                return 'DECIMAL(36,0)';
+            case 'DECIMAL':
+                return `DECIMAL(${dt.precision || 18},${dt.scale || 0})`;
+            case 'BOOLEAN':
+                return 'BOOLEAN';
+            case 'DATE':
+                return dt.precision ? `TIMESTAMP(${dt.precision})` : 'TIMESTAMP';
+            case 'DATEONLY':
+                return 'DATE';
+            default:
+                return super.getDataTypeSql(dataType);
+        }
+    }
+    /**
+     * Format a single column's definition for CREATE TABLE. Emits `IDENTITY`
+     * (rather than SERIAL) for auto-increment columns.
+     */
+    buildColumnSql(columnName, definition) {
+        let sql = `${this.escapeId(columnName)} ${this.getDataTypeSql(definition.type)}`;
+        if (definition.autoIncrement) {
+            // Exasol auto-increment: numeric column with an IDENTITY constraint.
+            sql += ' IDENTITY';
+        }
+        if (definition.allowNull === false) {
+            sql += ' NOT NULL';
+        }
+        if (definition.defaultValue !== undefined && !definition.autoIncrement) {
+            sql += ` DEFAULT ${this.formatDefault(definition.defaultValue)}`;
+        }
+        if (definition.primaryKey) {
+            sql += ' PRIMARY KEY';
+        }
+        if (definition.unique) {
+            // Exasol accepts a column-level UNIQUE constraint (it is tracked but not
+            // enforced by default, like foreign keys).
+            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}`;
+        }
+        return sql;
+    }
+    /** Format a DEFAULT value literal for a column definition. */
+    formatDefault(value) {
+        if (value === null) {
+            return 'NULL';
+        }
+        if (typeof value === 'string') {
+            if (value.toUpperCase().includes('CURRENT_') || value.toUpperCase() === 'NULL') {
+                return value;
+            }
+            return `'${value.replace(/'/g, "''")}'`;
+        }
+        if (typeof value === 'number' || typeof value === 'boolean') {
+            return String(value);
+        }
+        return `'${String(value).replace(/'/g, "''")}'`;
+    }
+    /** Render a `DISTRIBUTE BY` / `PARTITION BY` column list. */
+    columnList(cols) {
+        const arr = Array.isArray(cols) ? cols : [cols];
+        return arr.map((c) => this.escapeId(c)).join(', ');
+    }
+    /**
+     * Build a `CREATE TABLE` statement, including Exasol's MPP `DISTRIBUTE BY`
+     * and `PARTITION BY` clauses. Exposed synchronously so the emitted SQL can be
+     * built (and tested) without a live connection.
+     */
+    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(', ')})`;
+        // MPP distribution across cluster nodes.
+        if (options?.distributeBy) {
+            sql += ` DISTRIBUTE BY ${this.columnList(options.distributeBy)}`;
+        }
+        // On-disk partitioning within a node.
+        if (options?.partitionBy) {
+            sql += ` PARTITION BY ${this.columnList(options.partitionBy)}`;
+        }
+        return sql;
+    }
+    /**
+     * Create a table. Overrides the Postgres implementation to emit Exasol's
+     * IDENTITY columns and `DISTRIBUTE BY` / `PARTITION BY` clauses.
+     */
+    async createTable(tableName, columns, options) {
+        await this.query(this.buildCreateTableSQL(tableName, columns, options));
+    }
+    /**
+     * Add a column. Overrides the Postgres implementation, which would emit a
+     * `SERIAL` for auto-increment columns; Exasol uses `IDENTITY` instead (see
+     * {@link buildColumnSql}). Exasol accepts the optional `COLUMN` keyword.
+     */
+    async addColumn(tableName, columnName, definition) {
+        const sql = `ALTER TABLE ${this.escapeId(tableName)} ADD COLUMN ${this.buildColumnSql(columnName, definition)}`;
+        await this.query(sql);
+    }
+    /**
+     * Change a column's type. Exasol uses `ALTER TABLE ... MODIFY COLUMN col type`
+     * rather than PostgreSQL's `ALTER COLUMN col TYPE type`.
+     */
+    async changeColumn(tableName, columnName, definition) {
+        let sql = `ALTER TABLE ${this.escapeId(tableName)} MODIFY COLUMN ${this.escapeId(columnName)} ${this.getDataTypeSql(definition.type)}`;
+        if (definition.allowNull === false) {
+            sql += ' NOT NULL';
+        }
+        if (definition.defaultValue !== undefined) {
+            sql += ` DEFAULT ${this.formatDefault(definition.defaultValue)}`;
+        }
+        await this.query(sql);
+    }
+    /**
+     * Build an INSERT. Same as the PostgreSQL base but Exasol has no `RETURNING`
+     * clause, and upserts are expressed as a `MERGE` (Exasol has no
+     * `ON CONFLICT`). When `options.upsert` is set this delegates to
+     * {@link buildMergeSQL}; the `returning` option is ignored.
+     */
+    buildInsertQuery(tableName, values, options) {
+        if (options?.upsert) {
+            return this.buildMergeSQL(tableName, values, {
+                conflictFields: options.conflictFields,
+                updateOnDuplicate: options.updateOnDuplicate,
+            });
+        }
+        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++;
+            }
+        }
+        // No RETURNING on Exasol - deliberately omitted even if requested.
+        const sql = `INSERT INTO ${this.escapeId(tableName)} (${columns
+            .map((c) => this.escapeId(c))
+            .join(', ')}) VALUES (${placeholders.join(', ')})`;
+        return { sql, values: processedValues };
+    }
+    /**
+     * Build an UPSERT as an Exasol `MERGE` statement. Exasol has no
+     * `INSERT ... ON CONFLICT`.
+     */
+    buildUpsertQuery(tableName, values, options) {
+        return this.buildMergeSQL(tableName, values, {
+            conflictFields: options?.conflictFields,
+            updateOnDuplicate: options?.updateOnDuplicate,
+        });
+    }
+    /**
+     * Build the Exasol `MERGE INTO ... USING (SELECT ...) ON (...)` statement that
+     * implements an upsert for a single row of `values`.
+     *
+     * The row is presented as a one-row derived source via a FROM-less
+     * `SELECT $1 AS "col", ...` (Exasol permits SELECT without FROM). Rows are
+     * matched on `conflictFields`; matched rows are updated (excluding the
+     * conflict columns, which Exasol forbids updating because they appear in the
+     * `ON` condition) and unmatched rows are inserted.
+     */
+    buildMergeSQL(tableName, values, options) {
+        const conflictFields = options?.conflictFields;
+        if (!conflictFields || conflictFields.length === 0) {
+            throw new Error('buildMergeSQL: options.conflictFields is required - Exasol MERGE needs the ' +
+                'key column(s) to match existing rows on, so it cannot be inferred from the ' +
+                'inserted columns.');
+        }
+        const columns = Object.keys(values);
+        const processedValues = [];
+        let paramIndex = 1;
+        // FROM-less source select: one aliased expression per column.
+        const sourceExprs = columns.map((col) => {
+            const value = values[col];
+            if (value instanceof prorm_1.Literal) {
+                return `${value.val} AS ${this.escapeId(col)}`;
+            }
+            const placeholder = `$${paramIndex++}`;
+            processedValues.push(value);
+            return `${placeholder} AS ${this.escapeId(col)}`;
+        });
+        const onCondition = conflictFields
+            .map((c) => `dst.${this.escapeId(c)} = src.${this.escapeId(c)}`)
+            .join(' AND ');
+        // Columns to update on match: explicit list if given, otherwise every
+        // non-conflict column. Exasol forbids updating the ON-condition columns.
+        const conflictSet = new Set(conflictFields);
+        const updateFields = (options?.updateOnDuplicate && options.updateOnDuplicate.length > 0
+            ? options.updateOnDuplicate
+            : columns).filter((c) => !conflictSet.has(c));
+        let sql = `MERGE INTO ${this.escapeId(tableName)} dst` +
+            ` USING (SELECT ${sourceExprs.join(', ')}) src` +
+            ` ON (${onCondition})`;
+        if (updateFields.length > 0) {
+            const updateClauses = updateFields
+                .map((c) => `dst.${this.escapeId(c)} = src.${this.escapeId(c)}`)
+                .join(', ');
+            sql += ` WHEN MATCHED THEN UPDATE SET ${updateClauses}`;
+        }
+        const insertCols = columns.map((c) => this.escapeId(c)).join(', ');
+        const insertVals = columns.map((c) => `src.${this.escapeId(c)}`).join(', ');
+        sql += ` WHEN NOT MATCHED THEN INSERT (${insertCols}) VALUES (${insertVals})`;
+        return { sql, values: processedValues };
+    }
+    /**
+     * Build an UPDATE. Same as the PostgreSQL base, but Exasol supports neither a
+     * `RETURNING` clause nor a `LIMIT` on UPDATE, so both are stripped from the
+     * options before delegating.
+     */
+    buildUpdateQuery(tableName, values, where, options) {
+        const { returning: _returning, limit: _limit, ...rest } = options || {};
+        return super.buildUpdateQuery(tableName, values, where, rest);
+    }
+    /**
+     * Build a DELETE. Exasol has no `RETURNING` and no `LIMIT` on DELETE, so both
+     * are stripped; `truncate` (which maps to `TRUNCATE TABLE`) is preserved.
+     */
+    buildDeleteQuery(tableName, where, options) {
+        const { returning: _returning, limit: _limit, ...rest } = options || {};
+        return super.buildDeleteQuery(tableName, where, rest);
+    }
+    /**
+     * Build an Exasol `IMPORT INTO <table> FROM <format> AT '<endpoint>' FILE '<path>'`
+     * statement for bulk-loading data. `schema` on the options, if any, is not
+     * used here; qualify the table name yourself if needed.
+     */
+    buildImportSQL(tableName, options) {
+        const format = options.format || 'CSV';
+        return (`IMPORT INTO ${this.escapeId(tableName)} FROM ${format}` +
+            ` AT '${options.at.replace(/'/g, "''")}' FILE '${options.file.replace(/'/g, "''")}'`);
+    }
+    /**
+     * Build an Exasol `EXPORT <table> INTO <format> AT '<endpoint>' FILE '<path>'`
+     * statement for bulk-unloading data.
+     */
+    buildExportSQL(tableName, options) {
+        const format = options.format || 'CSV';
+        return (`EXPORT ${this.escapeId(tableName)} INTO ${format}` +
+            ` AT '${options.at.replace(/'/g, "''")}' FILE '${options.file.replace(/'/g, "''")}'`);
+    }
+}
+exports.ExasolDialect = ExasolDialect;
+/**
+ * Create a new Exasol dialect instance.
+ */
+function createExasolDialect(options) {
+    return new ExasolDialect(options || {});
+}
+exports.default = ExasolDialect;