@sap/cds 5.4.6 → 5.5.0

package/libx/_runtime/common/composition/delete.js

@@ -26,10 +26,10 @@ const _recursivelyAliasRefs = (something, newAlias, oldAlias, subselect = false)
   }
 }
 
-function _getSubWhereAndEntities(allBackLinks, links, draft, element, level) {
+function _getSubWhereAndEntities(element, parentWhere, draft, level = 0, compositionTree = {}) {
+  const allBackLinks = [...element.backLinks, ...element.customBackLinks]
   let entity1, entity2
-  const isBackLink = allBackLinks.length > 0
-  const linksForWhere = isBackLink ? allBackLinks : links
+  const linksForWhere = allBackLinks.length ? allBackLinks : element.links
 
   const subWhere = linksForWhere.reduce((result, backLink) => {
     // exclude static values from subwhere
@@ -43,29 +43,55 @@ function _getSubWhereAndEntities(allBackLinks, links, draft, element, level) {
     entity1 = {
       alias: `ALIAS${level + 1}`,
       entityName: ctUtils.addDraftSuffix(draft, element.source),
-      propertyName: isBackLink ? backLink.entityKey : backLink.targetKey
+      propertyName: backLink.entityKey
     }
 
-    const res1 = backLink.entityKey
-      ? { ref: [entity1.alias, entity1.propertyName] }
-      : { val: isBackLink ? backLink.entityVal : backLink.targetVal }
+    const res1 = backLink.entityKey ? { ref: [entity1.alias, entity1.propertyName] } : { val: backLink.entityVal }
 
     entity2 = {
       alias: `ALIAS${level}`,
       entityName: ctUtils.addDraftSuffix(draft, element.target || element.source),
-      propertyName: isBackLink ? backLink.targetKey : backLink.entityKey
+      propertyName: backLink.targetKey
     }
 
-    const res2 = backLink.targetKey
-      ? { ref: [entity2.alias, entity2.propertyName] }
-      : { val: isBackLink ? backLink.targetVal : backLink.entityVal }
+    const res2 = backLink.targetKey ? { ref: [entity2.alias, entity2.propertyName] } : { val: backLink.targetVal }
 
     result.push(res1, '=', res2)
     return result
   }, [])
 
+  const where = []
+  if (!subWhere.length) return { where, entity1, entity2 }
+
+  let whereKeys = _getWhereKeys(allBackLinks, entity1)
+  const staticWhereValues = _getStaticWhere(allBackLinks, entity1)
+  if (whereKeys.length === 0 && element.links.length === 1) {
+    // add is null check for each unused backlink
+    for (const ce of compositionTree.compositionElements || []) {
+      if (ce.source !== element.source) continue
+      if (ce.name === element.name) continue
+      const wk = _getWhereKeys([...ce.backLinks, ...ce.customBackLinks], entity1, 'null')
+      if (whereKeys.length === 0) whereKeys = wk
+      else whereKeys.push('and', ...wk)
+    }
+  }
+
+  if (whereKeys.length > 0) {
+    where.push('(', ...whereKeys, ')', 'and')
+  }
+  if (staticWhereValues.length > 0) {
+    where.push('(', ...staticWhereValues, ')', 'and')
+  }
+  where.push('exists', {
+    SELECT: {
+      columns: [{ val: 1, as: '_exists' }],
+      from: { ref: [entity2.entityName], as: entity2.alias },
+      where: parentWhere ? ['(', ...parentWhere, ')', 'and', '(', ...subWhere, ')'] : subWhere
+    }
+  })
+
   return {
-    subWhere,
+    where,
     entity1,
     entity2
   }
@@ -102,30 +128,25 @@ function _getStaticWhere(allBackLinks, entity1) {
   }, [])
 }
 
-const _csnElementFromTarget = (element, definitions) =>
-  element.target && definitions[element.target].elements[element.name]
-
-const _is2OneManaged = element => {
-  return element.is2one && ctUtils.isManaged(element)
+const _is2oneComposition = (element, definitions) => {
+  const csnElement = element.target && definitions[element.target].elements[element.name]
+  return csnElement && csnElement.is2one && csnElement._isCompositionEffective
 }
 
 const _addToCQNs = (cqns, subCQN, element, definitions, level) => {
-  if (cds.env.features._foreign_key_constraints) {
-    // deep delete should be handled by database constraints
-    // return [[cqn]]
-    const csnElement = _csnElementFromTarget(element, definitions)
-
-    // TODO: only managed to-one should be filtered, unmanaged with key in children can be ignored
-    if (csnElement && _is2OneManaged(csnElement)) {
-      cqns[level] = cqns[level] || []
-      cqns[level].push(subCQN)
-    }
-  } else {
-    cqns[level] = cqns[level] || []
+  cqns[level] = cqns[level] || []
+  // Since `>2.5.2` compiler generates constraints for compositions of one like for annotations
+  // Thus only single 2one case (`$self`-managed composition) has DELETE CASCADE
+  // Here it's ignored to simplify i.e. handle all "2ones" in a same manner
+  if (!cds.env.features._foreign_key_constraints || _is2oneComposition(element, definitions)) {
     cqns[level].push(subCQN)
   }
 }
 
+// unofficial config!
+const DEEP_DELETE_MAX_RECURSION_DEPTH =
+  (cds.env.features.recursion_depth && Number(cds.env.features.recursion_depth)) || 2
+
 const _addSubCascadeDeleteCQN = (
   definitions,
   compositionTree,
@@ -133,13 +154,14 @@ const _addSubCascadeDeleteCQN = (
   level,
   cqns,
   draft,
-  elementSet = new Set()
+  elementMap = new Map()
 ) => {
   for (const element of compositionTree.compositionElements) {
     if (element.skipPersistence) continue
 
     const fqn = compositionTree.source + ':' + element.name
-    if (elementSet.has(fqn)) {
+    const seen = elementMap.get(fqn)
+    if (seen && seen >= DEEP_DELETE_MAX_RECURSION_DEPTH) {
       // recursion -> abort
       continue
     }
@@ -147,47 +169,17 @@ const _addSubCascadeDeleteCQN = (
     // REVISIT: sometimes element.target is undefined which leads to self join
     if (!element.target) element.target = compositionTree.source
 
-    const allBackLinks = [...element.backLinks, ...element.customBackLinks]
-    const { entity1, entity2, subWhere } = _getSubWhereAndEntities(allBackLinks, element.links, draft, element, level)
-
-    let whereKeys = _getWhereKeys(allBackLinks, entity1)
-    const staticWhereValues = _getStaticWhere(allBackLinks, entity1)
-    if (allBackLinks.length > 0 || element.links.length > 0) {
-      const where = []
-
-      if (whereKeys.length === 0 && element.links.length === 1) {
-        // add is null check for each unused backlink
-        for (const ce of compositionTree.compositionElements) {
-          if (ce.source !== element.source) continue
-          if (ce.name === element.name) continue
-          const wk = _getWhereKeys([...ce.backLinks, ...ce.customBackLinks], entity1, 'null')
-          if (whereKeys.length === 0) whereKeys = wk
-          else whereKeys.push('and', ...wk)
-        }
-      }
-
-      if (whereKeys.length > 0) {
-        where.push('(', ...whereKeys, ')', 'and')
-      }
-      if (staticWhereValues.length > 0) {
-        where.push('(', ...staticWhereValues, ')', 'and')
-      }
-
-      where.push('exists', {
-        SELECT: {
-          columns: [{ val: 1, as: '_exists' }],
-          from: { ref: [entity2.entityName], as: entity2.alias },
-          where: parentWhere ? ['(', ...parentWhere, ')', 'and', '(', ...subWhere, ')'] : subWhere
-        }
-      })
-
+    const { entity1, where } = _getSubWhereAndEntities(element, parentWhere, draft, level, compositionTree)
+    if (where.length) {
       const subCQN = { DELETE: { from: { ref: [entity1.entityName], as: entity1.alias }, where: where } }
 
       _addToCQNs(cqns, subCQN, element, definitions, level)
 
-      elementSet.add(fqn)
-
-      _addSubCascadeDeleteCQN(definitions, element, subCQN.DELETE.where, level + 1, cqns, draft, elementSet)
+      // Make a copy and do not share the same map among brother compositions
+      // as we're only interested in deep recursions, not wide recursions.
+      const newElementMap = new Map(elementMap)
+      newElementMap.set(fqn, (seen && seen + 1) || 1)
+      _addSubCascadeDeleteCQN(definitions, element, subCQN.DELETE.where, level + 1, cqns, draft, newElementMap)
     }
   }
 
@@ -202,12 +194,41 @@ const hasDeepDelete = (definitions, cqn) => {
   const from = getEntityNameFromDeleteCQN(cqn)
   if (!from) return false
 
+  // hidden flag for DELETEs on draft root, we have a separate mechanism that deletes the rows using the DraftUUID
+  // Hence, we do not need a deep delete in that case.
+  if (cqn._suppressDeepDelete) return false
+
   const entity = definitions && definitions[ensureNoDraftsSuffix(from)]
+
   if (entity) return !!Object.keys(entity.elements || {}).find(k => entity.elements[k]._isCompositionEffective)
 
   return false
 }
 
+const _getSetNullParentForeignKeyCQNs = (definitions, entityName, parentWhere, draft) => {
+  const setNullCQNs = []
+  for (const { elements } of definitions[entityName].__oneCompositionParents.values()) {
+    for (const element of elements.values()) {
+      const data = element.links.reduce((d, fk) => {
+        d[fk.entityKey] = null
+        return d
+      }, {})
+      const { entity1, where } = _getSubWhereAndEntities(element, parentWhere, draft)
+      if (where.length) {
+        setNullCQNs.push({
+          UPDATE: {
+            entity: { ref: [entity1.entityName], as: entity1.alias },
+            data,
+            where,
+            _beforeDelete: true
+          }
+        })
+      }
+    }
+  }
+  return setNullCQNs
+}
+
 const getDeepDeleteCQNs = (definitions, cqn) => {
   const from = getEntityNameFromDeleteCQN(cqn)
   if (!from) return [[cqn]]
@@ -219,15 +240,20 @@ const getDeepDeleteCQNs = (definitions, cqn) => {
     definitions,
     rootEntityName: entityName,
     checkRoot: false,
-    resolveViews: !draft
+    resolveViews: !draft,
+    service: cds.db
   })
   const parentWhere = cqn.DELETE.where && JSON.parse(JSON.stringify(cqn.DELETE.where))
   if (parentWhere) {
     const parentAlias = cqn.DELETE.from.as || (cqn.DELETE.from.ref && cqn.DELETE.from.ref[0]) || cqn.DELETE.from // or however we get the table name...
     _recursivelyAliasRefs(parentWhere, 'ALIAS0', parentAlias)
   }
-
-  return [[cqn], ..._addSubCascadeDeleteCQN(definitions, compositionTree, parentWhere, 0, [], draft)].reverse()
+  const setNullUpdates = []
+  if (cds.env.features._foreign_key_constraints && definitions[entityName].own('__oneCompositionParents')) {
+    setNullUpdates.push(..._getSetNullParentForeignKeyCQNs(definitions, entityName, parentWhere, draft))
+  }
+  const subCascadeDeletes = _addSubCascadeDeleteCQN(definitions, compositionTree, parentWhere, 0, [], draft)
+  return [[cqn], ...subCascadeDeletes, ...setNullUpdates].reverse()
 }
 
 module.exports = {

package/libx/_runtime/common/composition/index.js

@@ -1,5 +1,5 @@
 const { getCompositionTree, getCompositionRoot } = require('./tree')
-const { hasDeepInsert, getDeepInsertCQNs } = require('./insert')
+const { hasDeepInsert, getDeepInsertCQNs, cleanEmptyCompositionsOfMany } = require('./insert')
 const { hasDeepUpdate, getDeepUpdateCQNs } = require('./update')
 const { hasDeepDelete, getDeepDeleteCQNs } = require('./delete')
 const { selectDeepUpdateData } = require('./data')
@@ -11,6 +11,7 @@ module.exports = {
   // insert
   hasDeepInsert,
   getDeepInsertCQNs,
+  cleanEmptyCompositionsOfMany,
   // update
   hasDeepUpdate,
   getDeepUpdateCQNs,

package/libx/_runtime/common/composition/insert.js

@@ -1,3 +1,5 @@
+const cds = require('../../cds')
+
 const { getCompositionTree } = require('./tree')
 const ctUtils = require('./utils')
 
@@ -25,13 +27,14 @@ const _addSubDeepInsertCQN = (definitions, compositionTree, data, cqns, draft) =
     const subData = data.reduce((result, entry) => {
       if (element.name in entry) {
         const elementValue = ctUtils.val(entry[element.name])
-        // remove empty entries
-        const subData = ctUtils.array(elementValue).filter(ele => Object.keys(ele).length > 0)
-
-        if (subData.length > 0) {
-          // REVISIT: this can make problems
-          insertCQN.INSERT.entries.push(...ctUtils.cleanDeepData(subEntity, subData))
-          result.push(...subData)
+        if (elementValue != null) {
+          // remove empty entries
+          const subData = ctUtils.array(elementValue).filter(ele => Object.keys(ele).length > 0)
+          if (subData.length > 0) {
+            // REVISIT: this can make problems
+            insertCQN.INSERT.entries.push(...ctUtils.cleanDeepData(subEntity, subData))
+            result.push(...subData)
+          }
         }
       }
       return result
@@ -50,10 +53,28 @@ const _addSubDeepInsertCQN = (definitions, compositionTree, data, cqns, draft) =
  * exports
  */
 
+const _entityFromINSERT = (definitions, INSERT) => {
+  if (INSERT && INSERT.into) {
+    const entityName = ensureNoDraftsSuffix(INSERT.into.name || INSERT.into)
+    return definitions && definitions[entityName]
+  }
+}
+
+const cleanEmptyCompositionsOfMany = (definitions, cqn) => {
+  const entity = _entityFromINSERT(definitions, cqn.INSERT)
+  if (!entity) return
+  for (const entry of cqn.INSERT.entries || []) {
+    for (const elName in entry || {}) {
+      const el = entity.elements[elName]
+      if (!el) continue
+      if (el.is2many && !entry[elName].length) delete entry[elName]
+    }
+  }
+}
+
 const hasDeepInsert = (definitions, cqn) => {
-  if (cqn && cqn.INSERT && cqn.INSERT.into && cqn.INSERT.entries) {
-    const entityName = ensureNoDraftsSuffix(cqn.INSERT.into.name || cqn.INSERT.into)
-    const entity = definitions && definitions[entityName]
+  if (cqn.INSERT.entries) {
+    const entity = _entityFromINSERT(definitions, cqn.INSERT)
     if (entity) {
       return !!cqn.INSERT.entries.find(entry => {
         return !!Object.keys(entry || {}).find(k => {
@@ -75,7 +96,8 @@ const getDeepInsertCQNs = (definitions, cqn) => {
     definitions,
     rootEntityName: entityName,
     checkRoot: false,
-    resolveViews: !draft
+    resolveViews: !draft,
+    service: cds.db
   })
 
   const flattenedCqn = { INSERT: Object.assign({}, cqn.INSERT) }
@@ -89,6 +111,7 @@ const getDeepInsertCQNs = (definitions, cqn) => {
 }
 
 module.exports = {
+  cleanEmptyCompositionsOfMany,
   hasDeepInsert,
   getDeepInsertCQNs
 }

package/libx/_runtime/common/composition/tree.js

@@ -1,23 +1,45 @@
 const cds = require('../../cds')
 
-const { getBackLinks, isSelfManaged, getOnCondElements, isBacklink } = require('../utils/backlinks')
-const ctUtils = require('./utils')
+const { isSelfManaged, isBacklink } = require('../utils/backlinks')
 
 const { ensureNoDraftsSuffix } = require('../utils/draft')
 const { isRootEntity } = require('../utils/csn')
 const { getTransition, getDBTable } = require('../utils/resolveView')
 
+const { foreignKeyPropagations } = require('../utils/foreignKeyPropagations')
+
 const getError = require('../../common/error')
 
 /*
  * own utils
  */
 
-const _resolvedElement = element => {
+const _foreignKeysToLinks = (element, inverse) =>
+  foreignKeyPropagations(element).map(e => {
+    e = inverse
+      ? {
+          childFieldName: e.parentFieldName,
+          parentFieldName: e.childFieldName,
+          childFieldValue: e.parentFieldValue,
+          parentFieldValue: e.childFieldValue,
+          prefix: e.prefix
+        }
+      : e
+    const link = {
+      entityKey:
+        e.prefix && !e.parentFieldName.includes(e.prefix) ? e.prefix + '_' + e.parentFieldName : e.parentFieldName,
+      targetKey: e.prefix && !e.childFieldName.includes(e.prefix) ? e.prefix + '_' + e.childFieldName : e.childFieldName
+    }
+    if (e.parentFieldValue !== undefined) link.entityVal = e.parentFieldValue
+    if (e.childFieldValue !== undefined) link.targetVal = e.childFieldValue
+    return link
+  })
+
+const _resolvedElement = (element, service) => {
   if (!element.target) return element
   // skip forbidden view check if association to view with foreign key in target
   const skipForbiddenViewCheck = element._isAssociationStrict && element.on && !element['@odata.contained']
-  const { target, mapping } = getTransition(element._target, undefined, skipForbiddenViewCheck)
+  const { target, mapping } = getTransition(element._target, service, skipForbiddenViewCheck)
   const newElement = { target: target.name, _target: target }
   Object.setPrototypeOf(newElement, element)
   if (element.on) {
@@ -35,87 +57,22 @@ const _resolvedElement = element => {
 const _navigationExistsInCompositionMap = (element, compositionMap) =>
   compositionMap.has(element.target) && element._isCompositionEffective
 
-const _addNavigationToCompositionElements = (element, definitions, compositionTree, compositionMap, isManaged) => {
-  const links = element.is2one ? getBackLinks(element) : []
-
-  const compositionElement = Object.assign({}, compositionMap.get(element.target), { name: element.name, links })
-  compositionElement.target = element.parent.name
-  const backLinks = element.is2many ? getBackLinks(element) : []
-
-  if (isManaged) {
-    compositionElement.backLinks = backLinks
-  } else {
-    compositionElement.customBackLinks = backLinks
-  }
-
-  compositionTree.compositionElements.push(compositionElement)
-}
-
 const _isUnManaged = element => element.on && !isSelfManaged(element)
 
 const _isNonRecursiveNavigation = (element, rootEntityName) =>
   rootEntityName !== element.target && element._isCompositionEffective
 
-const _getLinks = element => (element.is2one && !isSelfManaged(element) ? getBackLinks(element) : [])
-
 const _skipPersistence = (element, definitions) => definitions[element.target]._hasPersistenceSkip
 
-const _createSubElement = (element, definitions, parentEntityName) => {
-  const links = _getLinks(element, definitions)
-  const backLinks = []
-  const subObject = { name: element.name, backLinks, links }
-
+const _createSubElement = (element, definitions) => {
+  const subObject = { name: element.name, customBackLinks: [], links: [], backLinks: [] }
   if (_skipPersistence(element, definitions)) {
     subObject.skipPersistence = true
   }
-
-  if (_isUnManaged(element)) {
-    subObject.customBackLinks = getBackLinks(element)
-  }
-
   return subObject
 }
 
-const _isAssocComp = (element, parent) => {
-  return (
-    // REVISIT: are all three checks really required?
-    element.target === parent.name && element.isAssociation && element.on
-  )
-}
-
-const _checkIfBackLink = (element, definitions) => {
-  const target = definitions[element.target]
-  for (const elementName in target.elements) {
-    const targetElement = target.elements[elementName]
-    if (_isAssocComp(targetElement, element.parent)) {
-      const onCondElements = getOnCondElements(targetElement.on)
-      for (const el of onCondElements) {
-        const { entityKey, targetKey } = el
-        if (entityKey === `${elementName}.${element.name}` || targetKey === `${elementName}.${element.name}`) {
-          return true
-        }
-      }
-      return false
-    }
-  }
-}
-
-const _addBackLinksToCompositionTree = (element, definitions, compositionTree) => {
-  if (_isUnManaged(element)) {
-    if (_checkIfBackLink(element, definitions)) {
-      const backLinks = getBackLinks(element).map(backLink => ({
-        entityKey: backLink.targetKey,
-        targetKey: backLink.entityKey,
-        entityVal: backLink.targetVal,
-        targetVal: backLink.entityVal
-      }))
-      compositionTree.customBackLinks.push(...backLinks)
-    }
-  } else {
-    compositionTree.backLinks.push(...getBackLinks(element))
-  }
-}
-
+// eslint-disable-next-line complexity
 const _getCompositionTreeRec = ({
   rootEntityName,
   definitions,
@@ -123,7 +80,8 @@ const _getCompositionTreeRec = ({
   compositionTree,
   entityName,
   parentEntityName,
-  resolveViews
+  resolveViews,
+  service
 }) => {
   compositionMap.set(parentEntityName, compositionTree)
   compositionTree.source = parentEntityName
@@ -135,14 +93,52 @@ const _getCompositionTreeRec = ({
   compositionTree.customBackLinks = compositionTree.customBackLinks || []
 
   const parentEntity = definitions[parentEntityName]
-  const elements = Object.keys(parentEntity.elements).map(key => parentEntity.elements[key])
-
-  for (const element of elements) {
-    const el = resolveViews ? _resolvedElement(element) : element
-    if (_navigationExistsInCompositionMap(el, compositionMap)) {
-      _addNavigationToCompositionElements(el, definitions, compositionTree, compositionMap, ctUtils.isManaged(el))
-    } else if (_isNonRecursiveNavigation(el, rootEntityName)) {
-      const subObject = _createSubElement(el, definitions, parentEntityName)
+
+  for (const elementName in parentEntity.elements) {
+    const unresolvedEl = parentEntity.elements[elementName]
+    const element = resolveViews ? _resolvedElement(unresolvedEl, service) : unresolvedEl
+    if (!element.isAssociation) continue
+    if (_navigationExistsInCompositionMap(element, compositionMap)) {
+      const compositionElement = Object.assign({}, compositionMap.get(element.target), {
+        name: element.name,
+        target: parentEntityName,
+        links: [],
+        backLinks: [],
+        customBackLinks: []
+      })
+      if (!isSelfManaged(element)) {
+        const backLinks = _foreignKeysToLinks(element, true) || []
+        if (element.is2many) {
+          compositionElement.customBackLinks.push(...backLinks)
+        } else {
+          compositionElement.backLinks.push(...backLinks)
+        }
+      } else {
+        const targetEntity = definitions[element.target]
+        for (const backLinkName in targetEntity.elements) {
+          const _backLink = targetEntity.elements[backLinkName]
+          if (!_backLink._isAssociationEffective) continue
+          if (isBacklink(_backLink, definitions[compositionElement.target], false, element.name)) {
+            const backLinks = _foreignKeysToLinks(_backLink) || []
+            if (_isUnManaged(element)) {
+              compositionElement.customBackLinks.push(...backLinks)
+            } else {
+              compositionElement.backLinks.push(...backLinks)
+            }
+          }
+        }
+      }
+      compositionTree.compositionElements.push(compositionElement)
+    } else if (_isNonRecursiveNavigation(element, rootEntityName)) {
+      const subObject = _createSubElement(element, definitions)
+      if (!isSelfManaged(element)) {
+        const backLinks = _foreignKeysToLinks(element, true) || []
+        if (element.is2many) {
+          subObject.customBackLinks.push(...backLinks)
+        } else {
+          subObject.backLinks.push(...backLinks)
+        }
+      }
       compositionTree.compositionElements.push(subObject)
       _getCompositionTreeRec({
         rootEntityName,
@@ -150,15 +146,20 @@ const _getCompositionTreeRec = ({
         compositionMap,
         compositionTree: subObject,
         entityName: parentEntityName,
-        parentEntityName: el.target
+        parentEntityName: element.target,
+        service
       })
     } else if (
-      el._isAssociationEffective &&
-      el.target === compositionTree.target &&
-      isBacklink(el, el._target) &&
-      compositionMap.has(el.target)
+      element._isAssociationEffective &&
+      isBacklink(element, definitions[compositionTree.target], false, compositionTree.name) &&
+      compositionMap.has(element.target)
     ) {
-      _addBackLinksToCompositionTree(el, definitions, compositionTree)
+      const backLinks = _foreignKeysToLinks(element) || []
+      if (_isUnManaged(element)) {
+        compositionTree.customBackLinks.push(...backLinks)
+      } else {
+        compositionTree.backLinks.push(...backLinks)
+      }
     }
   }
 }
@@ -186,7 +187,7 @@ const _removeLocalizedTextsFromDraftTree = (compositionTree, definitions, checke
   }
 }
 
-const _getCompositionTree = ({ definitions, rootEntityName, checkRoot = true, resolveViews = false }) => {
+const _getCompositionTree = ({ definitions, rootEntityName, checkRoot = true, resolveViews = false, service }) => {
   const rootName = resolveViews ? _resolvedEntityName(rootEntityName, definitions) : rootEntityName
 
   if (checkRoot && !isRootEntity(definitions, rootEntityName)) {
@@ -200,7 +201,8 @@ const _getCompositionTree = ({ definitions, rootEntityName, checkRoot = true, re
     compositionTree,
     entityName: rootName,
     parentEntityName: rootName,
-    resolveViews
+    resolveViews,
+    service
   })
 
   if (definitions[rootEntityName]._isDraftEnabled) {
@@ -210,9 +212,34 @@ const _getCompositionTree = ({ definitions, rootEntityName, checkRoot = true, re
   return compositionTree
 }
 
+const _cacheCompositionParentsOfOne = ({ definitions }) => {
+  for (const parentName in definitions) {
+    const parent = definitions[parentName]
+    if (!parent.kind === 'entity' || !parent.elements) continue
+    for (const elementName in parent.elements) {
+      const element = parent.elements[elementName]
+      if (element._isCompositionEffective && element.is2one && !isSelfManaged(element)) {
+        const targetName = element.target
+        const target = definitions[targetName]
+        if (!target) continue
+        const parentMap = (target.own('__oneCompositionParents') && target.__oneCompositionParents) || new Map()
+        const binding = parentMap.get(parentName) || {}
+        binding.elements = binding.elements || new Map()
+        const el = _createSubElement(element, definitions)
+        el.target = targetName
+        el.source = parentName
+        el.links = _foreignKeysToLinks(element)
+        binding.elements.set(element.name, el)
+        parentMap.set(parentName, binding)
+        target.set('__oneCompositionParents', parentMap)
+      }
+    }
+  }
+}
+
 const _memoizeGetCompositionTree = fn => {
   const cache = new Map()
-  return ({ definitions, rootEntityName, checkRoot = true, resolveViews = false }) => {
+  return ({ definitions, rootEntityName, checkRoot = true, resolveViews = false, service }) => {
     const key = [rootEntityName, checkRoot].join('#')
 
     // use ApplicationService as cache key for extensibility
@@ -222,8 +249,8 @@ const _memoizeGetCompositionTree = fn => {
     const map = cache.get(cacheKey)
     const cachedResult = map && map.get(key)
     if (cachedResult) return cachedResult
-
-    const compTree = fn({ definitions, rootEntityName, checkRoot, resolveViews })
+    _cacheCompositionParentsOfOne({ definitions })
+    const compTree = fn({ definitions, rootEntityName, checkRoot, resolveViews, service })
 
     const _map = map || new Map()
     _map.set(key, compTree)

package/libx/_runtime/common/composition/update.js

@@ -1,3 +1,5 @@
+const cds = require('../../cds')
+
 const { getCompositionTree } = require('./tree')
 const { getDeepInsertCQNs } = require('./insert')
 const { getDeepDeleteCQNs } = require('./delete')
@@ -296,7 +298,8 @@ const getDeepUpdateCQNs = (definitions, cqn, selectData) => {
     definitions,
     rootEntityName: entityName,
     checkRoot: false,
-    resolveViews: !draft
+    resolveViews: !draft,
+    service: cds.db
   })
 
   const subCQNs = _addSubDeepUpdateCQN({ definitions, compositionTree, data: [entry], selectData, cqns: [], draft })

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

@@ -9,9 +9,7 @@ const addDraftSuffix = (draft, name) => {
 const whereKey = key => {
   const where = []
   Object.keys(key).forEach(keyPart => {
-    if (where.length > 0) {
-      where.push('and')
-    }
+    if (where.length > 0) where.push('and')
     where.push({ ref: [keyPart] }, '=', { val: key[keyPart] })
   })
   return where