@sap/cds 5.7.2 → 5.8.0

package/libx/_runtime/common/utils/resolveView.js

@@ -152,9 +152,15 @@ const _newColumns = (columns = [], transition, service, withAlias = false) => {
   const newColumns = []
 
   columns.forEach(column => {
+    let newColumn
+    if (column.func) {
+      newColumn = { ...column }
+      newColumn.args = _newColumns(column.args, transition, service, withAlias)
+      newColumns.push(newColumn)
+      return newColumns
+    }
     const mapped = column.ref && transition.mapping.get(column.ref[0])
 
-    let newColumn
     if (mapped && mapped.ref) {
       newColumn = { ...column }
 
@@ -238,7 +244,7 @@ const _newEntries = (entries = [], transition, service) =>
 const _newWhere = (where = [], transition, tableName, alias, isSubselect = false) => {
   const newWhere = where.map(whereElement => {
     const newWhereElement = { ...whereElement }
-    if (!whereElement.ref && !whereElement.SELECT) return whereElement
+    if (!whereElement.ref && !whereElement.SELECT && !whereElement.func) return whereElement
     if (whereElement.SELECT && whereElement.SELECT.where) {
       newWhereElement.SELECT.where = _newWhere(whereElement.SELECT.where, transition, tableName, alias, true)
       return newWhereElement
@@ -246,6 +252,9 @@ const _newWhere = (where = [], transition, tableName, alias, isSubselect = false
       if (newWhereElement.ref) {
         _newWhereRef(newWhereElement, transition, alias, tableName, isSubselect)
         return newWhereElement
+      } else if (newWhereElement.func) {
+        newWhereElement.args = _newWhere(newWhereElement.args, transition, tableName, alias)
+        return newWhereElement
       } else {
         return whereElement
       }
@@ -337,8 +346,7 @@ const _newSelect = (query, transitions, service) => {
   }
   if (!newSelect.columns && targetTransition.mapping.size) newSelect.columns = _initialColumns(targetTransition)
   if (newSelect.columns) {
-    const isDB = service instanceof cds.DatabaseService
-    rewriteAsterisks({ SELECT: query.SELECT }, service.model, isDB)
+    rewriteAsterisks({ SELECT: query.SELECT }, service.model, { _4db: service instanceof cds.DatabaseService })
     newSelect.columns = _newColumns(newSelect.columns, targetTransition, service, service.kind !== 'app-service')
   }
   if (newSelect.having) newSelect.having = _newColumns(newSelect.having, targetTransition)

package/libx/_runtime/common/utils/rewriteAsterisks.js

@@ -30,10 +30,11 @@ const _cqlDraftColumns = target => {
   ]
 }
 
-const _expandColumn = (column, target, db) => {
+const _expandColumn = (column, target, _4db) => {
   if (!(column.ref && column.expand)) return
   const nextTarget = getNavigationIfStruct(target, column.ref)
-  if (nextTarget && nextTarget._target && nextTarget._target.elements) _rewriteAsterisks(column, nextTarget._target, db)
+  if (nextTarget && nextTarget._target && nextTarget._target.elements)
+    _rewriteAsterisks(column, nextTarget._target, _4db)
   return column
 }
 
@@ -46,32 +47,33 @@ const rewriteExpandAsterisk = (columns, target) => {
     const { expand } = columns.splice(expandAllColIdx, 1)[0]
     for (const elName in target.elements) {
       if (target.elements[elName]._target && !columns.find(col => col.expand && col.ref && col.ref[0] === elName)) {
+        if (elName === 'SiblingEntity') continue
         columns.push({ ref: [elName], expand: [...expand] })
       }
     }
   }
 }
 
-const _rewriteAsterisk = (columns, target, db, isRoot) => {
+const _rewriteAsterisk = (columns, target, _4db, isRoot) => {
   const asteriskColumnIndex = columns.findIndex(col => isAsteriskColumn(col))
   if (asteriskColumnIndex > -1) {
     columns.splice(
       asteriskColumnIndex,
       1,
-      ...getColumns(target, { db })
+      ...getColumns(target, { _4db })
         .map(c => ({ ref: [c.name] }))
         .filter(c => !columns.find(_isDuplicate(c)) && (isRoot || c.ref[0] !== 'DraftAdministrativeData_DraftUUID'))
     )
   }
 }
 
-const _rewriteAsterisks = (cqn, target, db, isRoot) => {
+const _rewriteAsterisks = (cqn, target, _4db, isRoot) => {
   if (cqn.expand === '*') cqn.expand = ['*']
   const columns = cqn.expand || cqn.columns
-  _rewriteAsterisk(columns, target, db, isRoot)
+  _rewriteAsterisk(columns, target, _4db, isRoot)
   rewriteExpandAsterisk(columns, target)
   for (const column of columns) {
-    _expandColumn(column, target, db)
+    _expandColumn(column, target, _4db)
   }
   return columns
 }
@@ -83,9 +85,17 @@ const _targetOfQueryIfNotDraft = (query, model) => {
   return target
 }
 
-const rewriteAsterisks = (query, model, db = false, isDraft = false, onlyKeys = false) => {
+const rewriteAsterisks = (query, model, options) => {
+  /*
+   * REVISIT:
+   * - _4db: called on db level
+   * - _4fiori: cqn2cqn4sql called in a fiori handler
+   * this is extremely obfuscated!
+   */
+  const { _4db, _4fiori } = options
+
   if (!query.SELECT.columns || !query.SELECT.columns.length) {
-    if (isDraft || db) {
+    if (_4db || _4fiori) {
       if (
         query.SELECT.from.SET &&
         query.SELECT.from.SET.args[0] &&
@@ -101,7 +111,7 @@ const rewriteAsterisks = (query, model, db = false, isDraft = false, onlyKeys =
         for (const arg of query.SELECT.from.args) {
           const _targetName = arg.ref[0].id || arg.ref[0]
           const _target = model.definitions[ensureNoDraftsSuffix(_targetName)]
-          const columns = getColumns(_target, { db, onlyKeys })
+          const columns = getColumns(_target, { _4db })
             .filter(
               c =>
                 !query.SELECT.columns.some(
@@ -116,16 +126,20 @@ const rewriteAsterisks = (query, model, db = false, isDraft = false, onlyKeys =
       } else {
         const target = _targetOfQueryIfNotDraft(query, model)
         if (!target) return
-        query.SELECT.columns = getColumns(target, { db, onlyKeys }).map(col => ({ ref: [col.name] }))
-        if (db && target._isDraftEnabled) query.SELECT.columns.push(..._cqlDraftColumns(target))
+
+        query.SELECT.columns = getColumns(target, { _4db }).map(col => ({ ref: [col.name] }))
+        if (_4db && target._isDraftEnabled) query.SELECT.columns.push(..._cqlDraftColumns(target))
       }
     }
+
     return
   }
+
   const target = _targetOfQueryIfNotDraft(query, model)
   if (!target) return
+
   // REVISIT: Also support JOINs/SETs here
-  query.SELECT.columns = _rewriteAsterisks(query.SELECT, target, db, true)
+  query.SELECT.columns = _rewriteAsterisks(query.SELECT, target, _4db, true)
 }
 
 module.exports = {

package/libx/_runtime/common/utils/search2cqn4sql.js

@@ -18,8 +18,8 @@ const _search2cqn4sql = (query, model, options = {}) => {
 
   // Call custom (optimized search to cqn for sql implementation) that tries
   // to optimize the search behavior for a specific database service.
-  // Note: $search query option combined with $filter is not currently optimized
-  if (typeof search2cqn4sql === 'function' && !query.SELECT.where) {
+  // REVISIT: $search query option combined with $count is not currently optimized
+  if (typeof search2cqn4sql === 'function' && !query.SELECT.count) {
     const search2cqnOptions = { columns, locale: options.locale }
     return search2cqn4sql(query, entity, search2cqnOptions)
   }
@@ -30,9 +30,14 @@ const _search2cqn4sql = (query, model, options = {}) => {
   query._aggregated || /* if new parser */ query.SELECT.groupBy ? query.having(expression) : query.where(expression)
 }
 
-// convert $search system query option to WHERE/HAVING clause using
-// the operator LIKE or CONTAINS
-module.exports = (query, model, options) => {
-  if (query.SELECT.from.SET) return query.SELECT.from.SET.args.forEach(arg => _search2cqn4sql(arg, model, options))
+const search2cqn4sql = (query, model, options) => {
+  if (query.SELECT.from.SET) {
+    return query.SELECT.from.SET.args.forEach(arg => _search2cqn4sql(arg, model, options))
+  }
+
   return _search2cqn4sql(query, model, options)
 }
+
+// convert $search system query option to WHERE/HAVING clause using
+// the operator LIKE or CONTAINS
+module.exports = search2cqn4sql

package/libx/_runtime/common/utils/structured.js

@@ -284,7 +284,7 @@ const flattenStructuredSelect = ({ SELECT }, model) => {
       _flattenColumns(SELECT, flattenedElements, toBeDeleted, entity)
       SELECT.columns = SELECT.columns.filter(column => {
         const columnName = column.ref ? column.ref[0] : column.as
-        return (columnName && !toBeDeleted.includes(columnName)) || column.func || column.expand
+        return (columnName && !toBeDeleted.includes(columnName)) || column.func || column.expand || 'val' in column
       })
       if (flattenedElements.length) SELECT.columns.push(...flattenedElements)
     }

package/libx/_runtime/common/utils/vcap.js

@@ -1,11 +1,28 @@
-const vcapApplication = process.env.VCAP_APPLICATION && JSON.parse(process.env.VCAP_APPLICATION)
-
-module.exports = {
-  appName: vcapApplication && vcapApplication.application_name,
-  appID: vcapApplication && vcapApplication.application_id,
-  appURL:
-    vcapApplication &&
-    vcapApplication.application_uris &&
-    vcapApplication.application_uris[0] &&
-    `https://${vcapApplication.application_uris[0].replace(/^https?:\/\//, '')}`
+const cds = require('../../../../libx/_runtime/cds')
+
+const getAppMetadata = () => {
+  const appMetadata = cds.env.app
+
+  if (appMetadata) {
+    return {
+      appID: appMetadata.id,
+      appName: appMetadata.name,
+      appURL: appMetadata.url
+    }
+  }
+
+  // fallback: if the app metadata is undefined, then extract the metadata from the underlying environment (CF/Kyma/...)
+  const vcapApplication = process.env.VCAP_APPLICATION && JSON.parse(process.env.VCAP_APPLICATION)
+
+  return {
+    appID: vcapApplication && vcapApplication.application_id,
+    appName: vcapApplication && vcapApplication.application_name,
+    appURL:
+      vcapApplication &&
+      vcapApplication.application_uris &&
+      vcapApplication.application_uris[0] &&
+      `https://${vcapApplication.application_uris[0].replace(/^https?:\/\//, '')}`
+  }
 }
+
+module.exports = getAppMetadata()

package/libx/_runtime/db/data-conversion/post-processing.js

@@ -1,6 +1,6 @@
 const cds = require('../../cds')
 
-const { ensureUnlocalized } = require('../../common/utils/draft')
+const { ensureUnlocalized, ensureNoDraftsSuffix } = require('../../common/utils/draft')
 
 /**
  * Check if the value is a function or reference to private function.
@@ -48,49 +48,50 @@ const _getEntityName = (csn, from) => {
 
 const _refs = (refs, as) => {
   const arr = []
-  const hasOwnProperty = Object.prototype.hasOwnProperty
-
   for (const element of refs) {
     // multiple join are nested, so we need to find all the table names in there as well
-    if (hasOwnProperty.call(element, 'join')) {
+    if (Object.prototype.hasOwnProperty.call(element, 'join')) {
       arr.push(..._extractRefs(element))
       // Likely a union
-    } else if (hasOwnProperty.call(element, 'SELECT')) {
-      arr.push(..._extractRefs(element.SELECT.from, as))
+    } else if (Object.prototype.hasOwnProperty.call(element, 'SELECT')) {
+      arr.push(..._extractRefs(element.SELECT.from, element.as))
     } else {
-      arr.push(element)
+      arr.push(..._extractRefs(element, as))
     }
   }
 
   return arr
 }
 
+const _getActiveFromUnion = refs => {
+  if (refs.length !== 2) return
+  const [maybeDraft, maybeActive] = refs
+  if (ensureNoDraftsSuffix(maybeDraft.ref[0]) === maybeActive.ref[0]) return maybeActive
+  if (ensureNoDraftsSuffix(maybeActive.ref[0]) === maybeDraft.ref[0]) return maybeDraft
+}
+
 const _extractRefs = (from, as) => {
   if (from.SELECT) {
-    return _extractRefs(from.SELECT.from, from.SELECT.as)
+    return _extractRefs(from.SELECT.from, as || from.SELECT.as)
   }
-
-  const hasOwnProperty = Object.prototype.hasOwnProperty
-
-  if (hasOwnProperty.call(from, 'join')) {
+  if (Object.prototype.hasOwnProperty.call(from, 'join')) {
     // cqn with join in from
     return _refs(from.args)
   }
-
-  if (hasOwnProperty.call(from, 'SET')) {
-    return _refs(from.SET.args, from.SET.as || from.as)
+  if (Object.prototype.hasOwnProperty.call(from, 'SET')) {
+    let refs = _refs(from.SET.args).filter(a => !a.as || a.as !== 'filterAdmin')
+    refs = _getActiveFromUnion(refs) ? [_getActiveFromUnion(refs)] : refs
+    if (as) return refs.map(({ ref }) => ({ as, ref }))
+    return refs
   }
-
-  const ref = { ref: from.ref, as: from.as }
-
-  if (as) {
-    ref.as = as
-  }
-
+  if (!from.ref) return []
+  const ref = { ref: [...from.ref] }
+  if (as || from.as) ref.as = as || from.as
   return [ref]
 }
 
-const _addMapperFunction = (elements, toService, key, type, from, includeAlias) => {
+// REVISIT: check why we need includeAlias for some draft cases (check AFC tests)
+const _addMapperFunction = (elements, toService, key, type, alias, includeAlias) => {
   if (!toService.has(type)) {
     return
   }
@@ -99,9 +100,8 @@ const _addMapperFunction = (elements, toService, key, type, from, includeAlias)
 
   // ambiguous cases will lead to SQL syntax errors anyway, so no need for a check
   elements.set(key, convertFunction)
-
-  if (includeAlias) {
-    elements.set(`${from.as}_${key}`, convertFunction)
+  if (includeAlias && alias) {
+    elements.set(`${alias}_${key}`, convertFunction)
   }
 }
 
@@ -109,13 +109,13 @@ const _filterUnique = (value, index, arr) => {
   return arr.indexOf(value) === index
 }
 
-const _addMapperFunction4struct = (elements, toService, parent, struct, from, includeAlias) => {
+const _addMapperFunction4struct = (elements, toService, parent, struct, alias, includeAlias) => {
   for (const k in struct.elements) {
     const current = struct.elements[k]
     if (current._isStructured) {
-      _addMapperFunction4struct(elements, toService, `${parent}_${k}`, current, from, includeAlias)
+      _addMapperFunction4struct(elements, toService, `${parent}_${k}`, current, alias, includeAlias)
     } else {
-      _addMapperFunction(elements, toService, `${parent}_${k}`, current.type, from, includeAlias)
+      _addMapperFunction(elements, toService, `${parent}_${k}`, current.type, alias, includeAlias)
     }
   }
 }
@@ -126,7 +126,6 @@ const _addMapperFunction4struct = (elements, toService, parent, struct, from, in
  * @param {Map} toService - Mapping instructions for data conversions based on CDS data types
  * @param {object} csn - Reflected CSN
  * @param {object} cqn - CQN that is used to query the DB.
- * @param {boolean} [includeAlias] - Include mapping for aliases. Defaults to false.
  * @returns {Map<any, any>}
  * @private
  */
@@ -142,13 +141,16 @@ const _getElementCombinations = (toService, csn, cqn, includeAlias = false) => {
     }
 
     const entity = csn.definitions[ensureUnlocalized(entityName)]
-
     for (const key in entity.elements) {
       const element = entity.elements[key]
       if (element._isStructured) {
-        _addMapperFunction4struct(elements, toService, key, element, from, includeAlias)
+        _addMapperFunction4struct(elements, toService, key, element, from.as, includeAlias)
       } else {
-        _addMapperFunction(elements, toService, key, element.type, from, includeAlias)
+        if ('SET' in cqn.SELECT.from) {
+          _addMapperFunction(elements, toService, key, element.type, cqn.SELECT.from.as, includeAlias)
+        } else {
+          _addMapperFunction(elements, toService, key, element.type, from.as, includeAlias)
+        }
       }
     }
   }
@@ -182,15 +184,17 @@ const _getMapperForListedElements = (toService, csn, cqn) => {
 
   for (const element of cqn.SELECT.columns) {
     if (element.ref) {
-      const identifier = element.ref[element.ref.length - 1]
+      const identifier = element.ref.length === 1 ? element.ref[0] : undefined
       const name = element.as ? element.as : identifier
 
       if (element.cast) {
         mapper.set(name, _getCastFunction(element.cast))
       } else if (elements.has(name)) {
         mapper.set(name, elements.get(name))
-      } else if (elements.has(identifier) && !cqn.SELECT.from.args) {
+      } else if (elements.has(identifier)) {
         mapper.set(name, elements.get(identifier))
+      } else if (elements.has(element.ref.join('_'))) {
+        mapper.set(name || element.ref[element.ref.length - 1], elements.get(element.ref.join('_')))
       }
     } else if (element.as && element.cast) {
       mapper.set(element.as, _getCastFunction(element.cast))
@@ -514,6 +518,9 @@ const getPropertyMapper = (csn, cqn) => {
   return new Map()
 }
 
+/*
+ * this module is required by cds-pg. -> in case of incompatible changes, we should let them know.
+ */
 module.exports = {
   getPropertyMapper,
   getPostProcessMapper,

package/libx/_runtime/db/expand/expand-v2.js

@@ -11,9 +11,10 @@ const _removeParentKeysFromRow = (row, prefix, keys) => {
   }
 }
 
-const _autoExpandNavsAndAttachToResult = async (entity, previousResult, depth) => {
+const _autoExpandNavsAndAttachToResult = async (entity, previousResult, depth, options) => {
   for (const nav in entity._associations) {
     const navigation = entity._associations[nav]
+    if (options.onlyCompositions && navigation._isAssociationEffective) continue
 
     // do not expand backlinks
     if (navigation._isBacklink) continue
@@ -26,7 +27,9 @@ const _autoExpandNavsAndAttachToResult = async (entity, previousResult, depth) =
       .on(entity._relations[navigation.name].join(childAlias, parentAlias))
 
     // set alias for expanded columns already
-    const childColumns = getColumns(navigation._target).map(c => ({ ref: [childAlias, c.name] }))
+    const childColumns = getColumns(navigation._target, { _4db: true, onlyKeys: options.onlyKeys }).map(c => ({
+      ref: [childAlias, c.name]
+    }))
     const parentKeys = Object.keys(entity.keys).filter(k => !entity.keys[k].isAssociation)
     // mark parent key with prefix in alias
     const parentKeysWithAlias = parentKeys.map(pk => ({ ref: [parentAlias, pk], as: `$$pk_${pk}` }))
@@ -69,16 +72,17 @@ const _autoExpandNavsAndAttachToResult = async (entity, previousResult, depth) =
 
     // expand next level if needed
     if (depth - 1 !== 0 && result.length && navigation._target._associations) {
-      await _autoExpandNavsAndAttachToResult(navigation._target, result, depth - 1)
+      await _autoExpandNavsAndAttachToResult(navigation._target, result, depth - 1, options)
     }
   }
 
   return previousResult
 }
 
-const _foreignKeysOfTopLevelNavs = entity => {
+const _foreignKeysOfTopLevelNavs = (entity, options) => {
   const requiredFks = new Set()
   for (const nav in entity._associations) {
+    if (options.onlyCompositions && entity._associations[nav]._isAssociationEffective) continue
     const onCond = entity._relations[nav].join('child', 'parent')
     for (const ele of onCond) {
       if (ele.ref && ele.ref[0] === 'parent') {
@@ -89,6 +93,15 @@ const _foreignKeysOfTopLevelNavs = entity => {
   return [...requiredFks]
 }
 
+const _addForeignKeys = (columns, entity, options) => {
+  const fks = _foreignKeysOfTopLevelNavs(entity, options)
+  fks.forEach(fk => {
+    if (!columns.some(c => c.ref[0] === fk)) {
+      columns.push({ ref: [fk] })
+    }
+  })
+}
+
 /**
  * 1. Creates flattened SQL statements for each expand layer
  * 2. Mixes in foreign keys if needed
@@ -98,18 +111,15 @@ const _foreignKeysOfTopLevelNavs = entity => {
  * @returns object
  */
 const expandV2 = async (model, dbc, query, user, locale, txTimestamp, executeSelectCQN) => {
+  const expandColumn = query.SELECT.columns.find(c => c.expand && typeof c.expand === 'string')
+  const options = Object.assign({ onlyKeys: false, onlyCompositions: false }, expandColumn._options)
   // remove expand columns from query without modifying
   const topLevelSelect = query.clone().columns(query.SELECT.columns.filter(c => !c.expand))
 
   const entity = model.definitions[topLevelSelect.SELECT.from.ref[0]]
 
   // ensure foreign keys are selected if needed
-  const fks = _foreignKeysOfTopLevelNavs(entity)
-  fks.forEach(fk => {
-    if (!topLevelSelect.SELECT.columns.some(c => c.ref[0] === fk)) {
-      topLevelSelect.SELECT.columns.push({ ref: [fk] })
-    }
-  })
+  _addForeignKeys(topLevelSelect.SELECT.columns, entity, options)
 
   const result = await executeSelectCQN(model, dbc, topLevelSelect, user, locale, txTimestamp)
 
@@ -119,9 +129,8 @@ const expandV2 = async (model, dbc, query, user, locale, txTimestamp, executeSel
 
   // _associations contains compositions and associations
   if (entity._associations) {
-    const expandColumn = query.SELECT.columns.find(c => c.expand && typeof c.expand === 'string')
     const depth = expandColumn.expand === '**' ? -1 : Number(expandColumn.expand.replace('*', ''))
-    await _autoExpandNavsAndAttachToResult(entity, Array.isArray(result) ? result : [result], depth)
+    await _autoExpandNavsAndAttachToResult(entity, Array.isArray(result) ? result : [result], depth, options)
   }
 
   return result

package/libx/_runtime/db/expand/expandCQNToJoin.js

@@ -2,10 +2,15 @@ const cds = require('../../cds')
 
 const { getAllKeys } = require('../../cds-services/adapter/odata-v4/odata-to-cqn/utils')
 
+const { deepCopyObject } = require('../../common/utils/copy')
 const { getNavigationIfStruct } = require('../../common/utils/structured')
 const { ensureNoDraftsSuffix, ensureDraftsSuffix, ensureUnlocalized } = require('../../common/utils/draft')
-const { filterKeys } = require('../../fiori/utils/handler')
 const { isAsteriskColumn } = require('../../common/utils/rewriteAsterisks')
+const { getCQNUnionFrom } = require('../../common/utils/union')
+
+const { DRAFT_COLUMNS } = require('../../common/constants/draft')
+
+const { filterKeys } = require('../../fiori/utils/handler')
 
 // Symbols are used to add extra information in response structure
 const GET_KEY_VALUE = Symbol.for('sap.cds.getKeyValue')
@@ -16,12 +21,9 @@ const IDENTIFIER = Symbol.for('sap.cds.identifier')
 const IS_ACTIVE = Symbol.for('sap.cds.isActive')
 const IS_UNION_DRAFT = Symbol.for('sap.cds.isUnionDraft')
 
-const { DRAFT_COLUMNS } = require('../../common/constants/draft')
-
-const { getCQNUnionFrom } = require('../../common/utils/union')
-
 function getCqnCopy(readToOneCQN) {
-  const readToOneCQNCopy = JSON.parse(JSON.stringify(readToOneCQN))
+  // REVISIT: Use query.clone() instead
+  const readToOneCQNCopy = deepCopyObject(readToOneCQN)
   if (readToOneCQN[GET_KEY_VALUE] !== undefined) readToOneCQNCopy[GET_KEY_VALUE] = readToOneCQN[GET_KEY_VALUE]
   if (readToOneCQN[TO_MANY] !== undefined) readToOneCQNCopy[TO_MANY] = readToOneCQN[TO_MANY]
   if (readToOneCQN[TO_ACTIVE] !== undefined) readToOneCQNCopy[TO_ACTIVE] = readToOneCQN[TO_ACTIVE]
@@ -626,7 +628,7 @@ class JoinCQNFromExpanded {
     // if union always only expand with active, otherwise evaluate flag
     // if flag shows false, we check entity for associations to non draft
     const activeTableRequired =
-      readToOneCQN[IS_UNION_DRAFT] ||
+      readToOneCQN[IS_UNION_DRAFT] || // > REVISIT: blocks expanding comp2one
       readToOneCQN[IS_ACTIVE] ||
       (element && element.type === 'cds.Association' && !element['@odata.draft.enclosed']) ||
       !this._csn.definitions[target]._isDraftEnabled
@@ -665,9 +667,9 @@ class JoinCQNFromExpanded {
       readToOneCQN.from.args[1] = {
         SELECT: {
           columns: cols,
-          from: unionFrom,
-          as: tableAlias
-        }
+          from: unionFrom
+        },
+        as: tableAlias
       }
     }
 
@@ -755,9 +757,9 @@ class JoinCQNFromExpanded {
     return {
       SELECT: {
         columns: Array.from(readToOneCQN.columns),
-        from: readToOneCQN.from,
-        as: readToOneCQN.from.as
-      }
+        from: readToOneCQN.from
+      },
+      as: readToOneCQN.from.as
     }
   }
 
@@ -858,18 +860,18 @@ class JoinCQNFromExpanded {
 
       if (arg.args) {
         this._addJoinKeyColumnsToUnion(arg.args, on, parentAlias)
-      } else if (arg.SELECT.from.SET && arg.SELECT.as === parentAlias) {
-        this._addColumns(arg.SELECT.from.SET.args, on, parentAlias)
+      } else if (arg.SELECT.from.SET && (arg.as === parentAlias || arg.SELECT.from.as === parentAlias)) {
+        for (const _arg of arg.SELECT.from.SET.args) {
+          this._addColumns(_arg.SELECT.columns, on, parentAlias)
+        }
+        if (arg.SELECT.columns) {
+          this._addColumns(arg.SELECT.columns, on, parentAlias, true)
+        }
       }
     }
   }
 
-  _addColumns(args, on, parentAlias) {
-    const [
-      {
-        SELECT: { columns }
-      }
-    ] = args
+  _addColumns(columns, on, parentAlias, withAlias = false) {
     const keyColumns = on
       .filter(entry => {
         return (
@@ -878,15 +880,11 @@ class JoinCQNFromExpanded {
           !columns.some(column => column.ref && column.ref[column.ref.length - 1] === entry.ref[1])
         )
       })
-      .map(entry => ({ ref: [entry.ref[1]] }))
-
+      .map(entry =>
+        withAlias ? { ref: [parentAlias, entry.ref[1]], as: `${parentAlias}_${entry.ref[1]}` } : { ref: [entry.ref[1]] }
+      )
     if (keyColumns.length === 0) return
-
-    for (const {
-      SELECT: { columns }
-    } of args) {
-      columns.push(...keyColumns)
-    }
+    columns.push(...keyColumns)
   }
 
   /**

package/libx/_runtime/db/expand/index.js

@@ -2,6 +2,9 @@ const { hasExpand, createJoinCQNFromExpanded } = require('./expandCQNToJoin')
 const rawToExpanded = require('./rawToExpanded')
 const expandV2 = require('./expand-v2')
 
+/*
+ * this module is required by cds-pg. -> in case of incompatible changes, we should let them know.
+ */
 module.exports = {
   hasExpand,
   createJoinCQNFromExpanded,

package/libx/_runtime/db/generic/create.js

@@ -15,16 +15,6 @@ module.exports = async function (req) {
   }
 
   try {
-    // REVISIT: should be handled in protocol adapter
-    // execute validation query first to fail early
-    if (req.query._validationQuery) {
-      const validationResult = await this._read(this.model, this.dbc, req.query._validationQuery, req)
-
-      if (validationResult.length === 0) {
-        // > validation target (e.g., root of navigation) doesn't exist
-        req.reject(404)
-      }
-    }
     const results = await this._insert(this.model, this.dbc, req.query, req)
     return new InsertResult(req, results)
   } catch (err) {

package/libx/_runtime/db/generic/index.js

@@ -12,6 +12,9 @@ const DELETE = require('./delete')
 const structured = require('./structured')
 const arrayed = require('./arrayed')
 
+/*
+ * this module is required by cds-pg. -> in case of incompatible changes, we should let them know.
+ */
 module.exports = {
   rewrite,
   virtual,