linkgress-orm 0.4.76 → 0.4.79

package/dist/query/query-builder.js

@@ -4,6 +4,7 @@ exports.CollectionQueryBuilder = exports.ReferenceQueryBuilder = exports.SelectQ
 exports.getColumnNameMapForSchema = getColumnNameMapForSchema;
 exports.getRelationEntriesForSchema = getRelationEntriesForSchema;
 exports.getSchemaColumnMeta = getSchemaColumnMeta;
+exports.getDbToPropertyMapForSchema = getDbToPropertyMapForSchema;
 exports.getTargetSchemaForRelation = getTargetSchemaForRelation;
 exports.createNestedFieldRefProxy = createNestedFieldRefProxy;
 const conditions_1 = require("./conditions");
@@ -81,6 +82,23 @@ function getSchemaColumnMeta(schema) {
     }
     return meta;
 }
+/**
+ * Reverse of the column-name map — db column name → property name — cached per schema.
+ * An ordered collection needs it on every build to render the alias form of its ORDER BY;
+ * rebuilding it walked every column of the schema per build.
+ */
+const schemaDbToPropertyMapCache = new WeakMap();
+function getDbToPropertyMapForSchema(schema) {
+    let map = schemaDbToPropertyMapCache.get(schema);
+    if (map == null) {
+        map = new Map();
+        for (const [propName, meta] of getSchemaColumnMeta(schema)) {
+            map.set(meta.name, propName);
+        }
+        schemaDbToPropertyMapCache.set(schema, map);
+    }
+    return map;
+}
 /**
  * Mock-row descriptor cache for {@link ReferenceQueryBuilder.createMockTargetRow}.
  *
@@ -103,6 +121,13 @@ const MOCK_ROW_CHAIN_ID = Symbol('linkgressMockChainId');
 const navigationPathSignature = (path) => path
     .map(step => `${step.alias}:${step.targetTable}:${(step.foreignKeys ?? []).join('+')}:${(step.matches ?? []).join('+')}:${step.isMandatory ? 1 : 0}:${step.sourceAlias ?? ''}`)
     .join('>');
+/** A reference mock row: `Object.create(prototype)` plus its two own state slots. */
+const mintReferenceMockRow = (prototype) => {
+    const mock = Object.create(prototype);
+    mock[MOCK_ROW_FIELD_REFS] = {};
+    mock[MOCK_ROW_NAV_CACHE] = {};
+    return mock;
+};
 /**
  * Whether `value` is a mock row minted by the query builders (`createMockTargetRow`,
  * `SelectQueryBuilder._createMockRow`, `CollectionQueryBuilder.createMockItem`). Every
@@ -470,13 +495,25 @@ class QueryBuilder {
                 // Single reference navigation (many-to-one, one-to-one)
                 // Non-enumerable to prevent Object.entries triggering getters (avoids stack overflow
                 // with circular relations like User->Posts->User)
+                const holder = {};
                 descriptors[relName] = {
-                    get: () => {
+                    get() {
+                        // One mock target row per row and relation (a selector reading `p.user.*` several
+                        // times used to mint a builder and a row per access)
+                        const slots = this;
+                        const navCache = slots[MOCK_ROW_NAV_CACHE] ?? (slots[MOCK_ROW_NAV_CACHE] = {});
+                        const cachedRow = navCache[relName];
+                        if (cachedRow !== undefined) {
+                            return cachedRow;
+                        }
+                        if (holder.prototype !== undefined && mock_row_cache_1.MockRowCache.isEnabled()) {
+                            return (navCache[relName] = mintReferenceMockRow(holder.prototype));
+                        }
                         const refBuilder = new ReferenceQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKeys || [relConfig.foreignKey || ''], relConfig.matches || [], relConfig.isMandatory ?? false, targetSchema, schemaRegistry, // Pass schema registry for nested navigation resolution
                         [], // Empty navigation path for first level navigation
                         sourceTableName // Pass source table name for lateral join correlation
                         );
-                        return refBuilder.createMockTargetRow();
+                        return (navCache[relName] = refBuilder.createMockTargetRow(holder));
                     },
                     enumerable: false,
                     configurable: true,
@@ -632,12 +669,20 @@ class QueryBuilder {
                 // Single reference navigation
                 // Non-enumerable to prevent Object.entries triggering getters (avoids stack overflow)
                 Object.defineProperty(mock, relName, {
-                    get: () => {
+                    get() {
+                        // One mock target row per row and relation (a selector reading `p.user.*` several
+                        // times used to mint a builder and a row per access)
+                        const slots = this;
+                        const navCache = slots[MOCK_ROW_NAV_CACHE] ?? (slots[MOCK_ROW_NAV_CACHE] = {});
+                        const cachedRow = navCache[relName];
+                        if (cachedRow !== undefined) {
+                            return cachedRow;
+                        }
                         const refBuilder = new ReferenceQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKeys || [relConfig.foreignKey || ''], relConfig.matches || [], relConfig.isMandatory ?? false, targetSchema, this.schemaRegistry, // Pass schema registry for nested navigation resolution
                         [], // Empty navigation path for first level navigation
                         schema.name // Pass source table name for lateral join correlation
                         );
-                        return refBuilder.createMockTargetRow();
+                        return (navCache[relName] = refBuilder.createMockTargetRow());
                     },
                     enumerable: false,
                     configurable: true,
@@ -1188,12 +1233,20 @@ class SelectQueryBuilder {
                 // Single reference navigation
                 // Non-enumerable to prevent Object.entries triggering getters (avoids stack overflow)
                 Object.defineProperty(mock, relName, {
-                    get: () => {
+                    get() {
+                        // One mock target row per row and relation (a selector reading `p.user.*` several
+                        // times used to mint a builder and a row per access)
+                        const slots = this;
+                        const navCache = slots[MOCK_ROW_NAV_CACHE] ?? (slots[MOCK_ROW_NAV_CACHE] = {});
+                        const cachedRow = navCache[relName];
+                        if (cachedRow !== undefined) {
+                            return cachedRow;
+                        }
                         const refBuilder = new ReferenceQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKeys || [relConfig.foreignKey || ''], relConfig.matches || [], relConfig.isMandatory ?? false, targetSchema, this.schemaRegistry, // Pass schema registry for nested navigation resolution
                         [], // Empty navigation path for first level navigation
                         schema.name // Pass source table name for lateral join correlation
                         );
-                        return refBuilder.createMockTargetRow();
+                        return (navCache[relName] = refBuilder.createMockTargetRow());
                     },
                     enumerable: false,
                     configurable: true,
@@ -3646,15 +3699,27 @@ ${joinClauses.join('\n')}`;
             else {
                 // For single reference (many-to-one), create a ReferenceQueryBuilder
                 // Non-enumerable to prevent Object.entries triggering getters (avoids stack overflow)
+                const holder = {};
                 descriptors[relName] = {
-                    get: () => {
+                    get() {
+                        // One mock target row per row and relation (a selector reading `p.user.*` several
+                        // times used to mint a builder and a row per access)
+                        const slots = this;
+                        const navCache = slots[MOCK_ROW_NAV_CACHE] ?? (slots[MOCK_ROW_NAV_CACHE] = {});
+                        const cachedRow = navCache[relName];
+                        if (cachedRow !== undefined) {
+                            return cachedRow;
+                        }
+                        if (holder.prototype !== undefined && mock_row_cache_1.MockRowCache.isEnabled()) {
+                            return (navCache[relName] = mintReferenceMockRow(holder.prototype));
+                        }
                         const refBuilder = new ReferenceQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKeys || [relConfig.foreignKey || ''], relConfig.matches || [], relConfig.isMandatory ?? false, targetSchema, // Pass the target schema directly
                         schemaRegistry, // Pass schema registry for nested resolution
                         [], // Empty navigation path for first level navigation
                         sourceTableName // Pass source table name for lateral join correlation
                         );
                         // Return a mock object that exposes the target table's columns
-                        return refBuilder.createMockTargetRow();
+                        return (navCache[relName] = refBuilder.createMockTargetRow(holder));
                     },
                     enumerable: false,
                     configurable: true,
@@ -4204,7 +4269,11 @@ ${joinClauses.join('\n')}`;
         }
         else {
             // Process selection object properties
-            for (const [key, value] of Object.entries(selection)) {
+            for (const key in selection) {
+                if (!Object.prototype.hasOwnProperty.call(selection, key)) {
+                    continue;
+                }
+                const value = selection[key];
                 if (value instanceof CollectionQueryBuilder || (value && typeof value === 'object' && '__collectionResult' in value)) {
                     // Handle collection - delegate to strategy pattern via buildCTE
                     // The strategy handles CTE/LATERAL specifics and returns necessary info
@@ -4678,7 +4747,11 @@ ${joinClauses.join('\n')}`;
             //   - collections hit an explicit `continue` and were never emitted.
             // Both regressions are now covered by union-nested-select.test.ts and
             // union-collection-nav.test.ts.
-            for (const [key, value] of Object.entries(selection)) {
+            for (const key in selection) {
+                if (!Object.prototype.hasOwnProperty.call(selection, key)) {
+                    continue;
+                }
+                const value = selection[key];
                 if (value instanceof CollectionQueryBuilder || (value && typeof value === 'object' && '__collectionResult' in value)) {
                     // Collection projection inside a UNION leg — delegate to the
                     // collection strategy (LATERAL by default) and emit per-row
@@ -5828,7 +5901,7 @@ class ReferenceQueryBuilder {
      * Create a mock object that exposes the target table's columns
      * This allows accessing related fields like: p.user.username
      */
-    createMockTargetRow() {
+    createMockTargetRow(holder) {
         if (this.targetTableSchema) {
             // Prototype-level cache — see MockRowCache's doc. Everything the getters close over
             // is fully determined by (target schema object identity, relationName, sourceAlias,
@@ -5844,11 +5917,18 @@ class ReferenceQueryBuilder {
             // Consumers must not probe these rows with OWN-property APIs (`Object.keys`,
             // `getOwnPropertyNames`, `getOwnPropertyDescriptor` on the row itself) — the getters
             // are inherited. Use `isReferenceMockRow` / `findFirstGetterKey` instead.
-            const prototype = mock_row_cache_1.MockRowCache.getOrBuild(`${this.targetTable}|${this.relationName}|${this.sourceAlias ?? ''}|${navigationPathSignature(this.navigationPath)}`, () => Object.defineProperties({}, this.buildMockRowDescriptors()));
-            const mock = Object.create(prototype);
-            mock[MOCK_ROW_FIELD_REFS] = {};
-            mock[MOCK_ROW_NAV_CACHE] = {};
-            return mock;
+            //
+            // The getter that minted this builder may hand in its MockPrototypeHolder: a filled holder
+            // short-circuits the key build and the lookup, and a miss fills it (switch on only).
+            const enabled = mock_row_cache_1.MockRowCache.isEnabled();
+            let prototype = enabled ? holder?.prototype : undefined;
+            if (prototype === undefined) {
+                prototype = mock_row_cache_1.MockRowCache.getOrBuild(enabled ? `${this.targetTable}|${this.relationName}|${this.sourceAlias ?? ''}|${navigationPathSignature(this.navigationPath)}` : '', () => Object.defineProperties({}, this.buildMockRowDescriptors()));
+                if (enabled && holder !== undefined) {
+                    holder.prototype = prototype;
+                }
+            }
+            return mintReferenceMockRow(prototype);
         }
         else {
             // Fallback: use the shared nested proxy that supports deep property access
@@ -5967,18 +6047,24 @@ class ReferenceQueryBuilder {
                     // Reference navigation
                     // Non-enumerable to prevent Object.entries triggering getters (avoids stack overflow
                     // with circular relations like User->Posts->User)
+                    const holder = {};
                     descriptors[relName] = {
                         get() {
                             const slots = this;
                             const navCache = slots[MOCK_ROW_NAV_CACHE] ?? (slots[MOCK_ROW_NAV_CACHE] = {});
                             let cached = navCache[relName];
                             if (cached === undefined) {
-                                const refBuilder = new ReferenceQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKeys || [relConfig.foreignKey || ''], relConfig.matches || [], relConfig.isMandatory ?? false, nestedTargetSchema, // Pass the target schema directly
-                                schemaRegistry, // Pass schema registry for nested resolution
-                                extendedNavPath, // Pass navigation path for nested collections
-                                parentSourceAlias ? tableAlias : '' // Only set source if tracking path
-                                );
-                                cached = navCache[relName] = refBuilder.createMockTargetRow();
+                                if (holder.prototype !== undefined && mock_row_cache_1.MockRowCache.isEnabled()) {
+                                    cached = navCache[relName] = mintReferenceMockRow(holder.prototype);
+                                }
+                                else {
+                                    const refBuilder = new ReferenceQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKeys || [relConfig.foreignKey || ''], relConfig.matches || [], relConfig.isMandatory ?? false, nestedTargetSchema, // Pass the target schema directly
+                                    schemaRegistry, // Pass schema registry for nested resolution
+                                    extendedNavPath, // Pass navigation path for nested collections
+                                    parentSourceAlias ? tableAlias : '' // Only set source if tracking path
+                                    );
+                                    cached = navCache[relName] = refBuilder.createMockTargetRow(holder);
+                                }
                             }
                             return cached;
                         },
@@ -6158,16 +6244,28 @@ class CollectionQueryBuilder {
                 else {
                     // Reference navigation
                     // Non-enumerable to prevent Object.entries triggering getters (avoids stack overflow)
+                    const holder = {};
                     descriptors[relName] = {
-                        get: () => {
+                        get() {
                             // Don't call build() - it returns schema without relations
                             // Instead, pass undefined and let ReferenceQueryBuilder look it up from registry
+                            // One mock target row per ITEM row and relation: a selector that reads
+                            // `it.product.*` fifteen times used to mint fifteen builders and rows.
+                            const slots = this;
+                            const navCache = slots[MOCK_ROW_NAV_CACHE] ?? (slots[MOCK_ROW_NAV_CACHE] = {});
+                            const cachedRow = navCache[relName];
+                            if (cachedRow !== undefined) {
+                                return cachedRow;
+                            }
+                            if (holder.prototype !== undefined && mock_row_cache_1.MockRowCache.isEnabled()) {
+                                return (navCache[relName] = mintReferenceMockRow(holder.prototype));
+                            }
                             const refBuilder = new ReferenceQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKeys || [relConfig.foreignKey || ''], relConfig.matches || [], relConfig.isMandatory ?? false, undefined, // Don't pass schema, force registry lookup
                             schemaRegistry, // Pass schema registry for nested resolution
                             [], // Empty navigation path - this is the first reference in the chain
                             targetTable // Source alias is this collection's target table
                             );
-                            return refBuilder.createMockTargetRow();
+                            return (navCache[relName] = refBuilder.createMockTargetRow(holder));
                         },
                         enumerable: false,
                         configurable: true,
@@ -6529,6 +6627,12 @@ class CollectionQueryBuilder {
         }
         // Collect all table aliases referenced in the selection
         const allTableAliases = new Set();
+        // Aliases already joined — kept in step with `joins` so membership is O(1) instead of a
+        // `joins.some(...)` scan per field ref (a wide projection asks this for every field)
+        const joinedAliases = new Set();
+        for (const join of joins) {
+            joinedAliases.add(join.alias);
+        }
         // Helper to collect from a single selection
         const collectFromSelection = (sel) => {
             if (!sel || typeof sel !== 'object') {
@@ -6536,20 +6640,26 @@ class CollectionQueryBuilder {
             }
             // Handle single FieldRef
             if ('__tableAlias' in sel && '__dbColumnName' in sel) {
-                this.addNavigationJoinForFieldRef(sel, joins, currentSourceAlias, currentSchema, allTableAliases);
+                this.addNavigationJoinForFieldRef(sel, joins, currentSourceAlias, currentSchema, allTableAliases, joinedAliases);
                 return;
             }
             // Handle object with multiple fields
-            for (const [_key, value] of Object.entries(sel)) {
+            // Own enumerable keys only (the set Object.entries walks), without allocating the pairs:
+            // a wide collection projection runs this for every field on every build.
+            for (const key in sel) {
+                if (!Object.prototype.hasOwnProperty.call(sel, key)) {
+                    continue;
+                }
+                const value = sel[key];
                 if (value && typeof value === 'object' && '__tableAlias' in value && '__dbColumnName' in value) {
                     // This is a FieldRef with a table alias
-                    this.addNavigationJoinForFieldRef(value, joins, currentSourceAlias, currentSchema, allTableAliases);
+                    this.addNavigationJoinForFieldRef(value, joins, currentSourceAlias, currentSchema, allTableAliases, joinedAliases);
                 }
                 else if (value instanceof conditions_1.SqlFragment) {
                     // SqlFragment may contain navigation property references
                     const fieldRefs = value.getFieldRefs();
                     for (const fieldRef of fieldRefs) {
-                        this.addNavigationJoinForFieldRef(fieldRef, joins, currentSourceAlias, currentSchema, allTableAliases);
+                        this.addNavigationJoinForFieldRef(fieldRef, joins, currentSourceAlias, currentSchema, allTableAliases, joinedAliases);
                     }
                 }
                 else if (value instanceof CollectionQueryBuilder) {
@@ -6560,8 +6670,9 @@ class CollectionQueryBuilder {
                     // in its own FROM for the correlation to resolve.
                     const nestedPath = value.getNavigationPath();
                     for (const step of nestedPath) {
-                        if (!joins.some(j => j.alias === step.alias)) {
+                        if (!joinedAliases.has(step.alias)) {
                             joins.push(step);
+                            joinedAliases.add(step.alias);
                         }
                     }
                 }
@@ -6575,14 +6686,14 @@ class CollectionQueryBuilder {
         collectFromSelection(selection);
         // Second pass: resolve all navigation joins by finding the correct path through schemas
         if (allTableAliases.size > 0) {
-            this.resolveNavigationJoins(allTableAliases, joins, currentSchema);
+            this.resolveNavigationJoins(allTableAliases, joins, currentSchema, joinedAliases);
         }
     }
     /**
      * Add a navigation JOIN for a FieldRef if it references a related table
      * Handles multi-level navigation by recursively resolving the join chain
      */
-    addNavigationJoinForFieldRef(fieldRef, joins, sourceAlias, sourceSchema, allTableAliases) {
+    addNavigationJoinForFieldRef(fieldRef, joins, sourceAlias, sourceSchema, allTableAliases, joinedAliases) {
         if (!fieldRef || typeof fieldRef !== 'object' || !('__tableAlias' in fieldRef)) {
             return;
         }
@@ -6611,23 +6722,24 @@ class CollectionQueryBuilder {
         // Collect this table alias for later resolution
         allTableAliases.add(tableAlias);
         // Check if we already have this join
-        if (joins.some(j => j.alias === tableAlias)) {
+        if (joinedAliases !== undefined ? joinedAliases.has(tableAlias) : joins.some(j => j.alias === tableAlias)) {
             return;
         }
         // Find the relation in the current schema
         const relation = sourceSchema.relations?.[tableAlias];
         if (relation && relation.type === 'one') {
-            this.addNavigationJoin(tableAlias, relation, joins, sourceAlias);
+            this.addNavigationJoin(tableAlias, relation, joins, sourceAlias, joinedAliases);
         }
     }
     /**
      * Add a navigation join and return the target schema
      */
-    addNavigationJoin(alias, relation, joins, sourceAlias) {
+    addNavigationJoin(alias, relation, joins, sourceAlias, joinedAliases) {
         // Check if already added
-        if (joins.some(j => j.alias === alias)) {
+        if (joinedAliases !== undefined ? joinedAliases.has(alias) : joins.some(j => j.alias === alias)) {
             return undefined;
         }
+        joinedAliases?.add(alias);
         // Get the target table schema
         let targetSchema;
         let targetSchemaName;
@@ -6657,8 +6769,28 @@ class CollectionQueryBuilder {
      * Resolve all navigation joins by finding the correct path through the schema graph
      * This handles multi-level navigation like task.level.createdBy
      */
-    resolveNavigationJoins(allTableAliases, joins, startSchema) {
+    resolveNavigationJoins(allTableAliases, joins, startSchema, joinedAliases) {
+        // Aliases already joined, kept in step with `joins` (O(1) membership; the caller may hand
+        // in the set it maintained while collecting the field refs)
+        if (joinedAliases === undefined) {
+            joinedAliases = new Set();
+            for (const join of joins) {
+                joinedAliases.add(join.alias);
+            }
+        }
         // Keep resolving until we've resolved all aliases or can't make progress
+        // Fast path: every referenced alias is already joined (direct relations of the target table
+        // were added while the field refs were collected) — the loop below would only mark them.
+        let allJoined = true;
+        for (const alias of allTableAliases) {
+            if (!joinedAliases.has(alias)) {
+                allJoined = false;
+                break;
+            }
+        }
+        if (allJoined) {
+            return;
+        }
         let resolved = new Set();
         let lastResolvedCount = -1;
         let maxIterations = 100; // Prevent infinite loops
@@ -6696,7 +6828,7 @@ class CollectionQueryBuilder {
                     if (resolved.has(alias)) {
                         continue;
                     }
-                    if (joins.some(j => j.alias === alias)) {
+                    if (joinedAliases.has(alias)) {
                         resolved.add(alias);
                         continue;
                     }
@@ -6706,7 +6838,7 @@ class CollectionQueryBuilder {
                         if (!relation || relation.type !== 'one') {
                             continue;
                         }
-                        const targetSchema = this.addNavigationJoin(alias, relation, joins, schemaAlias);
+                        const targetSchema = this.addNavigationJoin(alias, relation, joins, schemaAlias, joinedAliases);
                         if (targetSchema) {
                             // Keep the anchor map current so the alias we just joined can serve as the
                             // source for further direct lookups in the next fixpoint round
@@ -6731,8 +6863,8 @@ class CollectionQueryBuilder {
                 }
                 // Add all intermediate joins
                 for (const step of path) {
-                    if (!joins.some(j => j.alias === step.alias)) {
-                        const stepSchema = this.addNavigationJoin(step.alias, step.relation, joins, step.sourceAlias);
+                    if (!joinedAliases.has(step.alias)) {
+                        const stepSchema = this.addNavigationJoin(step.alias, step.relation, joins, step.sourceAlias, joinedAliases);
                         if (stepSchema) {
                             joinedSchemas.set(step.alias, stepSchema);
                         }
@@ -6753,9 +6885,12 @@ class CollectionQueryBuilder {
         // Memoised per registry — the BFS below depends only on the target alias and the ORDERED
         // joined alias→table pairs (order decides which of several equal-length paths wins), so
         // the same query shape resolves to the same path on every build. See NavigationPathCache.
-        const signature = `${targetAlias}|${[...joinedSchemas]
-            .map(([alias, schema]) => `${alias}:${schema.schema ?? ''}.${schema.name}`)
-            .join(',')}`;
+        // Built by concatenation over the map (no spread / map / join allocations — this runs on every
+        // build of every projection that reaches an alias through a second hop)
+        let signature = targetAlias + '|';
+        for (const [alias, schema] of joinedSchemas) {
+            signature += alias + ':' + (schema.schema ?? '') + '.' + schema.name + ',';
+        }
         return navigation_path_cache_1.NavigationPathCache.getOrBuild(this.schemaRegistry, signature, () => this.computeNavigationPath(targetAlias, joinedSchemas));
     }
     /** The uncached BFS behind {@link findNavigationPath}. */
@@ -6842,6 +6977,7 @@ class CollectionQueryBuilder {
                 val.constructor === Object;
         };
         // Helper function to recursively process fields and build SelectedField structures
+        const collectionMarkerAlias = `__collection_${this.targetTable}__`;
         const processField = (alias, field) => {
             if (field instanceof conditions_1.SqlFragment) {
                 // SQL Fragment - build the SQL expression
@@ -6909,6 +7045,7 @@ class CollectionQueryBuilder {
                         nestedCteJoin: {
                             cteName: nestedResult.tableName,
                             joinClause: nestedJoinClause,
+                            memoId: nestedResult.memoId,
                         },
                         // Store nested collection info for recursive mapper transformation
                         nestedCollectionInfo: {
@@ -6951,11 +7088,10 @@ class CollectionQueryBuilder {
                 const sourceTable = field.__sourceTable; // Actual table name for schema lookup
                 // If tableAlias differs from the target table (or its collection marker), it's a navigation property reference
                 // The collection marker is `__collection_tableName__` and should be treated as the target table
-                const collectionMarker = `__collection_${this.targetTable}__`;
-                if (tableAlias && tableAlias !== this.targetTable && tableAlias !== collectionMarker) {
+                if (tableAlias && tableAlias !== this.targetTable && tableAlias !== collectionMarkerAlias) {
                     return { alias, expression: `"${tableAlias}"."${dbColumnName}"`, propertyName: fieldName, sourceTable };
                 }
-                return { alias, expression: `"${dbColumnName}"`, propertyName: fieldName };
+                return { alias, expression: `"${dbColumnName}"`, propertyName: fieldName, isColumn: true };
             }
             else if (typeof field === 'string') {
                 // Simple string reference (for backward compatibility)
@@ -6964,8 +7100,10 @@ class CollectionQueryBuilder {
             else if (isPlainObject(field)) {
                 // Nested object - recursively process its fields
                 const nestedFields = [];
-                for (const [nestedAlias, nestedField] of Object.entries(field)) {
-                    nestedFields.push(processField(nestedAlias, nestedField));
+                for (const nestedAlias in field) {
+                    if (Object.prototype.hasOwnProperty.call(field, nestedAlias)) {
+                        nestedFields.push(processField(nestedAlias, field[nestedAlias]));
+                    }
                 }
                 return { alias, nested: nestedFields };
             }
@@ -6995,6 +7133,7 @@ class CollectionQueryBuilder {
                     alias: dbColumnName,
                     expression: `"${dbColumnName}"`,
                     propertyName: fieldName,
+                    isColumn: true,
                 });
             }
             else if (selectedFields instanceof CollectionQueryBuilder || selectedFields instanceof conditions_1.SqlFragment) {
@@ -7003,8 +7142,11 @@ class CollectionQueryBuilder {
             }
             else {
                 // Object selection - extract each field (with support for nested objects)
-                for (const [alias, field] of Object.entries(selectedFields)) {
-                    selectedFieldConfigs.push(processField(alias, field));
+                // Own enumerable keys, without allocating the entry pairs (this runs per field per build)
+                for (const alias in selectedFields) {
+                    if (Object.prototype.hasOwnProperty.call(selectedFields, alias)) {
+                        selectedFieldConfigs.push(processField(alias, selectedFields[alias]));
+                    }
                 }
             }
         }
@@ -7018,6 +7160,7 @@ class CollectionQueryBuilder {
                         alias: colName,
                         expression: `"${dbColumnName}"`,
                         propertyName: colName, // Same as alias when selecting all fields
+                        isColumn: true,
                     });
                 }
             }
@@ -7055,13 +7198,7 @@ class CollectionQueryBuilder {
         let orderByClauseAlias;
         if (this.orderByFields.length > 0) {
             // Build reverse lookup: db column name -> property name
-            let dbToPropertyMap = null;
-            if (this.targetTableSchema) {
-                dbToPropertyMap = new Map();
-                for (const [propName, meta] of getSchemaColumnMeta(this.targetTableSchema)) {
-                    dbToPropertyMap.set(meta.name, propName);
-                }
-            }
+            const dbToPropertyMap = this.targetTableSchema ? getDbToPropertyMapForSchema(this.targetTableSchema) : null;
             const orderPartsDb = this.orderByFields.map(({ field, direction }) => {
                 // field is already the database column name
                 return `"${field}" ${direction}`;
@@ -7149,8 +7286,14 @@ class CollectionQueryBuilder {
         // which must be included in the lateral subquery for correlation
         // Include selectMany joins in both all and selector navigation joins
         // selectMany joins are structural (from flattening) and needed by both CTE and LATERAL
-        const allNavigationJoins = [...this.navigationPath, ...this.selectManyJoins, ...navigationJoins];
-        const allSelectorJoins = [...this.selectManyJoins, ...navigationJoins];
+        // (the common case — no navigation path, no selectMany — reuses the detected array instead of
+        // spreading it twice; strategies only read these lists)
+        const allNavigationJoins = this.navigationPath.length === 0 && this.selectManyJoins.length === 0
+            ? navigationJoins
+            : [...this.navigationPath, ...this.selectManyJoins, ...navigationJoins];
+        const allSelectorJoins = this.selectManyJoins.length === 0
+            ? navigationJoins
+            : [...this.selectManyJoins, ...navigationJoins];
         // Step 6: Build CollectionAggregationConfig object
         const config = {
             relationName: this.relationName,
@@ -7215,6 +7358,7 @@ class CollectionQueryBuilder {
             joinClause: result.joinClause,
             selectExpression: result.selectExpression,
             tableName: result.tableName,
+            memoId: result.memoId,
         };
     }
 }