ts-prorm-orm 1.1.0 → 1.2.1

package/dist/dialects/mssql/index.js

@@ -7,6 +7,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MSSQLDialect = void 0;
 exports.createMSSQLDialect = createMSSQLDialect;
 const mssql_1 = require("mssql");
+const operators_1 = require("../../operators");
 const types_1 = require("../../types");
 const query_stream_helper_1 = require("../query-stream-helper");
 const prorm_1 = require("../../prorm");
@@ -996,6 +997,48 @@ class MSSQLDialect {
     async dropIndex(tableName, indexName, _options) {
         await this.removeIndex(tableName, indexName);
     }
+    /**
+     * Create a SQL Server columnstore index — the storage format used for
+     * analytic/warehouse workloads.
+     *
+     * A *clustered* columnstore index (`clustered: true`, the default) converts
+     * the entire table to columnar storage and therefore takes NO column list —
+     * emitting one is a T-SQL syntax error, which is why the generic
+     * `addIndex()` (which always appends `(cols)`) cannot express it. A
+     * *nonclustered* columnstore index is layered on top of a rowstore table and
+     * DOES take an explicit column list.
+     *
+     * @param tableName - Table to build the columnstore index on
+     * @param indexName - Name for the index
+     * @param options.clustered - Clustered (whole-table columnar) when true/omitted; nonclustered when false
+     * @param options.columns - Columns for a nonclustered columnstore index (required when `clustered` is false; ignored when clustered)
+     * @param options.where - Filtered-index predicate (nonclustered columnstore only, SQL Server 2016+)
+     * @param options.compressionDelay - `COMPRESSION_DELAY = <n> MINUTES` WITH option
+     */
+    async createColumnstoreIndex(tableName, indexName, options) {
+        const clustered = options?.clustered !== false;
+        let sql;
+        if (clustered) {
+            sql = `CREATE CLUSTERED COLUMNSTORE INDEX ${this.escapeId(indexName)} ON ${this.escapeId(tableName)}`;
+        }
+        else {
+            const columns = options?.columns || [];
+            if (columns.length === 0) {
+                throw new Error('A NONCLUSTERED COLUMNSTORE index requires an explicit column list; pass options.columns.');
+            }
+            sql = `CREATE NONCLUSTERED COLUMNSTORE INDEX ${this.escapeId(indexName)} ON ${this.escapeId(tableName)} (${columns
+                .map((c) => this.escapeId(c))
+                .join(', ')})`;
+            // Filtered columnstore predicate is only valid on nonclustered columnstore.
+            if (options?.where) {
+                sql += ` WHERE ${options.where}`;
+            }
+        }
+        if (options?.compressionDelay !== undefined) {
+            sql += ` WITH (COMPRESSION_DELAY = ${Number(options.compressionDelay)} MINUTES)`;
+        }
+        await this.query(sql);
+    }
     async createConstraint(tableName, constraintDef) {
         const sql = `ALTER TABLE ${this.escapeId(tableName)} ADD ${this.buildConstraintSql(constraintDef)}`;
         await this.query(sql);
@@ -1481,7 +1524,8 @@ class MSSQLDialect {
         if (expr !== null && typeof expr === 'object') {
             const e = expr;
             if (e.__type === 'literal' || '$literal' in e) {
-                return (e.sql ?? e.$literal);
+                const rawSql = (e.sql ?? e.$literal);
+                return (0, operators_1.expandLiteralBindings)({ sql: rawSql, bindings: e.bindings }, (v) => this.escape(v));
             }
             if (e.__type === 'col' && e.col) {
                 return this.escapeId(e.col);
@@ -1730,14 +1774,39 @@ class MSSQLDialect {
     async dropUserMapping(_serverName, _userName, _options) {
         throw new Error('Foreign Data Wrappers are not supported by MSSQL. This is a PostgreSQL-specific feature. Consider using MSSQL linked servers (sp_addlinkedserver) instead.');
     }
-    async changeOwner(_newOwner, _tableName) {
-        throw new Error('changeOwner is not supported in MSSQL');
+    /**
+     * Change the owner (authorization principal) of a table. SQL Server has no
+     * `ALTER TABLE ... OWNER TO` — object ownership is changed with
+     * `ALTER AUTHORIZATION ON OBJECT::<table> TO <principal>`, which is the
+     * T-SQL equivalent (pass `SCHEMA OWNER` as the principal to revert to the
+     * containing schema's owner).
+     */
+    async changeOwner(newOwner, tableName) {
+        const principal = newOwner.toUpperCase() === 'SCHEMA OWNER' ? 'SCHEMA OWNER' : this.escapeId(newOwner);
+        const sql = `ALTER AUTHORIZATION ON OBJECT::${this.escapeId(tableName)} TO ${principal}`;
+        await this.query(sql);
     }
-    async addConstraint(_tableName, _options) {
-        throw new Error('addConstraint is not supported in MSSQL');
+    /**
+     * Add a table constraint via `ALTER TABLE ... ADD CONSTRAINT`. Delegates to
+     * `createConstraint`/`buildConstraintSql`, mapping the `references.fields`
+     * array shape onto the `references.field` shape those helpers expect.
+     */
+    async addConstraint(tableName, options) {
+        await this.createConstraint(tableName, {
+            name: options.name || `${tableName}_${options.type.toLowerCase().replace(/\s+/g, '_')}`,
+            type: options.type,
+            fields: options.fields,
+            references: options.references
+                ? { table: options.references.table, field: options.references.fields }
+                : undefined,
+            check: options.check,
+        });
     }
-    async removeConstraint(_tableName, _constraintName) {
-        throw new Error('removeConstraint is not supported in MSSQL');
+    /**
+     * Drop a named table constraint via `ALTER TABLE ... DROP CONSTRAINT`.
+     */
+    async removeConstraint(tableName, constraintName) {
+        await this.dropConstraint(tableName, constraintName);
     }
     async createSecurityPolicy(policyName, tableName, options) {
         const schema = options?.schema || 'dbo';