@sap/cds 6.8.4 → 7.0.1

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

@@ -67,8 +67,8 @@ const convertPathExpressionToWhere = (fromClause, model, options) => {
     const currentEntityName = draft ? entityName && ensureDraftsSuffix(entityName) : entityName
     if (!currentEntityName) continue
     if (!draft && currentEntityName.endsWith('_drafts')) draft = true
-    const tableAlias = `T${i}`
-    const currentSelect = SELECT.from(`${currentEntityName} as ${tableAlias}`)
+    const tableAlias = options.tableAliasPrefix ? `${options.tableAliasPrefix}${i}` : `T${i}`
+    const currentSelect = SELECT.from({ ref: [currentEntityName], as: tableAlias })
 
     if (fromClause.ref[i].where) {
       currentSelect.where(addAliasToExpression(fromClause.ref[i].where, tableAlias))
@@ -969,13 +969,16 @@ const _convertUpdate = (query, model, options) => {
 
   if (alias) update.UPDATE.entity = { ref: [target], as: alias }
   if (where) update.where(where)
+
   const targetEntity = model.definitions[target]
+
   if (query.UPDATE.where) {
     update.where(addAliasToExpression(query.UPDATE.where, alias))
     _convertToOneEqNullInFilter(update.UPDATE, targetEntity)
   }
 
   if (!targetEntity) return update
+
   return resolveView(update, model, cds.db)
 }
 

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

@@ -39,56 +39,6 @@ const _getUps = (entity, model) => {
   return entity.set('__parents', ups)
 }
 
-const _ifDataSubject = (entity, role) => {
-  return entity['@PersonalData.EntitySemantics'] === 'DataSubject' && entity['@PersonalData.DataSubjectRole'] === role
-}
-
-const _getDataSubjectUp = (role, model, entity, prev, next, result) => {
-  for (const element of _getUps(entity, model)) {
-    const me = { entity, relative: element.parent, element }
-    if (prev) prev.next = me
-    if (_ifDataSubject(element.parent, role)) {
-      if (!result) result = { dataSubjectEntity: element.parent, subs: [] }
-      result.subs.push(next || me)
-      return result
-    } else {
-      // dfs is a must here
-      result = _getDataSubjectUp(role, model, element.parent, me, next || me, result)
-    }
-  }
-  return result
-}
-
-const _getDataSubjectDown = (role, entity, prev, next) => {
-  const associations = Object.values(entity.associations || {}).filter(e => !e._isBacklink)
-  for (const element of associations) {
-    const me = { entity, relative: entity, element }
-    if (_ifDataSubject(element._target, role)) {
-      if (prev) prev.next = me
-      return { dataSubjectEntity: element._target, subs: [next || me] }
-    }
-  }
-  // bfs makes more sense here
-  for (const element of associations) {
-    const me = { entity, relative: entity, element }
-    if (prev) prev.next = me
-    const dataSubject = _getDataSubjectDown(role, element._target, me, next || me)
-    if (dataSubject) return dataSubject
-  }
-}
-
-const getDataSubject = (entity, model, role) => {
-  const hash = '__dataSubject4' + role
-  if (entity.own(hash)) return entity[hash]
-  // entities with EntitySemantics 'DataSubjectDetails' or 'Other' must not necessarily
-  // be always below or always above 'DataSubject' entity in CSN tree
-  let dataSubject = _getDataSubjectUp(role, model, entity)
-  if (!dataSubject) {
-    dataSubject = _getDataSubjectDown(role, entity)
-  }
-  return entity.set(hash, dataSubject)
-}
-
 const _resolve = (edmName, model, namespace) => {
   const resolved = model._edmToCSNNameMap[namespace][edmName.replace(/\./g, '_')]
   // the edm name has an additional suffix 'Parameters' in case of views with parameters
@@ -249,7 +199,6 @@ module.exports = {
   getEtagElement,
   findCsnTargetFor,
   getElementDeep,
-  getDataSubject,
   alias2ref,
   getComp2oneParents,
   prefixForStruct,

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

@@ -0,0 +1,30 @@
+const { isAsteriskColumn } = require('./rewriteAsterisks')
+
+/**
+ * Recursively adds etag columns if a manual list of columns is specified.
+ * If asterisk columns or no columns are given, the database layer will
+ * add the etag columns anyway.
+ */
+const addEtagColumns = (columns, entity) => {
+  if (!columns || !Array.isArray(columns)) return
+  if (
+    entity._etag &&
+    !columns.some(c => isAsteriskColumn(c)) &&
+    !(columns.length === 1 && columns[0].func === 'count') &&
+    !columns.some(c => c.ref && c.ref[c.ref.length - 1] === entity._etag.name)
+  ) {
+    columns.push({ ref: [entity._etag.name] })
+  }
+  const expands = columns.filter(c => c.expand)
+  for (const expand of expands) {
+    const refName = expand.ref[expand.ref.length - 1]
+    const targetEntity = refName && entity.elements[refName] && entity.elements[refName]._target
+    if (targetEntity) {
+      addEtagColumns(expand.expand, targetEntity)
+    }
+  }
+}
+
+module.exports = {
+  addEtagColumns
+}

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

@@ -92,7 +92,7 @@ function _getWhereFromUpdate(query, target, model) {
 
   const where = query.UPDATE.where || []
   if (query.UPDATE.entity.ref?.length === 1 && query.UPDATE.entity.ref[0].where)
-    return _mergeWhere(query.UPDATE.entity.ref[0].where, where)
+    return _mergeWhere(where.length ? [...query.UPDATE.entity.ref[0].where] : query.UPDATE.entity.ref[0].where, where)
   return where
 }
 

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

@@ -0,0 +1,25 @@
+const cds = require('../../cds')
+const PRECISION = cds.env.features.precise_timestamps ? 7 : 3
+
+const TZ_REGEX = new RegExp(/(Z|[+-][01]\d:?[0-5]\d)$/)
+const NON_DIGIT_REGEX = new RegExp(/\D/, 'g')
+
+const _lengthIfNotFoundIndex = (index, length) => (index > -1 ? index : length)
+
+module.exports = value => {
+  if (value instanceof Date) value = value.toISOString()
+  if (typeof value === 'number') value = new Date(value).toISOString()
+
+  const decimalPointIndex = _lengthIfNotFoundIndex(value.lastIndexOf('.'), value.length)
+  const tzRegexMatch = TZ_REGEX.exec(value)
+  const tz = tzRegexMatch?.[0] || ''
+  const tzIndex = _lengthIfNotFoundIndex(tzRegexMatch?.index, value.length)
+  const dateEndIndex = Math.min(decimalPointIndex, tzIndex)
+  const dateNoMillisNoTZ = new Date(value.slice(0, dateEndIndex) + tz).toISOString().slice(0, 19)
+  const normalizedFractionalDigits = value
+    .slice(dateEndIndex + 1, tzIndex)
+    .replace(NON_DIGIT_REGEX, '')
+    .padEnd(PRECISION, '0')
+    .slice(0, PRECISION)
+  return dateNoMillisNoTZ + (normalizedFractionalDigits ? '.' + normalizedFractionalDigits : '') + 'Z'
+}

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

@@ -9,7 +9,7 @@ const getEntityFromPath = (path, def) => {
   let id
   for (const segment of path.ref) {
     id = ensureNoDraftsSuffix(segment.id || segment)
-    current = current.elements[id]
+    current = current?.elements[id] || current
     if (current && current.target) current = current._target
   }
   return current

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

@@ -217,6 +217,7 @@ const _newInsertColumns = (columns = [], transition) => {
   return newColumns
 }
 
+// REVISIT: this hard-coding on ref indexes does not support path expressions
 const _newWhereRef = (newWhereElement, transition, alias, tableName, isSubSelect) => {
   const newRef = Array.isArray(newWhereElement.ref) ? [...newWhereElement.ref] : [newWhereElement.ref]
   if (newRef[0] === alias) {
@@ -249,7 +250,7 @@ const _newWhere = (where = [], transition, tableName, alias, isSubselect = false
 
     const newWhereElement = { ...whereElement }
     if (!whereElement.ref && !whereElement.SELECT && !whereElement.func) return whereElement
-    if (whereElement.SELECT && whereElement.SELECT.where) {
+    if (whereElement.SELECT && whereElement.SELECT.where && !whereElement._doNotResolve) {
       newWhereElement.SELECT.where = _newWhere(whereElement.SELECT.where, transition, tableName, alias, true)
       return newWhereElement
     } else {

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

@@ -6,8 +6,9 @@ const cds = require('../../cds')
 
 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
+const isDuplicate = newColumn => column => {
+  if (newColumn.as && column.as) return column.as === newColumn.as
+  if ((newColumn.as && !column.as) || (!newColumn.as && column.as)) return
   if (!column.ref) return
   if (Array.isArray(newColumn)) newColumn = { ref: newColumn }
   return newColumn.ref ? newColumn.ref.join('_') === column.ref.join('_') : newColumn === column.ref.join('_')
@@ -50,7 +51,7 @@ const _rewriteAsterisk = (columns, target, _4db, isRoot) => {
       1,
       ...getColumns(target, { _4db })
         .map(c => ({ ref: [c.name] }))
-        .filter(c => !columns.find(_isDuplicate(c)) && (isRoot || c.ref[0] !== 'DraftAdministrativeData_DraftUUID'))
+        .filter(c => !columns.find(isDuplicate(c)) && (isRoot || c.ref[0] !== 'DraftAdministrativeData_DraftUUID'))
     )
   }
 }
@@ -136,5 +137,6 @@ const rewriteAsterisks = (query, model, options) => {
 module.exports = {
   rewriteAsterisks,
   isAsteriskColumn,
-  rewriteExpandAsterisk
+  rewriteExpandAsterisk,
+  isDuplicate
 }

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

@@ -12,30 +12,26 @@ const _targetFrom = (cqn, options) => {
 const search2cqn4sql = (query, model, options = {}) => {
   const cqnSearchPhrase = query.SELECT.search
   if (!cqnSearchPhrase) return
+
   const { search2cqn4sql } = options
   const { entityName, alias } = _targetFrom(query.SELECT.from, options)
   const entity = model.definitions[entityName]
-  const localizedAssociation = entity.associations?.localized
+  const aggregated = query._aggregated || /* new parser */ query.SELECT.groupBy
+
   // Call custom (optimized search to cqn for sql implementation) that tries
   // to optimize the search behavior for a specific database service.
-  // REVISIT: $search query option combined with $count is not currently optimized
-  if (
-    typeof search2cqn4sql === 'function' &&
-    !query.SELECT.count &&
-    localizedAssociation &&
-    !(query._aggregated || /* new parser */ query.SELECT.groupBy)
-  ) {
+  if (typeof search2cqn4sql === 'function' && entity.associations?.localized && !aggregated) {
     const search2cqnOptions = { columns: computeColumnsToBeSearched(query, entity), locale: options.locale }
     return search2cqn4sql(query, entity, search2cqnOptions)
-  } else {
-    const columnsToBeSearched = computeColumnsToBeSearched(query, entity, alias)
-    const expression = columnsToBeSearched?.length
-      ? searchToLike(cqnSearchPhrase, columnsToBeSearched)
-      : [{ val: 0 }, '=', { val: 1 }]
-
-    // REVISIT: find out here if where or having must be used
-    query._aggregated || /* if new parser */ query.SELECT.groupBy ? query.having(expression) : query.where(expression)
   }
+
+  const columnsToBeSearched = computeColumnsToBeSearched(query, entity, alias)
+  const expression = columnsToBeSearched?.length
+    ? searchToLike(cqnSearchPhrase, columnsToBeSearched)
+    : [{ val: 0 }, '=', { val: 1 }]
+
+  // REVISIT: find out here if where or having must be used
+  aggregated ? query.having(expression) : query.where(expression)
 }
 
 module.exports = search2cqn4sql

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

@@ -0,0 +1,140 @@
+const cds = require('../../cds')
+const LOG = cds.log('odata')
+const { SELECT } = cds.ql
+const { deepCopyArray } = require('./copy')
+const { getTransition } = require('./resolveView')
+const { cqn2cqn4sql } = require('./cqn2cqn4sql')
+const getTemplate = require('./template')
+const templateProcessor = require('./templateProcessor')
+const { adaptStreamCQN } = require('../../fiori/utils/stream.js')
+const { isPathToDraft } = require('./cqn')
+
+// eslint-disable-next-line complexity
+const _getStreamProperties = (req, query, model) => {
+  // new odata parser sets streaming property in SELECT.from
+  const ref = query.SELECT
+    ? (query.SELECT.columns && query.SELECT.columns[0].ref) || query.SELECT.from.ref
+    : [query.STREAM.column]
+  const propertyName = ref[ref.length - 1]
+  let mediaTypeProperty
+  for (let key in req.target.elements) {
+    const val = req.target.elements[key]
+    if (val['@Core.MediaType'] && val.name === propertyName) {
+      mediaTypeProperty = val
+      break
+    }
+  }
+
+  let contentType, contentDispositionFilename
+  const columns = []
+  if (typeof mediaTypeProperty['@Core.MediaType'] === 'object') {
+    let contentTypeProperty = mediaTypeProperty['@Core.MediaType']['=']
+    if (!req.target.elements[contentTypeProperty]) {
+      LOG._warn &&
+        LOG.warn(
+          `@Core.MediaType in entity "${req.target.name}" points to property "${contentTypeProperty}" which was renamed or is not part of the projection. You must update the annotation value.`
+        )
+      const mapping = getTransition(req.target, cds.db).mapping
+      const key = [...mapping.entries()].find(({ 1: val }) => val.ref[0] === contentTypeProperty)
+      contentTypeProperty = key && key.length && key[0]
+    }
+    if (!req.target.elements[contentTypeProperty]) {
+      LOG._warn && LOG.warn(`MediaType ${contentTypeProperty} not found in entity "${req.target.name}".`)
+    } else {
+      columns.push({ ref: [contentTypeProperty], as: 'contentType' })
+    }
+  } else {
+    contentType = mediaTypeProperty['@Core.MediaType']
+  }
+  if (mediaTypeProperty['@Core.ContentDisposition.Filename']) {
+    if (typeof mediaTypeProperty['@Core.ContentDisposition.Filename'] === 'object') {
+      let contentDispositionProperty = mediaTypeProperty['@Core.ContentDisposition.Filename']['=']
+      if (!req.target.elements[contentDispositionProperty]) {
+        LOG._warn &&
+          LOG.warn(
+            `@Core.ContentDisposition.Filename in entity "${req.target.name}" points to property "${contentDispositionProperty}" which was renamed or is not part of the projection. You must update the annotation value.`
+          )
+        const mapping = getTransition(req.target, cds.db).mapping
+        const key = [...mapping.entries()].find(({ 1: val }) => val.ref[0] === contentDispositionProperty)
+        contentDispositionProperty = key && key.length && key[0]
+      }
+      if (!req.target.elements[contentDispositionProperty]) {
+        LOG._warn &&
+          LOG.warn(`ContentDisposition ${contentDispositionProperty} not found in entity "${req.target.name}".`)
+      } else {
+        columns.push({ ref: [contentDispositionProperty], as: 'contentDispositionFilename' })
+      }
+    } else {
+      contentDispositionFilename = mediaTypeProperty['@Core.ContentDisposition.Filename']
+    }
+  }
+  const contentDispositionType = mediaTypeProperty['@Core.ContentDisposition.Type']
+
+  if (columns.length && cds.db && !req.target._hasPersistenceSkip) {
+    // used cloned path
+    const ref = query.SELECT ? query.SELECT.from.ref : query.STREAM.from.ref
+    const as = query.SELECT ? query.SELECT.from.as : query.STREAM.from.as
+    let select = SELECT.one.from({ ref: deepCopyArray(ref), as }).columns(columns)
+    const where = query.SELECT ? query.SELECT.where : query.STREAM.where
+    if (where?.length) select.SELECT.where = where
+    if (!(isNewStream() || cds.env.fiori.lean_draft)) {
+      const draft = req.target._isDraftEnabled && isPathToDraft(select.SELECT.from.ref, model)
+      if (draft) {
+        select = cqn2cqn4sql(select, model)
+        adaptStreamCQN(select, draft)
+      }
+    }
+
+    return cds
+      .tx(req)
+      .run(select)
+      .then(res => ({
+        contentType: (res && res.contentType) || contentType,
+        contentDispositionFilename: (res && res.contentDispositionFilename) || contentDispositionFilename,
+        contentDispositionType
+      }))
+  }
+
+  return Promise.resolve({ contentType, contentDispositionFilename, contentDispositionType })
+}
+
+const enhanceStreamResult = async (req, query, result, model) => {
+  if (!result) return
+  if (result.$mediaContentType || result.$mediaContentDispositionFilename || result.$mediaContentDispositionType) return
+
+  const { contentType, contentDispositionFilename, contentDispositionType } = await _getStreamProperties(
+    req,
+    query,
+    model
+  )
+  if (contentType) result.$mediaContentType = contentType
+  if (contentDispositionFilename) {
+    result.$mediaContentDispositionFilename = contentDispositionFilename
+    if (contentDispositionType) result.$mediaContentDispositionType = contentDispositionType
+  }
+}
+
+const pick = element => {
+  return element['@Core.IsURL']
+}
+
+const processFn = ({ row, key }) => {
+  row[`${key}@odata.mediaReadLink`] = row[key]
+  delete row[key]
+}
+
+function transformRedirectProperties(req, service, result) {
+  if (!Array.isArray(result)) result = [result]
+  if (result.length === 0) return
+
+  const template = getTemplate('redirect-properties', service, req.target, { pick })
+  if (template && template.elements.size) {
+    for (const row of result) {
+      templateProcessor({ processFn, row, template })
+    }
+  }
+}
+
+const isNewStream = () => cds.env.features.new_stream && (!cds.db || !!cds.db.stream('foo').STREAM)
+
+module.exports = { isNewStream, enhanceStreamResult, transformRedirectProperties }

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

@@ -1,21 +1,38 @@
 const { ensureNoDraftsSuffix, ensureUnlocalized } = require('../../fiori/utils/handler')
+const { isDuplicate } = require('./rewriteAsterisks')
+
+const _addColumn = (name, type, columns) => {
+  if (typeof type === 'object') {
+    const ref = {
+      ref: [type['=']],
+      as: `${name}@odata.mediaContentType`
+    }
+    if (!columns.find(isDuplicate(ref))) columns.push(ref)
+  } else {
+    const val = { val: type, as: `${name}@odata.mediaContentType` }
+    if (!columns.find(isDuplicate(val))) columns.push(val)
+  }
+}
 
 const _changeStreamProperties = (target, columns, model) => {
-  for (let index = 0; index < columns.length; index++) {
+  let index = columns.length
+  while (index--) {
     const col = columns[index]
     const name = col.ref && col.ref[col.ref.length - 1]
     const element = name && target.elements[name]
-    const type = element && !element['@Core.IsURL'] && element['@Core.MediaType']
+    const type = element && element['@Core.MediaType']
 
-    if (col.ref && type) {
-      if (typeof type === 'object') {
-        columns[index] = {
-          ref: [...col.ref.slice(0, -1), type['=']],
-          as: `${name}@odata.mediaContentType`
+    if (col === '*') {
+      for (const k in target.elements) {
+        const el = target.elements[k]
+        if (el['@Core.MediaType']) {
+          const type = el['@Core.MediaType']
+          _addColumn(el.name, type, columns)
         }
-      } else {
-        columns[index] = { val: type, as: `${name}@odata.mediaContentType` }
       }
+    } else if (col.ref && type) {
+      _addColumn(name, type, columns)
+      if (!element['@Core.IsURL']) columns.splice(index, 1)
     } else if (col.expand && col.ref) {
       const tgt = target.elements[col.ref] && target.elements[col.ref].target
       tgt && _changeStreamProperties(model.definitions[ensureUnlocalized(ensureNoDraftsSuffix(tgt))], col.expand, model)
@@ -23,10 +40,10 @@ const _changeStreamProperties = (target, columns, model) => {
   }
 }
 
-const handleStreamProperties = (target, select, model) => {
-  const columns = select.SELECT.columns
+const handleStreamProperties = (target, select, model, _4odata) => {
+  const columns = select.SELECT?.columns
   if (!columns || !target || !model) return
-  if (!select.SELECT._4odata) return
+  if (!_4odata && !select.SELECT._4odata) return
   if (select._streaming) return
 
   _changeStreamProperties(target, columns, model)

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

@@ -1,5 +1,3 @@
-const cds = require('../../cds')
-
 const segmentSerializer = pathSegmentInfo => {
   const { key: tKey, row, elements, draftKeys } = pathSegmentInfo
   let keyNames = pathSegmentInfo.keyNames

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

@@ -1,7 +1,6 @@
 // before
 const rewrite = require('./rewrite')
 const input = require('./input')
-const integrity = require('./integrity')
 const { convertVirtuals: virtual } = require('./virtual')
 // on
 const CREATE = require('./create')
@@ -18,7 +17,6 @@ module.exports = {
   rewrite,
   virtual,
   input,
-  integrity,
   CREATE,
   READ,
   UPDATE,

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

@@ -1,10 +1,10 @@
 const { getFlatArray, processCQNs } = require('../utils/deep')
-const { timestampToISO } = require('../data-conversion/timestamp')
+const normalizeTimestamp = require('../../common/utils/normalizeTimestamp')
 const { hasDeepDelete, getDeepDeleteCQNs, getSetNullParentForeignKeyCQNs } = require('../../common/composition')
 
 const deleteFn = (executeDeleteCQN, executeUpdateCQN) => async (model, dbc, query, req) => {
   const { user, locale, timestamp } = req
-  const isoTs = timestampToISO(timestamp)
+  const isoTs = normalizeTimestamp(timestamp)
 
   let result
   if (model && hasDeepDelete(model, query)) {

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

@@ -1,10 +1,10 @@
 const { hasDeepInsert, getDeepInsertCQNs } = require('../../common/composition')
 const { getFlatArray, processCQNs } = require('../utils/deep')
-const { timestampToISO } = require('../data-conversion/timestamp')
+const normalizeTimestamp = require('../../common/utils/normalizeTimestamp')
 
 const insert = executeInsertCQN => async (model, dbc, query, req) => {
   const { user, locale, timestamp } = req
-  const isoTs = timestampToISO(timestamp)
+  const isoTs = normalizeTimestamp(timestamp)
 
   if (model && hasDeepInsert(model, query)) {
     const cqns = getFlatArray(getDeepInsertCQNs(model, query))

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

@@ -1,4 +1,4 @@
-const { timestampToISO } = require('../data-conversion/timestamp')
+const normalizeTimestamp = require('../../common/utils/normalizeTimestamp')
 const { deepCopyObject } = require('../../common/utils/copy')
 const getError = require('../../common/error')
 
@@ -39,7 +39,7 @@ const countValue = countResults => {
 
 const read = (executeSelectCQN, executeStreamCQN) => (model, dbc, query, req) => {
   const { user, locale, timestamp } = req
-  const isoTs = timestampToISO(timestamp)
+  const isoTs = normalizeTimestamp(timestamp)
 
   if (query._streaming) {
     if (!query.SELECT || (query.SELECT && !query.SELECT.columns)) {

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

@@ -1,4 +1,4 @@
-const { timestampToISO } = require('../data-conversion/timestamp')
+const normalizeTimestamp = require('../../common/utils/normalizeTimestamp')
 
 const run = (insert, read, update, deleet, cqn, sql) => (model, dbc, query, req, values) => {
   if (typeof query === 'string') {
@@ -22,7 +22,7 @@ const run = (insert, read, update, deleet, cqn, sql) => (model, dbc, query, req,
   }
 
   const { user, locale, timestamp } = req
-  const isoTs = timestampToISO(timestamp)
+  const isoTs = normalizeTimestamp(timestamp)
 
   return cqn(model, dbc, query, user, locale, isoTs)
 }

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

@@ -2,7 +2,7 @@ const cds = require('../../cds')
 
 const { hasDeepUpdate, getDeepUpdateCQNs, selectDeepUpdateData } = require('../../common/composition')
 const { getFlatArray, processCQNs } = require('../utils/deep')
-const { timestampToISO } = require('../data-conversion/timestamp')
+const normalizeTimestamp = require('../../common/utils/normalizeTimestamp')
 
 const _includesCompositionTarget = (cqns, target) => {
   return cqns.find(cqn => {
@@ -47,7 +47,7 @@ const _getFilteredCqns = (cqns, model) => {
 
 const update = executeUpdateCQN => async (model, dbc, req) => {
   const { query, user, locale, timestamp } = req
-  const isoTs = timestampToISO(timestamp)
+  const isoTs = normalizeTimestamp(timestamp)
 
   if (model && hasDeepUpdate(model, query)) {
     // REVISIT: _activeData gets set in case of draftActivate for performance, but this is a layer violation

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

@@ -35,12 +35,6 @@ class BaseBuilder {
     this._quotingStyle = cds.env.sql.names || 'plain'
     this._quoteElement = quotingStyles[this._quotingStyle]
     this._validateQuotingStyle()
-
-    // NOTE: unofficial feature flag!
-    this._parameterizedNumbers =
-      'parameterized_numbers' in this._options
-        ? this._options.parameterized_numbers
-        : cds.env && cds.env.features && cds.env.features.parameterized_numbers
   }
 
   getDefaultOptions() {

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

@@ -4,6 +4,7 @@ const BaseBuilder = require('./BaseBuilder')
 const { flattenStructuredWhereHaving } = require('../../common/utils/structured')
 
 const SQLITE_DATETIME_FUNCTIONS = new Set(['year', 'month', 'day', 'second', 'hour', 'minute'])
+const HANA_DATETIME_FUNCTIONS = new Set(['year', 'month', 'dayofmonth', 'second', 'hour', 'minute'])
 const OPERATORS = new Set(['=', '!=', '<>', '<', '>', '<=', '>='])
 
 function _fillAfterDot(val) {
@@ -96,6 +97,11 @@ class ExpressionBuilder extends BaseBuilder {
     if (_valButNoBuffer(op1) && comp === '=' && op2.ref) return true
   }
 
+  _hasValToValComparision(op1, comp, op2) {
+    const _operations = ['=', '!=']
+    return typeof op1.val === 'number' && _operations.includes(comp) && typeof op2.val === 'number'
+  }
+
   _expressionObjectsToSQL(objects) {
     const length = objects.length
     let i = 0
@@ -117,6 +123,14 @@ class ExpressionBuilder extends BaseBuilder {
           this._expressionObjectsToSQL(flattenedStructExpression)
           i += 3
           continue
+        } else if (this._hasValToValComparision(objects[i], objects[i + 1], objects[i + 2])) {
+          // Avoid utilizing placeholders to represent numerical values being (not) equal to other numbers due to an issue related to HDB.
+          const _outputObj = this._outputObj
+          _outputObj.sql.push(objects[i].val)
+          _outputObj.sql.push(objects[i + 1])
+          _outputObj.sql.push(objects[i + 2].val)
+          i += 3
+          continue
         }
 
         this._expressionElementToSQL(objects[i])
@@ -147,17 +161,17 @@ class ExpressionBuilder extends BaseBuilder {
       // sqlite requires leading 0 for numbers in datetime functions
       const f = objects[i].func ? i : OPERATORS.has(objects[i + 1]) ? i + 2 : i - 2
       const v = objects[i].val ? i : OPERATORS.has(objects[i + 1]) ? i + 2 : i - 2
-      if (objects[f] && SQLITE_DATETIME_FUNCTIONS.has(objects[f].func) && cds.db && cds.db.kind === 'sqlite') {
+      if (
+        objects[f] &&
+        cds.db &&
+        ((SQLITE_DATETIME_FUNCTIONS.has(objects[f].func) && cds.db.kind === 'sqlite') ||
+          (HANA_DATETIME_FUNCTIONS.has(objects[f].func) && cds.db.kind === 'hana'))
+      ) {
         if (objects[v] && objects[v].val !== undefined && typeof objects[v].val === 'number') {
           objects[v] = { val: `${objects[v].val < 10 ? 0 : ''}${objects[v].val}` }
           if (objects[f].func === 'second') objects[v].val = _fillAfterDot(objects[v].val)
         }
       }
-      // odata indexof function returns the zero-based character position of the first occurrence
-      if (this._options._4odata && objects[i].func && objects[i].func === 'indexof') {
-        if (objects[i + 2] && objects[i + 2].val !== undefined) objects[i + 2].val++
-        else if (objects[i - 2] && objects[i - 2].val !== undefined) this._outputObj.sql[i - 2]++
-      }
       return 0
     }
 
@@ -343,12 +357,9 @@ class ExpressionBuilder extends BaseBuilder {
    * @private
    */
   _valOutputFromElement(element) {
-    if (typeof element.val === 'number' && !this._parameterizedNumbers) {
-      this._outputObj.sql.push(element.val)
-    } else {
-      this._outputObj.sql.push(this._options.placeholder)
-      this._outputObj.values.push(element.val)
-    }
+    const _outputObj = this._outputObj
+    _outputObj.sql.push(this._options.placeholder)
+    _outputObj.values.push(element.val)
   }
 
   _addToOutputObj({ sql, values }, addBrackets) {