@sap/cds 5.6.4 → 5.7.4

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

@@ -51,12 +51,8 @@ class JoinCQNFromExpanded {
    * @returns {this}
    */
   buildJoinQueries() {
-    const unionTableRef = this._getUnionTable(this._SELECT)
     // side effect: this_aliases is set
-    const aliases = this._getTableAlias(this._SELECT, [], unionTableRef && unionTableRef.table)
-
-    // Add table aliases to all refs in where part obtained from annotations
-    this._adaptAliasForWhere(this._SELECT.where)
+    const aliases = this._getTableAlias(this._SELECT, [])
 
     // Update elements at WHERE, so there are no issues with ambiguity
     this._adaptWhereOrderBy(this._SELECT, aliases)
@@ -108,7 +104,7 @@ class JoinCQNFromExpanded {
 
     const unionTableRef = this._getUnionTable(SELECT)
     const unionTable = unionTableRef && unionTableRef.table
-    const tableAlias = this._getTableAlias(SELECT, toManyTree, unionTable)
+    const tableAlias = this._getTableAlias(SELECT, toManyTree)
 
     const readToOneCQN = this._getReadToOneCQN(SELECT, isJoinOfTwoSelects ? 'filterExpand' : tableAlias)
 
@@ -161,11 +157,14 @@ class JoinCQNFromExpanded {
    * @returns {string}
    * @private
    */
-  _getTableAlias(SELECT, toManyTree, unionTable) {
-    return this._createAlias(toManyTree.length === 0 ? unionTable || this._getRef(SELECT).table : toManyTree.join(':'))
+  _getTableAlias(SELECT, toManyTree) {
+    return this._createAlias(toManyTree.length === 0 ? this._getRef(SELECT).table : toManyTree.join(':'))
   }
 
   _getRef(SELECT) {
+    const unionTableRef = this._getUnionTable(SELECT)
+    if (unionTableRef) return unionTableRef
+
     const table = Object.prototype.hasOwnProperty.call(SELECT.from, 'join')
       ? this._getRefFromJoin(SELECT.from.args)
       : SELECT.from
@@ -256,10 +255,18 @@ class JoinCQNFromExpanded {
       : column
   }
 
-  _adaptJoin(tableAlias, cqn, from) {
+  _adaptJoin(tableAlias, cqn, from, mapping = {}) {
     from.args = from.args.slice(0)
     if (Object.prototype.hasOwnProperty.call(from.args[0], 'join')) {
-      this._adaptJoin(tableAlias, cqn, from.args[0])
+      this._adaptJoin(tableAlias, cqn, from.args[0], mapping)
+      if (from.on) {
+        // we come here for SiblingEntity with expand
+        for (const originalIdentifier in mapping) {
+          from.on = from.on.map(column =>
+            this._adaptTableNameInColumn(column, originalIdentifier, mapping[originalIdentifier])
+          )
+        }
+      }
     } else {
       const index = from.args[0].ref ? 0 : from.args.length - 1
       const target = Object.assign({}, from.args[index], { as: tableAlias })
@@ -268,6 +275,7 @@ class JoinCQNFromExpanded {
       from.args[index] = target
       from.on = from.on.map(column => this._adaptTableNameInColumn(column, originalIdentifier, tableAlias))
       cqn.columns = cqn.columns.map(column => this._adaptTableNameInColumn(column, originalIdentifier, tableAlias))
+      mapping[originalIdentifier] = tableAlias
     }
   }
 
@@ -331,32 +339,6 @@ class JoinCQNFromExpanded {
     whereElement.ref && whereElement.ref.splice(0, 1, Object.values(this._aliases)[0])
   }
 
-  _adaptAliasForFrom(from) {
-    if (from.args) {
-      from.args.forEach(arg => {
-        this._adaptAliasForFrom(arg)
-      })
-    } else if (from.SELECT) {
-      this._adaptAliasForFrom(from.SELECT.from)
-      if (from.SELECT.where) {
-        this._adaptAliasForWhere(from.SELECT.where)
-      }
-    }
-  }
-
-  _adaptAliasForWhere(where) {
-    if (where) {
-      for (const whereElement of where) {
-        if (whereElement.SELECT) {
-          if (whereElement.SELECT.where) {
-            this._adaptAliasForWhere(whereElement.SELECT.where)
-          }
-          this._adaptAliasForFrom(whereElement.SELECT.from)
-        }
-      }
-    }
-  }
-
   _navigationNeedsAlias(element, { table } = {}) {
     const entity = this._csn.definitions[table]
     if (entity) {
@@ -377,9 +359,9 @@ class JoinCQNFromExpanded {
 
       if (element.ref.length === 1) {
         element.ref.unshift(tableAlias)
-      } else if (this._elementAliasNeedsReplacement(element, this._getUnionTable(cqn) || this._getRef(cqn))) {
+      } else if (this._elementAliasNeedsReplacement(element, this._getRef(cqn))) {
         element.ref[0] = tableAlias
-      } else if (this._navigationNeedsAlias(element, this._getUnionTable(cqn) || this._getRef(cqn))) {
+      } else if (this._navigationNeedsAlias(element, this._getRef(cqn))) {
         element.ref.unshift(tableAlias)
       }
 
@@ -392,7 +374,7 @@ class JoinCQNFromExpanded {
     } else if (element.SELECT && element.SELECT.where) {
       element = {
         SELECT: Object.assign({}, element.SELECT, {
-          where: this._adaptWhereSELECT(this._getUnionTable(cqn) || this._getRef(cqn), element.SELECT.where, tableAlias)
+          where: this._adaptWhereSELECT(this._getRef(cqn), element.SELECT.where, tableAlias)
         })
       }
     }
@@ -588,13 +570,15 @@ class JoinCQNFromExpanded {
     const on = []
     for (const key in entity._target.keys) {
       if (key !== 'IsActiveEntity') {
+        if (on.length) on.push('AND')
         on.push({ ref: [`${tableAlias}_drafts`, key] }, '=', { ref: [tableAlias, key] })
       }
     }
+
     return {
       args: [cqn, { ref: [draftTable], as: `${tableAlias}_drafts` }],
       join: 'left',
-      on: on
+      on: ['(', ...on, ')']
     }
   }
 
@@ -613,8 +597,8 @@ class JoinCQNFromExpanded {
     )
   }
 
-  _getTarget(entity, column) {
-    const navigation = getNavigationIfStruct(entity, column.ref)
+  _getTarget(entity, column, parentAlias) {
+    const navigation = getNavigationIfStruct(entity, column.ref[0] === parentAlias ? column.ref.slice(1) : column.ref)
     return (navigation && navigation.target) || column.ref[0]
   }
 
@@ -632,17 +616,19 @@ class JoinCQNFromExpanded {
    */
   // eslint-disable-next-line complexity
   _addJoinAndElements({ column, entity, readToOneCQN, toManyTree, parentAlias, defaultLanguage }) {
-    const extendedToManyTree = toManyTree.concat(column.ref)
+    const extendedToManyTree = toManyTree.concat(column.ref[0] === parentAlias ? column.ref.slice(1) : column.ref)
     const tableAlias = this._createAlias(extendedToManyTree.join(':'))
-    const target = this._getTarget(entity, column)
+    const target = this._getTarget(entity, column, parentAlias)
+
+    const name = column.ref[column.ref.length - 1]
+    const element = name && entity.elements[name]
 
     // 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] ||
-      (entity.elements[column.ref[0]].type === 'cds.Association' &&
-        !entity.elements[column.ref[0]]['@odata.draft.enclosed']) ||
+      (element && element.type === 'cds.Association' && !element['@odata.draft.enclosed']) ||
       !this._csn.definitions[target]._isDraftEnabled
 
     const colTarget = target && ensureUnlocalized(target)
@@ -652,9 +638,7 @@ class JoinCQNFromExpanded {
       (colTarget && this._csn.definitions[colTarget] && this._csn.definitions[colTarget]['@cds.localized'] === false)
 
     const join =
-      column.ref[0] === 'DraftAdministrativeData' || !entity.elements[column.ref[0]].notNull || this._isDraft
-        ? 'left'
-        : 'inner'
+      column.ref[0] === 'DraftAdministrativeData' || !(element && element.notNull) || this._isDraft ? 'left' : 'inner'
 
     const args = [
       readToOneCQN.from.SET ? this._unionToSubQuery(readToOneCQN) : readToOneCQN.from,
@@ -681,9 +665,9 @@ class JoinCQNFromExpanded {
       readToOneCQN.from.args[1] = {
         SELECT: {
           columns: cols,
-          from: unionFrom,
-          as: tableAlias
-        }
+          from: unionFrom
+        },
+        as: tableAlias
       }
     }
 
@@ -695,11 +679,11 @@ class JoinCQNFromExpanded {
     }
 
     // special case of navigation to one requires additional LEFT JOIN and CASE for HasDraftEntity
-    const compToOne = this._isNavigationToOne(readToOneCQN[IS_ACTIVE], entity.elements[column.ref[0]])
+    const compToOne = this._isNavigationToOne(readToOneCQN[IS_ACTIVE], element)
     const index = column.expand.findIndex(col => col.ref && col.ref[col.ref.length - 1] === 'HasDraftEntity')
 
     if (compToOne && index !== -1) {
-      readToOneCQN.from = this._addJoinCompToOne(readToOneCQN.from, entity.elements[column.ref[0]], tableAlias)
+      readToOneCQN.from = this._addJoinCompToOne(readToOneCQN.from, element, tableAlias)
       if (activeTableRequired) {
         column.expand[index] = {
           xpr: [
@@ -771,9 +755,9 @@ class JoinCQNFromExpanded {
     return {
       SELECT: {
         columns: Array.from(readToOneCQN.columns),
-        from: readToOneCQN.from,
-        as: readToOneCQN.from.as
-      }
+        from: readToOneCQN.from
+      },
+      as: readToOneCQN.from.as
     }
   }
 
@@ -849,7 +833,9 @@ class JoinCQNFromExpanded {
     const subSelectColumns = this._getSubSelectColumns(readToOneCQN)
 
     if (subSelectColumns.length === 0) {
-      return entity._relations[tableAlias === columns[0] ? columns.slice(1) : columns].join(tableAlias, parentAlias)
+      return entity._relations[
+        tableAlias === columns[0] || parentAlias === columns[0] ? columns.slice(1) : columns
+      ].join(tableAlias, parentAlias)
     }
 
     const aliases = this._getAliases(subSelectColumns)
@@ -872,18 +858,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 (
@@ -892,15 +878,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

@@ -1,8 +1,10 @@
 const { hasExpand, createJoinCQNFromExpanded } = require('./expandCQNToJoin')
 const rawToExpanded = require('./rawToExpanded')
+const expandV2 = require('./expand-v2')
 
 module.exports = {
   hasExpand,
   createJoinCQNFromExpanded,
-  rawToExpanded
+  rawToExpanded,
+  expandV2
 }

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

@@ -14,7 +14,7 @@ const cds = require('../../cds')
 const normalizeTimeData = require('../utils/normalizeTimeData')
 
 const { enrichDataWithKeysFromWhere } = require('../../common/utils/keys')
-const { propagateForeignKeys } = require('../../common/utils/propagateForeignKeys')
+const propagateForeignKeys = require('../utils/propagateForeignKeys')
 const getTemplate = require('../../common/utils/template')
 const templateProcessor = require('../../common/utils/templateProcessor')
 
@@ -25,12 +25,14 @@ 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 _shouldGenerateUUID = element => element.key && !DRAFT_COLUMNS_MAP[element.name] && element.type === 'cds.UUID'
+
 const _processComplexCategory = ({ row, key, val, category, req, element }) => {
   const categoryArgs = category.args
   category = category.category
 
   // propagate keys
-  if (category === 'propagateForeignKeys') {
+  if (category === 'propagateForeignKeys' && row[key]) {
     propagateForeignKeys(key, row, element._foreignKeys, element._isCompositionEffective)
     return
   }
@@ -73,6 +75,20 @@ const _processCategory = ({ category, row, key, element, val, req }) => {
     return
   }
 
+  if (category === 'comp2one') {
+    if (!val) return
+
+    for (const keyName in element._target.keys) {
+      const k = element._target.keys[keyName]
+      if (k.type === 'cds.Association' || k.name === 'IsActiveEntity') continue
+
+      if (k.type !== 'cds.UUID' && !(k.name in val)) {
+        req.error(400, 'ASSERT_NOT_NULL', key + '[' + k + ']', [key + '[' + k + ']'])
+        return
+      }
+    }
+  }
+
   // not null without default (for better error message)
   if (category === '!default' && val == null && req.event === 'CREATE') {
     req.error(400, 'ASSERT_NOT_NULL', key, [key])
@@ -101,12 +117,24 @@ const processorFn =
     }
   }
 
+const _isVirtualOrCalculated = element => {
+  if (element.virtual) return true
+  if (
+    element.parent &&
+    element.parent.projection &&
+    element.parent.projection.columns &&
+    element.parent.projection.columns.find(c => c.as === element.name && (c.xpr || c.val || c.func))
+  ) {
+    return true
+  }
+}
+
 // params: element, target, parent, templateElements
-const _pick = element => {
+const _pickCRUD = element => {
   // collect actions to apply
   const categories = []
 
-  if (element.virtual) {
+  if (_isVirtualOrCalculated(element)) {
     categories.push('virtual')
     return { categories } // > no need to continue
   }
@@ -136,22 +164,37 @@ const _pick = element => {
     categories.push('associationEffective')
   }
 
+  // REVISIT: element._foreignKeys.length seems to be a very broad check
   if (element.isAssociation && element._foreignKeys.length) {
     categories.push({ category: 'propagateForeignKeys' })
   }
 
-  // generate uuid
-  if (element.key && !DRAFT_COLUMNS_MAP[element.name] && element.type === 'cds.UUID') {
+  if (_shouldGenerateUUID(element)) {
     categories.push('uuid')
   }
 
+  if (element.isComposition && element.is2one) {
+    categories.push('comp2one')
+  }
+
   if (categories.length) return { categories }
 }
 
-const _pickVirtual = element => {
+const _pickDraft = element => {
   // collect actions to apply
   const categories = []
+
   if (element.virtual) categories.push('virtual')
+
+  // REVISIT: element._foreignKeys.length seems to be a very broad check
+  if (element.isAssociation && element._foreignKeys.length) {
+    categories.push({ category: 'propagateForeignKeys' })
+  }
+
+  if (_shouldGenerateUUID(element)) {
+    categories.push('uuid')
+  }
+
   if (categories.length) return { categories }
 }
 
@@ -174,10 +217,9 @@ function _handler(req) {
 
   let template
   if (draft) {
-    // draft -> filter virtual only
-    template = getTemplate('db-virtual', this, target, { pick: _pickVirtual })
+    template = getTemplate('db-input-draft', this, target, { pick: _pickDraft })
   } else {
-    template = getTemplate('db-input', this, target, { pick: _pick })
+    template = getTemplate('db-input-crud', this, target, { pick: _pickCRUD })
   }
 
   if (template.elements.size === 0) return