ts-prorm-orm 1.1.0

package/dist/query-builders/sql-compiler.js

@@ -0,0 +1,2040 @@
+"use strict";
+/**
+ * SQL Compiler
+ * Compiles query objects to SQL strings with parameter substitution
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqlCompiler = void 0;
+exports.jsonExtract = jsonExtract;
+exports.jsonExtractUnquote = jsonExtractUnquote;
+exports.jsonSet = jsonSet;
+exports.jsonInsert = jsonInsert;
+exports.jsonReplace = jsonReplace;
+exports.jsonRemove = jsonRemove;
+exports.jsonKeys = jsonKeys;
+exports.jsonLength = jsonLength;
+exports.jsonContains = jsonContains;
+exports.jsonSearch = jsonSearch;
+const operators_1 = require("../operators");
+/**
+ * Default compiler options
+ */
+const defaultOptions = {
+    parameterized: true,
+    paramChar: '?',
+    inlineValues: false,
+    pretty: false,
+};
+/**
+ * SQL Compiler class
+ * Compiles query objects to SQL strings with proper escaping
+ */
+class SqlCompiler {
+    constructor(dialect, options) {
+        this.dialect = dialect;
+        this.options = { ...defaultOptions, ...options };
+        this.fieldMapping = options?.fieldMapping;
+    }
+    /**
+     * Set the field mapping
+     */
+    setFieldMapping(fieldMapping) {
+        this.fieldMapping = fieldMapping;
+    }
+    /**
+     * Get the DB column name for an attribute
+     */
+    getColumnName(attributeName) {
+        if (!this.fieldMapping) {
+            return attributeName;
+        }
+        return this.fieldMapping.attributeToColumn[attributeName] || attributeName;
+    }
+    /**
+     * Get the attribute name for a DB column
+     */
+    getAttributeName(columnName) {
+        if (!this.fieldMapping) {
+            return columnName;
+        }
+        return this.fieldMapping.columnToAttribute[columnName] || columnName;
+    }
+    /**
+     * Set the dialect
+     */
+    setDialect(dialect) {
+        this.dialect = dialect;
+    }
+    /**
+     * Set compiler options
+     */
+    setOptions(options) {
+        this.options = { ...this.options, ...options };
+    }
+    /**
+     * Escape a value for use in SQL
+     */
+    escape(value) {
+        if (this.dialect) {
+            return this.dialect.escape(value);
+        }
+        // Default escaping if no dialect
+        if (value === null || value === undefined) {
+            return 'NULL';
+        }
+        if (typeof value === 'boolean') {
+            return value ? '1' : '0';
+        }
+        if (typeof value === 'number') {
+            return String(value);
+        }
+        if (value instanceof Date) {
+            return `'${value.toISOString()}'`;
+        }
+        if (Buffer.isBuffer(value)) {
+            return `X'${value.toString('hex')}'`;
+        }
+        if (typeof value === 'object') {
+            return `'${JSON.stringify(value).replace(/'/g, "''")}'`;
+        }
+        return `'${String(value).replace(/'/g, "''")}'`;
+    }
+    /**
+     * Escape an identifier (column, table name)
+     */
+    escapeId(identifier) {
+        const id = String(identifier ?? '');
+        if (this.dialect) {
+            return this.dialect.quoteIdentifier(id);
+        }
+        // Default quoting if no dialect
+        return `"${id.replace(/"/g, '""')}"`;
+    }
+    /**
+     * Convert an attribute expression to SQL
+     * Handles fn(), col(), literal(), and plain strings
+     * @param attr - The attribute value (string, FnExpression, ColExpression, LiteralExpression, or array)
+     * @param tableAlias - Optional table alias to prepend to column names
+     * @returns The SQL representation of the attribute
+     */
+    attributeToSql(attr, tableAlias) {
+        // Handle array format: [expression, alias] or [fn, args, alias] or [col, alias]
+        if (Array.isArray(attr)) {
+            const expr = attr[0];
+            const alias = attr[1];
+            const sqlExpr = this.attributeToSql(expr, tableAlias);
+            return alias ? `${sqlExpr} AS ${this.escapeId(alias)}` : sqlExpr;
+        }
+        // Handle FnExpression: { __type: 'fn', fn: 'COUNT', args: [...] }
+        if ((0, operators_1.isFnExpression)(attr)) {
+            const args = attr.args.map((arg) => this.attributeToSql(arg, tableAlias)).join(', ');
+            return `${attr.fn}(${args})`;
+        }
+        // Handle ColExpression: { __type: 'col', col: 'field' }
+        if ((0, operators_1.isColExpression)(attr)) {
+            const col = attr.col;
+            if (col.includes('.')) {
+                // Already has table prefix
+                return col
+                    .split('.')
+                    .map((part) => this.escapeId(part))
+                    .join('.');
+            }
+            return tableAlias ? `${this.escapeId(tableAlias)}.${this.escapeId(col)}` : this.escapeId(col);
+        }
+        // Handle LiteralExpression: { __type: 'literal', sql: '...' }
+        if ((0, operators_1.isLiteralExpression)(attr)) {
+            return attr.sql;
+        }
+        // Handle CastExpression: { __type: 'cast', value: ..., type: ... }
+        if ((0, operators_1.isCastExpression)(attr)) {
+            const value = this.attributeToSql(attr.value, tableAlias);
+            const castType = attr.type || 'TEXT';
+            return `CAST(${value} AS ${castType})`;
+        }
+        // Handle ExtractExpression: { __type: 'extract', field: ..., part: ... }
+        if ((0, operators_1.isExtractExpression)(attr)) {
+            const field = this.attributeToSql(attr.field, tableAlias);
+            const part = (attr.part || 'YEAR').toUpperCase();
+            return `EXTRACT(${part} FROM ${field})`;
+        }
+        // Handle ConvExpression: { __type: 'conv', value: ..., from: ..., to: ... }
+        if ((0, operators_1.isConvExpression)(attr)) {
+            const value = this.attributeToSql(attr.value, tableAlias);
+            const to = attr.to || 10;
+            if (attr.from) {
+                return `CONVERT(${value} USING ${to})`;
+            }
+            return `CONVERT(${value}, ${to})`;
+        }
+        // Handle plain string (column name or SQL expression)
+        if (typeof attr === 'string') {
+            // Check if it looks like a SQL function or expression
+            if (attr.includes('(') || attr.includes(' ')) {
+                // It's likely a SQL expression - check if it's a simple column name with table prefix
+                if (attr.includes('.')) {
+                    // Check if it's just a table.column reference
+                    const parts = attr.split('.');
+                    if (parts.length === 2 && !parts[1].includes('(')) {
+                        return `${this.escapeId(parts[0])}.${this.escapeId(parts[1])}`;
+                    }
+                }
+                // It's a complex expression - pass through as-is (literal)
+                return attr;
+            }
+            // Simple column name
+            return tableAlias
+                ? `${this.escapeId(tableAlias)}.${this.escapeId(attr)}`
+                : this.escapeId(attr);
+        }
+        // Fallback: convert to string
+        return String(attr);
+    }
+    /**
+     * Process an attribute value (which could be a column name, fn expression, col expression, or literal)
+     * into a SQL expression string
+     *
+     * @param attr - The attribute value to process
+     * @param tableAlias - Optional table alias to prefix column names with
+     * @returns The SQL expression string
+     */
+    processAttribute(attr, tableAlias) {
+        // Handle CAST expressions: CAST(value AS type)
+        if ((0, operators_1.isCastExpression)(attr)) {
+            const value = this.processAttribute(attr.value, tableAlias);
+            return `CAST(${value} AS ${attr.type})`;
+        }
+        // Handle EXTRACT expressions: EXTRACT(part FROM field)
+        if ((0, operators_1.isExtractExpression)(attr)) {
+            const field = this.processAttribute(attr.field, tableAlias);
+            // Uppercase the part for SQL standard
+            const part = attr.part.toUpperCase();
+            return `EXTRACT(${part} FROM ${field})`;
+        }
+        // Handle CONVERT expressions: CONVERT(value, type) or CONVERT(value USING charset)
+        if ((0, operators_1.isConvExpression)(attr)) {
+            const value = this.processAttribute(attr.value, tableAlias);
+            if (attr.from) {
+                // MySQL: CONVERT(value USING charset)
+                return `CONVERT(${value} USING ${attr.to})`;
+            }
+            else {
+                // MySQL: CONVERT(value, type)
+                return `CONVERT(${value}, ${attr.to})`;
+            }
+        }
+        // Handle function expressions: fn('COUNT', col('id'))
+        if ((0, operators_1.isFnExpression)(attr)) {
+            const args = attr.args.map((arg) => this.processAttribute(arg, tableAlias));
+            return `${attr.fn}(${args.join(', ')})`;
+        }
+        // Handle column expressions: col('id') or col('table.column')
+        if ((0, operators_1.isColExpression)(attr)) {
+            const col = attr.col;
+            if (col.includes('.')) {
+                // Already has table prefix, use as-is with escaping
+                return col
+                    .split('.')
+                    .map((part) => this.escapeId(part))
+                    .join('.');
+            }
+            // Add table alias if provided
+            return tableAlias ? `${this.escapeId(tableAlias)}.${this.escapeId(col)}` : this.escapeId(col);
+        }
+        // Handle literal expressions: literal('COUNT(*)')
+        if ((0, operators_1.isLiteralExpression)(attr)) {
+            return attr.sql;
+        }
+        // Handle plain string - could be a column name or a literal SQL expression
+        if (typeof attr === 'string') {
+            // Check if it looks like a literal SQL expression (contains parentheses or aggregate functions)
+            if (attr.includes('(') || attr.includes('*') || attr.includes(' ')) {
+                // Likely a literal SQL expression, use as-is
+                return attr;
+            }
+            // Treat as column name
+            return tableAlias
+                ? `${this.escapeId(tableAlias)}.${this.escapeId(attr)}`
+                : this.escapeId(attr);
+        }
+        // Handle other types (numbers, etc.)
+        if (typeof attr === 'number') {
+            return String(attr);
+        }
+        // Fallback: stringify
+        return String(attr);
+    }
+    /**
+     * Convert an attribute to SQL with optional alias
+     * Handles formats like:
+     * - 'columnName' -> "columnName"
+     * - ['columnName', 'alias'] -> "columnName" AS "alias"
+     * - [fn('COUNT', col('id')), 'count'] -> COUNT("id") AS "count"
+     * - ['COUNT(*)', 'count'] -> COUNT(*) AS "count"
+     *
+     * @param attr - The attribute (string or array with alias)
+     * @param tableAlias - Optional table alias
+     * @returns SQL fragment with optional alias
+     */
+    attributeToSqlWithAlias(attr, tableAlias) {
+        if (Array.isArray(attr)) {
+            // Array format: [expression, alias] or [fn, args, alias] (legacy)
+            if (attr.length === 2) {
+                const [expr, alias] = attr;
+                const sqlExpr = this.processAttribute(expr, tableAlias);
+                return `${sqlExpr} AS ${this.escapeId(alias)}`;
+            }
+            else if (attr.length === 3) {
+                // Legacy format: [fn, args, alias]
+                const [fnName, args, alias] = attr;
+                const processedArgs = Array.isArray(args)
+                    ? args.map((a) => this.processAttribute(a, tableAlias)).join(', ')
+                    : this.processAttribute(args, tableAlias);
+                return `${fnName.toUpperCase()}(${processedArgs}) AS ${this.escapeId(alias)}`;
+            }
+        }
+        // Simple string or expression
+        return this.processAttribute(attr, tableAlias);
+    }
+    /**
+     * Compile WHERE clause
+     */
+    compileWhere(where, options) {
+        const values = [];
+        const paramChar = options?.paramChar || this.options.paramChar || '?';
+        if (!where || Object.keys(where).length === 0) {
+            return { sql: '', values };
+        }
+        const sql = this.buildWhereClause(where, values, paramChar);
+        return { sql, values };
+    }
+    /**
+     * Build WHERE clause from WhereOptions
+     */
+    buildWhereClause(where, values, paramChar) {
+        if (!where)
+            return '';
+        // Handle logical operators ($and, $or, $not)
+        if ('$and' in where || '$or' in where || '$not' in where) {
+            return this.buildLogicalWhereClause(where, values, paramChar);
+        }
+        // Handle regular field conditions
+        const conditions = [];
+        for (const [key, value] of Object.entries(where)) {
+            if (key.startsWith('$'))
+                continue; // Skip logical operators
+            const condition = this.buildFieldCondition(key, value, values, paramChar);
+            if (condition) {
+                conditions.push(condition);
+            }
+        }
+        return conditions.join(' AND ');
+    }
+    /**
+     * Build logical WHERE clause (AND, OR, NOT)
+     */
+    buildLogicalWhereClause(where, values, paramChar) {
+        const parts = [];
+        if (where.$and && Array.isArray(where.$and)) {
+            const andParts = where.$and.map((cond) => {
+                if (typeof cond === 'object' && cond !== null) {
+                    return `(${this.buildWhereClause(cond, values, paramChar)})`;
+                }
+                return `${paramChar}`;
+            });
+            if (andParts.length > 0) {
+                parts.push(`(${andParts.join(' AND ')})`);
+            }
+        }
+        if (where.$or && Array.isArray(where.$or)) {
+            const orParts = where.$or.map((cond) => {
+                if (typeof cond === 'object' && cond !== null) {
+                    return `(${this.buildWhereClause(cond, values, paramChar)})`;
+                }
+                return `${paramChar}`;
+            });
+            if (orParts.length > 0) {
+                parts.push(`(${orParts.join(' OR ')})`);
+            }
+        }
+        if (where.$not) {
+            const notPart = this.buildWhereClause(where.$not, values, paramChar);
+            if (notPart) {
+                parts.push(`NOT (${notPart})`);
+            }
+        }
+        return parts.join(' AND ');
+    }
+    /**
+     * Build a single field condition
+     */
+    buildFieldCondition(key, value, values, paramChar) {
+        // Direct value (simple equality)
+        if (!value || typeof value !== 'object') {
+            values.push(value);
+            return `${this.escapeId(key)} = ${paramChar}`;
+        }
+        // Object with operators
+        const opValue = value;
+        // Handle $eq
+        if (opValue.$eq !== undefined) {
+            values.push(opValue.$eq);
+            return `${this.escapeId(key)} = ${paramChar}`;
+        }
+        // Handle $ne
+        if (opValue.$ne !== undefined) {
+            values.push(opValue.$ne);
+            return `${this.escapeId(key)} != ${paramChar}`;
+        }
+        // Handle $gt
+        if (opValue.$gt !== undefined) {
+            values.push(opValue.$gt);
+            return `${this.escapeId(key)} > ${paramChar}`;
+        }
+        // Handle $gte
+        if (opValue.$gte !== undefined) {
+            values.push(opValue.$gte);
+            return `${this.escapeId(key)} >= ${paramChar}`;
+        }
+        // Handle $lt
+        if (opValue.$lt !== undefined) {
+            values.push(opValue.$lt);
+            return `${this.escapeId(key)} < ${paramChar}`;
+        }
+        // Handle $lte
+        if (opValue.$lte !== undefined) {
+            values.push(opValue.$lte);
+            return `${this.escapeId(key)} <= ${paramChar}`;
+        }
+        // Handle $like
+        if (opValue.$like !== undefined) {
+            values.push(opValue.$like);
+            return `${this.escapeId(key)} LIKE ${paramChar}`;
+        }
+        // Handle $notLike
+        if (opValue.$notLike !== undefined) {
+            values.push(opValue.$notLike);
+            return `${this.escapeId(key)} NOT LIKE ${paramChar}`;
+        }
+        // Handle $iLike (case-insensitive like)
+        if (opValue.$iLike !== undefined) {
+            values.push(opValue.$iLike);
+            return `${this.escapeId(key)} LIKE ${paramChar}`; // Use dialect-specific for case-insensitive
+        }
+        // Handle $notILike
+        if (opValue.$notILike !== undefined) {
+            values.push(opValue.$notILike);
+            return `${this.escapeId(key)} NOT LIKE ${paramChar}`;
+        }
+        // Handle $startsWith - LIKE 'value%'
+        if (opValue.$startsWith !== undefined) {
+            values.push(opValue.$startsWith + '%');
+            return `${this.escapeId(key)} LIKE ${paramChar}`;
+        }
+        // Handle $notStartsWith - NOT LIKE 'value%'
+        if (opValue.$notStartsWith !== undefined) {
+            values.push(opValue.$notStartsWith + '%');
+            return `${this.escapeId(key)} NOT LIKE ${paramChar}`;
+        }
+        // Handle $endsWith - LIKE '%value'
+        if (opValue.$endsWith !== undefined) {
+            values.push('%' + opValue.$endsWith);
+            return `${this.escapeId(key)} LIKE ${paramChar}`;
+        }
+        // Handle $notEndsWith - NOT LIKE '%value'
+        if (opValue.$notEndsWith !== undefined) {
+            values.push('%' + opValue.$notEndsWith);
+            return `${this.escapeId(key)} NOT LIKE ${paramChar}`;
+        }
+        // Handle $substring - LIKE '%value%'
+        if (opValue.$substring !== undefined) {
+            values.push('%' + opValue.$substring + '%');
+            return `${this.escapeId(key)} LIKE ${paramChar}`;
+        }
+        // Handle $notSubstring - NOT LIKE '%value%'
+        if (opValue.$notSubstring !== undefined) {
+            values.push('%' + opValue.$notSubstring + '%');
+            return `${this.escapeId(key)} NOT LIKE ${paramChar}`;
+        }
+        // Handle $any - for array ANY queries (PostgreSQL)
+        if (opValue.$any !== undefined) {
+            const anyValues = Array.isArray(opValue.$any) ? opValue.$any : [opValue.$any];
+            values.push(anyValues);
+            return `${this.escapeId(key)} = ANY(${paramChar})`;
+        }
+        // Handle $all - for array ALL queries (PostgreSQL)
+        if (opValue.$all !== undefined) {
+            const allValues = Array.isArray(opValue.$all) ? opValue.$all : [opValue.$all];
+            values.push(allValues);
+            return `${this.escapeId(key)} = ALL(${paramChar})`;
+        }
+        // Handle $in
+        if (opValue.$in !== undefined) {
+            const inValues = Array.isArray(opValue.$in) ? opValue.$in : [opValue.$in];
+            values.push(...inValues);
+            const placeholders = inValues.map(() => paramChar).join(', ');
+            return `${this.escapeId(key)} IN (${placeholders})`;
+        }
+        // Handle $notIn
+        if (opValue.$notIn !== undefined) {
+            const notInValues = Array.isArray(opValue.$notIn) ? opValue.$notIn : [opValue.$notIn];
+            values.push(...notInValues);
+            const placeholders = notInValues.map(() => paramChar).join(', ');
+            return `${this.escapeId(key)} NOT IN (${placeholders})`;
+        }
+        // Handle $between
+        if (opValue.$between !== undefined) {
+            const between = opValue.$between;
+            if (Array.isArray(between) && between.length >= 2) {
+                values.push(between[0], between[1]);
+                return `${this.escapeId(key)} BETWEEN ${paramChar} AND ${paramChar}`;
+            }
+        }
+        // Handle $notBetween
+        if (opValue.$notBetween !== undefined) {
+            const notBetween = opValue.$notBetween;
+            if (Array.isArray(notBetween) && notBetween.length >= 2) {
+                values.push(notBetween[0], notBetween[1]);
+                return `${this.escapeId(key)} NOT BETWEEN ${paramChar} AND ${paramChar}`;
+            }
+        }
+        // Handle $isNull
+        if (opValue.$isNull !== undefined) {
+            if (opValue.$isNull) {
+                return `${this.escapeId(key)} IS NULL`;
+            }
+            return `${this.escapeId(key)} IS NOT NULL`;
+        }
+        // Handle $isNotNull (alias for $isNull: false)
+        if (opValue.$isNotNull !== undefined) {
+            if (opValue.$isNotNull) {
+                return `${this.escapeId(key)} IS NOT NULL`;
+            }
+            return `${this.escapeId(key)} IS NULL`;
+        }
+        // Handle $regexp
+        if (opValue.$regexp !== undefined) {
+            values.push(opValue.$regexp);
+            return `${this.escapeId(key)} REGEXP ${paramChar}`;
+        }
+        // Handle $notRegexp
+        if (opValue.$notRegexp !== undefined) {
+            values.push(opValue.$notRegexp);
+            return `${this.escapeId(key)} NOT REGEXP ${paramChar}`;
+        }
+        // Handle $iRegexp (case-insensitive regexp)
+        if (opValue.$iRegexp !== undefined) {
+            values.push(opValue.$iRegexp);
+            return `${this.escapeId(key)} REGEXP ${paramChar}`;
+        }
+        // Default: equality
+        values.push(value);
+        return `${this.escapeId(key)} = ${paramChar}`;
+    }
+    /**
+     * Compile ORDER BY clause
+     */
+    compileOrder(order) {
+        if (!order || (Array.isArray(order) && order.length === 0)) {
+            return '';
+        }
+        const orderArray = Array.isArray(order) ? order : [order];
+        const orderParts = [];
+        for (const item of orderArray) {
+            if (typeof item === 'string') {
+                orderParts.push(item);
+            }
+            else if (Array.isArray(item)) {
+                const [modelOrField, direction] = item;
+                if (typeof modelOrField === 'string') {
+                    const field = modelOrField.includes('.')
+                        ? modelOrField
+                            .split('.')
+                            .map((part) => this.escapeId(part))
+                            .join('.')
+                        : this.escapeId(modelOrField);
+                    orderParts.push(direction ? `${field} ${direction}` : field);
+                }
+                else if (modelOrField && typeof modelOrField === 'object') {
+                    // Handle object format: [{ model: ModelStatic, as?: string }, field]
+                    const modelInfo = modelOrField;
+                    const tableName = modelInfo.tableName || modelInfo.name || '';
+                    const fieldStr = direction || '';
+                    if (tableName && fieldStr) {
+                        orderParts.push(`${this.escapeId(tableName)}.${this.escapeId(fieldStr)}`);
+                    }
+                    else if (fieldStr) {
+                        orderParts.push(this.escapeId(fieldStr));
+                    }
+                }
+            }
+            else if (item && typeof item === 'object') {
+                // Handle object like { tableName: 'users', fieldName: 'name' }
+                const itemObj = item;
+                if (itemObj.tableName && itemObj.fieldName) {
+                    orderParts.push(`${this.escapeId(itemObj.tableName)}.${this.escapeId(itemObj.fieldName)}`);
+                }
+                else if (itemObj.fieldName) {
+                    orderParts.push(this.escapeId(itemObj.fieldName));
+                }
+            }
+        }
+        return orderParts.length > 0 ? `ORDER BY ${orderParts.join(', ')}` : '';
+    }
+    /**
+     * Compile LIMIT/OFFSET clause
+     * Handles SQLite which requires LIMIT when using OFFSET
+     */
+    compileLimitOffset(limit, offset) {
+        let sql = '';
+        // Check if we're using SQLite
+        const isSQLite = this.dialect?.name === 'sqlite';
+        if (limit !== undefined && limit !== null) {
+            const limitValue = Number(limit);
+            if (!isNaN(limitValue) && limitValue >= 0) {
+                sql += ` LIMIT ${limitValue}`;
+                if (offset !== undefined && offset !== null) {
+                    const offsetValue = Number(offset);
+                    if (!isNaN(offsetValue) && offsetValue >= 0) {
+                        sql += ` OFFSET ${offsetValue}`;
+                    }
+                }
+            }
+        }
+        else if (offset !== undefined && offset !== null) {
+            // If only offset is provided without limit
+            const offsetValue = Number(offset);
+            if (!isNaN(offsetValue) && offsetValue >= 0) {
+                if (isSQLite) {
+                    // SQLite requires LIMIT when using OFFSET
+                    // Use a very large limit to get all remaining rows
+                    sql += ` LIMIT 9223372036854775807 OFFSET ${offsetValue}`;
+                }
+                else {
+                    // Other databases allow OFFSET without LIMIT
+                    sql += ` OFFSET ${offsetValue}`;
+                }
+            }
+        }
+        return sql;
+    }
+    /**
+     * Compile GROUP BY clause
+     * Supports:
+     * - Plain strings: 'role', 'userId'
+     * - Arrays of strings: ['role', 'status']
+     * - col() expressions: col('role'), col('table.column')
+     * - fn() expressions: fn('UPPER', col('name'))
+     * - literal expressions: literal('YEAR(created_at)')
+     * - Array of mixed expressions
+     *
+     * @example
+     * group: 'role'
+     * group: ['role', 'status']
+     * group: col('role')
+     * group: [col('role'), fn('COUNT', col('id'))]
+     */
+    compileGroupBy(group, groupType, groupingSets) {
+        const hasGroupType = groupType && groupType !== 'none';
+        const hasGroupingSets = groupingSets && groupingSets.length > 0;
+        // If no group and no advanced features, return empty
+        if (!group && !hasGroupType && !hasGroupingSets)
+            return '';
+        // Build the base GROUP BY clause from the group parameter
+        let groupFields = [];
+        if (group) {
+            const groupArray = Array.isArray(group) ? group : [group];
+            groupFields = groupArray.map((field) => {
+                // Handle col() expressions: { __type: 'col', col: 'field' }
+                if ((0, operators_1.isColExpression)(field)) {
+                    const col = field.col;
+                    if (col.includes('.')) {
+                        return col
+                            .split('.')
+                            .map((part) => this.escapeId(part))
+                            .join('.');
+                    }
+                    return this.escapeId(col);
+                }
+                // Handle fn() expressions: { __type: 'fn', fn: 'UPPER', args: [...] }
+                if ((0, operators_1.isFnExpression)(field)) {
+                    const args = field.args.map((arg) => this.processAttribute(arg)).join(', ');
+                    return `${field.fn}(${args})`;
+                }
+                // Handle literal expressions: { __type: 'literal', sql: '...' }
+                if ((0, operators_1.isLiteralExpression)(field)) {
+                    return field.sql;
+                }
+                // Handle plain string - could be a column name or a literal SQL expression
+                if (typeof field === 'string') {
+                    // Check if it's a literal SQL expression (contains parentheses, aggregate functions, etc.)
+                    if (field.includes('(') || field.includes('*') || field.includes(' ')) {
+                        // It's likely a literal SQL expression, use as-is
+                        return field;
+                    }
+                    // Check for dot notation: table.column
+                    if (field.includes('.')) {
+                        return field
+                            .split('.')
+                            .map((part) => this.escapeId(part))
+                            .join('.');
+                    }
+                    // Simple column name - escape it
+                    return this.escapeId(field);
+                }
+                // Fallback: convert to string
+                return String(field);
+            });
+        }
+        // Handle GROUPING SETS
+        if (hasGroupingSets) {
+            const setsSql = groupingSets
+                .map((set) => {
+                if (set.length === 0) {
+                    return '()'; // Grand total
+                }
+                return `(${set.map((col) => this.escapeId(col)).join(', ')})`;
+            })
+                .join(', ');
+            return `GROUP BY GROUPING SETS(${setsSql})`;
+        }
+        // Handle ROLLUP
+        if (groupType === 'rollup') {
+            if (groupFields.length === 0) {
+                return 'GROUP BY ROLLUP()';
+            }
+            return `GROUP BY ROLLUP(${groupFields.join(', ')})`;
+        }
+        // Handle CUBE
+        if (groupType === 'cube') {
+            if (groupFields.length === 0) {
+                return 'GROUP BY CUBE()';
+            }
+            return `GROUP BY CUBE(${groupFields.join(', ')})`;
+        }
+        // Standard GROUP BY (no advanced features)
+        if (groupFields.length > 0) {
+            return `GROUP BY ${groupFields.join(', ')}`;
+        }
+        return '';
+    }
+    /**
+     * Compile Common Table Expression (CTE) clause
+     * Supports both regular WITH and WITH RECURSIVE
+     */
+    compileCTE(ctes) {
+        if (!ctes || ctes.length === 0) {
+            return '';
+        }
+        // Check if any CTE is recursive
+        const hasRecursive = ctes.some((cte) => cte.recursive);
+        const keyword = hasRecursive ? 'WITH RECURSIVE' : 'WITH';
+        const cteDefinitions = ctes
+            .map((cte) => {
+            const columnsPart = cte.columns && cte.columns.length > 0 ? `(${cte.columns.join(', ')})` : '';
+            return `${cte.name}${columnsPart} AS (${cte.query})`;
+        })
+            .join(', ');
+        return `${keyword} ${cteDefinitions}`;
+    }
+    /**
+     * Compile HAVING clause for aggregation filtering
+     * Similar to WHERE but specifically for aggregated results
+     * Supports all operators: Op.gt, Op.eq, Op.between, etc.
+     * Also supports direct aggregation functions: COUNT(), SUM(), AVG(), MAX(), MIN()
+     */
+    compileHaving(having, options) {
+        const values = [];
+        const paramChar = options?.paramChar || this.options.paramChar || '?';
+        if (!having || (typeof having === 'object' && Object.keys(having).length === 0)) {
+            return { sql: '', values };
+        }
+        // Handle special having formats
+        // Format: { $where: { $col: 'count', $gt: 5 } }
+        if (having.$where && having.$where.$col) {
+            const wherePart = having.$where;
+            const col = wherePart.$col;
+            const opKey = Object.keys(wherePart).find((k) => k.startsWith('$') && k !== '$col' && k !== '$where');
+            if (opKey) {
+                values.push(wherePart[opKey]);
+                const op = opKey.replace('$', '');
+                const opSql = this.getOperatorSql(op);
+                return { sql: `${this.escapeId(col)} ${opSql} ${paramChar}`, values };
+            }
+        }
+        // Standard having format: { count: { $gt: 5 } }
+        const sql = this.buildHavingClause(having, values, paramChar);
+        return { sql, values };
+    }
+    /**
+     * Get SQL operator from operator key
+     */
+    getOperatorSql(op) {
+        const operatorMap = {
+            eq: '=',
+            ne: '!=',
+            gt: '>',
+            gte: '>=',
+            lt: '<',
+            lte: '<=',
+            like: 'LIKE',
+            notLike: 'NOT LIKE',
+            iLike: 'ILIKE',
+            notILike: 'NOT ILIKE',
+            in: 'IN',
+            notIn: 'NOT IN',
+            between: 'BETWEEN',
+            notBetween: 'NOT BETWEEN',
+            isNull: 'IS NULL',
+            isNotNull: 'IS NOT NULL',
+            regexp: 'REGEXP',
+            notRegexp: 'NOT REGEXP',
+            startsWith: 'LIKE',
+            endsWith: 'LIKE',
+            substring: 'LIKE',
+        };
+        return operatorMap[op] || '=';
+    }
+    /**
+     * Build HAVING clause from having options
+     */
+    buildHavingClause(having, values, paramChar) {
+        if (!having)
+            return '';
+        // Handle logical operators ($and, $or, $not)
+        if ('$and' in having || '$or' in having || '$not' in having) {
+            return this.buildLogicalHavingClause(having, values, paramChar);
+        }
+        // Handle regular field conditions
+        const conditions = [];
+        for (const [key, value] of Object.entries(having)) {
+            if (key.startsWith('$'))
+                continue; // Skip logical operators
+            const condition = this.buildHavingCondition(key, value, values, paramChar);
+            if (condition) {
+                conditions.push(condition);
+            }
+        }
+        return conditions.join(' AND ');
+    }
+    /**
+     * Build logical HAVING clause (AND, OR, NOT)
+     */
+    buildLogicalHavingClause(having, values, paramChar) {
+        const parts = [];
+        if (having.$and && Array.isArray(having.$and)) {
+            const andParts = having.$and.map((cond) => {
+                if (typeof cond === 'object' && cond !== null) {
+                    return `(${this.buildHavingClause(cond, values, paramChar)})`;
+                }
+                return `${paramChar}`;
+            });
+            if (andParts.length > 0) {
+                parts.push(`(${andParts.join(' AND ')})`);
+            }
+        }
+        if (having.$or && Array.isArray(having.$or)) {
+            const orParts = having.$or.map((cond) => {
+                if (typeof cond === 'object' && cond !== null) {
+                    return `(${this.buildHavingClause(cond, values, paramChar)})`;
+                }
+                return `${paramChar}`;
+            });
+            if (orParts.length > 0) {
+                parts.push(`(${orParts.join(' OR ')})`);
+            }
+        }
+        if (having.$not) {
+            const notPart = this.buildHavingClause(having.$not, values, paramChar);
+            if (notPart) {
+                parts.push(`NOT (${notPart})`);
+            }
+        }
+        return parts.join(' AND ');
+    }
+    /**
+     * Build a single HAVING condition
+     */
+    buildHavingCondition(key, value, values, paramChar) {
+        // Direct value (simple equality)
+        if (!value || typeof value !== 'object') {
+            values.push(value);
+            return `${this.escapeId(key)} = ${paramChar}`;
+        }
+        // Object with operators
+        const opValue = value;
+        // Handle $eq
+        if (opValue.$eq !== undefined) {
+            values.push(opValue.$eq);
+            return `${this.escapeId(key)} = ${paramChar}`;
+        }
+        // Handle $ne
+        if (opValue.$ne !== undefined) {
+            values.push(opValue.$ne);
+            return `${this.escapeId(key)} != ${paramChar}`;
+        }
+        // Handle $gt
+        if (opValue.$gt !== undefined) {
+            values.push(opValue.$gt);
+            return `${this.escapeId(key)} > ${paramChar}`;
+        }
+        // Handle $gte
+        if (opValue.$gte !== undefined) {
+            values.push(opValue.$gte);
+            return `${this.escapeId(key)} >= ${paramChar}`;
+        }
+        // Handle $lt
+        if (opValue.$lt !== undefined) {
+            values.push(opValue.$lt);
+            return `${this.escapeId(key)} < ${paramChar}`;
+        }
+        // Handle $lte
+        if (opValue.$lte !== undefined) {
+            values.push(opValue.$lte);
+            return `${this.escapeId(key)} <= ${paramChar}`;
+        }
+        // Handle $like
+        if (opValue.$like !== undefined) {
+            values.push(opValue.$like);
+            return `${this.escapeId(key)} LIKE ${paramChar}`;
+        }
+        // Handle $notLike
+        if (opValue.$notLike !== undefined) {
+            values.push(opValue.$notLike);
+            return `${this.escapeId(key)} NOT LIKE ${paramChar}`;
+        }
+        // Handle $iLike (case-insensitive like)
+        if (opValue.$iLike !== undefined) {
+            values.push(opValue.$iLike);
+            return `${this.escapeId(key)} ILIKE ${paramChar}`;
+        }
+        // Handle $notILike
+        if (opValue.$notILike !== undefined) {
+            values.push(opValue.$notILike);
+            return `${this.escapeId(key)} NOT ILIKE ${paramChar}`;
+        }
+        // Handle $startsWith - LIKE 'value%'
+        if (opValue.$startsWith !== undefined) {
+            values.push(opValue.$startsWith + '%');
+            return `${this.escapeId(key)} LIKE ${paramChar}`;
+        }
+        // Handle $notStartsWith - NOT LIKE 'value%'
+        if (opValue.$notStartsWith !== undefined) {
+            values.push(opValue.$notStartsWith + '%');
+            return `${this.escapeId(key)} NOT LIKE ${paramChar}`;
+        }
+        // Handle $endsWith - LIKE '%value'
+        if (opValue.$endsWith !== undefined) {
+            values.push('%' + opValue.$endsWith);
+            return `${this.escapeId(key)} LIKE ${paramChar}`;
+        }
+        // Handle $notEndsWith - NOT LIKE '%value'
+        if (opValue.$notEndsWith !== undefined) {
+            values.push('%' + opValue.$notEndsWith);
+            return `${this.escapeId(key)} NOT LIKE ${paramChar}`;
+        }
+        // Handle $substring - LIKE '%value%'
+        if (opValue.$substring !== undefined) {
+            values.push('%' + opValue.$substring + '%');
+            return `${this.escapeId(key)} LIKE ${paramChar}`;
+        }
+        // Handle $notSubstring - NOT LIKE '%value%'
+        if (opValue.$notSubstring !== undefined) {
+            values.push('%' + opValue.$notSubstring + '%');
+            return `${this.escapeId(key)} NOT LIKE ${paramChar}`;
+        }
+        // Handle $in
+        if (opValue.$in !== undefined) {
+            const inValues = Array.isArray(opValue.$in) ? opValue.$in : [opValue.$in];
+            values.push(...inValues);
+            const placeholders = inValues.map(() => paramChar).join(', ');
+            return `${this.escapeId(key)} IN (${placeholders})`;
+        }
+        // Handle $notIn
+        if (opValue.$notIn !== undefined) {
+            const notInValues = Array.isArray(opValue.$notIn) ? opValue.$notIn : [opValue.$notIn];
+            values.push(...notInValues);
+            const placeholders = notInValues.map(() => paramChar).join(', ');
+            return `${this.escapeId(key)} NOT IN (${placeholders})`;
+        }
+        // Handle $between
+        if (opValue.$between !== undefined) {
+            const between = opValue.$between;
+            if (Array.isArray(between) && between.length >= 2) {
+                values.push(between[0], between[1]);
+                return `${this.escapeId(key)} BETWEEN ${paramChar} AND ${paramChar}`;
+            }
+        }
+        // Handle $notBetween
+        if (opValue.$notBetween !== undefined) {
+            const notBetween = opValue.$notBetween;
+            if (Array.isArray(notBetween) && notBetween.length >= 2) {
+                values.push(notBetween[0], notBetween[1]);
+                return `${this.escapeId(key)} NOT BETWEEN ${paramChar} AND ${paramChar}`;
+            }
+        }
+        // Handle $isNull
+        if (opValue.$isNull !== undefined) {
+            if (opValue.$isNull) {
+                return `${this.escapeId(key)} IS NULL`;
+            }
+            return `${this.escapeId(key)} IS NOT NULL`;
+        }
+        // Handle $isNotNull (alias for $isNull: false)
+        if (opValue.$isNotNull !== undefined) {
+            if (opValue.$isNotNull) {
+                return `${this.escapeId(key)} IS NOT NULL`;
+            }
+            return `${this.escapeId(key)} IS NULL`;
+        }
+        // Handle $regexp
+        if (opValue.$regexp !== undefined) {
+            values.push(opValue.$regexp);
+            return `${this.escapeId(key)} REGEXP ${paramChar}`;
+        }
+        // Handle $notRegexp
+        if (opValue.$notRegexp !== undefined) {
+            values.push(opValue.$notRegexp);
+            return `${this.escapeId(key)} NOT REGEXP ${paramChar}`;
+        }
+        // Default: equality
+        values.push(value);
+        return `${this.escapeId(key)} = ${paramChar}`;
+    }
+    /**
+     * Compile a full SELECT query
+     */
+    compileSelect(options) {
+        const values = [];
+        // Build JOIN clause with support for nested includes first (to get includes info)
+        let flattenedIncludes = [];
+        if (options.include && options.include.length > 0) {
+            flattenedIncludes = this.flattenIncludesForJoins(options.include, 'main');
+        }
+        // Build SELECT clause with proper column handling to avoid duplicates
+        let selectSql;
+        if (options.attributes) {
+            // Use explicit attributes from main table only (to avoid duplicates)
+            if (Array.isArray(options.attributes)) {
+                // Handle array of attributes with support for fn(), col(), literal() and aliases
+                selectSql = options.attributes.map((a) => this.attributeToSql(a, 'main')).join(', ');
+            }
+            else if (options.attributes.include) {
+                // Handle include/exclude format with function expression support
+                selectSql = options.attributes.include
+                    .map((a) => this.attributeToSql(a, 'main'))
+                    .join(', ');
+            }
+            else if (options.attributes.exclude) {
+                // For exclude, we need all columns from main table except excluded ones
+                selectSql = `* EXCEPT (${options.attributes.exclude.map((a) => this.escapeId(a)).join(', ')})`;
+            }
+            else {
+                selectSql = this.generateSelectColumns(options.tableName, 'main', options.attributes, flattenedIncludes);
+            }
+        }
+        else if (flattenedIncludes.length > 0) {
+            // When there are includes, use table aliases to avoid duplicate columns
+            selectSql = this.generateSelectColumns(options.tableName, 'main', undefined, flattenedIncludes);
+        }
+        else {
+            // Simple case: just select all from main table
+            selectSql = `${this.escapeId('main')}.*`;
+        }
+        // Build CTE clause if present
+        const cteClause = this.compileCTE(options.cte);
+        const ctePrefix = cteClause ? `${cteClause} ` : '';
+        let sql = `${ctePrefix}SELECT ${selectSql} FROM ${this.escapeId(options.tableName)} AS ${this.escapeId('main')}`;
+        // Collect anti-join subqueries for WHERE clause
+        const antiJoinSubqueries = [];
+        const antiJoinValues = [];
+        // Build JOIN clause with support for nested includes
+        for (const item of flattenedIncludes) {
+            // Skip anti-joins that use notExists or notIn patterns (they'll be handled in WHERE)
+            if (item.antiJoin && (item.antiJoinType === 'notExists' || item.antiJoinType === 'notIn')) {
+                // Build subquery for anti-join
+                const subquery = this.buildAntiJoinSubquery(item, options.tableName);
+                if (item.antiJoinType === 'notExists') {
+                    antiJoinSubqueries.push(`NOT EXISTS (${subquery.sql})`);
+                }
+                else {
+                    antiJoinSubqueries.push(`NOT IN (${subquery.sql})`);
+                }
+                antiJoinValues.push(...subquery.values);
+                continue;
+            }
+            let joinType;
+            if (item.joinType) {
+                switch (item.joinType) {
+                    case 'INNER':
+                        joinType = 'INNER JOIN';
+                        break;
+                    case 'LEFT':
+                        joinType = 'LEFT JOIN';
+                        break;
+                    case 'RIGHT':
+                        joinType = 'RIGHT JOIN';
+                        break;
+                    case 'FULL':
+                        joinType = 'FULL OUTER JOIN';
+                        break;
+                    case 'CROSS':
+                        joinType = 'CROSS JOIN';
+                        break;
+                    default:
+                        joinType = item.required ? 'INNER JOIN' : 'LEFT JOIN';
+                }
+            }
+            else {
+                joinType = item.required ? 'INNER JOIN' : 'LEFT JOIN';
+            }
+            // For anti-joins with leftJoinIsNull, always use LEFT JOIN
+            if (item.antiJoin && item.antiJoinType === 'leftJoinIsNull') {
+                joinType = 'LEFT JOIN';
+            }
+            // Handle LATERAL keyword
+            const lateralKeyword = item.lateral ? 'LATERAL ' : '';
+            sql += ` ${joinType} ${lateralKeyword}${this.escapeId(item.tableName)} ${this.escapeId(item.alias)}`;
+            // Add ON clause
+            if (item.on) {
+                const onClause = this.buildWhereClause(item.on, values, this.options.paramChar || '?');
+                if (onClause) {
+                    sql += ` ON ${onClause}`;
+                }
+            }
+            else if (item.parentAlias && item.foreignKey && item.targetKey) {
+                // Build implicit ON clause from foreign key
+                sql += ` ON ${this.escapeId(item.parentAlias)}.${this.escapeId(item.targetKey)} = ${this.escapeId(item.alias)}.${this.escapeId(item.foreignKey)}`;
+            }
+            // Add WHERE clause for the joined table if specified
+            if (item.where) {
+                const whereClause = this.compileWhere(item.where);
+                if (whereClause.sql) {
+                    sql += ` AND (${whereClause.sql})`;
+                    values.push(...whereClause.values);
+                }
+            }
+            // For leftJoinIsNull anti-join, add WHERE clause to check for NULL
+            if (item.antiJoin && item.antiJoinType === 'leftJoinIsNull') {
+                sql += ` AND ${this.escapeId(item.alias)}.${this.escapeId(item.targetKey || 'id')} IS NULL`;
+            }
+        }
+        // Build WHERE clause
+        const whereConditions = [];
+        const whereValues = [];
+        // Add user-provided where conditions
+        if (options.where) {
+            const whereClause = this.compileWhere(options.where);
+            if (whereClause.sql) {
+                whereConditions.push(whereClause.sql);
+                whereValues.push(...whereClause.values);
+            }
+        }
+        // Add anti-join subqueries (NOT EXISTS or NOT IN)
+        if (antiJoinSubqueries.length > 0) {
+            whereConditions.push(...antiJoinSubqueries);
+            whereValues.push(...antiJoinValues);
+        }
+        if (whereConditions.length > 0) {
+            sql += ` WHERE ${whereConditions.join(' AND ')}`;
+            values.push(...whereValues);
+        }
+        // Build GROUP BY clause
+        if (options.group || options.groupType || options.groupingSets) {
+            sql += ` ${this.compileGroupBy(options.group, options.groupType, options.groupingSets)}`;
+        }
+        // Handle PIVOT clause
+        if (options.pivot) {
+            const pivot = options.pivot;
+            const groupByColumns = options.group
+                ? Array.isArray(options.group)
+                    ? options.group
+                    : [options.group]
+                : [];
+            // Get unique pivot values if not provided
+            const pivotValues = options.pivotValues || [];
+            if (pivotValues.length > 0) {
+                // Build CASE WHEN expressions for each pivot value and aggregated column
+                const aggregatedColumns = [];
+                const pivotColumn = this.escapeId(pivot.on);
+                for (const [column, aggregateFn] of Object.entries(pivot.using)) {
+                    const aggFn = aggregateFn.toUpperCase();
+                    const escapedColumn = this.escapeId(column);
+                    for (const pivotValue of pivotValues) {
+                        const columnAlias = `${column}_${pivotValue}`.replace(/[^a-zA-Z0-9_]/g, '_');
+                        aggregatedColumns.push(`${aggFn}(CASE WHEN ${pivotColumn} = ${this.escape(pivotValue)} THEN ${escapedColumn} END) AS ${this.escapeId(columnAlias)}`);
+                    }
+                }
+                // Replace the select clause with pivot columns
+                const groupByCols = groupByColumns.map((g) => this.escapeId(g)).join(', ');
+                selectSql = groupByCols
+                    ? `${groupByCols}, ${aggregatedColumns.join(', ')}`
+                    : aggregatedColumns.join(', ');
+            }
+        }
+        // Handle UNPIVOT clause
+        if (options.unpivot) {
+            const unpivot = options.unpivot;
+            const unpivotColumns = unpivot.in.map((col) => this.escapeId(col));
+            const valueColumn = this.escapeId(unpivot.valueColumn);
+            const nameColumn = this.escapeId(unpivot.nameColumn);
+            // Build the VALUES clause for CROSS JOIN
+            const valuesClauses = [];
+            for (const col of unpivot.in) {
+                const escapedCol = this.escapeId(col);
+                valuesClauses.push(`(${this.escape(col)}, ${escapedCol})`);
+            }
+            // Replace the select clause with unpivot columns
+            const groupByCols = options.group
+                ? (Array.isArray(options.group) ? options.group : [options.group])
+                    .map((g) => this.escapeId(g))
+                    .join(', ')
+                : '';
+            selectSql = groupByCols
+                ? `${groupByCols}, t.${nameColumn}, t.${valueColumn}`
+                : `t.${nameColumn}, t.${valueColumn}`;
+            // Add CROSS JOIN with VALUES after the main table
+            sql = sql.replace(`FROM ${this.escapeId(options.tableName)} AS ${this.escapeId('main')}`, `FROM ${this.escapeId(options.tableName)} AS ${this.escapeId('main')} CROSS JOIN (VALUES ${valuesClauses.join(', ')}) AS t(${nameColumn}, ${valueColumn})`);
+        }
+        // Build HAVING clause
+        if (options.having) {
+            const havingClause = this.compileHaving(options.having);
+            if (havingClause.sql) {
+                sql += ` HAVING ${havingClause.sql}`;
+                values.push(...havingClause.values);
+            }
+        }
+        // Build ORDER BY clause
+        if (options.order) {
+            const orderClause = this.compileOrder(options.order);
+            if (orderClause) {
+                sql += ` ${orderClause}`;
+            }
+        }
+        // Build LIMIT/OFFSET clause
+        sql += this.compileLimitOffset(options.limit, options.offset);
+        return { sql, values };
+    }
+    /**
+     * Compile a PIVOT query - transform rows to columns
+     */
+    compilePivot(options) {
+        const values = [];
+        const { pivot, groupBy } = options;
+        // Get unique values from the pivot column
+        const pivotColumn = this.escapeId(pivot.on);
+        // Build the SELECT clause with pivot columns
+        const groupByColumns = Array.isArray(groupBy)
+            ? groupBy.map((g) => this.escapeId(g)).join(', ')
+            : this.escapeId(groupBy);
+        // Build CASE WHEN expressions for each aggregated column
+        const pivotColumns = [];
+        const pivotValues = new Set();
+        // We need to get unique values from the pivot column at query time
+        // This will be handled by the query-generator which will first query unique values
+        // Build aggregated columns using CASE WHEN
+        const aggregatedColumns = [];
+        for (const [column, aggregateFn] of Object.entries(pivot.using)) {
+            const aggFn = aggregateFn.toUpperCase();
+            const escapedColumn = this.escapeId(column);
+            // Generate column alias from the pivot column value
+            // The actual pivot values will be provided by the query-generator
+            aggregatedColumns.push(`${aggFn}(CASE WHEN ${pivotColumn} = ? THEN ${escapedColumn} END) AS ${this.escapeId(column)}`);
+            values.push(pivot.on); // Placeholder for the value - will be replaced
+        }
+        let sql = `SELECT ${groupByColumns}, ${aggregatedColumns.join(', ')} FROM ${this.escapeId(options.tableName)}`;
+        // Add WHERE clause
+        if (options.where) {
+            const whereClause = this.compileWhere(options.where);
+            if (whereClause.sql) {
+                sql += ` WHERE ${whereClause.sql}`;
+                values.push(...whereClause.values);
+            }
+        }
+        // Add GROUP BY clause
+        sql += ` GROUP BY ${groupByColumns}`;
+        // Add ORDER BY clause
+        if (options.order) {
+            const orderClause = this.compileOrder(options.order);
+            if (orderClause) {
+                sql += ` ORDER BY ${orderClause}`;
+            }
+        }
+        // Add LIMIT/OFFSET clause
+        sql += this.compileLimitOffset(options.limit, options.offset);
+        return { sql, values };
+    }
+    /**
+     * Compile a PIVOT query with specific pivot values (after they're resolved)
+     */
+    compilePivotWithValues(options) {
+        const values = [];
+        const { pivot, pivotValues: valuesToPivot, groupBy } = options;
+        // Get the pivot column
+        const pivotColumn = this.escapeId(pivot.on);
+        // Build GROUP BY clause
+        const groupByColumns = Array.isArray(groupBy)
+            ? groupBy.map((g) => this.escapeId(g)).join(', ')
+            : this.escapeId(groupBy);
+        // Build CASE WHEN expressions for each pivot value and aggregated column
+        const aggregatedColumns = [];
+        for (const [column, aggregateFn] of Object.entries(pivot.using)) {
+            const aggFn = aggregateFn.toUpperCase();
+            const escapedColumn = this.escapeId(column);
+            for (const pivotValue of valuesToPivot) {
+                const columnAlias = `${column}_${pivotValue}`.replace(/[^a-zA-Z0-9_]/g, '_');
+                aggregatedColumns.push(`${aggFn}(CASE WHEN ${pivotColumn} = ${this.escape(pivotValue)} THEN ${escapedColumn} END) AS ${this.escapeId(columnAlias)}`);
+            }
+        }
+        let sql = `SELECT ${groupByColumns}, ${aggregatedColumns.join(', ')} FROM ${this.escapeId(options.tableName)}`;
+        // Add WHERE clause
+        if (options.where) {
+            const whereClause = this.compileWhere(options.where);
+            if (whereClause.sql) {
+                sql += ` WHERE ${whereClause.sql}`;
+                values.push(...whereClause.values);
+            }
+        }
+        // Add GROUP BY clause
+        sql += ` GROUP BY ${groupByColumns}`;
+        // Add ORDER BY clause
+        if (options.order) {
+            const orderClause = this.compileOrder(options.order);
+            if (orderClause) {
+                sql += ` ORDER BY ${orderClause}`;
+            }
+        }
+        // Add LIMIT/OFFSET clause
+        sql += this.compileLimitOffset(options.limit, options.offset);
+        return { sql, values };
+    }
+    /**
+     * Compile an UNPIVOT query - transform columns to rows
+     */
+    compileUnpivot(options) {
+        const values = [];
+        const { unpivot } = options;
+        // Columns to keep (not unpivoted) - we'll assume all non-unpivot columns are kept
+        // For simplicity, we'll include all columns and let the user specify via attributes
+        const unpivotColumns = unpivot.in.map((col) => this.escapeId(col));
+        const valueColumn = this.escapeId(unpivot.valueColumn);
+        const nameColumn = this.escapeId(unpivot.nameColumn);
+        // Build the VALUES clause for CROSS JOIN
+        const valuesClauses = [];
+        for (const col of unpivot.in) {
+            const escapedCol = this.escapeId(col);
+            valuesClauses.push(`(${this.escape(col)}, ${escapedCol})`);
+        }
+        let sql = `SELECT t.${nameColumn}, t.${valueColumn} FROM ${this.escapeId(options.tableName)}`;
+        // Add WHERE clause
+        if (options.where) {
+            const whereClause = this.compileWhere(options.where);
+            if (whereClause.sql) {
+                sql += ` WHERE ${whereClause.sql}`;
+                values.push(...whereClause.values);
+            }
+        }
+        // Add CROSS JOIN with VALUES
+        sql += ` CROSS JOIN (VALUES ${valuesClauses.join(', ')}) AS t(${nameColumn}, ${valueColumn})`;
+        // Add ORDER BY clause
+        if (options.order) {
+            const orderClause = this.compileOrder(options.order);
+            if (orderClause) {
+                sql += ` ORDER BY ${orderClause}`;
+            }
+        }
+        // Add LIMIT/OFFSET clause
+        sql += this.compileLimitOffset(options.limit, options.offset);
+        return { sql, values };
+    }
+    /**
+     * Compile an INSERT query
+     */
+    compileInsert(options) {
+        // Map attribute names to column names using field mapping
+        const columns = Object.keys(options.values).map((attrName) => this.getColumnName(attrName));
+        const values = Object.values(options.values);
+        const placeholders = columns.map(() => '?').join(', ');
+        let sql = `INSERT INTO ${this.escapeId(options.tableName)} (${columns.map((c) => this.escapeId(c)).join(', ')}) VALUES (${placeholders})`;
+        // Add RETURNING clause for supported databases
+        if (options.returning) {
+            if (Array.isArray(options.returning)) {
+                // Map attribute names to column names for RETURNING
+                sql += ` RETURNING ${options.returning.map((r) => this.escapeId(this.getColumnName(r))).join(', ')}`;
+            }
+            else {
+                sql += ' RETURNING *';
+            }
+        }
+        return { sql, values };
+    }
+    /**
+     * Compile an UPDATE query
+     */
+    compileUpdate(options) {
+        const setClauses = [];
+        const values = [];
+        for (const [key, value] of Object.entries(options.values)) {
+            // Map attribute name to column name using field mapping
+            const columnName = this.getColumnName(key);
+            setClauses.push(`${this.escapeId(columnName)} = ?`);
+            values.push(value);
+        }
+        const whereClause = this.compileWhere(options.where);
+        let sql = `UPDATE ${this.escapeId(options.tableName)} SET ${setClauses.join(', ')}`;
+        if (whereClause.sql) {
+            sql += ` WHERE ${whereClause.sql}`;
+            values.push(...whereClause.values);
+        }
+        // Add RETURNING clause
+        if (options.returning) {
+            if (Array.isArray(options.returning)) {
+                // Map attribute names to column names for RETURNING
+                sql += ` RETURNING ${options.returning.map((r) => this.escapeId(this.getColumnName(r))).join(', ')}`;
+            }
+            else {
+                sql += ' RETURNING *';
+            }
+        }
+        return { sql, values };
+    }
+    /**
+     * Compile a DELETE query
+     */
+    compileDelete(options) {
+        const whereClause = this.compileWhere(options.where);
+        let sql = `DELETE FROM ${this.escapeId(options.tableName)}`;
+        if (whereClause.sql) {
+            sql += ` WHERE ${whereClause.sql}`;
+        }
+        if (options.limit !== undefined) {
+            sql += ` LIMIT ${options.limit}`;
+        }
+        // Add RETURNING clause
+        if (options.returning) {
+            if (Array.isArray(options.returning)) {
+                sql += ` RETURNING ${options.returning.map((r) => this.escapeId(r)).join(', ')}`;
+            }
+            else {
+                sql += ' RETURNING *';
+            }
+        }
+        return { sql, values: whereClause.values };
+    }
+    /**
+     * Compile a UNION/EXCEPT/INTERSECT query
+     * Supports combining multiple queries with UNION, UNION ALL, EXCEPT, or INTERSECT
+     */
+    compileUnion(options) {
+        const values = [];
+        // Compile main query
+        const mainResult = this.compileSelect({
+            tableName: options.main.tableName,
+            attributes: options.main.attributes,
+            where: options.main.where,
+            include: options.main.include,
+            order: options.main.order,
+            limit: options.main.limit,
+            offset: options.main.offset,
+        });
+        values.push(...mainResult.values);
+        // Compile union queries
+        const unionParts = [mainResult.sql];
+        for (const u of options.union) {
+            let unionSql = '';
+            // Determine the table to query
+            const tableName = u.tableName ||
+                (u.model
+                    ? u.model.tableName || u.model.name
+                    : 'unknown');
+            // Compile the union query
+            const unionResult = this.compileSelect({
+                tableName,
+                attributes: u.attributes,
+                where: u.where,
+                include: u.include,
+                order: u.order,
+                limit: u.limit,
+                offset: u.offset,
+            });
+            values.push(...unionResult.values);
+            // Add the union type
+            unionSql = `${u.type} ${unionResult.sql}`;
+            unionParts.push(unionSql);
+        }
+        // Combine all parts
+        let sql = unionParts.join(' ');
+        // Add ORDER BY for the combined result
+        if (options.order) {
+            const orderClause = this.compileOrder(options.order);
+            if (orderClause) {
+                sql += ` ${orderClause}`;
+            }
+        }
+        // Add LIMIT/OFFSET for the combined result
+        sql += this.compileLimitOffset(options.limit, options.offset);
+        return { sql, values };
+    }
+    /**
+     * Compile an EXCEPT query - returns rows from main query that don't exist in except query
+     */
+    compileExcept(mainQuery, exceptQuery, options) {
+        return this.compileUnion({
+            main: mainQuery,
+            union: [
+                {
+                    type: 'EXCEPT',
+                    tableName: exceptQuery.tableName,
+                    attributes: exceptQuery.attributes,
+                    where: exceptQuery.where,
+                    include: exceptQuery.include,
+                },
+            ],
+            order: options?.order,
+            limit: options?.limit,
+            offset: options?.offset,
+        });
+    }
+    /**
+     * Compile an INTERSECT query - returns rows that exist in both queries
+     */
+    compileIntersect(mainQuery, intersectQuery, options) {
+        return this.compileUnion({
+            main: mainQuery,
+            union: [
+                {
+                    type: 'INTERSECT',
+                    tableName: intersectQuery.tableName,
+                    attributes: intersectQuery.attributes,
+                    where: intersectQuery.where,
+                    include: intersectQuery.include,
+                },
+            ],
+            order: options?.order,
+            limit: options?.limit,
+            offset: options?.offset,
+        });
+    }
+    /**
+     * Format SQL for different dialects
+     */
+    formatForDialect(sql, dialect) {
+        switch (dialect) {
+            case 'mysql':
+                return this.formatForMySQL(sql);
+            case 'postgres':
+                return this.formatForPostgres(sql);
+            case 'sqlite':
+                return this.formatForSQLite(sql);
+            case 'mssql':
+                return this.formatForMSSQL(sql);
+            default:
+                return sql;
+        }
+    }
+    /**
+     * Format SQL for MySQL
+     */
+    formatForMySQL(sql) {
+        // MySQL uses backticks for identifiers
+        return sql.replace(/"([^"]+)"/g, '`$1`');
+    }
+    /**
+     * Format SQL for PostgreSQL
+     */
+    formatForPostgres(sql) {
+        // PostgreSQL uses double quotes
+        return sql;
+    }
+    /**
+     * Format SQL for SQLite
+     */
+    formatForSQLite(sql) {
+        // SQLite uses double quotes
+        return sql;
+    }
+    /**
+     * Format SQL for MSSQL
+     */
+    formatForMSSQL(sql) {
+        // MSSQL uses square brackets
+        return sql.replace(/"([^"]+)"/g, '[$1]');
+    }
+    /**
+     * Resolve the 'all' include option to actual include configurations
+     */
+    resolveAllInclude(include, parentAlias, depth) {
+        const result = [];
+        const model = include.model;
+        const associations = model?.associations || {};
+        for (const [assocName, association] of Object.entries(associations)) {
+            // If 'all' is a string, only include that specific association
+            if (typeof include.all === 'string' && include.all !== assocName) {
+                continue;
+            }
+            const assocModel = association.target;
+            const assocTableName = assocModel?.tableName || assocModel?.name || assocName;
+            // Build the include config for this association
+            const assocInclude = {
+                model: assocModel,
+                as: assocName,
+                where: include.where,
+                required: include.required,
+                attributes: include.attributes,
+                order: include.order,
+                limit: include.limit,
+                offset: include.offset,
+                duplicating: include.duplicating,
+            };
+            // Handle nested includes within 'all' - recursively process them
+            if (include.include && include.include.length > 0) {
+                assocInclude.include = this.resolveAllInclude({ all: true, include: include.include }, assocName, depth + 1);
+            }
+            result.push(assocInclude);
+        }
+        return result;
+    }
+    /**
+     * Flatten nested includes for proper JOIN ordering
+     * Returns a flat array of include objects with parent alias information
+     */
+    flattenIncludesForJoins(includes, parentAlias = 'main', depth = 0) {
+        const flattened = [];
+        for (const include of includes) {
+            // Handle 'all' option - include all associations or filter by name
+            if (include.all) {
+                const resolvedIncludes = this.resolveAllInclude(include, parentAlias, depth);
+                for (const resolved of resolvedIncludes) {
+                    const nested = this.flattenIncludesForJoins([resolved], parentAlias, depth);
+                    flattened.push(...nested);
+                }
+                continue;
+            }
+            const model = include.model;
+            const tableName = model?.tableName || model?.name || '';
+            const alias = include.as || tableName;
+            // Guess foreign key if not specified
+            let foreignKey = include.foreignKey;
+            if (!foreignKey) {
+                const modelName = model?.name || tableName;
+                foreignKey = `${modelName.charAt(0).toLowerCase() + modelName.slice(1)}Id`;
+            }
+            const targetKey = (include.targetKey || 'id');
+            // Check for anti-join
+            const isAntiJoin = include.antiJoin === true || include.exclude === true;
+            const antiJoinType = include.antiJoinType || 'leftJoinIsNull';
+            flattened.push({
+                tableName,
+                alias,
+                parentAlias,
+                required: include.required || false,
+                where: include.where,
+                on: include.on,
+                foreignKey,
+                targetKey,
+                depth,
+                joinType: include.joinType,
+                lateral: include.lateral,
+                antiJoin: isAntiJoin,
+                antiJoinType,
+                apply: include.apply,
+                lateralSubquery: include.lateralSubquery,
+            });
+            // Recursively process nested includes
+            if (include.include && include.include.length > 0) {
+                const nested = this.flattenIncludesForJoins(include.include, alias, depth + 1);
+                flattened.push(...nested);
+            }
+        }
+        return flattened;
+    }
+    /**
+     * Build anti-join subquery for NOT EXISTS or NOT IN patterns
+     */
+    buildAntiJoinSubquery(item, mainTableName) {
+        const values = [];
+        // Build the subquery
+        let subquery = `SELECT 1 FROM ${this.escapeId(item.tableName)} ${this.escapeId(item.alias)}`;
+        // Build ON clause to connect to main table
+        const onConditions = [];
+        if (item.on) {
+            const onClause = this.buildWhereClause(item.on, values, this.options.paramChar || '?');
+            if (onClause) {
+                onConditions.push(onClause);
+            }
+        }
+        else if (item.parentAlias && item.foreignKey && item.targetKey) {
+            onConditions.push(`${this.escapeId(item.parentAlias)}.${this.escapeId(item.targetKey)} = ${this.escapeId(item.alias)}.${this.escapeId(item.foreignKey)}`);
+        }
+        if (onConditions.length > 0) {
+            subquery += ` WHERE ${onConditions.join(' AND ')}`;
+        }
+        // Add WHERE clause for the joined table if specified
+        if (item.where) {
+            const whereClause = this.compileWhere(item.where);
+            if (whereClause.sql) {
+                subquery += ` AND (${whereClause.sql})`;
+                values.push(...whereClause.values);
+            }
+        }
+        return { sql: subquery, values };
+    }
+    /**
+     * Build lateral subquery for inline subqueries with LATERAL keyword
+     */
+    buildLateralSubquery(item, values) {
+        const subqueryModel = item.lateralSubquery.model;
+        const tableName = subqueryModel?.tableName || subqueryModel?.name || 'subquery';
+        const subqueryAlias = item.alias;
+        // Build SELECT clause for the subquery
+        let selectColumns = '*';
+        if (item.lateralSubquery.attributes) {
+            if (Array.isArray(item.lateralSubquery.attributes)) {
+                selectColumns = item.lateralSubquery.attributes
+                    .map((c) => this.escapeId(c))
+                    .join(', ');
+            }
+            else if (item.lateralSubquery.attributes.include) {
+                selectColumns = item.lateralSubquery.attributes.include
+                    .map((c) => this.escapeId(c))
+                    .join(', ');
+            }
+        }
+        // Build the subquery
+        let subquery = `SELECT ${selectColumns} FROM ${this.escapeId(tableName)}`;
+        // If there's a foreign key relationship, add ON clause to connect to parent
+        if (item.parentAlias && item.foreignKey && item.targetKey) {
+            subquery += ` ON ${this.escapeId(item.parentAlias)}.${this.escapeId(item.targetKey)} = ${this.escapeId(subqueryAlias)}.${this.escapeId(item.foreignKey)}`;
+        }
+        // Add WHERE clause if specified
+        if (item.lateralSubquery.where) {
+            const whereClause = this.compileWhere(item.lateralSubquery.where);
+            if (whereClause.sql) {
+                subquery += ` WHERE ${whereClause.sql}`;
+                values.push(...whereClause.values);
+            }
+        }
+        return subquery;
+    }
+    /**
+     * Generate column list with proper aliasing to avoid duplicates
+     */
+    generateSelectColumns(mainTableName, mainTableAlias, attributes, includes) {
+        // If explicit attributes are provided, use those
+        if (attributes) {
+            if (Array.isArray(attributes)) {
+                // Add table alias prefix to avoid duplicates
+                return attributes
+                    .map((a) => `${this.escapeId(mainTableAlias)}.${this.escapeId(a)}`)
+                    .join(', ');
+            }
+            else if (attributes.include) {
+                return attributes.include
+                    .map((a) => `${this.escapeId(mainTableAlias)}.${this.escapeId(a)}`)
+                    .join(', ');
+            }
+            else if (attributes.exclude) {
+                // For exclude, we need to get all columns and exclude specific ones
+                // This is database-specific; for now, return * with EXCEPT
+                return `* EXCEPT (${attributes.exclude.map((a) => this.escapeId(a)).join(', ')})`;
+            }
+        }
+        // Default: select all columns from main table with alias prefix
+        // and all columns from included tables with their aliases
+        const mainColumns = [`${this.escapeId(mainTableAlias)}.*`];
+        // Add columns from included tables to avoid duplicates
+        if (includes && includes.length > 0) {
+            for (const inc of includes) {
+                mainColumns.push(`${this.escapeId(inc.alias)}.*`);
+            }
+        }
+        return mainColumns.join(', ');
+    }
+    // ==================== Window Function Compilation ====================
+    /**
+     * Compile PARTITION BY clause
+     */
+    compilePartitionBy(partitionBy) {
+        if (!partitionBy) {
+            return '';
+        }
+        const partitions = Array.isArray(partitionBy) ? partitionBy : [partitionBy];
+        const partitionParts = partitions.map((part) => {
+            if (part.includes('.')) {
+                return part
+                    .split('.')
+                    .map((p) => this.escapeId(p))
+                    .join('.');
+            }
+            return this.escapeId(part);
+        });
+        return `PARTITION BY ${partitionParts.join(', ')}`;
+    }
+    /**
+     * Compile window frame specification
+     * Examples:
+     * - ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING
+     * - RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
+     * - GROUPS 2 PRECEDING AND CURRENT ROW
+     */
+    compileWindowFrame(windowFrame) {
+        if (!windowFrame) {
+            return '';
+        }
+        const { type, start, end } = windowFrame;
+        const frameType = type || 'ROWS';
+        let frameStart = '';
+        let frameEnd = '';
+        // Handle start bound
+        if (start !== undefined) {
+            frameStart = this.compileFrameBound(start);
+        }
+        else {
+            frameStart = 'UNBOUNDED PRECEDING';
+        }
+        // Handle end bound
+        if (end !== undefined) {
+            frameEnd = this.compileFrameBound(end);
+        }
+        else {
+            frameEnd = 'CURRENT ROW';
+        }
+        return `${frameType} BETWEEN ${frameStart} AND ${frameEnd}`;
+    }
+    /**
+     * Compile a single frame bound (start or end)
+     */
+    compileFrameBound(bound) {
+        if (bound === 0) {
+            return 'CURRENT ROW';
+        }
+        if (bound < 0) {
+            const absBound = Math.abs(bound);
+            return absBound === 1 ? '1 PRECEDING' : `${absBound} PRECEDING`;
+        }
+        // bound > 0
+        return bound === 1 ? '1 FOLLOWING' : `${bound} FOLLOWING`;
+    }
+    /**
+     * Compile lock options for row-level locking
+     * Supports NOWAIT and SKIP LOCKED for PostgreSQL and MySQL 8.0+
+     * @param lock - Lock options
+     * @param dialect - The database dialect
+     * @returns The compiled lock SQL clause
+     */
+    compileLockOptions(lock, dialect = 'postgres') {
+        if (!lock) {
+            return '';
+        }
+        let lockType;
+        let nowait = false;
+        let skipLocked = false;
+        // Extract lock configuration
+        if (lock === true) {
+            lockType = 'UPDATE';
+        }
+        else if (typeof lock === 'string') {
+            lockType = lock;
+        }
+        else if (typeof lock === 'object') {
+            lockType = lock.level || lock;
+            nowait = lock.nowait === true;
+            skipLocked = lock.skipLocked === true;
+        }
+        // Build base lock clause
+        let lockClause = '';
+        if (lockType === 'UPDATE' || lockType === 'UPDATE') {
+            lockClause = 'FOR UPDATE';
+        }
+        else if (lockType === 'SHARE') {
+            if (dialect === 'mysql') {
+                lockClause = 'LOCK IN SHARE MODE';
+            }
+            else {
+                lockClause = 'FOR SHARE';
+            }
+        }
+        else if (lockType === 'KEY SHARE') {
+            lockClause = 'FOR KEY SHARE';
+        }
+        // Add NOWAIT or SKIP LOCKED (PostgreSQL and MySQL 8.0+)
+        if (nowait && (dialect === 'postgres' || dialect === 'mysql')) {
+            lockClause += ' NOWAIT';
+        }
+        else if (skipLocked && (dialect === 'postgres' || dialect === 'mysql')) {
+            lockClause += ' SKIP LOCKED';
+        }
+        return lockClause;
+    }
+    /**
+     * Compile OVER clause with partition, order, and window frame
+     */
+    compileOverClause(options) {
+        const partitionClause = this.compilePartitionBy(options.partitionBy);
+        const orderClause = options.orderBy ? this.compileOrder(options.orderBy) : '';
+        const frameClause = this.compileWindowFrame(options.windowFrame);
+        const clauses = [];
+        if (partitionClause)
+            clauses.push(partitionClause);
+        if (orderClause)
+            clauses.push(orderClause.replace('ORDER BY ', ''));
+        if (frameClause)
+            clauses.push(frameClause);
+        if (clauses.length > 0) {
+            return `OVER (${clauses.join(' ')})`;
+        }
+        return 'OVER ()';
+    }
+    /**
+     * Compile a window function expression
+     * @param functionName - The window function name (ROW_NUMBER, RANK, etc.)
+     * @param args - Arguments to the window function
+     * @param options - Window function options
+     * @returns The compiled SQL expression
+     */
+    compileWindowFunction(functionName, args = [], options = {}) {
+        const argsSql = args.map((arg) => this.attributeToSql(arg)).join(', ');
+        const overClause = this.compileOverClause(options);
+        if (argsSql) {
+            return `${functionName}(${argsSql}) ${overClause}`;
+        }
+        return `${functionName}() ${overClause}`;
+    }
+    /**
+     * Pretty print SQL
+     */
+    prettyPrint(sql) {
+        const keywords = [
+            'SELECT',
+            'FROM',
+            'WHERE',
+            'AND',
+            'OR',
+            'JOIN',
+            'LEFT JOIN',
+            'RIGHT JOIN',
+            'INNER JOIN',
+            'ON',
+            'GROUP BY',
+            'HAVING',
+            'ORDER BY',
+            'LIMIT',
+            'OFFSET',
+            'INSERT INTO',
+            'VALUES',
+            'UPDATE',
+            'SET',
+            'DELETE FROM',
+            'RETURNING',
+        ];
+        let result = sql;
+        for (const keyword of keywords) {
+            const regex = new RegExp(`\\b${keyword}\\b`, 'gi');
+            result = result.replace(regex, keyword);
+        }
+        return result;
+    }
+}
+exports.SqlCompiler = SqlCompiler;
+// ==================== MySQL JSON Helper Functions ====================
+/**
+ * Generate MySQL JSON_EXTRACT function
+ * @param columnName - The column containing JSON data
+ * @param path - The JSON path (e.g., '$.key' or '$.array[0]')
+ */
+function jsonExtract(columnName, path) {
+    return `JSON_EXTRACT(\`${columnName}\`, '${path}')`;
+}
+/**
+ * Generate MySQL JSON_UNQUOTE(JSON_EXTRACT(...)) for unquoted values
+ * @param columnName - The column containing JSON data
+ * @param path - The JSON path (e.g., '$.key' or '$.array[0]')
+ */
+function jsonExtractUnquote(columnName, path) {
+    return `JSON_UNQUOTE(JSON_EXTRACT(\`${columnName}\`, '${path}'))`;
+}
+/**
+ * Generate MySQL JSON_SET function to set a value in JSON
+ * @param columnName - The column containing JSON data
+ * @param path - The JSON path
+ * @param value - The value to set (can be a column reference or literal)
+ * @param extraPaths - Additional paths and values to set
+ */
+function jsonSet(columnName, path, value, ...extraPaths) {
+    let sql = `JSON_SET(\`${columnName}\`, '${path}', ${value})`;
+    for (const [extraPath, extraValue] of extraPaths) {
+        sql = `JSON_SET(${sql}, '${extraPath}', ${extraValue})`;
+    }
+    return sql;
+}
+/**
+ * Generate MySQL JSON_INSERT function to insert a value in JSON
+ * @param columnName - The column containing JSON data
+ * @param path - The JSON path
+ * @param value - The value to insert
+ */
+function jsonInsert(columnName, path, value) {
+    return `JSON_INSERT(\`${columnName}\`, '${path}', ${value})`;
+}
+/**
+ * Generate MySQL JSON_REPLACE function to replace a value in JSON
+ * @param columnName - The column containing JSON data
+ * @param path - The JSON path
+ * @param value - The value to replace
+ */
+function jsonReplace(columnName, path, value) {
+    return `JSON_REPLACE(\`${columnName}\`, '${path}', ${value})`;
+}
+/**
+ * Generate MySQL JSON_REMOVE function to remove a value from JSON
+ * @param columnName - The column containing JSON data
+ * @param path - The JSON path to remove
+ */
+function jsonRemove(columnName, path) {
+    return `JSON_REMOVE(\`${columnName}\`, '${path}')`;
+}
+/**
+ * Generate MySQL JSON_KEYS function to get keys from JSON object
+ * @param columnName - The column containing JSON data
+ * @param path - Optional path to get keys from specific object
+ */
+function jsonKeys(columnName, path) {
+    if (path) {
+        return `JSON_KEYS(\`${columnName}\`, '${path}')`;
+    }
+    return `JSON_KEYS(\`${columnName}\`)`;
+}
+/**
+ * Generate MySQL JSON_LENGTH function to get length of JSON array/object
+ * @param columnName - The column containing JSON data
+ * @param path - Optional path to get length of specific array/object
+ */
+function jsonLength(columnName, path) {
+    if (path) {
+        return `JSON_LENGTH(\`${columnName}\`, '${path}')`;
+    }
+    return `JSON_LENGTH(\`${columnName}\`)`;
+}
+/**
+ * Generate MySQL JSON_CONTAINS function to check if JSON contains a value
+ * @param columnName - The column containing JSON data
+ * @param value - The value to check for
+ * @param path - The path to check at
+ */
+function jsonContains(columnName, value, path) {
+    return `JSON_CONTAINS(\`${columnName}\`, ${value}, '${path}')`;
+}
+/**
+ * Generate MySQL JSON_SEARCH function for full-text search in JSON
+ * @param columnName - The column containing JSON data
+ * @param searchString - The string to search for
+ * @param escapeChar - Optional escape character
+ * @param path - Optional path to search within
+ */
+function jsonSearch(columnName, searchString, escapeChar, path) {
+    const searchArg = `'${searchString}'`;
+    const escapeArg = escapeChar ? `, '${escapeChar}'` : '';
+    const pathArg = path ? `, '${path}'` : '';
+    return `JSON_SEARCH(\`${columnName}\`${escapeArg}, 'one', ${searchArg}${pathArg})`;
+}
+exports.default = SqlCompiler;