@sap/cds 5.8.4 → 5.9.2

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

@@ -8,7 +8,7 @@ const { ensureNoDraftsSuffix, ensureDraftsSuffix, ensureUnlocalized } = require(
 const { isAsteriskColumn } = require('../../common/utils/rewriteAsterisks')
 const { getCQNUnionFrom } = require('../../common/utils/union')
 
-const { DRAFT_COLUMNS } = require('../../common/constants/draft')
+const { DRAFT_COLUMNS_MAP } = require('../../common/constants/draft')
 
 const { filterKeys } = require('../../fiori/utils/handler')
 
@@ -20,6 +20,7 @@ const SKIP_MAPPING = Symbol.for('sap.cds.skipMapping')
 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 CLEANUP_KEYS = Symbol.for('sap.cds.cleanupKeys')
 
 function getCqnCopy(readToOneCQN) {
   // REVISIT: Use query.clone() instead
@@ -31,6 +32,7 @@ function getCqnCopy(readToOneCQN) {
   if (readToOneCQN[IDENTIFIER] !== undefined) readToOneCQNCopy[IDENTIFIER] = readToOneCQN[IDENTIFIER]
   if (readToOneCQN[IS_ACTIVE] !== undefined) readToOneCQNCopy[IS_ACTIVE] = readToOneCQN[IS_ACTIVE]
   if (readToOneCQN[IS_UNION_DRAFT] !== undefined) readToOneCQNCopy[IS_UNION_DRAFT] = readToOneCQN[IS_UNION_DRAFT]
+  if (readToOneCQN[CLEANUP_KEYS] !== undefined) readToOneCQNCopy[CLEANUP_KEYS] = readToOneCQN[CLEANUP_KEYS]
   return readToOneCQNCopy
 }
 
@@ -533,7 +535,6 @@ class JoinCQNFromExpanded {
         }
       }
     }
-
     // only as second step handle expand to many, or else keys might still be unknown
     this._toMany({
       entity,
@@ -611,11 +612,7 @@ class JoinCQNFromExpanded {
   }
 
   _isNavigationToOne(activeTable, target) {
-    return (
-      target &&
-      ((activeTable && target.type === 'cds.Composition') || target.type === 'cds.Association') &&
-      target.is2one
-    )
+    return target && ((activeTable && target.isComposition) || target._isAssociationStrict) && target.is2one
   }
 
   _getTarget(entity, column, parentAlias) {
@@ -649,7 +646,7 @@ class JoinCQNFromExpanded {
     const activeTableRequired =
       readToOneCQN[IS_UNION_DRAFT] || // > REVISIT: blocks expanding comp2one
       readToOneCQN[IS_ACTIVE] ||
-      (element && element.type === 'cds.Association' && !element['@odata.draft.enclosed']) ||
+      (element && element._isAssociationStrict && !element['@odata.draft.enclosed']) ||
       !this._csn.definitions[target]._isDraftEnabled
 
     const colTarget = target && ensureUnlocalized(target)
@@ -677,9 +674,9 @@ class JoinCQNFromExpanded {
 
     const expandedEntity = this._getEntityForTable(target)
     if (readToOneCQN[IS_UNION_DRAFT] && expandedEntity.drafts) {
-      const cols = column.expand.filter(c => !c.expand && !DRAFT_COLUMNS.includes(c.ref[0])).map(c => c.ref[0])
+      const cols = column.expand.filter(c => !c.expand && !(c.ref[0] in DRAFT_COLUMNS_MAP)).map(c => c.ref[0])
       const ks = Object.keys(expandedEntity.keys).filter(
-        c => !expandedEntity.keys[c].isAssociation && !DRAFT_COLUMNS.includes(c)
+        c => !expandedEntity.keys[c].isAssociation && !(c in DRAFT_COLUMNS_MAP)
       )
       const user = (cds.context && cds.context.user && cds.context.user.id) || 'anonymous'
       const unionFrom = getCQNUnionFrom(cols, expandedEntity.name, expandedEntity.name + '.drafts', ks, user)
@@ -746,8 +743,19 @@ class JoinCQNFromExpanded {
       return col
     })
 
+    const targetEntity = this._getEntityForTable(target)
+    if (
+      'IsActiveEntity' in targetEntity.elements &&
+      this._isNotIncludedIn(givenColumns)('IsActiveEntity') &&
+      typeof activeTableRequired === 'boolean'
+    ) {
+      const col = this._createCalculatedBooleanColumn('IsActiveEntity', activeTableRequired)
+      col[CLEANUP_KEYS] = true
+      givenColumns.push(col)
+    }
+
     this._expandedToFlat({
-      entity: this._getEntityForTable(target),
+      entity: targetEntity,
       givenColumns,
       readToOneCQN,
       tableAlias,
@@ -959,6 +967,12 @@ class JoinCQNFromExpanded {
 
     if (!column[SKIP_MAPPING]) {
       mappings[column[IDENTIFIER] || identifier] = as
+      // REVISIT: remove flag cds.env.features.auto_fetch_expand_keys after two month grace period
+      if (column[CLEANUP_KEYS] && !cds.env.features.auto_fetch_expand_keys) {
+        delete aliasedElement[CLEANUP_KEYS]
+        if (!mappings[CLEANUP_KEYS]) mappings[CLEANUP_KEYS] = {}
+        mappings[CLEANUP_KEYS][column[IDENTIFIER] || identifier] = as
+      }
     }
 
     return aliasedElement
@@ -983,7 +997,7 @@ class JoinCQNFromExpanded {
     if (splitted.length > 1 && entity.elements[splitted[0]]) return true
 
     // Draft column
-    return DRAFT_COLUMNS.includes(ref[0])
+    return ref[0] in DRAFT_COLUMNS_MAP
   }
 
   _toMany({
@@ -1031,12 +1045,14 @@ class JoinCQNFromExpanded {
         readToOneCQN.columns.push({
           val: readToOneCQN[IS_ACTIVE],
           as: 'IsActiveEntity',
-          cast: { type: 'cds.Boolean' }
+          cast: { type: 'cds.Boolean' },
+          [CLEANUP_KEYS]: true
         })
       } else {
         readToOneCQN.columns.push({
           as: `${tableAlias}_${name}`,
-          ref: [tableAlias, name]
+          ref: [tableAlias, name],
+          [CLEANUP_KEYS]: true
         })
       }
     }
@@ -1092,7 +1108,7 @@ class JoinCQNFromExpanded {
 
     const expandActive =
       readToOneCQN[IS_ACTIVE] ||
-      (element.type === 'cds.Association' && !element['@odata.draft.enclosed']) ||
+      (element._isAssociationStrict && !element['@odata.draft.enclosed']) ||
       !this._csn.definitions[colTarget]._isDraftEnabled
     const ref = this._getJoinRef(entity.elements, colRef[0], expandActive, defaultLanguageThis)
     const tableAlias = this._createAlias(toManyTree.concat(colRef).join(':'))
@@ -1135,7 +1151,7 @@ class JoinCQNFromExpanded {
     cqn = this._adaptWhereOrderBy(cqn, tableAlias)
 
     if (isUnion) {
-      const cols = column.expand.filter(c => !c.expand && !DRAFT_COLUMNS.includes(c.ref[0])).map(c => c.ref[0])
+      const cols = column.expand.filter(c => !c.expand && !(c.ref[0] in DRAFT_COLUMNS_MAP)).map(c => c.ref[0])
       // ensure the join columns are selected
       for (const each of joinColumns) {
         const col = each.ref[each.ref.length - 1]
@@ -1146,7 +1162,7 @@ class JoinCQNFromExpanded {
         if (each.expand) {
           const assoc = expandedEntity.associations[each.ref[0]]
           if (assoc.is2one) {
-            const fks = Object.values(expandedEntity.elements).filter(ele => ele['@odata.foreignKey4'] === assoc.name)
+            const fks = Object.values(expandedEntity.elements).filter(ele => ele._foreignKey4 === assoc.name)
             cols.push(...fks.map(fk => fk.name))
           }
         }
@@ -1154,7 +1170,7 @@ class JoinCQNFromExpanded {
 
       if (!cqn[IS_ACTIVE]) {
         const ks = Object.keys(expandedEntity.keys).filter(
-          c => !expandedEntity.keys[c].isAssociation && !DRAFT_COLUMNS.includes(c)
+          c => !expandedEntity.keys[c].isAssociation && !(c in DRAFT_COLUMNS_MAP)
         )
         const user = (cds.context && cds.context.user && cds.context.user.id) || 'anonymous'
         const unionFrom = getCQNUnionFrom(cols, ref.replace(/_drafts$/, ''), ref, ks, user)
@@ -1189,30 +1205,12 @@ class JoinCQNFromExpanded {
 
   _getJoinRef(elements, column, isActive, defaultLanguage) {
     const assoc = elements[column]
-    if (typeof isActive !== 'boolean' || isActive || assoc.type !== 'cds.Composition') {
+    if (typeof isActive !== 'boolean' || isActive || !assoc.isComposition) {
       return defaultLanguage ? ensureUnlocalized(assoc.target) : assoc.target
     }
     return assoc.target + '_drafts'
   }
 
-  /**
-   * Get the list of key columns in ref format.
-   * Add the table alias to avoid ambiguity issues.
-   *
-   * @param tableAlias
-   * @param isActive
-   * @param expandedEntity
-   * @returns {Array}
-   * @private
-   */
-  _getKeyColumnForTarget(tableAlias, isActive, expandedEntity) {
-    return getAllKeys(expandedEntity)
-      .filter(column => typeof isActive !== 'boolean' || column !== 'IsActiveEntity')
-      .map(column => {
-        return { ref: [tableAlias, column] }
-      })
-  }
-
   _getLimitInSelect(cqn, columns, limit, orderBy, expandedEntity) {
     const select = {
       SELECT: {
@@ -1391,7 +1389,10 @@ class JoinCQNFromExpanded {
       value = entry[`${parentAlias}_${key}`] || entry[`${parentAlias}_${key}`.toUpperCase()]
     }
 
-    if (value === undefined && cds.env.effective.odata && cds.env.effective.odata.structs) {
+    if (
+      value === undefined &&
+      ((cds.env.effective.odata && cds.env.effective.odata.structs) || cds.env.features.ucsn_struct_conversion)
+    ) {
       // here, it should be a structured key
       const keys = Object.keys(entry).filter(k => k.startsWith(key + '_'))
       if (keys.length) {
@@ -1572,7 +1573,7 @@ class JoinCQNFromExpanded {
     return entry =>
       !columns.some(
         column =>
-          (typeof column === 'object' && column.ref && column.ref[1] === entry) ||
+          (typeof column === 'object' && column.ref && column.ref[column.ref.length - 1] === entry) ||
           ('val' in column && column.as === entry)
       )
   }
@@ -1605,12 +1606,15 @@ class JoinCQNFromExpanded {
   _addMissingKeyColumns(columns, tableAlias, keys, isActive, entity) {
     for (const key of keys.filter(this._isNotIncludedIn(columns))) {
       if (key === 'IsActiveEntity' && typeof isActive === 'boolean') {
-        columns.push(this._createCalculatedBooleanColumn(key, isActive))
+        const col = this._createCalculatedBooleanColumn(key, isActive)
+        col[CLEANUP_KEYS] = true
+        columns.push(col)
       } else if (!entity.elements[key].elements) {
         // > don't add if complex key
         columns.push({
           ref: [tableAlias, key],
-          as: `${tableAlias}_${key}`
+          as: `${tableAlias}_${key}`,
+          [CLEANUP_KEYS]: true
         })
       }
     }

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

@@ -1,8 +1,11 @@
+const { DRAFT_COLUMNS_MAP } = require('../../common/constants/draft')
+const DRAFT_COLUMNS_ARRAY = Object.keys(DRAFT_COLUMNS_MAP)
+
 const EXPAND = Symbol.for('sap.cds.expand')
 const GET_KEY_VALUE = Symbol.for('sap.cds.getKeyValue')
 const TO_MANY = Symbol.for('sap.cds.toMany')
 const TO_ACTIVE = Symbol.for('sap.cds.toActive')
-const { DRAFT_COLUMNS } = require('../../common/constants/draft')
+const CLEANUP_KEYS = Symbol.for('sap.cds.cleanupKeys')
 
 class RawToExpanded {
   constructor(configs, queries, one, rootEntity) {
@@ -22,8 +25,13 @@ class RawToExpanded {
   async toExpanded() {
     const { queries, mappings } = this._configs
 
+    const conversionMapper = new Map()
+    for (const each of queries) {
+      if (each._conversionMapper) for (const [k, v] of [...each._conversionMapper]) conversionMapper.set(k, v)
+    }
+
     for (let i = 0, length = this._queries.length; i < length; i++) {
-      const { _conversionMapper: conversionMapper = new Map(), _toManyTree: toManyTree = [] } = queries[i]
+      const { _toManyTree: toManyTree = [] } = queries[i]
       const result = await this._queries[i]
       if (toManyTree.length === 0) {
         this._parseMainResult(result, mappings, conversionMapper, toManyTree)
@@ -39,6 +47,10 @@ class RawToExpanded {
     for (const entry of result) {
       const parsed = this._parseRaw({ mappings, toManyTree, conversionMapper, entry })
 
+      if (mappings[CLEANUP_KEYS]) {
+        for (const key of Object.keys(mappings[CLEANUP_KEYS])) delete parsed[key]
+      }
+
       if (parsed) {
         this._result.push(parsed)
       }
@@ -50,7 +62,7 @@ class RawToExpanded {
       const el = mapping[key]
       // if we expand automatically in groupby we have no other columns than objects
       if (typeof el !== 'string') return false
-      if (result[el] !== null && !DRAFT_COLUMNS.some(col => el.endsWith(`_${col}`))) {
+      if (result[el] !== null && !DRAFT_COLUMNS_ARRAY.some(col => el.endsWith(`_${col}`))) {
         return false
       }
     }
@@ -99,7 +111,12 @@ class RawToExpanded {
           else expandedItems = expandedItems.filter(ele => ele.IsActiveEntity === rootIsActiveEntity)
         }
 
-        row[key] = expandedItems
+        row[key] = !mapping[CLEANUP_KEYS]
+          ? expandedItems
+          : expandedItems.map(item => {
+              for (const key of Object.keys(mapping[CLEANUP_KEYS])) delete item[key]
+              return item
+            })
       } else if (typeof mapping === 'object') {
         // > Will be true in case of 1:1 expands
         // check if the expanded entry doesn't exists
@@ -122,11 +139,14 @@ class RawToExpanded {
           else if (rootIsActiveEntity) row[key] = parsed && parsed.IsActiveEntity !== false ? parsed : null
           else row[key] = parsed && parsed.IsActiveEntity === rootIsActiveEntity ? parsed : null
         }
+        if (mapping[CLEANUP_KEYS]) {
+          for (const key in mapping[CLEANUP_KEYS]) delete parsed[key]
+        }
       } else {
         // > No expand convert the result directly.
         const rawValue = entry[mapping]
         // Assume a DB will not return undefined, but always null
-        row[key] = this._convertValue(rawValue, conversionMapper.get(mapping))
+        this._convertValue(rawValue, conversionMapper.get(mapping), mapping, row, key)
 
         isEntityNull = this._isNull(isEntityNull, rawValue)
       }
@@ -164,12 +184,13 @@ class RawToExpanded {
    * @returns {*}
    * @private
    */
-  _convertValue(value, converter) {
+  _convertValue(value, converter, key, row, unaliasedKey) {
     if (converter) {
-      return converter(value)
+      converter(value, key, row, unaliasedKey)
+      return
     }
 
-    return value
+    row[unaliasedKey || key] = value
   }
 
   _parseExpandResult(result, mappings, conversionMapper, toManyTree) {

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

@@ -10,7 +10,6 @@ const UPDATE = require('./update')
 const DELETE = require('./delete')
 // after
 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.
@@ -24,6 +23,5 @@ module.exports = {
   READ,
   UPDATE,
   DELETE,
-  structured,
-  arrayed
+  structured
 }

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

@@ -25,7 +25,7 @@ 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 _shouldGenerateUUID = element => element.key && !DRAFT_COLUMNS_MAP[element.name] && element.isUUID
 
 const _processComplexCategory = ({ row, key, val, category, req, element }) => {
   const categoryArgs = category.args
@@ -55,7 +55,7 @@ const _processComplexCategory = ({ row, key, val, category, req, element }) => {
     if ('val' in dfault) row[key] = dfault.val
     else if ('ref' in dfault && dfault.ref[0] === '$now') {
       row[key] =
-        categoryArgs.type === 'cds.DateTime'
+        categoryArgs._type === 'cds.DateTime'
           ? new Date(req.timestamp).toISOString().replace(/\.\d\d\d/, '')
           : req.timestamp
     }
@@ -80,9 +80,9 @@ const _processCategory = ({ category, row, key, element, val, req }) => {
 
     for (const keyName in element._target.keys) {
       const k = element._target.keys[keyName]
-      if (k.type === 'cds.Association' || k.name === 'IsActiveEntity') continue
+      if (k.isAssociation || k.name === 'IsActiveEntity') continue
 
-      if (k.type !== 'cds.UUID' && !(k.name in val)) {
+      if (!k.isUUID && !(k.name in val)) {
         req.error(400, 'ASSERT_NOT_NULL', key + '[' + k + ']', [key + '[' + k + ']'])
         return
       }
@@ -139,12 +139,7 @@ const _pickCRUD = element => {
     return { categories } // > no need to continue
   }
 
-  if (
-    element.notNull &&
-    element['@assert.notNull'] !== false &&
-    !element.default &&
-    element.type !== 'cds.Association'
-  ) {
+  if (element.notNull && element['@assert.notNull'] !== false && !element.default && !element._isAssociationStrict) {
     categories.push('!default')
   }
 

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

@@ -12,8 +12,11 @@ const _isLinked = req => {
 }
 
 function handler(req) {
-  // REVISIT: req.target._unresolved for join queries
-  if (!this.model || typeof req.query === 'string' /* || !req.target || req.target._unresolved */) {
+  if (typeof req.query === 'string') return
+
+  if (!this.model) {
+    // best-effort rewrite of path in from
+    req.query = cqn2cqn4sql(req.query, { definitions: {} }, { service: this })
     return
   }
 

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

@@ -73,14 +73,14 @@ const _flatToStructured = (structuredType, data, prefixes = [], subData = data)
  * @returns {Promise}
  */
 module.exports = function (result, req) {
+  // REVISIT if result has a property length that is 0 we will return here
   if (!this.model || result == null || result.length === 0) return
 
-  if (!Array.isArray(result)) result = [result]
-
   // REVISIT: No entity for sets/unions outside of common draft scenarios
   const entity = getEntityFromCQN(req, this)
   if (!entity) return
 
+  if (!Array.isArray(result)) result = [result]
   const structuredTypes = _getStructuredTypes(entity)
   for (let i = 0; i < result.length; i++) {
     const d = result[i]

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

@@ -7,7 +7,7 @@ const deleteFn = (executeDeleteCQN, executeUpdateCQN) => async (model, dbc, quer
   const isoTs = timestampToISO(timestamp)
 
   let result
-  if (hasDeepDelete(model, query)) {
+  if (model && hasDeepDelete(model, query)) {
     let cqns = await getDeepDeleteCQNs(model, req)
 
     // the delete chunks, i.e., how many deletes can be processed in parallel
@@ -25,7 +25,7 @@ const deleteFn = (executeDeleteCQN, executeUpdateCQN) => async (model, dbc, quer
     result = results[results.length - 1]
   } else {
     result = await executeDeleteCQN(model, dbc, query, user, locale, isoTs)
-    if (result) {
+    if (result && model) {
       const updateCQNs = await getSetNullParentForeignKeyCQNs(model, req)
       for (const cqn of updateCQNs) {
         await executeUpdateCQN(model, dbc, cqn, user, locale, isoTs)

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

@@ -6,7 +6,7 @@ const insert = executeInsertCQN => async (model, dbc, query, req) => {
   const { user, locale, timestamp } = req
   const isoTs = timestampToISO(timestamp)
 
-  if (hasDeepInsert(model, query)) {
+  if (model && hasDeepInsert(model, query)) {
     const cqns = getFlatArray(getDeepInsertCQNs(model, query))
 
     // return array of individual results

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

@@ -12,7 +12,8 @@ const _includesCompositionTarget = (cqns, target) => {
 
 const _getFilteredCqns = (cqns, model) => {
   // right to left processing necessary!
-  for (let i = cqns.length - 1; i >= 0; i--) {
+  // no need to process first (= root)
+  for (let i = cqns.length - 1; i > 0; i--) {
     const cqn = cqns[i]
 
     const entity = model && cqn.UPDATE && model.definitions[cqn.UPDATE.entity]
@@ -26,21 +27,15 @@ const _getFilteredCqns = (cqns, model) => {
     let moreThanManaged = Object.keys(cqn.UPDATE.data).some(
       k => entity.elements[k]['@cds.on.update'] === undefined || !cqn.UPDATE.data[k].startsWith('$')
     )
-
     if (moreThanManaged) continue
 
-    // REVISIT: remove feature flag update_header_item after grace period of at least two months (> April release)
-    if (cds.env.features.update_header_item !== false) {
-      const comps = Object.values(entity.associations || {}).filter(assoc => assoc._isCompositionEffective)
-
-      for (const comp of comps) {
-        if (_includesCompositionTarget(cqns, comp.target)) {
-          moreThanManaged = true
-          break
-        }
+    const comps = Object.values(entity.associations || {}).filter(assoc => assoc._isCompositionEffective)
+    for (const comp of comps) {
+      if (_includesCompositionTarget(cqns, comp.target)) {
+        moreThanManaged = true
+        break
       }
     }
-
     if (moreThanManaged) continue
 
     // remove current cqn
@@ -54,7 +49,7 @@ const update = executeUpdateCQN => async (model, dbc, req) => {
   const { query, user, locale, timestamp } = req
   const isoTs = timestampToISO(timestamp)
 
-  if (hasDeepUpdate(model, query)) {
+  if (model && hasDeepUpdate(model, query)) {
     // REVISIT: _activeData gets set in case of draftActivate for performance, but this is a layer violation
     let selectData = req._ && req._.query && req._.query._activeData
 
@@ -71,7 +66,7 @@ const update = executeUpdateCQN => async (model, dbc, req) => {
     const chunks = []
     for (const each of cqns) chunks.push(each.filter(e => e.DELETE).length)
 
-    // remove queries that only want to update @cds.on.update properties
+    // remove child queries that only want to update @cds.on.update properties
     cqns = _getFilteredCqns(getFlatArray(cqns), model)
 
     if (cqns.length === 0) return 0

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

@@ -102,8 +102,9 @@ class CreateBuilder extends BaseBuilder {
       if (structuredType[property].elements) {
         this._flattenStructuredElement(`${prefix}_${property}`, structuredType[property].elements, flattenedElements)
       } else if (
-        structuredType[property].type === 'cds.Association' &&
-        (structuredType[property].keys || structuredType[property].foreignKeys)
+        structuredType[property].isAssociation &&
+        (structuredType[property].keys ||
+          (Array.isArray(structuredType[property].foreignKeys) && structuredType[property].foreignKeys))
       ) {
         // OLD CSN
         flattenedElements.push(...this._association(`${prefix}_${property}`, structuredType[property]))
@@ -118,7 +119,7 @@ class CreateBuilder extends BaseBuilder {
   }
 
   _association(associationName, element) {
-    const keys = element.foreignKeys || element.keys // OLD CSN
+    const keys = element.keys || (Array.isArray(element.foreignKeys) && element.foreignKeys) // OLD CSN
     if (keys) {
       return keys.map(key => {
         const ref = key.ref ? key.ref[0] : key // OLD CSN

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

@@ -56,12 +56,13 @@ class FunctionBuilder extends BaseBuilder {
   }
 
   _escapeLikeParameters(parameters) {
-    for (const parameter of parameters) {
-      if (parameter.val) parameter.val = parameter.val.replace(/(\^|_|%)/g, '^$1')
-      else if (parameter.func) parameter.args = this._escapeLikeParameters(parameter.args)
-    }
-
-    return parameters
+    return parameters.map(parameter => {
+      if (parameter.val) return { ...parameter, val: parameter.val.replace(/(\^|_|%)/g, '^$1') }
+      if (parameter.func) {
+        return { ...parameter, args: this._escapeLikeParameters(parameter.args) }
+      }
+      return parameter
+    })
   }
 
   _handleFunction() {
@@ -117,8 +118,7 @@ class FunctionBuilder extends BaseBuilder {
     const functionName = this._functionName()
     const not = functionName.startsWith('not') ? 'NOT ' : ''
     const columns = this._columns(args)
-    const params = args.slice(1)
-    this._escapeLikeParameters(params)
+    const params = this._escapeLikeParameters(args.slice(1))
 
     const _pattern = (() => {
       if (functionName.includes('contains')) return _ => ["'%'", _, "'%'"]

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

@@ -67,6 +67,12 @@ class InsertBuilder extends BaseBuilder {
 
     const entityName = this._into()
 
+    // table alias as string
+    if (this._obj.INSERT.into.as) {
+      this._outputObj.sql.push('AS')
+      this._outputObj.sql.push(this._obj.INSERT.into.as)
+    }
+
     // side effect: sets this.uuidKeys if found any
     this._findUuidKeys(entityName)
 
@@ -89,6 +95,7 @@ class InsertBuilder extends BaseBuilder {
       this._entries(annotatedColumns)
     }
 
+    // INSERT INTO ... WITH ... AS SELECT FROM ...
     if (this._obj.INSERT.as) {
       this._as(this._obj.INSERT.as)
     }
@@ -116,6 +123,12 @@ class InsertBuilder extends BaseBuilder {
       return this._obj.INSERT.into
     }
 
+    if (this._obj.INSERT.into.ref) {
+      const dbName = this._getDatabaseName(this._obj.INSERT.into.ref[0])
+      this._outputObj.sql.push(this._quoteElement(dbName))
+      return this._obj.INSERT.into.ref[0]
+    }
+
     const dbName = this._getDatabaseName(this._obj.INSERT.into.name)
     this._outputObj.sql.push(this._quoteElement(dbName))
     return this._obj.INSERT.into.name
@@ -139,7 +152,7 @@ class InsertBuilder extends BaseBuilder {
     const uuidKeys = []
     if (this._csn && this._csn.definitions[entityName] && this._csn.definitions[entityName].keys) {
       for (const key of Object.values(this._csn.definitions[entityName].keys)) {
-        if (key.type === 'cds.UUID') {
+        if (key.isUUID) {
           uuidKeys.push(key.name)
         }
       }

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

@@ -1,7 +1,7 @@
 const cds = require('../../cds')
 
 const BaseBuilder = require('./BaseBuilder')
-const { DRAFT_COLUMNS } = require('../../common/constants/draft')
+const { DRAFT_COLUMNS_MAP } = require('../../common/constants/draft')
 
 /**
  * SelectBuilder is used to take a CQN object as an input and to build a SQL Select string from it.
@@ -81,6 +81,7 @@ class SelectBuilder extends BaseBuilder {
     }
 
     this._columns(noQuoting)
+
     this._from()
 
     if (this._obj.SELECT.where && this._obj.SELECT.where.length) {
@@ -331,7 +332,7 @@ class SelectBuilder extends BaseBuilder {
   _quoteDraftSpecificColumns(element) {
     if (this._quotingStyle === 'plain' && element.ref) {
       element.ref = element.ref.map(el => {
-        if (DRAFT_COLUMNS.includes(el)) {
+        if (el in DRAFT_COLUMNS_MAP) {
           return this._quote(el)
         }
 

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

@@ -25,12 +25,12 @@ typeConversionMap.set('cds.LargeBinary', 'BLOB')
  * @private
  */
 const convertDataType = (element, csn, options) => {
-  const converted = options.typeConversion.get(element.type)
+  const converted = options.typeConversion.get(element._type)
 
   if (!converted) {
     // no type in map
-    const newType = csn.definitions[element.type]
-    return newType ? convertDataType(newType, csn, options) : element.type
+    const newType = csn.definitions[element._type]
+    return newType ? convertDataType(newType, csn, options) : element._type
   }
 
   if (typeof converted === 'string') {

package/libx/_runtime/db/utils/columns.js

@@ -1,7 +1,7 @@
 const cds = require('../../cds')
 const resolveStructured = require('../../common/utils/resolveStructured')
 
-const { DRAFT_COLUMNS } = require('../../common/constants/draft')
+const { DRAFT_COLUMNS_MAP } = require('../../common/constants/draft')
 
 /**
  * This method gets all columns for an entity.
@@ -21,8 +21,8 @@ const getColumns = (entity, { _4db, onlyKeys } = { _4db: true, onlyKeys: false }
     const element = elements[elementName]
     if (onlyKeys && !element.key) continue
     if (element.isAssociation) continue
-    if (_4db && entity._isDraftEnabled && DRAFT_COLUMNS.includes(elementName)) continue
-    if (cds.env.effective.odata.structs && element.elements) {
+    if (_4db && entity._isDraftEnabled && elementName in DRAFT_COLUMNS_MAP) continue
+    if ((cds.env.effective.odata.structs || cds.env.features.ucsn_struct_conversion) && element.elements) {
       columnNames.push(...resolveStructured({ structName: elementName, structProperties: [] }, element.elements, false))
       continue
     }