@cap-js/db-service 1.15.1 → 1.16.1

package/CHANGELOG.md

@@ -4,6 +4,32 @@
 - The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - This project adheres to [Semantic Versioning](http://semver.org/).
 
+## [1.16.1](https://github.com/cap-js/cds-dbs/compare/db-service-v1.16.0...db-service-v1.16.1) (2024-12-16)
+
+
+### Fixed
+
+* handle undefined DEBUG ([#942](https://github.com/cap-js/cds-dbs/issues/942)) ([dd2da3a](https://github.com/cap-js/cds-dbs/commit/dd2da3a8d8feb5beaae5860d493e9e1158dbf99f)), closes [#941](https://github.com/cap-js/cds-dbs/issues/941)
+* only expand partial foreign key if explicitly requested ([#916](https://github.com/cap-js/cds-dbs/issues/916)) ([96911ad](https://github.com/cap-js/cds-dbs/commit/96911ada1831e71febb84d8a382b57d55d24c1bc))
+* quoted mode ([#937](https://github.com/cap-js/cds-dbs/issues/937)) ([9e62b22](https://github.com/cap-js/cds-dbs/commit/9e62b22a1be90ada9f57cfa63505735d8b8eed88))
+* sort property is case insensitive ([#924](https://github.com/cap-js/cds-dbs/issues/924)) ([2c72c87](https://github.com/cap-js/cds-dbs/commit/2c72c871d6c7f65797b8bd8692305149b3ea65f8))
+* wildcard expand with aggregation ([#923](https://github.com/cap-js/cds-dbs/issues/923)) ([bbe7be0](https://github.com/cap-js/cds-dbs/commit/bbe7be00498ad083cf951daf344b7f5fd9f68ab9))
+
+## [1.16.0](https://github.com/cap-js/cds-dbs/compare/db-service-v1.15.1...db-service-v1.16.0) (2024-11-25)
+
+
+### Changed
+
+* single column in `search` function is also treated as CQN `list` ([#898](https://github.com/cap-js/cds-dbs/issues/898)) ([f6593e6](https://github.com/cap-js/cds-dbs/commit/f6593e69de6df3e85a39c048794a56c7eb842c4c))
+
+
+### Fixed
+
+* foreignKeys aspect on association may not be set ([#903](https://github.com/cap-js/cds-dbs/issues/903)) ([732a2f3](https://github.com/cap-js/cds-dbs/commit/732a2f385074f50b87ff9715b8bdf48d28a36309))
+* insert on uuid with default value ([#911](https://github.com/cap-js/cds-dbs/issues/911)) ([545e489](https://github.com/cap-js/cds-dbs/commit/545e489ecd07b5a3ece9441d95804fb2f3d436fa))
+* `session_context`, `current_date`, `current_time` and `current_timestamp` are treated as SAP HANA functions and are callable in upper case ([#910](https://github.com/cap-js/cds-dbs/issues/910)) ([50ebd10](https://github.com/cap-js/cds-dbs/commit/50ebd106b9ee5bf7e1026658b89401e904ffe051))
+* wrap values in array if it is object, so it can be spreaded ([#882](https://github.com/cap-js/cds-dbs/issues/882)) ([11f3e8b](https://github.com/cap-js/cds-dbs/commit/11f3e8bdf37d57295c1f2ffb40e217f86ec7d423))
+
 ## [1.15.1](https://github.com/cap-js/cds-dbs/compare/db-service-v1.15.0...db-service-v1.15.1) (2024-11-18)
 
 

package/lib/common/DatabaseService.js

@@ -47,13 +47,14 @@ class DatabaseService extends cds.Service {
    * transaction with `BEGIN`
    * @returns this
    */
-  async begin() {
+  async begin (min) {
     // We expect tx.begin() being called for an txed db service
     const ctx = this.context
 
     // If .begin is called explicitly it starts a new transaction and executes begin
-    if (!ctx) return this.tx().begin()
+    if (!ctx) return this.tx().begin(min)
 
+    // REVISIT: can we revisit the below revisit now?
     // REVISIT: tenant should be undefined if !this.isMultitenant
     let isMultitenant = 'multiTenant' in this.options ? this.options.multiTenant : cds.env.requires.multitenancy
     let tenant = isMultitenant && ctx.tenant
@@ -63,10 +64,10 @@ class DatabaseService extends cds.Service {
 
     // Acquire a pooled connection
     this.dbc = await this.acquire()
-    this.dbc.destroy = this.destroy.bind(this)
+    this.dbc.destroy = this.destroy.bind(this) // REVISIT: this is bad
 
     // Begin a session...
-    try {
+    if (!min) try {
       await this.set(new SessionContext(ctx))
       await this.send('BEGIN')
     } catch (e) {
@@ -153,8 +154,8 @@ class DatabaseService extends cds.Service {
    */
   run(query, data, ...etc) {
     // Allow db.run('...',1,2,3,4)
-    if (data !== undefined && typeof query === 'string' && typeof data !== 'object') data = [data, ...etc]
-    return super.run(query, data)
+    if (data !== undefined && typeof query === 'string' && typeof data !== 'object') arguments[1] = [data, ...etc]
+    return super.run(...arguments) //> important to call like that for tagged template literal args
   }
 
   /**

package/lib/common/generic-pool.js

@@ -1,14 +1,12 @@
 const { createPool } = require('generic-pool')
 
-class ConnectionPool {
-  constructor(factory, tenant) {
-    let bound_factory = { __proto__: factory, create: factory.create.bind(null, tenant) }
-    return _track_connections4(createPool(bound_factory, factory.options))
-  }
+function ConnectionPool (factory, tenant) {
+  let bound_factory = { __proto__: factory, create: factory.create.bind(null, tenant) }
+  return createPool(bound_factory, factory.options)
 }
 
-// REVISIT: Is that really neccessary ?!
-function _track_connections4(pool) {
+function TrackedConnectionPool (factory, tenant) {
+  const pool = new ConnectionPool (factory, tenant)
   const { acquire, release } = pool
   return Object.assign(pool, {
     async acquire() {
@@ -23,7 +21,6 @@ function _track_connections4(pool) {
         throw err
       }
     },
-
     release(dbc) {
       this._trackedConnections?.delete(dbc._beginStack)
       return release.call(this, dbc)
@@ -31,4 +28,5 @@ function _track_connections4(pool) {
   })
 }
 
-module.exports = ConnectionPool
+const DEBUG = /\bpool\b/.test(process.env.DEBUG)
+module.exports = DEBUG ? TrackedConnectionPool : ConnectionPool

package/lib/cql-functions.js

@@ -33,7 +33,7 @@ const StandardFunctions = {
       val = sub[2] || sub[3] || ''
     }
     arg.val = arg.__proto__.val = val
-    const refs = ref.list || [ref]
+    const refs = ref.list
     const { toString } = ref
     return '(' + refs.map(ref2 => this.contains(this.tolower(toString(ref2)), this.tolower(arg))).join(' or ') + ')'
   },
@@ -159,10 +159,6 @@ const StandardFunctions = {
 
   // Date and Time Functions
 
-  current_date: p => (p ? `current_date(${p})` : 'current_date'),
-  current_time: p => (p ? `current_time(${p})` : 'current_time'),
-  current_timestamp: p => (p ? `current_timestamp(${p})` : 'current_timestamp'),
-
   /**
    * Generates SQL statement that produces current point in time (date and time with time zone)
    * @returns {string}
@@ -257,20 +253,23 @@ const StandardFunctions = {
         ) - 0.5
       )
     ) * 86400
-  )`,
+  )`
+}
+
+const HANAFunctions = {
+  // https://help.sap.com/docs/SAP_HANA_PLATFORM/4fe29514fd584807ac9f2a04f6754767/f12b86a6284c4aeeb449e57eb5dd3ebd.html
 
   /**
    * Generates SQL statement that calls the session_context function with the given parameter
    * @param {string} x session variable name or SQL expression
    * @returns {string}
    */
-  session_context: x => `session_context('${x.val}')`,
-}
-
-const HANAFunctions = {
-  // https://help.sap.com/docs/SAP_HANA_PLATFORM/4fe29514fd584807ac9f2a04f6754767/f12b86a6284c4aeeb449e57eb5dd3ebd.html
+    session_context: x => `session_context('${x.val}')`,
 
   // Time functions
+  current_date: p => (p ? `current_date(${p})` : 'current_date'),
+  current_time: p => (p ? `current_time(${p})` : 'current_time'),
+  current_timestamp: p => (p ? `current_timestamp(${p})` : 'current_timestamp'),
   /**
    * Generates SQL statement that calculates the difference in 100nanoseconds between two timestamps
    * @param {string} x left timestamp

package/lib/cqn2sql.js

@@ -6,16 +6,9 @@ const _strict_booleans = _simple_queries < 2
 
 const { Readable } = require('stream')
 
-const DEBUG = (() => {
-  const LOG = cds.log('sql-json')
-  if (LOG._debug) return cds.debug('sql-json')
-  return cds.debug('sql|sqlite')
-  //if (DEBUG) {
-  //  return DEBUG
-  // (sql, ...more) => DEBUG (sql.replace(/(?:SELECT[\n\r\s]+(json_group_array\()?[\n\r\s]*json_insert\((\n|\r|.)*?\)[\n\r\s]*\)?[\n\r\s]+as[\n\r\s]+_json_[\n\r\s]+FROM[\n\r\s]*\(|\)[\n\r\s]*(\)[\n\r\s]+AS )|\)$)/gim,(a,b,c,d) => d || ''), ...more)
-  // FIXME: looses closing ) on INSERT queries
-  //}
-})()
+const DEBUG = cds.debug('sql|sqlite')
+const LOG_SQL = cds.log('sql')
+const LOG_SQLITE =  cds.log('sqlite')
 
 class CQN2SQLRenderer {
   /**
@@ -28,10 +21,12 @@ class CQN2SQLRenderer {
     this.class = new.target // for IntelliSense
     this.class._init() // is a noop for subsequent calls
     this.model = srv?.model
-
     // Overwrite smart quoting
     if (cds.env.sql.names === 'quoted') {
-      this.class.prototype.name = (name) => name.id || name
+      this.class.prototype.name = (name, query) => {
+        const e = name.id || name
+        return (query?.target || this.model?.definitions[e])?.['@cds.persistence.name'] || e 
+      }
       this.class.prototype.quote = (s) => `"${String(s).replace(/"/g, '""')}"`
     }
   }
@@ -90,10 +85,17 @@ class CQN2SQLRenderer {
     if (vars?.length && !this.values?.length) this.values = vars
     if (vars && Object.keys(vars).length && !this.values?.length) this.values = vars
     const sanitize_values = process.env.NODE_ENV === 'production' && cds.env.log.sanitize_values !== false
-    DEBUG?.(
-      this.sql,
-      ...(sanitize_values && (this.entries || this.values?.length > 0) ? ['***'] : this.entries || this.values || []),
-    )
+
+    
+    if (DEBUG && (LOG_SQL._debug || LOG_SQLITE._debug)) {
+      let values = sanitize_values && (this.entries || this.values?.length > 0) ? ['***'] : this.entries || this.values || []
+      if (values && !Array.isArray(values)) {
+        values = [values]
+      }
+      DEBUG(this.sql, ...values)
+    }
+
+    
     return this
   }
 
@@ -124,7 +126,7 @@ class CQN2SQLRenderer {
       target = typeof entity === 'string' ? { name: entity } : q.CREATE.entity
     }
 
-    const name = this.name(target.name)
+    const name = this.name(target.name, q)
     // Don't allow place holders inside views
     delete this.values
     this.sql =
@@ -213,7 +215,7 @@ class CQN2SQLRenderer {
     const { target } = q
     const isView = target?.query || target?.projection || q.DROP.view
     const name = target?.name || q.DROP.table?.ref?.[0] || q.DROP.view?.ref?.[0]
-    return (this.sql = `DROP ${isView ? 'VIEW' : 'TABLE'} IF EXISTS ${this.quote(this.name(name))}`)
+    return (this.sql = `DROP ${isView ? 'VIEW' : 'TABLE'} IF EXISTS ${this.quote(this.name(name, q))}`)
   }
 
   // SELECT Statements ------------------------------------------------
@@ -352,15 +354,10 @@ class CQN2SQLRenderer {
     const _aliased = as ? s => s + ` as ${this.quote(as)}` : s => s
     if (ref) {
       let z = ref[0]
-      if (cds.env.sql.names === 'quoted') {
-        // use SELECT.from to infer query, cds.infer also expects a query
-        const { target } = q || SELECT.from(from)
-        z = target?.['@cds.persistence.name'] || ref[0]
-      }
       if (z.args) {
-        return _aliased(`${this.quote(this.name(z))}${this.from_args(z.args)}`)
+        return _aliased(`${this.quote(this.name(z, q))}${this.from_args(z.args)}`)
       }
-      return _aliased(this.quote(this.name(z)))
+      return _aliased(this.quote(this.name(z, q)))
     }
     if (from.SELECT) return _aliased(`(${this.SELECT(from)})`)
     if (from.join) return `${this.from(from.args[0])} ${from.join} JOIN ${this.from(from.args[1])}${from.on ? ` ON ${this.where(from.on)}` : ''}`
@@ -423,8 +420,8 @@ class CQN2SQLRenderer {
         ? c =>
           this.expr(c) +
           (c.element?.[this.class._localized] ? ' COLLATE NOCASE' : '') +
-          (c.sort === 'desc' || c.sort === -1 ? ' DESC' : ' ASC')
-        : c => this.expr(c) + (c.sort === 'desc' || c.sort === -1 ? ' DESC' : ' ASC'),
+          (c.sort?.toLowerCase() === 'desc' || c.sort === -1 ? ' DESC' : ' ASC')
+        : c => this.expr(c) + (c.sort?.toLowerCase() === 'desc' || c.sort === -1 ? ' DESC' : ' ASC'),
     )
   }
 
@@ -504,7 +501,7 @@ class CQN2SQLRenderer {
     this.columns = columns
 
     const alias = INSERT.into.as
-    const entity = this.name(q.target?.name || INSERT.into.ref[0])
+    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: ['?'] })
@@ -638,7 +635,7 @@ class CQN2SQLRenderer {
    */
   INSERT_rows(q) {
     const { INSERT } = q
-    const entity = this.name(q.target?.name || INSERT.into.ref[0])
+    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 columns = this.columns = INSERT.columns || cds.error`Cannot insert rows without columns or elements`
@@ -684,7 +681,7 @@ class CQN2SQLRenderer {
    */
   INSERT_select(q) {
     const { INSERT } = q
-    const entity = this.name(q.target.name)
+    const entity = this.name(q.target.name, q)
     const alias = INSERT.into.as
     const elements = q.elements || q.target?.elements || {}
     const columns = (this.columns = (INSERT.columns || ObjectKeys(elements)).filter(
@@ -752,7 +749,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])
+    const entity = this.name(q.target?.name || UPSERT.into.ref[0], q)
     sql = `SELECT ${managed.map(c => c.upsert)} FROM (SELECT value, ${extractkeys} from json_each(?)) as NEW LEFT JOIN ${this.quote(entity)} AS OLD ON ${keyCompare}`
 
     const updateColumns = columns.filter(c => {
@@ -779,7 +776,7 @@ class CQN2SQLRenderer {
   UPDATE(q) {
     const { entity, with: _with, data, where } = q.UPDATE
     const elements = q.target?.elements
-    let sql = `UPDATE ${this.quote(this.name(entity.ref?.[0] || entity))}`
+    let sql = `UPDATE ${this.quote(this.name(entity.ref?.[0] || entity, q))}`
     if (entity.as) sql += ` AS ${this.quote(entity.as)}`
 
     let columns = []
@@ -811,8 +808,9 @@ class CQN2SQLRenderer {
    * @param {import('./infer/cqn').DELETE} param0
    * @returns {string} SQL
    */
-  DELETE({ DELETE: { from, where } }) {
-    let sql = `DELETE FROM ${this.from(from)}`
+  DELETE(q) {
+    const { DELETE: { from, where } } = q
+    let sql = `DELETE FROM ${this.from(from, q)}`
     if (where) sql += ` WHERE ${this.where(where)}`
     return (this.sql = sql)
   }
@@ -1028,6 +1026,7 @@ class CQN2SQLRenderer {
   /**
    * Calculates the Database name of the given name
    * @param {string|import('./infer/cqn').ref} name
+   * @param {import('./infer/cqn').Query} query
    * @returns {string} Database name
    */
   name(name) {

package/lib/cqn4sql.js

@@ -51,7 +51,7 @@ function cqn4sql(originalQuery, model) {
 
   if (!hasCustomJoins && inferred.SELECT?.search) {
     // we need an instance of query because the elements of the query are needed for the calculation of the search columns
-    if (!inferred.SELECT.elements) Object.setPrototypeOf(inferred, Object.getPrototypeOf(SELECT()))
+    if (!inferred.SELECT.elements) Object.setPrototypeOf(inferred, SELECT.class.prototype)
     const searchTerm = getSearchTerm(inferred.SELECT.search, inferred)
     if (searchTerm) {
       // Search target can be a navigation, in that case use _target to get the correct entity
@@ -408,6 +408,7 @@ function cqn4sql(originalQuery, model) {
       const last = $refLinks?.[$refLinks.length - 1]
       if (last && !last.skipExpand && last.definition.isAssociation) {
         const expandedSubqueryColumn = expandColumn(col)
+        if (!expandedSubqueryColumn) return []
         setElementOnColumns(expandedSubqueryColumn, col.element)
         res.push(expandedSubqueryColumn)
       } else if (!last?.skipExpand) {
@@ -438,7 +439,10 @@ function cqn4sql(originalQuery, model) {
 
       let baseName
       if (col.ref.length >= 2) {
-        baseName = col.ref.slice(col.ref[0] === tableAlias ? 1 : 0, col.ref.length - 1).join('_')
+        baseName = col.ref
+          .map(idOnly)
+          .slice(col.ref[0] === tableAlias ? 1 : 0, col.ref.length - 1)
+          .join('_')
       }
 
       let columnAlias = col.as || (col.isJoinRelevant ? col.flatName : null)
@@ -863,7 +867,7 @@ function cqn4sql(originalQuery, model) {
      * @param {Object} column - To expand.
      * @param {Array} baseRef - The base reference for the expanded column.
      * @param {string} subqueryAlias - The alias of the `expand` subquery column.
-     * @returns {Object} - The subquery object.
+     * @returns {Object} - The subquery object or null if the expand has a wildcard.
      * @throws {Error} - If one of the `ref`s in the `column.expand` is not part of the GROUP BY clause.
      */
     function _subqueryForGroupBy(column, baseRef, subqueryAlias) {
@@ -873,7 +877,13 @@ function cqn4sql(originalQuery, model) {
 
       // to be attached to dummy query
       const elements = {}
+      const wildcardIndex = column.expand.findIndex(e => e === '*')
+      if (wildcardIndex !== -1) {
+        // 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) {
@@ -976,7 +986,10 @@ function cqn4sql(originalQuery, model) {
         let baseName
         if (col.ref.length >= 2) {
           // leaf might be intermediate structure
-          baseName = col.ref.slice(col.ref[0] === tableAlias ? 1 : 0, col.ref.length - 1).join('_')
+          baseName = col.ref
+            .map(idOnly)
+            .slice(col.ref[0] === tableAlias ? 1 : 0, col.ref.length - 1)
+            .join('_')
         }
         const flatColumns = getFlatColumnsFor(col, { baseName, tableAlias })
         /**
@@ -1160,10 +1173,9 @@ function cqn4sql(originalQuery, model) {
     else if (element.virtual === true) return []
     else if (!isJoinRelevant && flatName) baseName = flatName
     else if (isJoinRelevant) {
-      const leaf = column.$refLinks[column.$refLinks.length - 1]
+      const leaf = column.$refLinks.at(-1)
       leafAssoc = [...column.$refLinks].reverse().find(link => link.definition.isAssociation)
-      let elements
-      elements = leafAssoc.definition.elements || leafAssoc.definition.foreignKeys
+      let elements = leafAssoc.definition.elements || leafAssoc.definition.foreignKeys
       if (elements && leaf.definition.name in elements) {
         element = leafAssoc.definition
         baseName = getFullName(leafAssoc.definition)
@@ -1203,68 +1215,76 @@ function cqn4sql(originalQuery, model) {
 
     if (element.keys) {
       const flatColumns = []
-      element.keys.forEach(fk => {
-        const fkElement = getElementForRef(fk.ref, getDefinition(element.target))
-        let fkBaseName
-        if (!leafAssoc || leafAssoc.onlyForeignKeyAccess)
-          fkBaseName = `${baseName}_${fk.as || fk.ref[fk.ref.length - 1]}`
-        // e.g. if foreign key is accessed via infix filter - use join alias to access key in target
-        else fkBaseName = fk.ref[fk.ref.length - 1]
-        const fkPath = [...csnPath, fk.ref[fk.ref.length - 1]]
-        if (fkElement.elements) {
-          // structured key
-          Object.values(fkElement.elements).forEach(e => {
-            let alias
-            if (columnAlias) {
-              const fkName = fk.as
-                ? `${fk.as}_${e.name}` // foreign key might also be re-named: `assoc { id as foo }`
-                : `${fk.ref.join('_')}_${e.name}`
-              alias = `${columnAlias}_${fkName}`
+      for (const k of element.keys) {
+        // if only one part of a foreign key is requested, only flatten the partial key
+        const keyElement = getElementForRef(k.ref, getDefinition(element.target))
+        const flattenThisForeignKey =
+          !$refLinks || // the association is passed as element, not as ref --> flatten full foreign key
+          element === $refLinks.at(-1).definition || // the association is the leaf of the ref --> flatten full foreign key
+          keyElement === $refLinks.at(-1).definition // the foreign key is the leaf of the ref --> only flatten this specific foreign key
+        if (flattenThisForeignKey) {
+          const fkElement = getElementForRef(k.ref, getDefinition(element.target))
+          let fkBaseName
+          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)]
+          if (fkElement.elements) {
+            // structured key
+            for (const e of Object.values(fkElement.elements)) {
+              let alias
+              if (columnAlias) {
+                const fkName = k.as
+                  ? `${k.as}_${e.name}` // foreign key might also be re-named: `assoc { id as foo }`
+                  : `${k.ref.join('_')}_${e.name}`
+                alias = `${columnAlias}_${fkName}`
+              }
+              flatColumns.push(
+                ...getFlatColumnsFor(
+                  e,
+                  { baseName: fkBaseName, columnAlias: alias, tableAlias },
+                  [...fkPath],
+                  excludeAndReplace,
+                  isWildcard,
+                ),
+              )
             }
+          } else if (fkElement.isAssociation) {
+            // assoc as key
             flatColumns.push(
               ...getFlatColumnsFor(
-                e,
-                { baseName: fkBaseName, columnAlias: alias, tableAlias },
-                [...fkPath],
+                fkElement,
+                { baseName, columnAlias, tableAlias },
+                csnPath,
                 excludeAndReplace,
                 isWildcard,
               ),
             )
-          })
-        } else if (fkElement.isAssociation) {
-          // assoc as key
-          flatColumns.push(
-            ...getFlatColumnsFor(
-              fkElement,
-              { baseName, columnAlias, tableAlias },
-              csnPath,
-              excludeAndReplace,
-              isWildcard,
-            ),
-          )
-        } else {
-          // leaf reached
-          let flatColumn
-          if (columnAlias) {
-            // if the column has an explicit alias AND the orignal ref
-            // directly resolves to the foreign key, we must not append the fk name to the column alias
-            // e.g. `assoc.fk as FOO` => columns.alias = FOO
-            //      `assoc as FOO`    => columns.alias = FOO_fk
-            let columnAliasWithFlatFk
-            if (!(column.as && fkElement === column.$refLinks?.at(-1).definition))
-              columnAliasWithFlatFk = `${columnAlias}_${fk.as || fk.ref.join('_')}`
-            flatColumn = { ref: [fkBaseName], as: columnAliasWithFlatFk || columnAlias }
-          } else flatColumn = { ref: [fkBaseName] }
-          if (tableAlias) flatColumn.ref.unshift(tableAlias)
-
-          // in a flat model, we must assign the foreign key rather than the key in the target
-          const flatForeignKey = getDefinition(element.parent.name)?.elements[fkBaseName]
-
-          setElementOnColumns(flatColumn, flatForeignKey || fkElement)
-          Object.defineProperty(flatColumn, '_csnPath', { value: csnPath, writable: true })
-          flatColumns.push(flatColumn)
+          } else {
+            // leaf reached
+            let flatColumn
+            if (columnAlias) {
+              // if the column has an explicit alias AND the original ref
+              // directly resolves to the foreign key, we must not append the fk name to the column alias
+              // e.g. `assoc.fk as FOO` => columns.alias = FOO
+              //      `assoc as FOO`    => columns.alias = FOO_fk
+              let columnAliasWithFlatFk
+              if (!(column.as && fkElement === column.$refLinks?.at(-1).definition))
+                columnAliasWithFlatFk = `${columnAlias}_${k.as || k.ref.join('_')}`
+              flatColumn = { ref: [fkBaseName], as: columnAliasWithFlatFk || columnAlias }
+            } else flatColumn = { ref: [fkBaseName] }
+            if (tableAlias) flatColumn.ref.unshift(tableAlias)
+
+            // in a flat model, we must assign the foreign key rather than the key in the target
+            const flatForeignKey = getDefinition(element.parent.name)?.elements[fkBaseName]
+
+            setElementOnColumns(flatColumn, flatForeignKey || fkElement)
+            Object.defineProperty(flatColumn, '_csnPath', { value: csnPath, writable: true })
+            flatColumns.push(flatColumn)
+          }
         }
-      })
+      }
       return flatColumns
     } else if (element.elements) {
       const flatRefs = []
@@ -1297,7 +1317,7 @@ function cqn4sql(originalQuery, model) {
 
     function getReplacement(from) {
       return from?.find(replacement => {
-        const nameOfExcludedColumn = replacement.as || replacement.ref?.[replacement.ref.length - 1] || replacement
+        const nameOfExcludedColumn = replacement.as || replacement.ref?.at(-1) || replacement
         return nameOfExcludedColumn === element.name
       })
     }
@@ -1581,7 +1601,10 @@ function cqn4sql(originalQuery, model) {
       if (leaf.definition.parent.kind !== 'entity')
         // we need the base name
         return getFlatColumnsFor(leaf.definition, {
-          baseName: def.ref.slice(0, def.ref.length - 1).join('_'),
+          baseName: def.ref
+            .map(idOnly)
+            .slice(0, def.ref.length - 1)
+            .join('_'),
           tableAlias,
         })
       return getFlatColumnsFor(leaf.definition, { tableAlias })
@@ -1726,7 +1749,8 @@ function cqn4sql(originalQuery, model) {
       transformedFrom.$refLinks.splice(0, transformedFrom.$refLinks.length - 1)
 
       let args = from.ref.at(-1).args
-      const subquerySource = transformedFrom.$refLinks[0].target
+      const subquerySource =
+        getDefinition(transformedFrom.$refLinks[0].definition.target) || transformedFrom.$refLinks[0].target
       if (subquerySource.params && !args) args = {}
       const id = localized(subquerySource)
       transformedFrom.ref = [args ? { id, args } : id]
@@ -2202,10 +2226,7 @@ function cqn4sql(originalQuery, model) {
       const xpr = search
       const searchFunc = {
         func: 'search',
-        args: [
-          searchIn.length > 1 ? { list: searchIn } : { ...searchIn[0] },
-          xpr.length === 1 && 'val' in xpr[0] ? xpr[0] : { xpr },
-        ],
+        args: [{ list: searchIn }, xpr.length === 1 && 'val' in xpr[0] ? xpr[0] : { xpr }],
       }
       return searchFunc
     } else {

package/lib/fill-in-keys.js

@@ -35,7 +35,7 @@ const generateUUIDandPropagateKeys = (entity, data, event) => {
   if (event === 'CREATE') {
     const keys = entity.keys
     for (const k in keys)
-      if (keys[k].isUUID && !data[k] && !assoc4(keys[k])) //> skip key assocs, and foreign keys thereof
+      if (keys[k].isUUID && !data[k] && !assoc4(keys[k]) && !keys[k].default) //> skip key assocs, and foreign keys thereof
         data[k] = cds.utils.uuid()
   }
   for (const each in entity.elements) {