@sap/cds 5.7.5 → 5.8.0

package/libx/_runtime/fiori/generic/before.js

@@ -12,9 +12,7 @@ const { DRAFT_COLUMNS_ADMIN } = require('../../common/constants/draft')
 
 // copied from adapter/odata-v4/utils/context-object
 const _getTargetEntityName = (service, pathSegments) => {
-  if (isCustomOperation(pathSegments, false)) {
-    return undefined
-  }
+  if (isCustomOperation(pathSegments, false)) return
 
   let navSegmentName
   let entityName = `${service.name}.${pathSegments[0].getEntitySet().getName()}`
@@ -36,12 +34,11 @@ const _getTargetEntityName = (service, pathSegments) => {
  * @returns {object}
  * @private
  */
-const _getParent = (service, req) => {
+const _getParent = (req, service) => {
   // REVISIT: get rid of getUriInfo
   if (!req.getUriInfo) return
 
   const segments = req.getUriInfo().getPathSegments()
-
   if (segments.length === 1) return
 
   const parent = {
@@ -50,6 +47,7 @@ const _getParent = (service, req) => {
 
   const parentKeyPredicates = segments[segments.length - 2].getKeyPredicates()
   let keyPredicateName, keyPredicateText
+
   for (const keyPredicate of parentKeyPredicates) {
     keyPredicateName = keyPredicate.getEdmRef().getName()
     keyPredicateText = keyPredicate.getText()
@@ -65,36 +63,28 @@ const _getParent = (service, req) => {
   return parent
 }
 
-const _validateDraft = (draftResult, req) => {
-  if (!draftResult || draftResult.length === 0) {
-    req.reject(404)
-  }
-
+const _validateDraft = (req, draftResult, isBoundAction) => {
+  if (!draftResult || draftResult.length === 0) req.reject(404)
   const draftAdminData = draftResult[0]
 
-  // the same user that locked the entity can always delete it
-  if (draftAdminData.InProcessByUser === req.user.id) {
-    return
-  }
+  // the same user that locked the entity can always delete/update it
+  if (draftAdminData.InProcessByUser === req.user.id) return
 
-  // proceed with the delete action only if it was initiated by a different user
-  // than the one who locked the entity and the configured drafts cancellation
+  // proceed with the delete/update action only if it was initiated by a different
+  // user than the one who locked the entity and the configured drafts cancellation
   // timeout timer has expired
   if (draftIsLocked(draftAdminData.LastChangeDateTime)) {
     req.reject(403, 'DRAFT_LOCKED_BY_ANOTHER_USER')
   }
+
+  // At this point, the request user ID isn't the owner of the draft.
+  if (isBoundAction) req.reject(403)
 }
 
 const _addDraftDataToContext = (req, result) => {
-  _validateDraft(result, req)
-
-  if (req.rejected) {
-    return
-  }
-
-  if (!req._draftMetadata) {
-    req._draftMetadata = {}
-  }
+  if (!result || result.length === 0) return
+  if (req.rejected) return
+  if (!req._draftMetadata) req._draftMetadata = {}
 
   DRAFT_COLUMNS_ADMIN.forEach(column => {
     if (column in result[0]) req._draftMetadata[column] = result[0][column]
@@ -103,11 +93,7 @@ const _addDraftDataToContext = (req, result) => {
   req.data.DraftAdministrativeData_DraftUUID = result[0].DraftUUID
 }
 
-const _prefixDraftColumns = () => {
-  return DRAFT_COLUMNS_ADMIN.map(col => {
-    return { ref: ['DRAFT_DraftAdministrativeData', col] }
-  })
-}
+const _prefixDraftColumns = () => DRAFT_COLUMNS_ADMIN.map(col => ({ ref: ['DRAFT_DraftAdministrativeData', col] }))
 
 const _getSelectDraftDataCqn = (entityName, where) => {
   return SELECT.from(ensureDraftsSuffix(entityName), _prefixDraftColumns())
@@ -116,27 +102,41 @@ const _getSelectDraftDataCqn = (entityName, where) => {
     .where(where)
 }
 
-const _addDraftDataFromExistingDraft = async (req, service) => {
-  const parent = _getParent(service, req)
-  let result
-
-  if (parent && parent.IsActiveEntity === 'false') {
-    const parentWhere = [{ ref: [parent.keyName] }, '=', { val: parent.keyValue }]
-    result = await cds.tx(req).run(_getSelectDraftDataCqn(parent.entityName, parentWhere))
-    _addDraftDataToContext(req, result)
-    return result
+const _getDraftDataFromExistingDraft = async (req, service, parent = _getParent(req, service)) => {
+  if (parent) {
+    if (parent.IsActiveEntity === 'false') {
+      const parentWhere = [{ ref: [parent.keyName] }, '=', { val: parent.keyValue }]
+      const query = _getSelectDraftDataCqn(parent.entityName, parentWhere)
+      const result = await cds.tx(req).run(query)
+      return result
+    }
+
+    return []
   }
 
-  if (!parent) {
-    const rootWhere = getKeysCondition(req.target, req.data)
-    result = await cds.tx(req).run(_getSelectDraftDataCqn(ensureNoDraftsSuffix(req.target.name), rootWhere))
-    if (result && result.length > 0) {
+  const rootWhere = getKeysCondition(req.target, req.data)
+  const query = _getSelectDraftDataCqn(ensureNoDraftsSuffix(req.target.name), rootWhere)
+  const result = await cds.tx(req).run(query)
+  return result
+}
+
+const _addDraftDataFromExistingDraft = async (req, service) => {
+  const parent = _getParent(req, service)
+  const result = await _getDraftDataFromExistingDraft(req, service, parent)
+
+  if (parent) {
+    if (parent.IsActiveEntity === 'false') {
+      _validateDraft(req, result)
       _addDraftDataToContext(req, result)
+      return result
     }
-    return result
+
+    return []
   }
 
-  return []
+  if (result && result.length > 0) _validateDraft(req, result)
+  _addDraftDataToContext(req, result)
+  return result
 }
 
 const _addGeneratedDraftUUID = async req => {
@@ -156,11 +156,12 @@ const _new = async function (req) {
   if (isNavigationToMany(req)) {
     const result = await _addDraftDataFromExistingDraft(req, this)
 
-    // in order to fix strange case where active subitems are created in draft case
+    // in order to fix corner case where active subitems are created in draft case
     if (result.length === 0) req.reject(404)
-  } else {
-    _addGeneratedDraftUUID(req)
+    return
   }
+
+  _addGeneratedDraftUUID(req)
 }
 
 /**
@@ -173,7 +174,7 @@ const _patchUpdate = async function (req) {
 
   const result = await _addDraftDataFromExistingDraft(req, this)
 
-  // means that draft not exists
+  // means that the draft does not exists
   if (result.length === 0) req.reject(404)
 }
 
@@ -186,6 +187,28 @@ const _deleteCancel = async function (req) {
   await _addDraftDataFromExistingDraft(req, this)
 }
 
+const _validateDraftBoundAction = async function (req, srv) {
+  const result = await _getDraftDataFromExistingDraft(req, srv)
+  const isBoundAction = true
+  if (result && result.length > 0) _validateDraft(req, result, isBoundAction)
+}
+
+const _registerBoundActionHandlers = function (entityName, actions) {
+  if (!actions) return
+
+  const boundActions = Object.values(actions).filter(
+    action =>
+      action.kind === 'action' &&
+      action.name !== 'draftPrepare' &&
+      action.name !== 'draftEdit' &&
+      action.name !== 'draftActivate'
+  )
+
+  for (const action of boundActions) {
+    this.before(action.name, entityName, req => _validateDraftBoundAction(req, this))
+  }
+}
+
 module.exports = cds.service.impl(function () {
   _new._initial = true
   _patchUpdate._initial = true
@@ -196,5 +219,6 @@ module.exports = cds.service.impl(function () {
     this.before('NEW', entity, _new)
     this.before(['PATCH', 'UPDATE'], entity, _patchUpdate)
     this.before(['DELETE', 'CANCEL'], entity, _deleteCancel)
+    _registerBoundActionHandlers.call(this, entity.name, entity.actions)
   }
 })

package/libx/_runtime/fiori/generic/edit.js

@@ -56,21 +56,18 @@ const _getLockWhere = (where, columnsMap) => {
   return lockWhere
 }
 
-const _select = async (CQNs, req, dbtx) => {
-  let allResults
-
+const _select = async (lockRecordCQN, draftExistsCQN, selectCQNs, req, dbtx) => {
   try {
-    allResults = await Promise.all(CQNs.map(CQN => dbtx.run(CQN)))
-  } catch (err) {
-    // resource busy and NOWAIT (WAIT 0) specified (heuristic error handling method)
-    if (err.query.includes('FOR UPDATE')) {
-      req.reject(409, 'DRAFT_ALREADY_EXISTS')
-    }
-
-    req.reject(err)
+    await dbtx.run(lockRecordCQN)
+  } catch (e) {
+    const drafts = await dbtx.run(draftExistsCQN)
+    if (drafts.length) req.reject(409, 'DRAFT_ALREADY_EXISTS')
+    req.reject(409, 'ENTITY_LOCKED')
   }
-
-  return allResults
+  const promisesResults = await Promise.allSettled([dbtx.run(draftExistsCQN), ...selectCQNs.map(cqn => dbtx.run(cqn))])
+  const firstRejected = promisesResults.find(r => r.status === 'rejected')
+  if (firstRejected) req.reject(firstRejected.reason)
+  return promisesResults.map(r => r.value)
 }
 
 /**
@@ -127,11 +124,9 @@ const _handler = async function (req) {
     }
   }
 
-  const lockAndSelectCQNs = [lockRecordCQN, draftExistsCQN, ...selectCQNs]
-
   const dbtx = cds.tx(req)
   // REVISIT: Use service.read with expand **
-  const [, draftExists, ...results] = await _select(lockAndSelectCQNs, req, dbtx)
+  const [draftExists, ...results] = await _select(lockRecordCQN, draftExistsCQN, [...selectCQNs], req, dbtx)
 
   if (!results[0].length) {
     req.reject(404)
@@ -169,12 +164,13 @@ const _handler = async function (req) {
 
   await Promise.all(insertCQNs.map(CQN => dbtx.run(CQN)))
   setStatusCodeAndHeader(req._.odataRes, rootWhere, req.target.name.replace(`${this.name}.`, ''), false)
-
   return Object.assign({}, results[0][0], { HasDraftEntity: false, HasActiveEntity: true, IsActiveEntity: false })
 }
 
 module.exports = cds.service.impl(function () {
-  for (const entity of Object.values(this.entities).filter(e => e._isDraftEnabled)) {
+  const entities = Object.values(this.entities).filter(e => e._isDraftEnabled)
+
+  for (const entity of entities) {
     this.on('EDIT', entity, _handler)
   }
 })

package/libx/_runtime/fiori/generic/patch.js

@@ -10,7 +10,6 @@ const {
 } = require('../utils/handler')
 const { getKeysCondition } = require('../utils/where')
 const { getColumns } = require('../../cds-services/services/utils/columns')
-
 const { DRAFT_COLUMNS_CQN } = require('../../common/constants/draft')
 
 const _getSelectCQN = (model, { data, target: { name } }, keysCondition, checkUser = true) => {
@@ -24,6 +23,7 @@ const _getSelectCQN = (model, { data, target: { name } }, keysCondition, checkUs
     ),
     ...DRAFT_COLUMNS_CQN
   ]
+
   if (checkUser) {
     columns.push({ ref: ['DRAFT.DraftAdministrativeData', 'inProcessByUser'], as: 'draftAdmin_inProcessByUser' })
   }
@@ -42,14 +42,16 @@ const _getSelectCQN = (model, { data, target: { name } }, keysCondition, checkUs
 
 const _getUpdateDraftCQN = ({ query, target: { name } }, keysCondition) => {
   const set = {}
+
   for (const entry in query.UPDATE.data) {
     if (entry === 'DraftAdministrativeData_DraftUUID') {
       continue
     }
+
     set[entry] = query.UPDATE.data[entry]
   }
-  if (set.IsActiveEntity) set.IsActiveEntity = false
 
+  if (set.IsActiveEntity) set.IsActiveEntity = false
   return UPDATE(ensureDraftsSuffix(name)).data(set).where(keysCondition)
 }
 
@@ -65,9 +67,7 @@ const _handler = async function (req) {
   if (req.data.IsActiveEntity === 'true') req.reject(400, 'Patch can only be applied to a draft entity')
 
   const keysCondition = getKeysCondition(req.target, req.data)
-
   const dbtx = cds.tx(req)
-
   let result = await dbtx.run(_getSelectCQN(this.model, req, keysCondition))
 
   // Potential timeout scenario supported
@@ -80,19 +80,16 @@ const _handler = async function (req) {
   const updateDraftAdminCQN = getUpdateDraftAdminCQN(req, result[0].DraftAdministrativeData_DraftUUID)
 
   await Promise.all([dbtx.run(updateDraftCQN), dbtx.run(updateDraftAdminCQN)])
-
   result = await dbtx.run(_getSelectCQN(this.model, req, keysCondition, false))
-  if (result.length === 0) {
-    req.reject(404)
-  }
-
+  if (result.length === 0) req.reject(404)
   removeDraftUUIDIfNecessary(result[0], req)
-
   return result[0]
 }
 
 module.exports = cds.service.impl(function () {
-  for (const entity of Object.values(this.entities).filter(e => e._isDraftEnabled)) {
+  const entities = Object.values(this.entities).filter(e => e._isDraftEnabled)
+
+  for (const entity of entities) {
     this.on('PATCH', entity, _handler)
   }
 })

package/libx/_runtime/fiori/generic/read.js

@@ -779,13 +779,16 @@ const _getDraftDoc = (req, draftName, draftWhere) => {
   return draftDocs
 }
 
-const _getOrderByEnrichedColumns = (orderBy, columns) => {
+const _getOrderByEnrichedColumns = (orderBy, columns, entity) => {
   const enrichedCol = []
   if (orderBy && orderBy.length > 1) {
     const colNames = columns.map(el => el.ref[el.ref.length - 1])
     // REVISIT: GET Books?$select=title&$expand=NotBooks($select=pages)&$orderby=NotBooks/title - what's then?
     for (const el of orderBy) {
-      if (!DRAFT_COLUMNS.includes(el.ref[el.ref.length - 1]) && !colNames.includes(el.ref[el.ref.length - 1])) {
+      // For associations we need to 'materialise' the resulting field, otherwise we cannot access it in an outer SELECT.
+      if (entity && entity.elements[el.ref[0]] && entity.elements[el.ref[0]].isAssociation) {
+        enrichedCol.push({ ref: [...el.ref], as: _poorMansAlias4(el) })
+      } else if (!DRAFT_COLUMNS.includes(el.ref[el.ref.length - 1]) && !colNames.includes(el.ref[el.ref.length - 1])) {
         enrichedCol.push({ ref: [...el.ref] })
       }
     }
@@ -807,11 +810,11 @@ const _replaceDraftAlias = where => {
 
 const _poorMansAlias4 = xpr => '_' + xpr.ref.join('_') + '_'
 
-const _getUnionCQN = (req, draftName, columns, subSelect, draftWhere, model) => {
+const _getUnionCQN = (req, draftName, columns, subSelect, draftWhere, model, entity) => {
   const draftActiveWhere = _getWhereForActive(draftWhere)
   const activeDocs = getEnrichedCQN(SELECT.from(req.target), req.query.SELECT, draftActiveWhere, undefined, false)
   activeDocs.where(_getWhereWithAppendedDraftRestrictions([], req))
-  convertWhereExists(activeDocs, model, {})
+  convertWhereExists(activeDocs.SELECT, model, {})
 
   // @restrict.where not applicable for drafts (I can ALWAYS read mine)
   _replaceDraftAlias(draftWhere)
@@ -838,7 +841,7 @@ const _getUnionCQN = (req, draftName, columns, subSelect, draftWhere, model) =>
     return union.columns({ func: 'sum', args: [{ ref: ['$count'] }], as: '$count' })
   }
 
-  const enrichedColumns = _getOrderByEnrichedColumns(req.query.SELECT.orderBy, columns)
+  const enrichedColumns = _getOrderByEnrichedColumns(req.query.SELECT.orderBy, columns, entity)
 
   for (const col of enrichedColumns) {
     // if we have columns for outer order by that may also be needed for joins, we need to duplicate them
@@ -915,12 +918,14 @@ const _excludeActiveDraftExists = (req, draftWhere, columns, model) => {
     ])
     .where(_inProcessByUserWhere(req.user.id))
 
+  const targetName = ensureNoDraftsSuffix(req.target.name)
   for (const key of _getTargetKeys(req)) {
-    subSelect.where([{ ref: [ensureNoDraftsSuffix(req.target.name), key] }, '=', { ref: [draftName, key] }])
+    subSelect.where([{ ref: [targetName, key] }, '=', { ref: [draftName, key] }])
   }
 
+  const entity = model.definitions[targetName]
   draftWhere = removeIsActiveEntityRecursively(draftWhere)
-  const cqn = _getUnionCQN(req, draftName, columns, subSelect, draftWhere, model)
+  const cqn = _getUnionCQN(req, draftName, columns, subSelect, draftWhere, model, entity)
   cqn.SELECT.from.as = name
 
   if (cqn.SELECT.orderBy) {
@@ -960,13 +965,16 @@ const _validatedWithSiblingInProcess = (req, draftWhere, draftParameters, column
   )
     return _excludeActiveDraftExists(req, draftWhere, columns, model)
   if (
+    draftInProcessByUser &&
     draftInProcessByUser.op === '!=' &&
     _isValidWithDraftLocked(isActiveEntity, siblingIsActive, draftInProcessByUser)
   ) {
     return _activeWithDraftInProcess(req, draftWhere, columns, req.user.id)
-  } else if (_isValidWithDraftTimeout(isActiveEntity, siblingIsActive, draftInProcessByUser)) {
+  } else if (draftInProcessByUser && _isValidWithDraftTimeout(isActiveEntity, siblingIsActive, draftInProcessByUser)) {
     return _activeWithDraftInProcess(req, draftWhere, columns, null)
   }
+
+  //
 }
 
 const _validatedDraftOfWhichIAmOwner = (req, draftWhere, draftParameters, columns) =>
@@ -1215,16 +1223,13 @@ const _handler = async function (req) {
   // handle localized here as it was previously handled for req.target
   req.target = _getLocalizedEntity(this.model, req.target, req.user) || req.target
 
-  // REVISIT
-  delete req.query._validationQuery
-
   const originalFrom = _copyCQNPartial(req.query.SELECT.from)
 
   // REVISIT DRAFT HANDLING: cqn2cqn4sql must not be called here
-  const sqlQuery = cqn2cqn4sql(req.query, this.model, { draft: true })
+  const query4sql = cqn2cqn4sql(req.query, this.model, { _4fiori: true })
 
   // do not clone with Object.assign as that would skip all non-enumerable properties
-  const reqClone = { __proto__: req, query: _copyCQNPartial(sqlQuery) }
+  const reqClone = { __proto__: req, query: _copyCQNPartial(query4sql) }
 
   // ensure draft restrictions are copied to new query
   reqClone.query._draftRestrictions = req.query._draftRestrictions
@@ -1234,6 +1239,7 @@ const _handler = async function (req) {
     reqClone.query._streaming = true
     return cds.tx(req).run(reqClone.query)
   }
+
   let cqnScenario
 
   // to replace scenario CQNs for queries with $apply SELECT chain (new odata2cqn parser)
@@ -1264,16 +1270,13 @@ const _handler = async function (req) {
   )
 
   _adaptSubSelects(cqnScenario.cqn, cqnScenario.scenario)
-
   _adaptAnnotationAliases(cqnScenario.cqn)
 
   // unlocalize for db and after handlers as it was before
   req.target = this.model.definitions[ensureUnlocalized(req.target.name)]
 
   const result = await cds.tx(req).send({ query: cqnScenario.cqn, target: req.target })
-
   const resultAsArray = Array.isArray(result) ? result : result ? [result] : []
-
   removeDraftUUIDIfNecessary(resultAsArray, req)
 
   if (cqnScenario.scenario === SCENARIO.DRAFT_ADMIN) {

package/libx/_runtime/fiori/generic/readOverDraft.js

@@ -45,7 +45,7 @@ const _handler = async function (req) {
   }
 
   // REVISIT DRAFT HANDLING: cqn2cqn4sql must not be called here
-  const sqlQuery = cqn2cqn4sql(req.query, this.model, { draft: true })
+  const sqlQuery = cqn2cqn4sql(req.query, this.model, { _4fiori: true })
   if (req.query._streaming) {
     sqlQuery._streaming = true
   }
@@ -53,9 +53,6 @@ const _handler = async function (req) {
   const hasDraftEntity = hasDraft(this.model.definitions, sqlQuery)
 
   if (hasDraftEntity && sqlQuery.SELECT.where && sqlQuery.SELECT.where.length !== 0) {
-    // REVISIT
-    delete req.query._validationQuery
-
     let cqnDraft = SELECT.from({
       ref: [...sqlQuery.SELECT.from.ref],
       as: sqlQuery.SELECT.from.as

package/libx/_runtime/hana/Service.js

@@ -41,7 +41,7 @@ class HanaDatabase extends DatabaseService {
     this._insert = this._queries.insert(execute.insert)
     this._read = this._queries.read(execute.select, execute.stream)
     this._update = this._queries.update(execute.update, execute.select)
-    this._delete = this._queries.delete(execute.delete)
+    this._delete = this._queries.delete(execute.delete, execute.update)
     this._run = this._queries.run(this._insert, this._read, this._update, this._delete, execute.cqn, execute.sql)
   }
 

package/libx/_runtime/hana/conversion.js

@@ -1,3 +1,5 @@
+const cds = require('../cds')
+
 const convertToBoolean = boolean => {
   if (boolean === null) {
     return null
@@ -47,6 +49,14 @@ const HANA_TYPE_CONVERSION_MAP = new Map([
   ['cds.LargeString', convertToString]
 ])
 
+if (cds.env.features.bigjs) {
+  const Big = require('big.js')
+  const convertToBig = value => new Big(value)
+
+  HANA_TYPE_CONVERSION_MAP.set('cds.Integer64', convertToBig)
+  HANA_TYPE_CONVERSION_MAP.set('cds.Decimal', convertToBig)
+}
+
 module.exports = {
   HANA_TYPE_CONVERSION_MAP
 }

package/libx/_runtime/hana/execute.js

@@ -1,3 +1,6 @@
+const cds = require('../cds')
+const LOG = cds.log('hana|db|sql')
+
 const { HANA_TYPE_CONVERSION_MAP } = require('./conversion')
 const CustomBuilder = require('./customBuilder')
 const { sqlFactory } = require('../db/sql-builder/')
@@ -30,9 +33,6 @@ function _cqnToSQL(model, query, user, locale, txTimestamp) {
   )
 }
 
-const cds = require('../cds')
-const LOG = cds.log('hana|db|sql')
-
 const SANITIZE_VALUES = process.env.NODE_ENV === 'production' && cds.env.log.sanitize_values !== false
 
 function _getOutputParameters(stmt) {
@@ -48,6 +48,26 @@ function _getOutputParameters(stmt) {
   return Object.keys(result).length > 0 ? result : undefined
 }
 
+const BINARY_TYPES = {
+  12: 'BINARY',
+  13: 'VARBINARY',
+  25: 'CLOB',
+  26: 'NCLOB',
+  27: 'BLOB'
+}
+
+function _getBinaries(stmt) {
+  // hdb vs. @sap/hana-client
+  const parameters = stmt.parameterMetadata || stmt.getParameterInfo()
+  const typeKey = stmt.parameterMetadata ? 'dataType' : 'nativeType'
+  return parameters.reduce((acc, cur, i) => {
+    if (BINARY_TYPES[cur[typeKey]]) acc.push(i)
+    return acc
+  }, [])
+}
+
+const BASE64 = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{4}|[A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{2}={2})$/
+
 function _executeAsPreparedStatement(dbc, sql, values, reject, resolve) {
   dbc.prepare(sql, function (err, stmt) {
     if (err) {
@@ -56,18 +76,15 @@ function _executeAsPreparedStatement(dbc, sql, values, reject, resolve) {
       return reject(err)
     }
 
-    // REVISIT: adjust binary values on hdb
-    if (_hasValues(values) && dbc.name === 'hdb' && stmt.parameterMetadata) {
-      const vals = Array.isArray(values[0]) ? values : [values]
-      for (const row of vals) {
-        for (let i = 0; i < stmt.parameterMetadata.length; i++) {
-          /*
-           * BINARY: 12
-           * VARBINARY: 13
-           */
-          if (stmt.parameterMetadata[i].dataType === 12 || stmt.parameterMetadata[i].dataType === 13) {
-            if (row[i] && !Buffer.isBuffer(row[i])) {
-              row[i] = Buffer.from(row[i].match(/.{1,2}/g).map(val => parseInt(val, 16)))
+    // convert binary strings to buffers ()
+    if (cds.env.hana.base64_to_buffer !== false && _hasValues(values)) {
+      const binaries = _getBinaries(stmt)
+      if (binaries.length) {
+        const vals = Array.isArray(values[0]) ? values : [values]
+        for (const i of binaries) {
+          for (const row of vals) {
+            if (row[i] && typeof row[i] === 'string' && row[i].match(BASE64)) {
+              row[i] = Buffer.from(row[i], 'base64')
             }
           }
         }
@@ -108,7 +125,7 @@ function _executeSimpleSQL(dbc, sql, values) {
       values = Object.values(values)
     }
     // ensure that stored procedure with parameters is always executed as prepared
-    if (_hasValues(sql, values) || sql.match(/^call.*?\?.*$/i)) {
+    if (_hasValues(values) || sql.match(/^call.*?\?.*$/i)) {
       _executeAsPreparedStatement(dbc, sql, values, reject, resolve)
     } else {
       dbc.exec(sql, function (err, result, procedureReturn) {

package/libx/_runtime/hana/search.js

@@ -11,9 +11,9 @@ function searchHandler(req) {
   // REVISIT: remove feature toggle optimized_search after grace period
   // inject the search2cqn4sql module into the rewrite handler only when
   // the optimized search feature toggle is turned on
-  if (!cds.env.features.optimized_search) return
-
-  _setSearchOptions(req.query, { search2cqn4sql, locale: req.locale })
+  if (cds.env.features.optimized_search) {
+    _setSearchOptions(req.query, { search2cqn4sql, locale: req.locale })
+  }
 }
 
 // handlers marked with `._initial = true` run in sequence