ts-prorm-orm 1.1.0 → 1.2.1

package/dist/dialects/db2/index.js

@@ -14,7 +14,23 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DB2Dialect = void 0;
-const ibm_db_1 = require("ibm_db");
+// Lazily-loaded `ibm_db` driver. This native (ODBC-based) addon is only loaded
+// the first time a connection is opened, so importing this ORM never dlopens
+// the ibm_db native binding.
+let ibmDbModule = null;
+function loadIbmDb() {
+    if (!ibmDbModule) {
+        try {
+            ibmDbModule = require('ibm_db');
+        }
+        catch (err) {
+            throw new Error("The 'ibm_db' package is required to use the Db2 dialect but could not be loaded. " +
+                'Install it with `npm install ibm_db`. Original error: ' +
+                (err instanceof Error ? err.message : String(err)));
+        }
+    }
+    return ibmDbModule;
+}
 const query_stream_helper_1 = require("../query-stream-helper");
 const prorm_1 = require("../../prorm");
 /**
@@ -135,7 +151,7 @@ class DB2Dialect {
     }
     async connect() {
         await this.withRetry(async () => {
-            const pool = new ibm_db_1.Pool();
+            const pool = new (loadIbmDb().Pool)();
             pool.setMaxPoolSize(this.poolOptions.max || DEFAULT_POOL_OPTIONS.max);
             // Verify connectivity by opening and immediately releasing a connection.
             const conn = await pool.open(this.connectionString);
@@ -1527,6 +1543,11 @@ class DB2Dialect {
                 return 'CLOB';
             case 'JSONB':
                 return 'BLOB';
+            case 'XML':
+                // Db2 pureXML native XML storage.
+                return 'XML';
+            case 'DECFLOAT':
+                return dt?.precision ? `DECFLOAT(${String(dt.precision)})` : 'DECFLOAT';
             case 'UUID':
                 return 'CHAR(36)';
             case 'GEOMETRY':
@@ -2221,5 +2242,134 @@ class DB2Dialect {
             .join(', ');
         return `JSON_TABLE(${jsonExpression}, '${rowPath}' COLUMNS(${columnDefs})) AS ${this.escapeId(alias)}`;
     }
+    /**
+     * Build a `JSON_VALUE(column, 'path' RETURNING type)` scalar accessor
+     * (Db2 11.5+). `path` may be a dot path (`address.city`) or an explicit
+     * SQL/JSON path (`$.address.city`); the former is normalized to the latter.
+     */
+    buildJsonValue(column, path, options) {
+        const jsonPath = path.startsWith('$') ? path : `$.${path.replace(/^\./, '')}`;
+        const returning = options?.returning ? ` RETURNING ${options.returning}` : '';
+        return `JSON_VALUE(${this.escapeId(column)}, '${jsonPath}'${returning})`;
+    }
+    // ==================== String / XML aggregation ====================
+    /**
+     * Build a Db2 `LISTAGG(expr, delimiter) WITHIN GROUP (ORDER BY ...)`
+     * expression — Db2's string-aggregation idiom (distinct from MySQL's
+     * `GROUP_CONCAT` and Postgres' `STRING_AGG`).
+     */
+    listAgg(expr, delimiter = ',', orderBy) {
+        const escapedDelimiter = delimiter.replace(/'/g, "''");
+        const orderByClause = orderBy ? ` WITHIN GROUP (ORDER BY ${orderBy})` : '';
+        return `LISTAGG(${expr}, '${escapedDelimiter}')${orderByClause}`;
+    }
+    /**
+     * Build a Db2 `XMLAGG(XMLELEMENT(NAME tag, expr) ORDER BY ...)` expression for
+     * aggregating rows into an XML fragment (pureXML).
+     */
+    xmlAgg(expr, elementName = 'item', orderBy) {
+        const orderByClause = orderBy ? ` ORDER BY ${orderBy}` : '';
+        return `XMLAGG(XMLELEMENT(NAME "${elementName}", ${expr})${orderByClause})`;
+    }
+    // ==================== pureXML (XML data type + XQuery) ====================
+    /**
+     * Build a Db2 `XMLQUERY('xquery' PASSING column)` expression to evaluate an
+     * XQuery/XPath expression against a pureXML column.
+     */
+    buildXmlQuery(column, xquery) {
+        return `XMLQUERY('${xquery.replace(/'/g, "''")}' PASSING ${this.escapeId(column)})`;
+    }
+    /**
+     * Build a Db2 `XMLEXISTS('xquery' PASSING column)` predicate to test whether
+     * an XQuery/XPath matches anything in a pureXML column — for WHERE clauses.
+     */
+    buildXmlExists(column, xquery) {
+        return `XMLEXISTS('${xquery.replace(/'/g, "''")}' PASSING ${this.escapeId(column)})`;
+    }
+    /**
+     * Build a Db2 `XMLTABLE(...)` expression to shred a pureXML document into
+     * relational rows, analogous to `JSON_TABLE` for XML.
+     */
+    buildXmlTable(rowXQuery, passing, columns, alias) {
+        const columnDefs = columns
+            .map((col) => {
+            if (col.forOrdinality) {
+                return `${this.escapeId(col.name)} FOR ORDINALITY`;
+            }
+            return `${this.escapeId(col.name)} ${col.type}${col.path ? ` PATH '${col.path}'` : ''}`;
+        })
+            .join(', ');
+        return `XMLTABLE('${rowXQuery.replace(/'/g, "''")}' PASSING ${this.escapeId(passing)} COLUMNS ${columnDefs}) AS ${this.escapeId(alias)}`;
+    }
+    // ==================== Global / session variables ====================
+    /**
+     * Create a Db2 global (or session-scoped) variable
+     * (`CREATE VARIABLE name type [DEFAULT ...]`).
+     */
+    async createVariable(name, type, options) {
+        const orReplace = options?.orReplace ? 'OR REPLACE ' : '';
+        let sql = `CREATE ${orReplace}VARIABLE ${this.escapeId(name)} ${type}`;
+        if (options?.default !== undefined) {
+            sql += ` DEFAULT ${this.escape(options.default)}`;
+        }
+        await this.query(sql);
+    }
+    /** Drop a Db2 global variable (`DROP VARIABLE name`). */
+    async dropVariable(name) {
+        await this.query(`DROP VARIABLE ${this.escapeId(name)}`);
+    }
+    /** Assign a value to a Db2 global/session variable (`SET name = value`). */
+    async setVariable(name, value) {
+        await this.query(`SET ${this.escapeId(name)} = ${this.escape(value)}`);
+    }
+    // ==================== BLU / column-organized & MDC tables ====================
+    /**
+     * Build the trailing table-organization clause for a Db2 `CREATE TABLE`:
+     * `ORGANIZE BY COLUMN` (BLU Acceleration column-organized) or
+     * `ORGANIZE BY DIMENSIONS (col, ...)` (Multidimensional Clustering / MDC).
+     * Returns an empty string when neither is requested.
+     */
+    buildOrganizeByClause(options) {
+        if (options.dimensions && options.dimensions.length > 0) {
+            return `ORGANIZE BY DIMENSIONS (${options.dimensions.map((d) => this.escapeId(d)).join(', ')})`;
+        }
+        if (options.organizeBy === 'column') {
+            return 'ORGANIZE BY COLUMN';
+        }
+        if (options.organizeBy === 'row') {
+            return 'ORGANIZE BY ROW';
+        }
+        return '';
+    }
+    /**
+     * Create a column-organized (BLU Acceleration) table by appending
+     * `ORGANIZE BY COLUMN` (or `ORGANIZE BY DIMENSIONS (...)` for MDC) to a
+     * standard `CREATE TABLE`. Convenience wrapper for analytics workloads.
+     */
+    async createColumnOrganizedTable(tableName, columns, options) {
+        const columnDefs = [];
+        for (const [columnName, definition] of Object.entries(columns)) {
+            columnDefs.push(this.buildColumnDefinition(columnName, definition));
+        }
+        if (options?.constraints) {
+            for (const constraint of options.constraints) {
+                const constraintSql = this.buildConstraintSql(constraint);
+                if (constraintSql)
+                    columnDefs.push(constraintSql);
+            }
+        }
+        let sql = `CREATE TABLE ${this.quoteTable(tableName)} (${columnDefs.join(', ')})`;
+        if (options?.tablespace) {
+            sql += ` IN ${options.tablespace}`;
+        }
+        const organize = this.buildOrganizeByClause({
+            organizeBy: 'column',
+            dimensions: options?.dimensions,
+        });
+        if (organize) {
+            sql += ` ${organize}`;
+        }
+        await this.query(sql);
+    }
 }
 exports.DB2Dialect = DB2Dialect;