@undefineds.co/drizzle-solid 0.2.10 → 0.2.13

package/dist/esm/core/query-builders/select-query-builder.js

@@ -1,10 +1,12 @@
 var _a;
 import { entityKind, SQL } from 'drizzle-orm';
-import { PodColumnBase } from '../schema';
+import { PodTable, PodColumnBase } from '../schema';
 import { inArray } from '../query-conditions';
 import { isAggregateExpression } from '../aggregates';
-import { createLiteralCondition, buildConditionTreeFromObject } from './helpers';
+import { createLiteralCondition, buildConditionTreeFromObject, inferSPARQLQueryType } from './helpers';
 import { UriResolverImpl } from '../uri';
+import { isOrderByExpression } from '../order-by';
+import { SelectionAliasExpression } from '../expressions';
 export class SelectQueryBuilder {
     constructor(session, fields) {
         this.session = session;
@@ -129,17 +131,35 @@ export class SelectQueryBuilder {
     fullJoin(table, condition) {
         return this.addJoin('fullJoin', table, condition);
     }
+    crossJoin(table) {
+        return this.addJoin('crossJoin', table);
+    }
     groupBy(...fields) {
         const refs = fields.map((field) => this.resolveColumnReference(field));
         this.groupByColumns.push(...refs);
         return this;
     }
+    having(condition) {
+        this.havingCondition = typeof condition === 'function'
+            ? condition(this.createSelectedFieldAliases())
+            : condition;
+        return this;
+    }
+    createSelectedFieldAliases() {
+        const aliases = {};
+        for (const alias of Object.keys(this.selectedFields ?? {})) {
+            aliases[alias] = new SelectionAliasExpression(alias);
+        }
+        return aliases;
+    }
     addJoin(type, table, condition) {
         if (type === 'rightJoin' || type === 'fullJoin') {
             throw new Error(`${type} is not yet supported in Solid dialect`);
         }
         const alias = this.ensureAliasForTable(table);
-        const resolvedConditions = this.resolveJoinConditions(condition, alias);
+        const resolvedConditions = type === 'crossJoin'
+            ? undefined
+            : this.resolveJoinConditions(condition, alias);
         this.joins.push({
             type,
             table,
@@ -164,8 +184,11 @@ export class SelectQueryBuilder {
         return alias;
     }
     resolveJoinConditions(condition, joinAlias) {
+        if (this.isQueryCondition(condition)) {
+            return this.resolveJoinConditionExpression(condition, joinAlias);
+        }
         if (!condition || typeof condition !== 'object') {
-            throw new Error('JOIN condition must be an object mapping columns');
+            throw new Error('JOIN condition must be an equality expression or column mapping');
         }
         const entries = Object.entries(condition);
         if (entries.length === 0) {
@@ -180,6 +203,44 @@ export class SelectQueryBuilder {
             return { left: leftRef, right: rightRef };
         });
     }
+    resolveJoinConditionExpression(condition, joinAlias) {
+        if (condition.type === 'logical_expr') {
+            const operator = (condition.operator ?? '').toUpperCase();
+            const expressions = (condition.expressions ?? []);
+            if (operator !== 'AND' || expressions.length === 0) {
+                throw new Error('JOIN condition only supports equality expressions combined with AND');
+            }
+            return expressions.flatMap((expression) => this.resolveJoinConditionExpression(expression, joinAlias));
+        }
+        if (condition.type !== 'binary_expr' || condition.operator !== '=') {
+            throw new Error('JOIN condition only supports equality expressions');
+        }
+        const leftRef = this.getConditionColumnReference(condition.left);
+        const rightRef = this.getConditionColumnReference(condition.right);
+        if (!leftRef || !rightRef) {
+            throw new Error('JOIN equality must compare two table columns');
+        }
+        if (leftRef.alias !== joinAlias && rightRef.alias !== joinAlias) {
+            throw new Error('JOIN condition must reference the joined table in at least one side');
+        }
+        return [{ left: leftRef, right: rightRef }];
+    }
+    getConditionColumnReference(field, fallbackAlias) {
+        if (field instanceof PodColumnBase) {
+            return this.resolveColumnReference(field, fallbackAlias);
+        }
+        if (typeof field === 'string') {
+            if (field.includes('.')) {
+                return this.resolveColumnReference(field, fallbackAlias);
+            }
+            const alias = fallbackAlias ?? this.primaryAlias;
+            const table = alias ? this.aliasToTable.get(alias) : undefined;
+            if (table && field in (table.columns ?? {})) {
+                return this.resolveColumnReference(field, fallbackAlias);
+            }
+        }
+        return undefined;
+    }
     resolveColumnReference(field, fallbackAlias) {
         if (field instanceof PodColumnBase) {
             const table = field.table;
@@ -274,6 +335,7 @@ export class SelectQueryBuilder {
             joins: planJoins.length > 0 ? planJoins : undefined,
             joinFilters: this.joinFilters.length > 0 ? [...this.joinFilters] : undefined,
             groupBy: this.groupByColumns.length > 0 ? [...this.groupByColumns] : undefined,
+            having: this.havingCondition,
             orderBy: this.orderByClauses.length > 0
                 ? this.orderByClauses.map((clause) => ({
                     rawColumn: clause.column,
@@ -301,49 +363,115 @@ export class SelectQueryBuilder {
         this.offsetCount = count;
         return this;
     }
-    orderBy(column, direction = 'asc') {
+    addOrderByClause(column, direction = 'asc') {
         const columnName = typeof column === 'string' ? column : column.name;
         if (!columnName) {
             throw new Error('ORDER BY requires a valid column name');
         }
         this.orderByClauses.push({ column: columnName, direction });
+    }
+    orderBy(...args) {
+        if (args.length === 0) {
+            throw new Error('ORDER BY requires at least one column or expression');
+        }
+        if (args.length === 2
+            && (args[0] instanceof PodColumnBase || typeof args[0] === 'string')
+            && (args[1] === 'asc' || args[1] === 'desc')) {
+            this.addOrderByClause(args[0], args[1]);
+            return this;
+        }
+        for (const arg of args) {
+            if (isOrderByExpression(arg)) {
+                this.addOrderByClause(arg.column, arg.direction);
+                continue;
+            }
+            if (arg instanceof PodColumnBase || typeof arg === 'string') {
+                this.addOrderByClause(arg, 'asc');
+                continue;
+            }
+            throw new Error('ORDER BY received an unsupported argument');
+        }
         return this;
     }
     distinct(enable = true) {
         this.isDistinct = enable;
         return this;
     }
+    buildSPARQLQuery(methodName = 'toSPARQL()') {
+        if (this.sql) {
+            const query = this.sql.queryChunks.join('');
+            const type = inferSPARQLQueryType(query);
+            if (!type) {
+                throw new Error(`${methodName} could not infer SPARQL query type from raw AST input`);
+            }
+            return { type, query, prefixes: {} };
+        }
+        if (!this.selectedTable) {
+            throw new Error('No table specified for SELECT query');
+        }
+        if (this.joins.length > 0) {
+            throw new Error(`${methodName} is not yet supported for JOIN queries in Solid dialect`);
+        }
+        if (this.shouldUseProjectionFallback()) {
+            throw new Error(`${methodName} does not support structured selections in Solid dialect`);
+        }
+        const converter = this.session.getDialect().getSPARQLConverter?.();
+        if (!converter) {
+            throw new Error(`${methodName} requires dialect SPARQL converter support`);
+        }
+        return converter.convertSelectPlan(this.toIR());
+    }
+    toSPARQL() {
+        return this.buildSPARQLQuery('toSPARQL()');
+    }
+    toSparql() {
+        return this.toSPARQL();
+    }
     async execute() {
         if (!this.selectedTable) {
             throw new Error('No table specified for SELECT query');
         }
+        if (this.limitCount === 0) {
+            return [];
+        }
         if (this.sql) {
             return await this.session.executeSql(this.sql, this.selectedTable);
         }
         else {
             const plan = this.toIR();
             const wherePayload = plan.conditionTree;
+            const hasJoins = this.joins.length > 0;
+            const useAggregateFallback = this.shouldUseAggregateFallback();
+            const useProjectionFallback = this.shouldUseProjectionFallback();
+            const shouldDeferQueryModifiers = hasJoins || useAggregateFallback;
+            if (hasJoins || useAggregateFallback || useProjectionFallback) {
+                plan.select = undefined;
+                plan.selectAll = true;
+            }
+            const executionPlan = shouldDeferQueryModifiers
+                ? {
+                    ...plan,
+                    limit: undefined,
+                    offset: undefined,
+                    orderBy: undefined,
+                    ...(useAggregateFallback ? { groupBy: undefined, having: undefined } : {}),
+                }
+                : plan;
             const operation = {
                 type: 'select',
                 table: this.selectedTable,
                 where: wherePayload,
-                limit: this.limitCount,
-                offset: this.offsetCount,
-                orderBy: this.orderByClauses.length > 0 ? this.orderByClauses : undefined,
+                limit: shouldDeferQueryModifiers ? undefined : this.limitCount,
+                offset: shouldDeferQueryModifiers ? undefined : this.offsetCount,
+                orderBy: shouldDeferQueryModifiers || this.orderByClauses.length === 0 ? undefined : this.orderByClauses,
                 distinct: this.isDistinct || undefined
             };
-            const hasJoins = this.joins.length > 0;
-            const useAggregateFallback = this.shouldUseAggregateFallback();
-            if (hasJoins || useAggregateFallback) {
-                plan.select = undefined;
-                plan.selectAll = true;
-            }
-            operation.plan = plan;
+            operation.plan = executionPlan;
             if (this.groupByColumns.length === 0 && this.hasMixedAggregateSelection()) {
                 throw new Error('Mixed aggregate and non-aggregate selections require groupBy columns');
             }
             let intermediateRows;
-            if (!hasJoins && !useAggregateFallback) {
+            if (!hasJoins && !useAggregateFallback && !useProjectionFallback) {
                 if (this.selectedFields) {
                     operation.select = this.selectedFields;
                 }
@@ -354,7 +482,7 @@ export class SelectQueryBuilder {
                 if (hasJoins) {
                     operation.select = undefined;
                 }
-                else if (!useAggregateFallback) {
+                else if (!useAggregateFallback && !useProjectionFallback) {
                     operation.select = this.selectedFields;
                 }
                 else {
@@ -371,51 +499,141 @@ export class SelectQueryBuilder {
                 }
             }
             if (useAggregateFallback) {
-                return this.handleAggregateFallback(intermediateRows);
+                let aggregateRows = this.handleAggregateFallback(intermediateRows);
+                aggregateRows = this.applyHavingFilter(aggregateRows);
+                if (shouldDeferQueryModifiers) {
+                    aggregateRows = this.applyDeferredOrderBy(aggregateRows);
+                    aggregateRows = this.applyDeferredOffsetAndLimit(aggregateRows);
+                }
+                return aggregateRows;
             }
             let finalRows = intermediateRows;
             if (!hasJoins) {
                 finalRows = this.mergeRowsBySubject(finalRows);
             }
             if (this.selectedTable) {
-                finalRows = await this.hydrateInlineColumns(finalRows, this.selectedTable);
+                finalRows = await this.hydrateInlineColumns(finalRows, this.selectedTable, !hasJoins);
                 // 处理引用字段：将 URI 转换回 ID
                 finalRows = this.resolveReferenceIds(finalRows, this.selectedTable);
             }
+            if (hasJoins) {
+                finalRows = this.applyDeferredOrderBy(finalRows);
+            }
             if (this.selectedFields) {
                 finalRows = finalRows.map((row) => this.projectSelectedRow(row));
             }
-            finalRows = this.mergeRowsBySubject(finalRows);
+            finalRows = this.applyDistinctRows(finalRows);
+            if (!hasJoins) {
+                finalRows = this.mergeRowsBySubject(finalRows);
+            }
+            if (hasJoins) {
+                finalRows = this.applyDeferredOffsetAndLimit(finalRows);
+            }
             return finalRows;
         }
     }
     projectSelectedRow(row) {
-        const projected = {};
         if (!this.selectedFields) {
             return row;
         }
-        for (const key of Object.keys(this.selectedFields)) {
-            const field = this.selectedFields[key];
-            if (isAggregateExpression(field)) {
-                projected[key] = row[key];
-                continue;
-            }
-            let assigned = false;
-            for (const candidate of this.resolveFieldBindingCandidates(key, field)) {
-                if (row[candidate] !== undefined) {
-                    projected[key] = row[candidate];
-                    assigned = true;
-                    break;
+        return this.projectFieldMap(row, this.selectedFields);
+    }
+    projectFieldMap(row, fields, allowAliasFallback = true) {
+        const projected = {};
+        for (const [key, field] of Object.entries(fields)) {
+            projected[key] = this.projectFieldValue(row, key, field, allowAliasFallback);
+        }
+        return projected;
+    }
+    projectFieldValue(row, alias, field, allowAliasFallback = true) {
+        if (isAggregateExpression(field)) {
+            return allowAliasFallback ? row[alias] : undefined;
+        }
+        if (field instanceof PodTable) {
+            return this.projectTableValue(row, field);
+        }
+        if (this.isSelectFieldMap(field)) {
+            const aliases = this.collectSelectionAliases(field);
+            const isJoinedOnlySelection = aliases.size === 1 && !aliases.has(this.primaryAlias ?? '');
+            const projected = this.projectFieldMap(row, field, !isJoinedOnlySelection);
+            if (aliases.size === 1) {
+                const [targetAlias] = Array.from(aliases);
+                if (targetAlias && targetAlias !== this.primaryAlias && this.isProjectedValueEmpty(projected)) {
+                    return null;
                 }
             }
-            if (!assigned) {
-                projected[key] = row[key];
+            return projected;
+        }
+        for (const candidate of this.resolveFieldBindingCandidates(alias, field)) {
+            if (row[candidate] !== undefined) {
+                return row[candidate];
             }
         }
+        return allowAliasFallback ? row[alias] : undefined;
+    }
+    projectTableValue(row, table) {
+        const alias = this.tableAliases.get(table) ?? table.config.name;
+        const projected = {};
+        let hasValue = false;
+        for (const columnName of Object.keys(table.columns)) {
+            const candidates = alias === this.primaryAlias
+                ? [columnName, `${alias}.${columnName}`]
+                : [`${alias}.${columnName}`];
+            const match = candidates.find((candidate) => row[candidate] !== undefined);
+            projected[columnName] = match ? row[match] : undefined;
+            if (projected[columnName] !== undefined) {
+                hasValue = true;
+            }
+        }
+        if (alias !== this.primaryAlias && !hasValue) {
+            return null;
+        }
         return projected;
     }
+    isSelectFieldMap(field) {
+        return !!field
+            && typeof field === 'object'
+            && !(field instanceof PodColumnBase)
+            && !(field instanceof PodTable)
+            && !isAggregateExpression(field);
+    }
+    collectSelectionAliases(field) {
+        if (typeof field === 'string') {
+            const { alias } = this.parseColumnReferenceString(field);
+            return new Set(alias ? [alias] : this.primaryAlias ? [this.primaryAlias] : []);
+        }
+        if (field instanceof PodColumnBase) {
+            return new Set([this.resolveColumnReference(field).alias]);
+        }
+        if (field instanceof PodTable) {
+            return new Set([this.tableAliases.get(field) ?? field.config.name]);
+        }
+        if (!this.isSelectFieldMap(field)) {
+            return new Set();
+        }
+        const aliases = new Set();
+        for (const child of Object.values(field)) {
+            for (const alias of this.collectSelectionAliases(child)) {
+                aliases.add(alias);
+            }
+        }
+        return aliases;
+    }
+    isProjectedValueEmpty(value) {
+        if (value === undefined || value === null) {
+            return true;
+        }
+        if (Array.isArray(value)) {
+            return value.length === 0;
+        }
+        if (typeof value === 'object') {
+            const entries = Object.values(value);
+            return entries.length > 0 && entries.every((entry) => this.isProjectedValueEmpty(entry));
+        }
+        return false;
+    }
     resolveFieldBindingCandidates(alias, field) {
-        const candidates = new Set([alias]);
+        const candidates = new Set();
         if (typeof field === 'string') {
             const { alias: refAlias, column } = this.parseColumnReferenceString(field);
             candidates.add(field);
@@ -426,8 +644,10 @@ export class SelectQueryBuilder {
         }
         else if (field instanceof PodColumnBase) {
             const columnRef = this.resolveColumnReference(field);
-            candidates.add(field.name);
             candidates.add(`${columnRef.alias}.${columnRef.column}`);
+            if (!columnRef.alias || columnRef.alias === this.primaryAlias) {
+                candidates.add(field.name);
+            }
         }
         else if (field && typeof field === 'object') {
             const candidateName = field.name;
@@ -437,13 +657,31 @@ export class SelectQueryBuilder {
         }
         return Array.from(candidates);
     }
+    shouldUseProjectionFallback() {
+        if (!this.selectedFields) {
+            return false;
+        }
+        const containsStructuredField = (field) => {
+            if (field instanceof PodTable) {
+                return true;
+            }
+            if (this.isSelectFieldMap(field)) {
+                return true;
+            }
+            return false;
+        };
+        return Object.values(this.selectedFields).some((field) => containsStructuredField(field));
+    }
     shouldUseAggregateFallback() {
-        // GROUP BY is handled at SPARQL level (both LDP/Comunica and SPARQL endpoint support it)
+        if (this.havingCondition) {
+            return true;
+        }
+        if (this.joins.length > 0) {
+            return this.groupByColumns.length > 0 || this.hasAggregateSelection();
+        }
         if (this.groupByColumns.length > 0) {
             return false;
         }
-        // For pure aggregate queries (no GROUP BY), Comunica seems to have issues with multiple aggregates
-        // So we use JS fallback for these cases
         if (!this.selectedFields) {
             return false;
         }
@@ -654,6 +892,12 @@ export class SelectQueryBuilder {
         }
         return undefined;
     }
+    hasAggregateSelection() {
+        if (!this.selectedFields) {
+            return false;
+        }
+        return Object.values(this.selectedFields).some((field) => isAggregateExpression(field));
+    }
     hasMixedAggregateSelection() {
         if (!this.selectedFields) {
             return false;
@@ -718,15 +962,17 @@ export class SelectQueryBuilder {
             return result;
         });
     }
-    async hydrateInlineColumns(rows, table) {
+    async hydrateInlineColumns(rows, table, mergeRows = true) {
         if (!rows.length) {
             return rows;
         }
-        rows = this.mergeRowsBySubject(rows);
         const inlineColumns = Object.values(table.columns ?? {}).filter((col) => this.isInlineObjectColumn(col));
         if (inlineColumns.length === 0) {
             return rows;
         }
+        if (mergeRows) {
+            rows = this.mergeRowsBySubject(rows);
+        }
         const predicateToColumn = new Map();
         inlineColumns.forEach((col) => {
             const predicate = col.getPredicate(table.config.namespace);
@@ -779,7 +1025,7 @@ export class SelectQueryBuilder {
             if (!childIri || !pred)
                 return;
             const child = childMap.get(childIri) ?? { '@id': childIri, id: this.extractIdFromSubject(childIri, table) };
-            const key = inlineNamespace && pred.startsWith(inlineNamespace) ? pred.slice(inlineNamespace.length) : pred;
+            const key = this.normalizeInlinePredicateKey(pred, inlineNamespace);
             if (obj === undefined) {
                 childMap.set(childIri, child);
                 return;
@@ -865,6 +1111,20 @@ export class SelectQueryBuilder {
             return result;
         });
     }
+    normalizeInlinePredicateKey(predicate, inlineNamespace) {
+        if (inlineNamespace && predicate.startsWith(inlineNamespace)) {
+            return predicate.slice(inlineNamespace.length);
+        }
+        const hashIndex = predicate.lastIndexOf('#');
+        if (hashIndex !== -1 && hashIndex < predicate.length - 1) {
+            return predicate.slice(hashIndex + 1);
+        }
+        const slashIndex = predicate.lastIndexOf('/');
+        if (slashIndex !== -1 && slashIndex < predicate.length - 1) {
+            return predicate.slice(slashIndex + 1);
+        }
+        return predicate;
+    }
     normalizeInlineObjectValue(value) {
         if (value === null || value === undefined)
             return undefined;
@@ -887,6 +1147,73 @@ export class SelectQueryBuilder {
             return value.value;
         return undefined;
     }
+    applyDeferredOrderBy(rows) {
+        if (this.orderByClauses.length === 0 || rows.length < 2) {
+            return rows;
+        }
+        const sorted = [...rows];
+        sorted.sort((leftRow, rightRow) => {
+            for (const clause of this.orderByClauses) {
+                const leftValue = this.getOrderByValue(leftRow, clause.column);
+                const rightValue = this.getOrderByValue(rightRow, clause.column);
+                const comparison = this.compareOrderByValues(leftValue, rightValue);
+                if (comparison !== 0) {
+                    return clause.direction === 'desc' ? -comparison : comparison;
+                }
+            }
+            return 0;
+        });
+        return sorted;
+    }
+    applyDistinctRows(rows) {
+        if (!this.isDistinct || rows.length < 2) {
+            return rows;
+        }
+        const seen = new Set();
+        const deduped = [];
+        for (const row of rows) {
+            const key = this.serializeValueForKey(row);
+            if (seen.has(key)) {
+                continue;
+            }
+            seen.add(key);
+            deduped.push(row);
+        }
+        return deduped;
+    }
+    applyDeferredOffsetAndLimit(rows) {
+        const offset = this.offsetCount ?? 0;
+        const offsetRows = offset > 0 ? rows.slice(offset) : rows;
+        if (this.limitCount === undefined) {
+            return offsetRows;
+        }
+        return offsetRows.slice(0, this.limitCount);
+    }
+    getOrderByValue(row, columnName) {
+        if (columnName in row) {
+            return row[columnName];
+        }
+        const aliasKey = Object.keys(row).find((key) => key.endsWith(`.${columnName}`));
+        if (aliasKey) {
+            return row[aliasKey];
+        }
+        return undefined;
+    }
+    compareOrderByValues(left, right) {
+        if (left === right) {
+            return 0;
+        }
+        if (left === undefined || left === null) {
+            return 1;
+        }
+        if (right === undefined || right === null) {
+            return -1;
+        }
+        if (typeof left === 'number' && typeof right === 'number') {
+            return left - right;
+        }
+        return String(left).localeCompare(String(right));
+    }
     mergeRowsBySubject(rows) {
         const merged = new Map();
         const order = [];
@@ -984,11 +1311,11 @@ export class SelectQueryBuilder {
     isInlineObjectColumn(column) {
         if (!column)
             return false;
-        if (column.dataType === 'object')
+        if (column.dataType === 'object' || column.dataType === 'json')
             return true;
         if (column.dataType === 'array') {
             const elementType = column.elementType ?? column.options?.baseType;
-            return elementType === 'object';
+            return elementType === 'object' || elementType === 'json';
         }
         return false;
     }
@@ -1001,6 +1328,10 @@ export class SelectQueryBuilder {
         return combinedRows;
     }
     async fetchJoinRows(join, baseRows) {
+        if (join.type === 'crossJoin') {
+            const joinRows = await this.session.select().from(join.table);
+            return this.normalizeJoinRows(join, joinRows);
+        }
         const conditions = join.resolvedConditions ?? [];
         if (conditions.length === 0) {
             return [];
@@ -1054,6 +1385,18 @@ export class SelectQueryBuilder {
         });
     }
     mergeRowsWithJoin(baseRows, join, joinRows) {
+        if (join.type === 'crossJoin') {
+            if (baseRows.length === 0 || joinRows.length === 0) {
+                return [];
+            }
+            const merged = [];
+            for (const baseRow of baseRows) {
+                for (const joinRow of joinRows) {
+                    merged.push({ ...baseRow, ...joinRow });
+                }
+            }
+            return merged;
+        }
         const conditions = join.resolvedConditions ?? [];
         if (conditions.length === 0) {
             return baseRows;
@@ -1106,6 +1449,12 @@ export class SelectQueryBuilder {
         }
         return rows.filter((row) => this.joinFilters.every((condition) => this.evaluateCondition(row, condition)));
     }
+    applyHavingFilter(rows) {
+        if (!this.havingCondition) {
+            return rows;
+        }
+        return rows.filter((row) => this.evaluateCondition(row, this.havingCondition));
+    }
     evaluateCondition(row, condition) {
         switch (condition.type) {
             case 'binary_expr':
@@ -1125,27 +1474,8 @@ export class SelectQueryBuilder {
         if (!left) {
             return true;
         }
-        // Extract column name and table alias from left
-        let colName;
-        let tableAlias;
-        if (typeof left === 'string') {
-            if (left.includes('.')) {
-                [tableAlias, colName] = left.split('.');
-            }
-            else {
-                colName = left;
-            }
-        }
-        else if (left && typeof left === 'object') {
-            colName = left.name;
-            tableAlias = left.table;
-        }
-        else {
-            return true;
-        }
-        const columnRef = this.resolveColumnReference(`${tableAlias ?? this.primaryAlias}.${colName}`);
-        const value = this.getRowValueForColumn(row, columnRef);
-        const target = right;
+        const value = this.resolveConditionOperandValue(row, left, this.primaryAlias);
+        const target = this.resolveConditionOperandValue(row, right);
         switch (op.toUpperCase()) {
             case '=':
                 return value === target;
@@ -1173,33 +1503,13 @@ export class SelectQueryBuilder {
     evaluateUnaryCondition(row, condition) {
         const op = condition.operator;
         const val = condition.value;
-        // For NOT operator, value is another condition
         if (op.toUpperCase() === 'NOT') {
             return !this.evaluateCondition(row, val);
         }
-        // For IS NULL / IS NOT NULL, value is the column reference
         if (!val) {
             return true;
         }
-        let colName;
-        let tableAlias;
-        if (typeof val === 'string') {
-            if (val.includes('.')) {
-                [tableAlias, colName] = val.split('.');
-            }
-            else {
-                colName = val;
-            }
-        }
-        else if (val && typeof val === 'object' && 'name' in val) {
-            colName = val.name;
-            tableAlias = val.table;
-        }
-        else {
-            return true;
-        }
-        const columnRef = this.resolveColumnReference(`${tableAlias ?? this.primaryAlias}.${colName}`);
-        const rowValue = this.getRowValueForColumn(row, columnRef);
+        const rowValue = this.resolveConditionOperandValue(row, val, this.primaryAlias);
         switch (op.toUpperCase()) {
             case 'IS NULL':
                 return rowValue === null || rowValue === undefined;
@@ -1220,6 +1530,16 @@ export class SelectQueryBuilder {
         }
         return true;
     }
+    resolveConditionOperandValue(row, operand, fallbackAlias) {
+        if (operand instanceof SelectionAliasExpression) {
+            return row[operand.alias];
+        }
+        const columnRef = this.getConditionColumnReference(operand, fallbackAlias);
+        if (columnRef) {
+            return this.getRowValueForColumn(row, columnRef);
+        }
+        return operand;
+    }
     getColumnKeyCandidates(column) {
         const candidates = [];
         const baseAlias = this.primaryAlias;