@cap-js/db-service 1.17.2 → 1.19.0

package/lib/cqn2sql.js

@@ -25,7 +25,7 @@ class CQN2SQLRenderer {
     if (cds.env.sql.names === 'quoted') {
       this.class.prototype.name = (name, query) => {
         const e = name.id || name
-        return (query?.target || this.model?.definitions[e])?.['@cds.persistence.name'] || e
+        return (query?._target || this.model?.definitions[e])?.['@cds.persistence.name'] || e
       }
       this.class.prototype.quote = (s) => `"${String(s).replace(/"/g, '""')}"`
     }
@@ -92,7 +92,7 @@ class CQN2SQLRenderer {
       if (values && !Array.isArray(values)) {
         values = [values]
       }
-      DEBUG(this.sql, ...values)
+      DEBUG(this.sql, values)
     }
 
 
@@ -105,7 +105,7 @@ class CQN2SQLRenderer {
    * @returns {import('./infer/cqn').Query}
    */
   infer(q) {
-    return q.target ? q : cds_infer(q)
+    return q._target instanceof cds.entity ? q : cds_infer(q)
   }
 
   cqn4sql(q) {
@@ -226,7 +226,7 @@ class CQN2SQLRenderer {
    * @param {import('./infer/cqn').SELECT} q
    */
   SELECT(q) {
-    let { from, expand, where, groupBy, having, orderBy, limit, one, distinct, localized, forUpdate, forShareLock } =
+    let { from, expand, where, groupBy, having, orderBy, limit, one, distinct, localized, forUpdate, forShareLock, recurse } =
       q.SELECT
 
     if (from?.join && !q.SELECT.columns) {
@@ -239,12 +239,13 @@ class CQN2SQLRenderer {
     let sql = `SELECT`
     if (distinct) sql += ` DISTINCT`
     if (!_empty(columns)) sql += ` ${columns}`
-    if (!_empty(from)) sql += ` FROM ${this.from(from, q)}`
+    if (recurse) sql += ` FROM ${this.SELECT_recurse(q)}`
+    else if (!_empty(from)) sql += ` FROM ${this.from(from, q)}`
     else sql += this.from_dummy()
-    if (!_empty(where)) sql += ` WHERE ${this.where(where)}`
-    if (!_empty(groupBy)) sql += ` GROUP BY ${this.groupBy(groupBy)}`
-    if (!_empty(having)) sql += ` HAVING ${this.having(having)}`
-    if (!_empty(orderBy)) sql += ` ORDER BY ${this.orderBy(orderBy, localized)}`
+    if (!recurse && !_empty(where)) sql += ` WHERE ${this.where(where)}`
+    if (!recurse && !_empty(groupBy)) sql += ` GROUP BY ${this.groupBy(groupBy)}`
+    if (!recurse && !_empty(having)) sql += ` HAVING ${this.having(having)}`
+    if (!recurse && !_empty(orderBy)) sql += ` ORDER BY ${this.orderBy(orderBy, localized)}`
     if (one) limit = Object.assign({}, limit, { rows: { val: 1 } })
     if (limit) sql += ` LIMIT ${this.limit(limit)}`
     if (forUpdate) sql += ` ${this.forUpdate(forUpdate)}`
@@ -257,13 +258,23 @@ class CQN2SQLRenderer {
     return (this.sql = sql)
   }
 
+  SELECT_recurse() {
+    cds.error`Feature "recurse" queries not supported.`
+  }
+
   /**
    * Renders a column clause into generic SQL
    * @param {import('./infer/cqn').SELECT} param0
    * @returns {string} SQL
    */
   SELECT_columns(q) {
-    return (q.SELECT.columns ?? ['*']).map(x => this.column_expr(x, q))
+    const ret = []
+    const arr = q.SELECT.columns ?? ['*']
+    for (const x of arr) {
+      if (x.SELECT?.count) arr.push(this.SELECT_count(x))
+      ret.push(this.column_expr(x, q))
+    }
+    return ret
   }
 
   /**
@@ -292,24 +303,12 @@ class CQN2SQLRenderer {
       ? x => {
         const name = this.column_name(x)
         const escaped = `${name.replace(/"/g, '""')}`
-        let col = `${this.output_converter4(x.element, this.quote(name))} AS "${escaped}"`
-        if (x.SELECT?.count) {
-          // Return both the sub select and the count for @odata.count
-          const qc = cds.ql.clone(x, { columns: [{ func: 'count' }], one: 1, limit: 0, orderBy: 0 })
-          return [col, `${this.expr(qc)} AS "${escaped}@odata.count"`]
-        }
-        return col
+        return `${this.output_converter4(x.element, this.quote(name))} AS "${escaped}"`
       }
       : x => {
         const name = this.column_name(x)
         const escaped = `${name.replace(/"/g, '""')}`
-        let col = `'$."${escaped}"',${this.output_converter4(x.element, this.quote(name))}`
-        if (x.SELECT?.count) {
-          // Return both the sub select and the count for @odata.count
-          const qc = cds.ql.clone(x, { columns: [{ func: 'count' }], one: 1, limit: 0, orderBy: 0 })
-          return [col, `'$."${escaped}@odata.count"',${this.expr(qc)}`]
-        }
-        return col
+        return `'$."${escaped}"',${this.output_converter4(x.element, this.quote(name))}`
       }).flat()
 
     if (isSimple) return `SELECT ${cols} FROM (${sql})`
@@ -322,6 +321,17 @@ class CQN2SQLRenderer {
     return `SELECT ${isRoot || SELECT.one ? obj.replace('jsonb', 'json') : `jsonb_group_array(${obj})`} as _json_ FROM (${sql})`
   }
 
+  SELECT_count(q) {
+    const countQuery = cds.ql.clone(q, {
+      columns: [{ func: 'count' }],
+      one: 0, limit: 0, orderBy: 0, expand: 0, count: 0
+    })
+    countQuery.as = q.as + '@odata.count'
+    countQuery.elements = undefined
+    countQuery.element = cds.builtin.types.Int64
+    return countQuery
+  }
+
   /**
    * Renders a SELECT column expression into generic SQL
    * @param {import('./infer/cqn').col} x
@@ -416,14 +426,15 @@ class CQN2SQLRenderer {
    * @returns {string[] | string} SQL
    */
   orderBy(orderBy, localized) {
-    return orderBy.map(
-      localized
-        ? c =>
-          this.expr(c) +
+    return orderBy.map(c => {
+      const o = localized
+        ? this.expr(c) +
           (c.element?.[this.class._localized] ? ' COLLATE NOCASE' : '') +
           (c.sort?.toLowerCase() === 'desc' || c.sort === -1 ? ' DESC' : ' ASC')
-        : c => this.expr(c) + (c.sort?.toLowerCase() === 'desc' || c.sort === -1 ? ' DESC' : ' ASC'),
-    )
+        : this.expr(c) + (c.sort?.toLowerCase() === 'desc' || c.sort === -1 ? ' DESC' : ' ASC')
+      if (c.nulls) return o + ' NULLS ' + (c.nulls.toLowerCase() === 'first' ? 'FIRST' : 'LAST')
+      return o
+    })
   }
 
   /**
@@ -443,9 +454,10 @@ class CQN2SQLRenderer {
    * @returns {string} SQL
    */
   forUpdate(update) {
-    const { wait, of } = update
+    const { wait, of, ignoreLocked } = update
     let sql = 'FOR UPDATE'
     if (!_empty(of)) sql += ` OF ${of.map(x => this.expr(x)).join(', ')}`
+    if (ignoreLocked) sql += ' IGNORE LOCKED'
     if (typeof wait === 'number') sql += ` WAIT ${wait}`
     return sql
   }
@@ -490,7 +502,7 @@ class CQN2SQLRenderer {
    */
   INSERT_entries(q) {
     const { INSERT } = q
-    const elements = q.elements || q.target?.elements
+    const elements = q.elements || q._target?.elements
     if (!elements && !INSERT.entries?.length) {
       return // REVISIT: mtx sends an insert statement without entries and no reference entity
     }
@@ -502,7 +514,7 @@ class CQN2SQLRenderer {
     this.columns = columns
 
     const alias = INSERT.into.as
-    const entity = this.name(q.target?.name || INSERT.into.ref[0], q)
+    const entity = this.name(q._target?.name || INSERT.into.ref[0], q)
     if (!elements) {
       this.entries = INSERT.entries.map(e => columns.map(c => e[c]))
       const param = this.param.bind(this, { ref: ['?'] })
@@ -528,7 +540,7 @@ class CQN2SQLRenderer {
   }
 
   async *INSERT_entries_stream(entries, binaryEncoding = 'base64') {
-    const elements = this.cqn.target?.elements || {}
+    const elements = this.cqn._target?.elements || {}
     const bufferLimit = 65536 // 1 << 16
     let buffer = '['
 
@@ -577,7 +589,7 @@ class CQN2SQLRenderer {
   }
 
   async *INSERT_rows_stream(entries, binaryEncoding = 'base64') {
-    const elements = this.cqn.target?.elements || {}
+    const elements = this.cqn._target?.elements || {}
     const bufferLimit = 65536 // 1 << 16
     let buffer = '['
 
@@ -630,9 +642,9 @@ class CQN2SQLRenderer {
    */
   INSERT_rows(q) {
     const { INSERT } = q
-    const entity = this.name(q.target?.name || INSERT.into.ref[0], q)
+    const entity = this.name(q._target?.name || INSERT.into.ref[0], q)
     const alias = INSERT.into.as
-    const elements = q.elements || q.target?.elements
+    const elements = q.elements || q._target?.elements
     const columns = this.columns = INSERT.columns || cds.error`Cannot insert rows without columns or elements`
 
     if (!elements) {
@@ -676,9 +688,9 @@ class CQN2SQLRenderer {
    */
   INSERT_select(q) {
     const { INSERT } = q
-    const entity = this.name(q.target.name, q)
+    const entity = this.name(q._target.name, q)
     const alias = INSERT.into.as
-    const elements = q.elements || q.target?.elements || {}
+    const elements = q.elements || q._target?.elements || {}
     const columns = (this.columns = (INSERT.columns || ObjectKeys(elements)).filter(
       c => c in elements && !elements[c].virtual && !elements[c].isAssociation,
     ))
@@ -719,15 +731,15 @@ class CQN2SQLRenderer {
     const { UPSERT } = q
 
     let sql = this.INSERT({ __proto__: q, INSERT: UPSERT })
-    if (!q.target?.keys) return sql
+    if (!q._target?.keys) return sql
     const keys = []
-    for (const k of ObjectKeys(q.target?.keys)) {
-      const element = q.target.keys[k]
+    for (const k of ObjectKeys(q._target?.keys)) {
+      const element = q._target.keys[k]
       if (element.isAssociation || element.virtual) continue
       keys.push(k)
     }
 
-    const elements = q.target?.elements || {}
+    const elements = q._target?.elements || {}
     // temporal data
     for (const k of ObjectKeys(elements)) {
       if (elements[k]['@cds.valid.from']) keys.push(k)
@@ -744,7 +756,7 @@ class CQN2SQLRenderer {
       .filter(c => keys.includes(c.name))
       .map(c => `${c.onInsert || c.sql} as ${this.quote(c.name)}`)
 
-    const entity = this.name(q.target?.name || UPSERT.into.ref[0], q)
+    const entity = this.name(q._target?.name || UPSERT.into.ref[0], q)
     sql = `SELECT ${managed.map(c => c.upsert
       .replace(/value->/g, '"$$$$value$$$$"->')
       .replace(/json_type\(value,/g, 'json_type("$$$$value$$$$",'))
@@ -773,7 +785,7 @@ class CQN2SQLRenderer {
    */
   UPDATE(q) {
     const { entity, with: _with, data, where } = q.UPDATE
-    const elements = q.target?.elements
+    const elements = q._target?.elements
     let sql = `UPDATE ${this.quote(this.name(entity.ref?.[0] || entity, q))}`
     if (entity.as) sql += ` AS ${this.quote(entity.as)}`
 

package/lib/cqn4sql.js

@@ -1,10 +1,11 @@
 'use strict'
 
 const cds = require('@sap/cds')
+cds.infer.target ??= q => q._target || q.target // instanceof cds.entity ? q._target : q.target
 
 const infer = require('./infer')
 const { computeColumnsToBeSearched } = require('./search')
-const { prettyPrintRef, isCalculatedOnRead, isCalculatedElement } = require('./utils')
+const { prettyPrintRef, isCalculatedOnRead, isCalculatedElement, getImplicitAlias } = require('./utils')
 
 /**
  * For operators of <eqOps>, this is replaced by comparing all leaf elements with null, combined with and.
@@ -60,6 +61,22 @@ function cqn4sql(originalQuery, model) {
       else if (having) inferred.SELECT.having = having
     }
   }
+  // query modifiers can also be defined in from ref leaf infix filter
+  // > SELECT from bookshop.Books[order by price] {ID}
+  if (inferred.SELECT?.from.ref) {
+    for (const [key, val] of Object.entries(inferred.SELECT.from.ref.at(-1))) {
+      if (key in { orderBy: 1, groupBy: 1 }) {
+        if (inferred.SELECT[key]) inferred.SELECT[key].push(...val)
+        else inferred.SELECT[key] = val
+      } else if (key === 'limit') {
+        // limit defined on the query has precedence
+        if (!inferred.SELECT.limit) inferred.SELECT.limit = val
+      } else if (key === 'having') {
+        if (!inferred.SELECT.having) inferred.SELECT.having = val
+        else inferred.SELECT.having.push('and', ...val)
+      }
+    }
+  }
   inferred = infer(inferred, model)
   // if the query has custom joins we don't want to transform it
   // TODO: move all the way to the top of this function once cds.infer supports joins as well
@@ -208,7 +225,8 @@ function cqn4sql(originalQuery, model) {
    */
   function transformQueryForInsertUpsert(kind) {
     const { as } = transformedQuery[kind].into
-    transformedQuery[kind].into = { ref: [inferred.target.name] }
+    const target = cds.infer.target (inferred) // REVISIT: we should reliably use inferred._target instead
+    transformedQuery[kind].into = { ref: [target.name] }
     if (as) transformedQuery[kind].into.as = as
     return transformedQuery
   }
@@ -784,7 +802,7 @@ function cqn4sql(originalQuery, model) {
     } else {
       outerAlias = transformedQuery.SELECT.from.as
       subqueryFromRef = [
-        ...(transformedQuery.SELECT.from.ref || /* subq in from */ [transformedQuery.SELECT.from.target.name]),
+        ...(transformedQuery.SELECT.from.ref || /* subq in from */ transformedQuery.SELECT.from.SELECT.from.ref),
         ...ref,
       ]
     }
@@ -800,18 +818,20 @@ function cqn4sql(originalQuery, model) {
       return _subqueryForGroupBy(column, baseRef, columnAlias)
     }
 
-    // we need to respect the aliases of the outer query, so the columnAlias might not be suitable
-    // as table alias for the correlated subquery
-    const uniqueSubqueryAlias = getNextAvailableTableAlias(columnAlias, inferred.outerQueries)
+    // Alias in expand subquery is derived from but not equal to
+    // the alias of the column because to account for potential ambiguities
+    // the alias cannot be addressed anyways
+    const uniqueSubqueryAlias = getNextAvailableTableAlias(getImplicitAlias(columnAlias), inferred.outerQueries)
 
     // `SELECT from Authors {  books.genre as genreOfBooks { name } } becomes `SELECT from Books:genre as genreOfBooks`
     const from = { ref: subqueryFromRef, as: uniqueSubqueryAlias }
     const subqueryBase = {}
-    for (const [key, value] of Object.entries(column)) {
-      if (!(key in { ref: true, expand: true })) {
+    const queryModifiers = { ...column }
+    for (const [key, value] of Object.entries(queryModifiers)) {
+      if (key in { limit: 1, orderBy: 1, groupBy: 1, excluding: 1, where: 1, having: 1, count: 1 })
         subqueryBase[key] = value
-      }
     }
+
     const subquery = {
       SELECT: {
         ...subqueryBase,
@@ -853,6 +873,7 @@ function cqn4sql(originalQuery, model) {
         const existsSubqueryAlias = recent[existsIndex + 1].SELECT.from.as
         if (existsSubqueryAlias === x.ref?.[0]) return { ref: [outer, ...x.ref.slice(1)] }
         if (x.xpr) x.xpr = x.xpr.map(replaceAliasWithSubqueryAlias)
+        if (x.args) x.args = x.args.map(replaceAliasWithSubqueryAlias)
         return x
       }
       return subq
@@ -877,40 +898,48 @@ function cqn4sql(originalQuery, model) {
 
       // to be attached to dummy query
       const elements = {}
-      const wildcardIndex = column.expand.findIndex(e => e === '*')
-      if (wildcardIndex !== -1) {
+      const containsWildcard = column.expand.includes('*')
+      if (containsWildcard) {
         // expand with wildcard vanishes as expand is part of the group by (OData $apply + $expand)
         return null
       }
-      const expandedColumns = column.expand.flatMap(expand => {
-        if (!expand.ref) return expand
-        const fullRef = [...baseRef, ...expand.ref]
-
-        if (expand.expand) {
-          const nested = _subqueryForGroupBy(expand, fullRef, expand.as || expand.ref.map(idOnly).join('_'))
-          setElementOnColumns(nested, expand.element)
-          elements[expand.as || expand.ref.map(idOnly).join('_')] = nested
-          return nested
-        }
+      const expandedColumns = column.expand
+        .flatMap(expand => {
+          if (!expand.ref) return expand
+          const fullRef = [...baseRef, ...expand.ref]
+
+          if (expand.expand) {
+            const nested = _subqueryForGroupBy(expand, fullRef, expand.as || expand.ref.map(idOnly).join('_'))
+            if (nested) {
+              setElementOnColumns(nested, expand.element)
+              elements[expand.as || expand.ref.map(idOnly).join('_')] = nested
+            }
+            return nested
+          }
 
-        const groupByRef = groupByLookup.get(fullRef.map(refWithConditions).join('.'))
-        if (!groupByRef) {
-          throw new Error(
-            `The expanded column "${fullRef.map(refWithConditions).join('.')}" must be part of the group by clause`,
-          )
-        }
+          const groupByRef = groupByLookup.get(fullRef.map(refWithConditions).join('.'))
+          if (!groupByRef) {
+            throw new Error(
+              `The expanded column "${fullRef.map(refWithConditions).join('.')}" must be part of the group by clause`,
+            )
+          }
 
-        const copy = Object.create(groupByRef)
-        // always alias for this special case, so that they nested element names match the expected result structure
-        // otherwise we'd get `author { <outer>.author_ID }`, but we need `author { <outer>.author_ID as ID }`
-        copy.as = expand.as || expand.ref.at(-1)
-        const tableAlias = getTableAlias(copy)
-        const res = getFlatColumnsFor(copy, { tableAlias })
-        res.forEach(c => {
-          elements[c.as || c.ref.at(-1)] = c.element
+          const copy = Object.create(groupByRef)
+          // always alias for this special case, so that they nested element names match the expected result structure
+          // otherwise we'd get `author { <outer>.author_ID }`, but we need `author { <outer>.author_ID as ID }`
+          copy.as = expand.as || expand.ref.at(-1)
+          const tableAlias = getTableAlias(copy)
+          const res = getFlatColumnsFor(copy, { tableAlias })
+          res.forEach(c => {
+            elements[c.as || c.ref.at(-1)] = c.element
+          })
+          return res
         })
-        return res
-      })
+        .filter(c => c)
+
+      if (expandedColumns.length === 0) {
+        return null
+      }
 
       const SELECT = {
         from: null,
@@ -1041,7 +1070,8 @@ function cqn4sql(originalQuery, model) {
       outerQueries.push(inferred)
       Object.defineProperty(q, 'outerQueries', { value: outerQueries })
     }
-    if (isLocalized(inferred.target)) q.SELECT.localized = true
+    const target = cds.infer.target (inferred) // REVISIT: we should reliably use inferred._target instead
+    if (isLocalized(target)) q.SELECT.localized = true
     if (q.SELECT.from.ref && !q.SELECT.from.as) assignUniqueSubqueryAlias()
     return cqn4sql(q, model)
 
@@ -1049,7 +1079,7 @@ function cqn4sql(originalQuery, model) {
       if (q.SELECT.from.uniqueSubqueryAlias) return
       const last = q.SELECT.from.ref.at(-1)
       const uniqueSubqueryAlias = inferred.joinTree.addNextAvailableTableAlias(
-        getLastStringSegment(last.id || last),
+        getImplicitAlias(last.id || last),
         inferred.outerQueries,
       )
       Object.defineProperty(q.SELECT.from, 'uniqueSubqueryAlias', { value: uniqueSubqueryAlias })
@@ -1225,8 +1255,7 @@ function cqn4sql(originalQuery, model) {
         if (flattenThisForeignKey) {
           const fkElement = getElementForRef(k.ref, getDefinition(element.target))
           let fkBaseName
-          if (!leafAssoc || leafAssoc.onlyForeignKeyAccess)
-            fkBaseName = `${baseName}_${k.as || k.ref.at(-1)}`
+          if (!leafAssoc || leafAssoc.onlyForeignKeyAccess) fkBaseName = `${baseName}_${k.as || k.ref.at(-1)}`
           // e.g. if foreign key is accessed via infix filter - use join alias to access key in target
           else fkBaseName = k.ref.at(-1)
           const fkPath = [...csnPath, k.ref.at(-1)]
@@ -1379,7 +1408,7 @@ function cqn4sql(originalQuery, model) {
             j = nextAssocIndex
           }
 
-          const as = getNextAvailableTableAlias(getLastStringSegment(next.alias))
+          const as = getNextAvailableTableAlias(getImplicitAlias(next.alias))
           next.alias = as
           if (!next.definition.target) {
             let type = next.definition.type
@@ -1478,8 +1507,7 @@ function cqn4sql(originalQuery, model) {
           // reject associations in expression, except if we are in an infix filter -> $baseLink is set
           assertNoStructInXpr(token, $baseLink)
           // reject virtual elements in expressions as they will lead to a sql error down the line
-          if(definition?.virtual)
-            throw new Error(`Virtual elements are not allowed in expressions`)
+          if (definition?.virtual) throw new Error(`Virtual elements are not allowed in expressions`)
 
           let result = is_regexp(token?.val) ? token : copy(token) // REVISIT: too expensive! //
           if (token.ref) {
@@ -1676,12 +1704,12 @@ function cqn4sql(originalQuery, model) {
     function _transformFrom() {
       if (typeof from === 'string') {
         // normalize to `ref`, i.e. for `UPDATE.entity('bookshop.Books')`
-        return { transformedFrom: { ref: [from], as: getLastStringSegment(from) } }
+        return { transformedFrom: { ref: [from], as: getImplicitAlias(from) } }
       }
       transformedFrom.as =
         from.uniqueSubqueryAlias ||
         from.as ||
-        getLastStringSegment(transformedFrom.$refLinks[transformedFrom.$refLinks.length - 1].definition.name)
+        getImplicitAlias(transformedFrom.$refLinks[transformedFrom.$refLinks.length - 1].definition.name)
       const whereExistsSubSelects = []
       const filterConditions = []
       const refReverse = [...from.ref].reverse()
@@ -1703,14 +1731,17 @@ function cqn4sql(originalQuery, model) {
                 .findIndex(rl => rl.definition.isAssociation || rl.definition.kind === 'entity')
             next = $refLinksReverse[nextStepIndex]
           }
-          let as = getLastStringSegment(next.alias)
+          let as = getImplicitAlias(next.alias)
           /**
            * for an `expand` subquery, we do not need to add
            * the table alias of the `expand` host to the join tree
            * --> This is an artificial query, which will later be correlated
            * with the main query alias. see @function expandColumn()
+           * There is one exception:
+           * - if current and next have the same alias, we need to assign a new alias to the next
+           *                          
            */
-          if (!(inferred.SELECT?.expand === true)) {
+          if (!(inferred.SELECT?.expand === true && current.alias.toLowerCase() !== as.toLowerCase())) {
             as = getNextAvailableTableAlias(as)
           }
           next.alias = as
@@ -1897,9 +1928,11 @@ function cqn4sql(originalQuery, model) {
             })
             let pseudoPath = false
             ref.reduce((prev, res, i) => {
-              if (res === '$self')
+              if (res === '$self') {
                 // next is resolvable in entity
+                thing.$refLinks.push({ definition: prev, target: prev })
                 return prev
+              }
               if (res in pseudos.elements) {
                 pseudoPath = true
                 thing.$refLinks.push({ definition: pseudos.elements[res], target: pseudos })
@@ -1911,7 +1944,11 @@ function cqn4sql(originalQuery, model) {
               const definition =
                 prev?.elements?.[res] || getDefinition(prev?.target)?.elements[res] || pseudos.elements[res]
               const target = getParentEntity(definition)
-              thing.$refLinks[i] = { definition, target, alias: definition.name }
+              thing.$refLinks[i] = {
+                definition,
+                target,
+                alias: definition === assocRefLink.definition ? assocRefLink.alias : definition.name,
+              }
               return prev?.elements?.[res] || getDefinition(prev?.target)?.elements[res] || pseudos.elements[res]
             }, assocHost)
           }
@@ -1936,15 +1973,16 @@ function cqn4sql(originalQuery, model) {
               lhs.ref[0] in { $self: true, $projection: true } ? getParentEntity(assocRefLink.definition) : target,
             )
           else {
-            const lhsLeafArt = lhs.ref && lhs.$refLinks.at(-1).definition
-            const rhsLeafArt = rhs.ref && rhs.$refLinks.at(-1).definition
+            const lhsLeafDef = lhs.ref && lhs.$refLinks.at(-1).definition
+            const rhsLeafDef = rhs.ref && rhs.$refLinks.at(-1).definition
+            const lhsFirstDef = lhs.$refLinks.find(r => r.definition.kind === 'element')?.definition
             // compare structures in on-condition
-            if ((lhsLeafArt?.target && rhsLeafArt?.target) || (lhsLeafArt?.elements && rhsLeafArt?.elements)) {
+            if ((lhsLeafDef?.target && rhsLeafDef?.target) || (lhsLeafDef?.elements && rhsLeafDef?.elements)) {
               if (rhs.$refLinks[0].definition !== assocRefLink.definition) {
                 rhs.ref.unshift(targetSideRefLink.alias)
                 rhs.$refLinks.unshift(targetSideRefLink)
               }
-              if (lhs.$refLinks[0].definition !== assocRefLink.definition) {
+              if (lhsFirstDef !== assocRefLink.definition) {
                 lhs.ref.unshift(targetSideRefLink.alias)
                 lhs.$refLinks.unshift(targetSideRefLink)
               }
@@ -1954,16 +1992,15 @@ function cqn4sql(originalQuery, model) {
               i += res.length
               continue
             }
-            // naive assumption: if first step is the association itself, all following ref steps must be resolvable
+            // assumption: if first step is the association itself, all following ref steps must be resolvable
             // within target `assoc.assoc.fk` -> `assoc.assoc_fk`
             else if (
-              lhs.$refLinks[0]?.definition ===
-              getParentEntity(assocRefLink.definition).elements[assocRefLink.definition.name]
+              lhsFirstDef === getParentEntity(assocRefLink.definition).elements[assocRefLink.definition.name]
             )
-              result[i].ref = [assocRefLink.alias, lhs.ref.slice(1).join('_')]
+              result[i].ref = [assocRefLink.alias, lhs.ref.slice(lhs.ref[0] === '$self' ? 2 : 1).join('_')]
             // naive assumption: if the path starts with an association which is not the association from
             // which the on-condition originates, it must be a foreign key and hence resolvable in the source
-            else if (lhs.$refLinks[0]?.definition.target) result[i].ref = [result[i].ref.join('_')]
+            else if (lhsFirstDef?.target) result[i].ref = [result[i].ref.join('_')]
           }
         }
         if (backlink) {
@@ -1986,7 +2023,7 @@ function cqn4sql(originalQuery, model) {
             // sanity check: error out if we can't produce a join
             if (backlink.keys.length === 0) {
               throw new Error(
-                `Path step “${assocRefLink.alias}” is a self comparison with “${getFullName(backlink)}” that has no foreign keys`,
+                `Path step “${assocRefLink.definition.name}” is a self comparison with “${getFullName(backlink)}” that has no foreign keys`,
               )
             }
             // managed backlink -> calculate fk-pk pairs
@@ -2012,7 +2049,7 @@ function cqn4sql(originalQuery, model) {
             if (lhs.ref[0] !== assocRefLink.alias && lhs.ref[0] !== targetSideRefLink.alias) {
               // we need to find correct table alias for the structured access
               const { definition } = lhs.$refLinks[0]
-              if (definition === assocRefLink.definition) {
+              if (definition === getParentEntity(assocRefLink.definition).elements[assocRefLink.definition.name]) {
                 // first step is the association itself -> use it's name as it becomes the table alias
                 result[i].ref.splice(0, 1, assocRefLink.alias)
               } else if (
@@ -2030,6 +2067,7 @@ function cqn4sql(originalQuery, model) {
     }
     /**
      * Recursively calculates the containing entity for a given element.
+     * If the query is localized, this function may return the localized entity.
      *
      * @param {CSN.element} element
      * @returns {CSN.definition} the entity containing the given element
@@ -2223,7 +2261,7 @@ function cqn4sql(originalQuery, model) {
    * - or null, if no searchable columns are found in neither in `@cds.search` nor in the target entity itself.
    */
   function getSearchTerm(search, query) {
-    const entity = query.SELECT.from.SELECT ? query.SELECT.from : query.target
+    const entity = query.SELECT.from.SELECT ? query.SELECT.from : cds.infer.target(query) // REVISIT: we should reliably use inferred._target instead
     const searchIn = computeColumnsToBeSearched(inferred, entity)
     if (searchIn.length > 0) {
       const xpr = search
@@ -2284,7 +2322,7 @@ function cqn4sql(originalQuery, model) {
         if (
           inferred.SELECT?.from.uniqueSubqueryAlias &&
           !inferred.SELECT?.from.as &&
-          firstStep === getLastStringSegment(transformedQuery.SELECT.from.ref[0])
+          getImplicitAlias(firstStep) === getImplicitAlias(transformedQuery.SELECT.from.ref[0])
         ) {
           return inferred.SELECT?.from.uniqueSubqueryAlias
         }
@@ -2293,7 +2331,7 @@ function cqn4sql(originalQuery, model) {
     }
 
     function getCombinedElementAlias(node) {
-      return getLastStringSegment(inferred.$combinedElements[node.ref[0].id || node.ref[0]]?.[0].index)
+      return inferred.$combinedElements[node.ref[0].id || node.ref[0]]?.[0].index
     }
   }
   function getTransformedFunctionArgs(args, $baseLink = null) {
@@ -2366,17 +2404,6 @@ function hasLogicalOr(tokenStream) {
   return tokenStream.some(t => t in { OR: true, or: true })
 }
 
-/**
- * Returns the last segment of a string after the last dot.
- *
- * @param {string} str - The input string.
- * @returns {string} The last segment of the string after the last dot. If there is no dot in the string, the function returns the original string.
- */
-function getLastStringSegment(str) {
-  const index = str.lastIndexOf('.')
-  return index != -1 ? str.substring(index + 1) : str
-}
-
 function getParentEntity(element) {
   if (element.kind === 'entity') return element
   else return getParentEntity(element.parent)

package/lib/deep-queries.js

@@ -39,9 +39,9 @@ async function onDeep(req, next) {
   // const target = query.sources[Object.keys(query.sources)[0]]
   if (!this.model?.definitions[_target_name4(req.query)]) return next()
 
-  const { target } = this.infer(query)
-  if (!hasDeep(query, target)) return next()
+  if (!hasDeep(query)) return next()
 
+  const target = this.infer(query)._target
   const beforeData = query.INSERT ? [] : await this.run(getExpandForDeep(query, target, true))
   if (query.UPDATE && !beforeData.length) return 0
 
@@ -64,10 +64,10 @@ async function onDeep(req, next) {
   return rootResult ?? beforeData.length
 }
 
-const hasDeep = (q, target) => {
+const hasDeep = (q) => {
   const data = q.INSERT?.entries || (q.UPDATE?.data && [q.UPDATE.data]) || (q.UPDATE?.with && [q.UPDATE.with])
   if (data)
-    for (const c in target.compositions) {
+    for (const c in q._target.compositions) {
       for (const row of data) if (row[c] !== undefined) return true
     }
 }