@sap/cds 5.5.2 → 5.6.0

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

@@ -2,6 +2,7 @@ const cds = require('../../cds')
 let LOG = cds.log('app')
 let _event
 const PERSISTENCE_TABLE = '@cds.persistence.table'
+const { rewriteAsterisks } = require('../../common/utils/rewriteAsterisks')
 
 const getError = require('../error')
 const { getEntityNameFromDeleteCQN, getEntityNameFromUpdateCQN } = require('../utils/cqn')
@@ -172,7 +173,7 @@ const _newColumns = (columns = [], transition, service, withAlias = false) => {
     }
 
     // ensure that renaming of a redirected assoc are also respected
-    if (column.expand) {
+    if (mapped && column.expand) {
       // column.ref might be structured elements
       let def
       column.ref.forEach((ref, i) => {
@@ -186,9 +187,7 @@ const _newColumns = (columns = [], transition, service, withAlias = false) => {
       // reuse _newColumns with new transition
       const expandTarget = def._target
       const subtransition = getTransition(expandTarget, service)
-
-      // REVISIT: in edom-retailer case, mapped was undefined which lead to a type error
-      if (mapped) mapped.transition = subtransition
+      mapped.transition = subtransition
 
       newColumn.expand = _newColumns(column.expand, subtransition, service, withAlias)
     }
@@ -338,8 +337,11 @@ const _newSelect = (query, transitions, service) => {
     ref: _rewriteQueryPath(query.SELECT.from, transitions)
   }
   if (!newSelect.columns && targetTransition.mapping.size) newSelect.columns = _initialColumns(targetTransition)
-  if (newSelect.columns)
+  if (newSelect.columns) {
+    const isDB = service instanceof cds.DatabaseService
+    rewriteAsterisks({ SELECT: newSelect }, targetTransition.queryTarget, isDB)
     newSelect.columns = _newColumns(newSelect.columns, targetTransition, service, service.kind !== 'app-service')
+  }
   if (newSelect.having) newSelect.having = _newColumns(newSelect.having, targetTransition)
   if (newSelect.groupBy) newSelect.groupBy = _newColumns(newSelect.groupBy, targetTransition)
   if (newSelect.orderBy) newSelect.orderBy = _newColumns(newSelect.orderBy, targetTransition)
@@ -417,7 +419,7 @@ const _queryColumns = (target, columns = [], persistenceTable = false, force = f
   if (!(target && target.query && target.query.SELECT)) return columns
   const cqnColumns = target.query.SELECT.columns || []
   const from = target.query.SELECT.from
-  const isTargetAliased = from.as && !target.query._target.query && cqnColumns.some(c => c.ref && c.ref[0] === from.as)
+  const isTargetAliased = from.as && cqnColumns.some(c => c.ref && c.ref[0] === from.as)
   if (!columns.length) columns = Object.keys(target.elements).map(e => ({ ref: [e], as: e }))
   return columns.reduce((res, column) => {
     const renamed = _findRenamed(cqnColumns, column)
@@ -500,18 +502,26 @@ const _getTransitionData = (target, columns, service, skipForbiddenViewCheck) =>
   if (!skipForbiddenViewCheck) _checkForForbiddenViews(target)
   const targetStartsWithSrvName = service.namespace && target.name.startsWith(`${service.namespace}.`)
   const persistenceTable = _isPersistenceTable(target)
-  columns = _queryColumns(target, columns, persistenceTable, service.name !== 'db' && !targetStartsWithSrvName)
-  if (persistenceTable && service.name === 'db') {
+  columns = _queryColumns(
+    target,
+    columns,
+    persistenceTable,
+    !(service instanceof cds.DatabaseService) && !targetStartsWithSrvName
+  )
+  if (persistenceTable && service instanceof cds.DatabaseService) {
     return { target, transitionColumns: columns }
   }
   // stop projection resolving if it starts with the service name prefix
-  if (service.name !== 'db' && targetStartsWithSrvName) {
+  if (!(service instanceof cds.DatabaseService) && targetStartsWithSrvName) {
     return { target, transitionColumns: columns }
   }
   // continue projection resolving if the target is a projection
   if (target.query && target.query._target) {
     const newTarget = target.query._target
-    if (!(service.namespace && newTarget.name.startsWith(`${service.namespace}.`))) {
+    if (
+      service instanceof cds.DatabaseService ||
+      !(service.namespace && newTarget.name.startsWith(`${service.namespace}.`))
+    ) {
       return _getTransitionData(newTarget, columns, service, skipForbiddenViewCheck)
     }
     return { target: newTarget, transitionColumns: columns }

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

@@ -0,0 +1,94 @@
+const { getNavigationIfStruct } = require('./structured')
+const getColumns = require('../../db/utils/columns')
+const { ensureDraftsSuffix } = require('./draft')
+
+const isAsteriskColumn = col => col === '*' || (col.ref && col.ref[0] === '*' && !col.expand)
+
+const _isDuplicate = newColumn => column => {
+  if (newColumn.as) return column.as && column.as === newColumn.as
+  if (!column.ref) return
+  if (Array.isArray(newColumn)) newColumn = { ref: newColumn }
+  return newColumn.ref ? newColumn.ref.join('_') === column.ref.join('_') : newColumn === column.ref.join('_')
+}
+
+const _cqlDraftColumns = target => {
+  if (target.name.endsWith('DraftAdministrativeData')) return []
+  const draftName = ensureDraftsSuffix(target.name)
+  const subSelect = SELECT.from(draftName).columns([1])
+  for (const key in target.keys) {
+    if (key !== 'IsActiveEntity') subSelect.where([{ ref: [target.name, key] }, '=', { ref: [draftName, key] }])
+  }
+  return [
+    { val: true, as: 'IsActiveEntity', cast: { type: 'cds.Boolean' } },
+    { val: false, as: 'HasActiveEntity', cast: { type: 'cds.Boolean' } },
+    {
+      xpr: ['case', 'when', 'exists', subSelect, 'then', 'true', 'else', 'false', 'end'],
+      as: 'HasDraftEntity',
+      cast: { type: 'cds.Boolean' }
+    }
+  ]
+}
+
+const _expandColumn = (column, target, db) => {
+  if (!(column.ref && column.expand)) return
+  const nextTarget = getNavigationIfStruct(target, column.ref)
+  if (nextTarget && nextTarget._target && nextTarget._target.elements) _rewriteAsterisks(column, nextTarget._target, db)
+  return column
+}
+
+const rewriteExpandAsterisk = (columns, target) => {
+  const expandAllColIdx = columns.findIndex(col => {
+    if (col.ref || !col.expand) return
+    return !Array.isArray(col.expand) ? col.expand === '*' : col.expand.indexOf('*') > -1
+  })
+  if (expandAllColIdx > -1) {
+    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)) {
+        columns.push({ ref: [elName], expand: [...expand] })
+      }
+    }
+  }
+}
+
+const _rewriteAsterisk = (columns, target, db, isRoot) => {
+  const asteriskColumnIndex = columns.findIndex(col => isAsteriskColumn(col))
+  if (asteriskColumnIndex > -1) {
+    columns.splice(
+      asteriskColumnIndex,
+      1,
+      ...getColumns(target, { db })
+        .map(c => ({ ref: [c.name] }))
+        .filter(c => !columns.find(_isDuplicate(c)) && (isRoot || c.ref[0] !== 'DraftAdministrativeData_DraftUUID'))
+    )
+  }
+}
+
+const _rewriteAsterisks = (cqn, target, db, isRoot) => {
+  if (cqn.expand === '*') cqn.expand = ['*']
+  const columns = cqn.expand || cqn.columns
+  _rewriteAsterisk(columns, target, db, isRoot)
+  rewriteExpandAsterisk(columns, target)
+  for (const column of columns) {
+    _expandColumn(column, target, db)
+  }
+  return columns
+}
+
+const rewriteAsterisks = (query, target, db = false, isDraft = false, onlyKeys = false) => {
+  if (!target || target.name.endsWith('_drafts')) return
+  if (!query.SELECT.columns || (query.SELECT.columns && !query.SELECT.columns.length)) {
+    if (isDraft || db) {
+      query.SELECT.columns = getColumns(target, { db, onlyKeys }).map(col => ({ ref: [col.name] }))
+      if (db && target._isDraftEnabled) query.SELECT.columns.push(..._cqlDraftColumns(target))
+    }
+    return
+  }
+  query.SELECT.columns = _rewriteAsterisks(query.SELECT, target, db, true)
+}
+
+module.exports = {
+  rewriteAsterisks,
+  isAsteriskColumn,
+  rewriteExpandAsterisk
+}

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

@@ -3,23 +3,24 @@ const searchToLike = require('./searchToLike')
 
 // convert $search system query option to WHERE/HAVING clause using
 // the operator LIKE or CONTAINS
-const search2cqn4sql = (cqn, model, options) => {
-  const { search2cqn4sql, targetName = cqn.SELECT.from.ref[0] } = options
+const search2cqn4sql = (query, model, options) => {
+  const { search2cqn4sql, targetName = query.SELECT.from.ref[0] } = options
   const entity = model.definitions[targetName]
-  const columns = computeColumnsToBeSearched(cqn, entity)
+  const columns = computeColumnsToBeSearched(query, entity)
 
-  // call custom (optimized search to cqn for sql implementation) that tries
+  // Call custom (optimized search to cqn for sql implementation) that tries
   // to optimize the search behavior for a specific database service.
-  if (typeof search2cqn4sql === 'function') {
+  // Note: $search query option combined with $filter is not currently optimized
+  if (typeof search2cqn4sql === 'function' && !query.SELECT.where) {
     const search2cqnOptions = { columns, locale: options.locale }
-    return search2cqn4sql(cqn, entity, search2cqnOptions)
+    return search2cqn4sql(query, entity, search2cqnOptions)
   }
 
-  const cqnSearchPhrase = cqn.SELECT.search
+  const cqnSearchPhrase = query.SELECT.search
   const expression = searchToLike(cqnSearchPhrase, columns)
 
   // REVISIT: find out here if where or having must be used
-  cqn._aggregated ? cqn.having(expression) : cqn.where(expression)
+  query._aggregated ? query.having(expression) : query.where(expression)
 }
 
 module.exports = search2cqn4sql

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

@@ -48,57 +48,60 @@ const _getNextTarget = (model, element, currentPath = []) => {
       nextTargetName,
       nextTarget: model.definitions[nextTargetName]
     }
-  } else if (_isInlineStructured(element)) {
+  }
+
+  if (_isInlineStructured(element)) {
     return {
       nextTargetName: [...currentPath, element.name].join(DELIMITER),
       nextTarget: element.items || element
     }
   }
+
   return {}
 }
 
 /**
  *
- * @param {CSN} model: Model
- * @param {*} cache: Internal - do not use
- * @param {CSN} target: target entity which needs to be traversed
- * @param {*} param1.pick: Function to pick items. If it returns a truthy value, the item will be picked. The returned value is part of the template.
- * @param {*} param1.ignore: Function to ignore items. If it returns a truthy value, the item will be ignored.
- * @param {*} parent: The parent entity
- * @param {*} entityMap: Internal - do not use
- * @param model
- * @param targetName
- * @param parent
- * @param entityMap
+ * @param {import('@sap/cds-compiler/lib/api/main').CSN} model Model
+ * @param {Map} cache Internal - do not use
+ * @param {object} targetEntity The target entity which needs to be traversed
+ * @param {object} callbacks
+ * @param {function} callbacks.pick Callback function to pick elements. If it returns a truthy value, the element will be picked. The returned value is part of the template.
+ * @param {function} callbacks.ignore Callback function to ignore elements. If it returns a truthy value, the element will be ignored.
+ * @param {object} [parent=null] The parent entity
+ * @param {Map} [_entityMap] This parameter is an implementation side-effect — don't use it
+ * @param {array} [targetPath=[]]
  */
-function _getTemplate(model, cache, target, { pick, ignore }, parent = null, entityMap = new Map(), targetPath = []) {
+function _getTemplate(model, cache, targetEntity, callbacks, parent = null, _entityMap = new Map(), targetPath = []) {
+  const { pick, ignore } = callbacks
   const templateElements = new Map()
-  const template = { target, elements: templateElements }
-  const currentPath = [...targetPath, target.name]
-  entityMap.set(currentPath.join(DELIMITER), { template })
-
-  if (target.elements) {
-    for (const elementName in target.elements) {
-      const element = target.elements[elementName]
-      if (ignore && ignore(element, target, parent)) continue
-
-      _pick(pick, element, target, parent, templateElements, elementName)
-      if (element.items) {
-        _pick(pick, element.items, target, parent, templateElements, ['_itemsOf', elementName].join(DELIMITER))
-      }
-
-      const { nextTargetName, nextTarget } = _getNextTarget(model, element, currentPath)
-      const nextTargetCached = entityMap.get(nextTargetName)
-      if (nextTargetCached) {
-        _addCacheToTemplateElements(templateElements, elementName, nextTargetCached)
-      } else if (nextTarget) {
-        // For associations and _typed_ structured elements, there's a (cacheable) target,
-        // inline structures must be handled separately.
-        const subTemplate = _isInlineStructured(element)
-          ? _getTemplate(model, cache, nextTarget, { pick, ignore }, target, entityMap, currentPath)
-          : cache.for(nextTarget, getTemplate(model, { pick, ignore }, target, entityMap))
-        _addSubTemplate(templateElements, elementName, subTemplate)
-      }
+  const template = { target: targetEntity, elements: templateElements }
+  const currentPath = [...targetPath, targetEntity.name]
+  _entityMap.set(currentPath.join(DELIMITER), { template })
+  if (!targetEntity.elements) return template
+
+  for (const elementName in targetEntity.elements) {
+    const element = targetEntity.elements[elementName]
+    if (ignore && ignore(element, targetEntity, parent)) continue
+
+    _pick(pick, element, targetEntity, parent, templateElements, elementName)
+
+    if (element.items) {
+      _pick(pick, element.items, targetEntity, parent, templateElements, ['_itemsOf', elementName].join(DELIMITER))
+    }
+
+    const { nextTargetName, nextTarget } = _getNextTarget(model, element, currentPath)
+    const nextTargetCached = _entityMap.get(nextTargetName)
+
+    if (nextTargetCached) {
+      _addCacheToTemplateElements(templateElements, elementName, nextTargetCached)
+    } else if (nextTarget) {
+      // For associations and _typed_ structured elements, there's a (cacheable) target,
+      // inline structures must be handled separately.
+      const subTemplate = _isInlineStructured(element)
+        ? _getTemplate(model, cache, nextTarget, { pick, ignore }, targetEntity, _entityMap, currentPath)
+        : cache.for(nextTarget, getTemplate(model, { pick, ignore }, targetEntity, _entityMap))
+      _addSubTemplate(templateElements, elementName, subTemplate)
     }
   }
 
@@ -112,11 +115,11 @@ const getTemplate =
 
 const getCache = (anything, cache, newCacheFn) => {
   let _cached = cache.get(anything)
-  if (!_cached) {
-    _cached = (typeof newCacheFn === 'function' && newCacheFn(anything, cache)) || new Map()
-    _cached.for = (_usecase, _newCacheFn) => getCache(_usecase, _cached, _newCacheFn)
-    cache.set(anything, _cached)
-  }
+  if (_cached) return _cached
+
+  _cached = (typeof newCacheFn === 'function' && newCacheFn(anything, cache)) || new Map()
+  _cached.for = (_usecase, _newCacheFn) => getCache(_usecase, _cached, _newCacheFn)
+  cache.set(anything, _cached)
   return _cached
 }
 
@@ -124,11 +127,13 @@ module.exports = (usecase, tx, target, ...args) => {
   // get model first as it may be added to tx (cf. "_ensureModel")
   const model = tx.model
   if (!model) return
+
   // double-check with get target from model
   // since target might come from anywhere like via cqn etc
   if (!target) return
   const root = (model && model.definitions[target.name]) || (target.elements && target)
   if (!root) return
+
   // tx could be the service itself
   // prefer ApplicationService (i.e., tx.context._tx.__proto__)
   // REVISIT: context._tx is not a stable API -> pls do not rely on that
@@ -136,10 +141,13 @@ module.exports = (usecase, tx, target, ...args) => {
     ? (tx.context._tx && Object.getPrototypeOf(tx.context._tx)) || Object.getPrototypeOf(tx)
     : tx
   if (!service) return
+
   // cache templates at service for garbage collection
-  if (!service._templateCache) service._templateCache = new Map()
+  if (usecase && !service._templateCache) service._templateCache = new Map()
   // model can be also a subset from tx
-  return getCache(usecase, service._templateCache)
+
+  // if no usecase, don't save cache on the service object
+  return getCache(usecase, usecase ? service._templateCache : new Map())
     .for(model)
     .for(root, getTemplate(model, ...args))
 }

package/libx/_runtime/db/Service.js

@@ -109,6 +109,7 @@ class DatabaseService extends cds.Service {
         if (query && (!streamQuery.SELECT.columns || streamQuery.SELECT.columns.length !== 0)) {
           streamQuery.columns([query])
         }
+
         delete streamQuery.SELECT.one
         streamQuery._streaming = true
 
@@ -119,12 +120,18 @@ class DatabaseService extends cds.Service {
           }
         })
 
-        if (!streamQuery.SELECT.where) {
+        if (
+          !streamQuery.SELECT.where &&
+          !(
+            streamQuery.SELECT.from &&
+            streamQuery.SELECT.from.ref &&
+            streamQuery.SELECT.from.ref[streamQuery.SELECT.from.ref.length - 1].where
+          )
+        ) {
           return {
             where: (...args) => {
               streamQuery.where(...args)
               this._runStream(streamQuery, result)
-
               return result
             }
           }

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

@@ -1,11 +1,11 @@
 const cds = require('../../cds')
 
 const { getAllKeys } = require('../../cds-services/adapter/odata-v4/odata-to-cqn/utils')
-const { getOnCond } = require('../../common/utils/generateOnCond')
 
 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')
 
 // Symbols are used to add extra information in response structure
 const GET_KEY_VALUE = Symbol.for('sap.cds.getKeyValue')
@@ -656,7 +656,7 @@ class JoinCQNFromExpanded {
         SELECT: {
           columns: cols,
           from: unionFrom,
-          as: 'b'
+          as: tableAlias
         }
       }
     }
@@ -822,23 +822,12 @@ class JoinCQNFromExpanded {
     // No sub select
     const subSelectColumns = this._getSubSelectColumns(readToOneCQN)
 
-    const navigation = getNavigationIfStruct(entity, tableAlias === columns[0] ? columns.slice(1) : columns)
-    const onConditionOptions = {
-      associationNames: columns,
-      csn: this._csn,
-      aliases: {
-        select: tableAlias,
-        join: parentAlias
-      },
-      resolveView: false
-    }
-
     if (subSelectColumns.length === 0) {
-      return getOnCond(navigation, onConditionOptions)
+      return entity._relations[tableAlias === columns[0] ? columns.slice(1) : columns].join(tableAlias, parentAlias)
     }
 
     const aliases = this._getAliases(subSelectColumns)
-    const on = getOnCond(navigation, onConditionOptions)
+    const on = entity._relations[tableAlias === columns[0] ? columns.slice(1) : columns].join(tableAlias, parentAlias)
 
     for (const element of on) {
       if (element.ref && aliases[element.ref[0]] && aliases[element.ref[0]][element.ref[1]]) {
@@ -1069,15 +1058,7 @@ class JoinCQNFromExpanded {
       !this._csn.definitions[colTarget]._isDraftEnabled
     const ref = this._getJoinRef(entity.elements, colRef[0], expandActive, defaultLanguageThis)
     const tableAlias = this._createAlias(toManyTree.concat(colRef).join(':'))
-    const onConditionOptions = {
-      associationNames: colRef[0],
-      csn: this._csn,
-      aliases: {
-        select: tableAlias,
-        join: 'filterExpand'
-      }
-    }
-    const on = getOnCond(element, onConditionOptions)
+    const on = entity._relations[colRef[0]].join(tableAlias, 'filterExpand')
     const filterExpand = this._getFilterExpandCQN(readToOneCQN, on, parentAlias, entity.keys)
     const expandedEntity = this._csn.definitions[colTarget]
     const joinColumns = this._getJoinColumnsFromOnAddToMapping(mappings[colRef[0]], parentAlias, on, entity)
@@ -1529,8 +1510,13 @@ class JoinCQNFromExpanded {
   }
 
   _isNotIncludedIn(columns) {
+    if (columns.some(column => isAsteriskColumn(column))) return _ => false
     return entry =>
-      !columns.some(column => (column.ref && column.ref[1] === entry) || ('val' in column && column.as === entry))
+      !columns.some(
+        column =>
+          (typeof column === 'object' && column.ref && column.ref[1] === entry) ||
+          ('val' in column && column.as === entry)
+      )
   }
 
   /**

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

@@ -95,7 +95,7 @@ class RawToExpanded {
 
         // the expanded items may include the actives of the deleted drafts -> filter out
         if (rootIsActiveEntity !== null) {
-          if (mapping[TO_ACTIVE]) expandedItems = expandedItems.filter(ele => ele.IsActiveEntity === true)
+          if (mapping[TO_ACTIVE]) expandedItems = expandedItems.filter(ele => ele.IsActiveEntity !== false)
           else expandedItems = expandedItems.filter(ele => ele.IsActiveEntity === rootIsActiveEntity)
         }
 
@@ -119,6 +119,7 @@ class RawToExpanded {
           row[key] = parsed || null
         } else if (rootIsActiveEntity !== null) {
           if (mapping[TO_ACTIVE]) row[key] = parsed && parsed.IsActiveEntity !== false ? parsed : null
+          else if (rootIsActiveEntity) row[key] = parsed && parsed.IsActiveEntity !== false ? parsed : null
           else row[key] = parsed && parsed.IsActiveEntity === rootIsActiveEntity ? parsed : null
         }
       } else {

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

@@ -31,6 +31,7 @@ module.exports = async function (req) {
     // If entry is available, reject event
     // REVISIT: db specifics
     if (err.message.match(/unique constraint/i)) {
+      err.originalMessage = err.message
       err.message = 'ENTITY_ALREADY_EXISTS'
       err.code = 400
     }

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

@@ -13,8 +13,8 @@ const cds = require('../../cds')
 
 const normalizeTimeData = require('../utils/normalizeTimeData')
 
-const enrichDataWithKeysFromWhere = require('../../common/utils/enrichWithKeysFromWhere')
-const { foreignKeyPropagations, propagateForeignKeys } = require('../../common/utils/foreignKeyPropagations')
+const { enrichDataWithKeysFromWhere } = require('../../common/utils/keys')
+const { propagateForeignKeys } = require('../../common/utils/propagateForeignKeys')
 const getTemplate = require('../../common/utils/template')
 const templateProcessor = require('../../common/utils/templateProcessor')
 
@@ -25,13 +25,13 @@ const { DRAFT_COLUMNS_MAP } = require('../../common/constants/draft')
 const _isManaged = (category, event) =>
   (category === '@cds.on.insert' && event === 'CREATE') || (category === '@cds.on.update' && event === 'UPDATE')
 
-const _processComplexCategory = ({ row, key, val, category, req }) => {
+const _processComplexCategory = ({ row, key, val, category, req, element }) => {
   const categoryArgs = category.args
   category = category.category
 
   // propagate keys
   if (category === 'propagateForeignKeys') {
-    propagateForeignKeys(key, row, categoryArgs.foreignKeyPropagations, { onlyWriteCompositionEffective: true })
+    propagateForeignKeys(key, row, element._foreignKeys, element._isCompositionEffective)
     return
   }
 
@@ -63,7 +63,7 @@ const _processComplexCategory = ({ row, key, val, category, req }) => {
 const _processCategory = ({ category, row, key, element, val, req }) => {
   // use args only inside this if (sonar type error warning)
   if (typeof category === 'object') {
-    _processComplexCategory({ category, row, key, val, req })
+    _processComplexCategory({ category, row, key, val, req, element })
     return
   }
 
@@ -136,12 +136,8 @@ const _pick = element => {
     categories.push('associationEffective')
   }
 
-  if (element.isAssociation) {
-    const _foreignKeyPropagations = foreignKeyPropagations(element)
-
-    if (_foreignKeyPropagations) {
-      categories.push({ category: 'propagateForeignKeys', args: { foreignKeyPropagations: _foreignKeyPropagations } })
-    }
+  if (element.isAssociation && element._foreignKeys.length) {
+    categories.push({ category: 'propagateForeignKeys' })
   }
 
   // generate uuid

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

@@ -1,7 +1,7 @@
 const cds = require('../../cds')
 const { SELECT } = cds.ql
 
-const cqn2cqn4sql = require('../../common/utils/cqn2cqn4sql')
+const { cqn2cqn4sql } = require('../../common/utils/cqn2cqn4sql')
 const { getDependents } = require('../../common/utils/csn')
 
 const CRUD = {
@@ -54,7 +54,7 @@ async function beforeDelete(req) {
     select = select.where(req.query.DELETE.where)
   }
 
-  select = cqn2cqn4sql(select, this.model)
+  select = cqn2cqn4sql(select, this.model, { service: this })
 
   req._beforeDeleteData = await this._read(this.model, this.dbc, select, req.context || req)
 }

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

@@ -1,6 +1,5 @@
-const cqn2cqn4sql = require('../../common/utils/cqn2cqn4sql')
+const { cqn2cqn4sql } = require('../../common/utils/cqn2cqn4sql')
 const generateAliases = require('../utils/generateAliases')
-const rewriteAsterisk = require('../../common/utils/rewriteAsterisk')
 const { restoreLink } = require('../../common/utils/resolveView')
 
 const _isLinked = req => {
@@ -21,13 +20,11 @@ function handler(req) {
   const streaming = req.query._streaming
   const validationQuery = req.query._validationQuery
 
-  rewriteAsterisk(req)
-
   // for restore link to req.data
   const linked = _isLinked(req)
 
   // convert to sql cqn
-  req.query = cqn2cqn4sql(req.query, this.model)
+  req.query = cqn2cqn4sql(req.query, this.model, { service: this })
 
   // REVISIT: should not be necessary
   // restore link to req.data

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

@@ -75,6 +75,7 @@ module.exports = async function (req) {
   } catch (err) {
     // REVISIT: db specifics
     if (err.message.match(/unique constraint/i)) {
+      err.originalMessage = err.message
       err.message = 'UNIQUE_CONSTRAINT_VIOLATION'
       err.code = 400
     }

package/libx/_runtime/db/query/read.js

@@ -10,8 +10,8 @@ function _arrayWithCount(a, count) {
 }
 
 function _createCountQuery(query) {
-  const _query = JSON.parse(JSON.stringify(query))
-  _query.SELECT.columns = [{ func: 'count', args: [{ val: 1 }], as: '_counted_' }]
+  const _query = JSON.parse(JSON.stringify(query)) // REVISIT: Use query.clone() instead
+  _query.SELECT.columns = [{ func: 'count', args: [{ val: 1 }], as: '$count' }]
   delete _query.SELECT.groupBy
   delete _query.SELECT.limit
   delete _query.SELECT.orderBy // not necessary to keep that
@@ -25,6 +25,11 @@ function _createCountQuery(query) {
   return _query
 }
 
+const countValue = countResult => {
+  if (countResult._counted_ != null) return countResult._counted_
+  if (countResult.$count != null) return countResult.$count
+}
+
 const read = (executeSelectCQN, executeStreamCQN) => (model, dbc, query, req) => {
   const { user, locale, timestamp } = req
   const isoTs = timestampToISO(timestamp)
@@ -37,7 +42,7 @@ const read = (executeSelectCQN, executeStreamCQN) => (model, dbc, query, req) =>
   }
 
   // needed in case of expand
-  query._rootEntity = req.target
+  if (query._target !== req.target) query._target = req.target
 
   if (query.SELECT.count) {
     if (query.SELECT.limit) {
@@ -45,11 +50,11 @@ const read = (executeSelectCQN, executeStreamCQN) => (model, dbc, query, req) =>
       const countResultPromise = executeSelectCQN(model, dbc, countQuery, user, locale, isoTs)
       if (query.SELECT.limit.rows && query.SELECT.limit.rows.val === 0) {
         // We don't need to perform our result query
-        return countResultPromise.then(countResult => _arrayWithCount([], countResult[0]._counted_))
+        return countResultPromise.then(countResult => _arrayWithCount([], countValue(countResult[0])))
       } else {
         const resultPromise = executeSelectCQN(model, dbc, query, user, locale, isoTs)
         return Promise.all([countResultPromise, resultPromise]).then(([countResult, result]) =>
-          _arrayWithCount(result, countResult[0]._counted_)
+          _arrayWithCount(result, countValue(countResult[0]))
         )
       }
     } else {

package/libx/_runtime/db/sql-builder/ExpressionBuilder.js

@@ -227,6 +227,12 @@ class ExpressionBuilder extends BaseBuilder {
    * @private
    */
   _addInOrNotIn(reference, operator, values) {
+    if (values.val === null) {
+      this._addToOutputObj(new this.ReferenceBuilder(reference, this._options, this._csn).build(), false)
+      this._outputObj.sql.push('is null')
+      return true
+    }
+
     if (Array.isArray(values.val)) {
       this._addArrayForInQuery(reference, operator, values.val)
       return true