ts-prorm-orm 1.1.0

package/dist/query-optimizers/batch-optimizer.js

@@ -0,0 +1,426 @@
+"use strict";
+/**
+ * Query Batch/Bulk Optimization
+ * Provides functionality to optimize batch operations for better performance
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchQueryOptimizer = void 0;
+exports.optimizeBatchInsert = optimizeBatchInsert;
+exports.optimizeBatchUpdate = optimizeBatchUpdate;
+exports.optimizeBatchDelete = optimizeBatchDelete;
+/**
+ * Batch query optimizer
+ */
+class BatchQueryOptimizer {
+    constructor(dialect, defaultOptions) {
+        this.dialect = dialect;
+        this.defaultOptions = {
+            chunkSize: 1000,
+            useTransaction: true,
+            validate: true,
+            skipDuplicates: false,
+            stopOnError: false,
+            ...defaultOptions,
+        };
+    }
+    /**
+     * Set default options for batch operations
+     */
+    setDefaultOptions(options) {
+        this.defaultOptions = { ...this.defaultOptions, ...options };
+    }
+    /**
+     * Optimize batch insert by combining multiple INSERT statements
+     * @param tableName - Name of the table to insert into
+     * @param records - Array of records to insert
+     * @param options - Batch options
+     */
+    async optimizeBatchInsert(tableName, records, options) {
+        const opts = { ...this.defaultOptions, ...options };
+        const startTime = Date.now();
+        if (records.length === 0) {
+            return {
+                success: [],
+                failed: [],
+                total: 0,
+                chunkSize: opts.chunkSize,
+                batches: 0,
+                duration: 0,
+            };
+        }
+        const success = [];
+        const failed = [];
+        const chunks = this.chunkArray(records, opts.chunkSize);
+        const totalBatches = Math.ceil(records.length / opts.chunkSize);
+        for (let batchIndex = 0; batchIndex < chunks.length; batchIndex++) {
+            const chunk = chunks[batchIndex];
+            try {
+                // Try multi-value INSERT first (most efficient)
+                const result = await this.executeBatchInsert(tableName, chunk, opts);
+                success.push(...chunk);
+                this.logProgress(opts, {
+                    total: records.length,
+                    processed: success.length + failed.length,
+                    success: success.length,
+                    failed: failed.length,
+                    batchIndex,
+                    totalBatches,
+                });
+            }
+            catch (error) {
+                if (opts.stopOnError) {
+                    throw error;
+                }
+                // Fall back to individual inserts
+                for (const record of chunk) {
+                    try {
+                        await this.executeSingleInsert(tableName, record, opts);
+                        success.push(record);
+                    }
+                    catch (individualError) {
+                        if (!opts.skipDuplicates || !this.isDuplicateKeyError(individualError)) {
+                            failed.push({ record, error: individualError });
+                        }
+                    }
+                }
+                this.logProgress(opts, {
+                    total: records.length,
+                    processed: success.length + failed.length,
+                    success: success.length,
+                    failed: failed.length,
+                    batchIndex,
+                    totalBatches,
+                });
+            }
+        }
+        return {
+            success,
+            failed,
+            total: records.length,
+            chunkSize: opts.chunkSize,
+            batches: totalBatches,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Build the next placeholder token for a bound parameter, given the running
+     * 1-based parameter index. Matches the placeholder convention each dialect's
+     * own buildInsertQuery/buildUpdateQuery/buildDeleteQuery already uses:
+     *   - postgres: $1, $2, ...
+     *   - mssql:    @p1, @p2, ...
+     *   - oracle:   :1, :2, ...
+     *   - others (mysql/mariadb/sqlite): ?
+     */
+    nextPlaceholder(paramIndex) {
+        switch (this.dialect.name) {
+            case 'postgres':
+                return `$${paramIndex}`;
+            case 'mssql':
+                return `@p${paramIndex}`;
+            case 'oracle':
+                return `:${paramIndex}`;
+            default:
+                return '?';
+        }
+    }
+    /**
+     * Execute a batch insert using multi-value INSERT
+     * Uses bound parameters with dialect-correct placeholders ($1, $2, ... for
+     * PostgreSQL, `?` for the other dialects) instead of interpolating values.
+     */
+    async executeBatchInsert(tableName, records, options) {
+        if (records.length === 0)
+            return;
+        const columns = Object.keys(records[0]);
+        const quotedTable = this.dialect.quoteTable(tableName);
+        const quotedColumns = columns.map((c) => this.dialect.quoteIdentifier(c)).join(', ');
+        // Build multi-value INSERT
+        const valuesClauses = [];
+        const allParams = [];
+        let paramIndex = 1;
+        for (const record of records) {
+            const placeholders = [];
+            for (const col of columns) {
+                placeholders.push(this.nextPlaceholder(paramIndex++));
+                allParams.push(record[col]);
+            }
+            valuesClauses.push(`(${placeholders.join(', ')})`);
+        }
+        const sql = `INSERT INTO ${quotedTable} (${quotedColumns}) VALUES ${valuesClauses.join(', ')}`;
+        await this.dialect.query(sql, { raw: true, replacements: allParams });
+    }
+    /**
+     * Execute a single record insert
+     */
+    async executeSingleInsert(tableName, record, options) {
+        const { sql, values } = this.dialect.buildInsertQuery(tableName, record);
+        await this.dialect.query(sql, { raw: true, replacements: values });
+    }
+    /**
+     * Optimize batch update
+     * @param tableName - Name of the table to update
+     * @param records - Records to update (must have primary key or unique identifier)
+     * @param identifierColumn - Column to use for identifying records
+     * @param options - Batch options
+     */
+    async optimizeBatchUpdate(tableName, records, identifierColumn = 'id', options) {
+        const opts = { ...this.defaultOptions, ...options };
+        const startTime = Date.now();
+        if (records.length === 0) {
+            return {
+                success: [],
+                failed: [],
+                total: 0,
+                chunkSize: opts.chunkSize,
+                batches: 0,
+                duration: 0,
+            };
+        }
+        const success = [];
+        const failed = [];
+        const chunks = this.chunkArray(records, opts.chunkSize);
+        const totalBatches = Math.ceil(records.length / opts.chunkSize);
+        for (let batchIndex = 0; batchIndex < chunks.length; batchIndex++) {
+            const chunk = chunks[batchIndex];
+            try {
+                // Try batch UPDATE with CASE expressions (more efficient)
+                await this.executeBatchUpdate(tableName, chunk, identifierColumn, opts);
+                success.push(...chunk);
+                this.logProgress(opts, {
+                    total: records.length,
+                    processed: success.length + failed.length,
+                    success: success.length,
+                    failed: failed.length,
+                    batchIndex,
+                    totalBatches,
+                });
+            }
+            catch (error) {
+                if (opts.stopOnError) {
+                    throw error;
+                }
+                // Fall back to individual updates
+                for (const record of chunk) {
+                    try {
+                        const idValue = record[identifierColumn];
+                        const updateValues = { ...record };
+                        delete updateValues[identifierColumn];
+                        await this.executeSingleUpdate(tableName, updateValues, { [identifierColumn]: idValue }, opts);
+                        success.push(record);
+                    }
+                    catch (individualError) {
+                        failed.push({ record, error: individualError });
+                    }
+                }
+                this.logProgress(opts, {
+                    total: records.length,
+                    processed: success.length + failed.length,
+                    success: success.length,
+                    failed: failed.length,
+                    batchIndex,
+                    totalBatches,
+                });
+            }
+        }
+        return {
+            success,
+            failed,
+            total: records.length,
+            chunkSize: opts.chunkSize,
+            batches: totalBatches,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Execute batch update using CASE expressions
+     * Uses bound parameters with dialect-correct placeholders instead of
+     * interpolating escaped literals directly into the SQL string.
+     */
+    async executeBatchUpdate(tableName, records, identifierColumn, options) {
+        if (records.length === 0)
+            return;
+        const columns = Object.keys(records[0]).filter((col) => col !== identifierColumn);
+        const quotedTable = this.dialect.quoteTable(tableName);
+        // Build CASE expressions for each column
+        const caseClauses = [];
+        const params = [];
+        let paramIndex = 1;
+        for (const column of columns) {
+            const whenClauses = [];
+            for (const record of records) {
+                const idPlaceholder = this.nextPlaceholder(paramIndex++);
+                params.push(record[identifierColumn]);
+                const valuePlaceholder = this.nextPlaceholder(paramIndex++);
+                params.push(record[column]);
+                whenClauses.push(`WHEN ${idPlaceholder} THEN ${valuePlaceholder}`);
+            }
+            caseClauses.push(`${this.dialect.quoteIdentifier(column)} = CASE ${whenClauses.join(' ')} END`);
+        }
+        // Get unique IDs for WHERE clause
+        const ids = records.map((r) => r[identifierColumn]);
+        const idPlaceholders = ids.map(() => this.nextPlaceholder(paramIndex++));
+        params.push(...ids);
+        const whereClause = `WHERE ${this.dialect.quoteIdentifier(identifierColumn)} IN (${idPlaceholders.join(', ')})`;
+        const sql = `UPDATE ${quotedTable} SET ${caseClauses.join(', ')} ${whereClause}`;
+        await this.dialect.query(sql, { raw: true, replacements: params });
+    }
+    /**
+     * Execute a single record update
+     */
+    async executeSingleUpdate(tableName, values, where, options) {
+        const { sql, values: queryValues } = this.dialect.buildUpdateQuery(tableName, values, where);
+        await this.dialect.query(sql, { raw: true, replacements: queryValues });
+    }
+    /**
+     * Optimize batch delete
+     * @param tableName - Name of the table to delete from
+     * @param identifiers - Array of identifiers for records to delete
+     * @param identifierColumn - Column to use for identifying records
+     * @param options - Batch options
+     */
+    async optimizeBatchDelete(tableName, identifiers, identifierColumn = 'id', options) {
+        const opts = { ...this.defaultOptions, ...options };
+        const startTime = Date.now();
+        if (identifiers.length === 0) {
+            return {
+                success: [],
+                failed: [],
+                total: 0,
+                chunkSize: opts.chunkSize,
+                batches: 0,
+                duration: 0,
+            };
+        }
+        const success = [];
+        const failed = [];
+        const chunks = this.chunkArray(identifiers, opts.chunkSize);
+        const totalBatches = Math.ceil(identifiers.length / opts.chunkSize);
+        for (let batchIndex = 0; batchIndex < chunks.length; batchIndex++) {
+            const chunk = chunks[batchIndex];
+            try {
+                await this.executeBatchDelete(tableName, chunk, identifierColumn);
+                success.push(...chunk);
+                this.logProgress(opts, {
+                    total: identifiers.length,
+                    processed: success.length + failed.length,
+                    success: success.length,
+                    failed: failed.length,
+                    batchIndex,
+                    totalBatches,
+                });
+            }
+            catch (error) {
+                if (opts.stopOnError) {
+                    throw error;
+                }
+                // Fall back to individual deletes
+                for (const id of chunk) {
+                    try {
+                        await this.executeSingleDelete(tableName, { [identifierColumn]: id });
+                        success.push(id);
+                    }
+                    catch (individualError) {
+                        failed.push({ record: id, error: individualError });
+                    }
+                }
+                this.logProgress(opts, {
+                    total: identifiers.length,
+                    processed: success.length + failed.length,
+                    success: success.length,
+                    failed: failed.length,
+                    batchIndex,
+                    totalBatches,
+                });
+            }
+        }
+        return {
+            success,
+            failed,
+            total: identifiers.length,
+            chunkSize: opts.chunkSize,
+            batches: totalBatches,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Execute batch delete using IN clause
+     * Uses bound parameters with dialect-correct placeholders instead of
+     * interpolating escaped literals directly into the SQL string.
+     */
+    async executeBatchDelete(tableName, identifiers, identifierColumn) {
+        if (identifiers.length === 0)
+            return;
+        const quotedTable = this.dialect.quoteTable(tableName);
+        let paramIndex = 1;
+        const placeholders = identifiers.map(() => this.nextPlaceholder(paramIndex++));
+        const whereClause = `WHERE ${this.dialect.quoteIdentifier(identifierColumn)} IN (${placeholders.join(', ')})`;
+        const sql = `DELETE FROM ${quotedTable} ${whereClause}`;
+        await this.dialect.query(sql, { raw: true, replacements: identifiers });
+    }
+    /**
+     * Execute a single record delete
+     */
+    async executeSingleDelete(tableName, where) {
+        const { sql, values } = this.dialect.buildDeleteQuery(tableName, where);
+        await this.dialect.query(sql, { raw: true, replacements: values });
+    }
+    /**
+     * Check if error is a duplicate key error
+     */
+    isDuplicateKeyError(error) {
+        const errorMessage = error?.message?.toLowerCase() || '';
+        return (errorMessage.includes('duplicate') ||
+            errorMessage.includes('unique constraint') ||
+            errorMessage.includes('unique key'));
+    }
+    /**
+     * Chunk an array into smaller arrays
+     */
+    chunkArray(array, size) {
+        const chunks = [];
+        for (let i = 0; i < array.length; i += size) {
+            chunks.push(array.slice(i, i + size));
+        }
+        return chunks;
+    }
+    /**
+     * Log progress
+     */
+    logProgress(options, progress) {
+        if (options.logging) {
+            const percent = Math.round((progress.processed / progress.total) * 100);
+            options.logging(`Batch progress: ${progress.processed}/${progress.total} (${percent}%)`);
+        }
+        if (options.onProgress) {
+            options.onProgress(progress);
+        }
+    }
+}
+exports.BatchQueryOptimizer = BatchQueryOptimizer;
+/**
+ * Optimize a batch insert operation
+ */
+async function optimizeBatchInsert(dialect, tableName, records, options) {
+    const optimizer = new BatchQueryOptimizer(dialect, options);
+    return optimizer.optimizeBatchInsert(tableName, records, options);
+}
+/**
+ * Optimize a batch update operation
+ */
+async function optimizeBatchUpdate(dialect, tableName, records, identifierColumn, options) {
+    const optimizer = new BatchQueryOptimizer(dialect, options);
+    return optimizer.optimizeBatchUpdate(tableName, records, identifierColumn, options);
+}
+/**
+ * Optimize a batch delete operation
+ */
+async function optimizeBatchDelete(dialect, tableName, identifiers, identifierColumn, options) {
+    const optimizer = new BatchQueryOptimizer(dialect, options);
+    return optimizer.optimizeBatchDelete(tableName, identifiers, identifierColumn, options);
+}
+exports.default = {
+    BatchQueryOptimizer,
+    optimizeBatchInsert,
+    optimizeBatchUpdate,
+    optimizeBatchDelete,
+};