@sap/cds 5.7.5 → 5.8.2

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

@@ -3,10 +3,8 @@ const { SELECT } = cds.ql
 
 const { cqn2cqn4sql, convertWhereExists } = require('../../common/utils/cqn2cqn4sql')
 const { getElementDeep } = require('../../common/utils/csn')
-
 const { DRAFT_COLUMNS, DRAFT_COLUMNS_MAP, SCENARIO } = require('../../common/constants/draft')
 const {
-  adaptStreamCQN,
   addColumnAlias,
   draftIsLocked,
   ensureDraftsSuffix,
@@ -18,8 +16,8 @@ const {
   filterKeys
 } = require('../utils/handler')
 const { deleteCondition, readAndDeleteKeywords, removeIsActiveEntityRecursively } = require('../utils/where')
-
 const { getColumns } = require('../../cds-services/services/utils/columns')
+const { adaptStreamCQN } = require('../../cds-services/adapter/odata-v4/utils/stream')
 
 const _findRootSubSelectFor = query => {
   if (query.SELECT.where) {
@@ -779,13 +777,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 +808,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 +839,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 +916,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 +963,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 +1221,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 +1237,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 +1268,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/fiori/utils/handler.js

@@ -1,6 +1,5 @@
 const cds = require('../../cds')
 const { UPDATE, SELECT } = cds.ql
-const { removeIsActiveEntityRecursively, isActiveEntityRequested } = require('./where')
 const { getColumns } = require('../../cds-services/services/utils/columns')
 const { ensureNoDraftsSuffix, ensureDraftsSuffix, ensureUnlocalized } = require('../../common/utils/draft')
 const getTemplate = require('../../common/utils/template')
@@ -126,7 +125,7 @@ const getEnrichedCQN = (cqn, select, draftWhere, scenarioAlias, addLimitOrder =
   }
 
   if (select.distinct) {
-    cqn.distinct()
+    cqn.SELECT.distinct = true
   }
 
   const alias = (select.from && select.from.as) || scenarioAlias
@@ -249,14 +248,6 @@ const replaceRefWithDraft = ref => {
   ref[0] = ensureDraftsSuffix(ref[0])
 }
 
-const adaptStreamCQN = cqn => {
-  if (isActiveEntityRequested(cqn.SELECT.where)) {
-    cqn.SELECT.where = removeIsActiveEntityRecursively(cqn.SELECT.where)
-  } else {
-    replaceRefWithDraft(cqn.SELECT.from.ref)
-  }
-}
-
 const draftIsLocked = lastChangedAt => {
   // default timeout timer is 15 minutes
   const DRAFT_CANCEL_TIMEOUT_IN_MS = ((cds.env.drafts && cds.env.drafts.cancellationTimeout) || 15) * 60 * 1000
@@ -289,7 +280,6 @@ module.exports = {
   hasDraft,
   proxifyToNoDraftsName,
   addColumnAlias,
-  adaptStreamCQN,
   replaceRefWithDraft,
   getKeyProperty,
   filterKeys,

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
@@ -44,9 +46,18 @@ const HANA_TYPE_CONVERSION_MAP = new Map([
   ['cds.Integer64', convertInt64ToString],
   ['cds.DateTime', convertToISONoMillis],
   ['cds.Timestamp', convertToISO],
-  ['cds.LargeString', convertToString]
+  ['cds.LargeString', convertToString],
+  ['cds.hana.CLOB', 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/dynatrace.js

@@ -7,11 +7,12 @@ try {
 }
 
 const isDynatraceEnabled = () => {
-  return dynatrace.sdk !== undefined
+  return dynatrace.sdk !== undefined && !process.env.CDS_SKIP_DYNATRACE
 }
 
 const _dynatraceResultCallback = function (tracer, cb) {
-  return function (err, results, fields) {
+  return function (err, ...args) {
+    const results = args.shift()
     if (err) {
       tracer.error(err)
     } else {
@@ -19,7 +20,7 @@ const _dynatraceResultCallback = function (tracer, cb) {
         rowsReturned: (results && results.length) || results
       })
     }
-    tracer.end(cb, err, results, fields)
+    tracer.end(cb, err, results, ...args)
   }
 }
 
@@ -73,9 +74,14 @@ const dynatraceClient = (client, credentials, tenant) => {
   // hana-client does not like decorating.
   // because of that, we need to override the fn and pass the original fn for execution
   const originalExecFn = client.exec
-  const originalPrepareFn = client.prepare
   client.exec = _execUsingDynatrace(client, originalExecFn, dbInfo)
-  client.prepare = _preparedStmtUsingDynatrace(client, originalPrepareFn, dbInfo)
+  const originalPrepareFn = client.prepare
+  if (client.name === '@sap/hana-client') {
+    // client.prepare = ... doesn't work for hana-client
+    Object.defineProperty(client, 'prepare', { value: _preparedStmtUsingDynatrace(client, originalPrepareFn, dbInfo) })
+  } else {
+    client.prepare = _preparedStmtUsingDynatrace(client, originalPrepareFn, dbInfo)
+  }
 
   return client
 }

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,32 +48,145 @@ function _getOutputParameters(stmt) {
   return Object.keys(result).length > 0 ? result : undefined
 }
 
+const BINARY_TYPES = {
+  12: 'BINARY',
+  13: 'VARBINARY',
+  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 _isProcedureCall(sql) {
+  return sql.trim().match(/^call \s*"{0,1}\w*/i)
+}
+
+function _getProcedureName(sql) {
+  const match = sql.trim().match(/^call \s*"{0,1}(\w*)/i)
+  return match && match[1]
+}
+
+function _hdbGetResultForProcedure(rows, args, outParameters) {
+  // on hdb, rows already contains results for scalar params
+  const result = rows || {}
+  // merge table output params into scalar params
+  if (args && args.length && outParameters) {
+    const params = outParameters.filter(md => !(md.PARAMETER_NAME in rows))
+    for (let i = 0; i < args.length; i++) {
+      result[params[i].PARAMETER_NAME] = args[i]
+    }
+  }
+  return result
+}
+
+function _hcGetResultForProcedure(stmt, resultSet, outParameters) {
+  const result = {}
+  // build result from scalar params
+  const paramInfo = stmt.getParameterInfo()
+  if (paramInfo.some(p => p.direction > 1)) {
+    for (let i = 0; i < paramInfo.length; i++) {
+      if (paramInfo[i].direction > 1) {
+        result[paramInfo[i].name] = stmt.getParameterValue(i)
+      }
+    }
+  }
+  // merge table output params into scalar params
+  if (outParameters && outParameters.length) {
+    const params = outParameters.filter(md => !(md.PARAMETER_NAME in result))
+    let i = 0
+    while (resultSet.next()) {
+      result[params[i].PARAMETER_NAME] = [resultSet.getValues()]
+      resultSet.nextResult()
+      i++
+    }
+  }
+  return result
+}
+
+function _getProcedureMetadata(procedureName, dbc) {
+  return new Promise((resolve, reject) => {
+    dbc.exec(
+      `SELECT PARAMETER_NAME FROM SYS.PROCEDURE_PARAMETERS WHERE SCHEMA_NAME = CURRENT_SCHEMA AND PROCEDURE_NAME = '${procedureName}' AND PARAMETER_TYPE IN ('OUT', 'INOUT') ORDER BY POSITION`,
+      (err, res) => {
+        if (err) reject(err)
+        else resolve(res)
+      }
+    )
+  })
+}
+
 function _executeAsPreparedStatement(dbc, sql, values, reject, resolve) {
-  dbc.prepare(sql, function (err, stmt) {
+  dbc.prepare(sql, async function (err, stmt) {
     if (err) {
       err.query = sql
       if (values) err.values = SANITIZE_VALUES ? ['***'] : values
       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')
             }
           }
         }
       }
     }
 
+    if (cds.env.features.new_call_prodecure) {
+      // procedure call metadata
+      let outParameters
+      const isProcedureCall = _isProcedureCall(sql)
+      if (isProcedureCall) {
+        try {
+          const procedureName = _getProcedureName(sql)
+          outParameters = await _getProcedureMetadata(procedureName, dbc)
+        } catch (e) {
+          LOG._warn && LOG.warn('Unable to fetch procedure metadata due to error:', e)
+        }
+      }
+
+      // on @sap/hana-client, we need to use execQuery in case of calling procedures
+      stmt[isProcedureCall && dbc.name !== 'hdb' ? 'execQuery' : 'exec'](values, function (err, rows, ...args) {
+        if (err) {
+          stmt.drop(() => {})
+          err.query = sql
+          if (values) err.values = SANITIZE_VALUES ? ['***'] : values
+          return reject(err)
+        }
+
+        let result
+        if (isProcedureCall) {
+          result =
+            dbc.name === 'hdb'
+              ? _hdbGetResultForProcedure(rows, args, outParameters)
+              : _hcGetResultForProcedure(stmt, rows, outParameters)
+        } else {
+          result = rows
+        }
+
+        stmt.drop(() => {})
+
+        resolve(result)
+      })
+
+      return
+    }
+
     stmt.exec(values, function (err, rows, procedureReturn) {
       if (err) {
         stmt.drop(() => {})
@@ -108,15 +221,15 @@ 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) || _isProcedureCall(sql)) {
       _executeAsPreparedStatement(dbc, sql, values, reject, resolve)
     } else {
-      dbc.exec(sql, function (err, result, procedureReturn) {
+      dbc.exec(sql, function (err, result) {
         if (err) {
           err.query = sql
           return reject(err)
         }
-        resolve(procedureReturn || result)
+        resolve(result)
       })
     }
   })

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

package/libx/_runtime/hana/search2cqn4sql.js

@@ -1,6 +1,7 @@
 const { computeColumnsToBeSearched } = require('../cds-services/services/utils/columns')
 const searchToLike = require('../common/utils/searchToLike')
 const { isContainsPredicateSupported, searchToContains } = require('./searchToContains')
+const { addAliasToExpression } = require('../db/utils/generateAliases')
 
 /**
  * Computes a CQN expression for a search query.
@@ -33,8 +34,7 @@ const search2cqn4sql = (query, entity, options) => {
   // suppress the localize handler from redirecting the query's target to the localized view
   Object.defineProperty(query, '_suppressLocalization', { value: true })
 
-  // do not join if subquery exists - already done in there
-  if (resolveLocalizedDataAtRuntime && !query.SELECT.from.SELECT) {
+  if (resolveLocalizedDataAtRuntime) {
     const onCondition = entity._relations[localizedAssociation.name].join(localizedAssociation.target, entity.name)
 
     // replace $user_locale placeholder with the user locale or the HANA session context
@@ -46,56 +46,54 @@ const search2cqn4sql = (query, entity, options) => {
     query.join(localizedEntityName).on(onCondition)
 
     // prevent SQL ambiguity error for columns with the same name
-    columnsToBeSearched = _addAliasToColumns(query, entity, columnsToBeSearched)
+    columnsToBeSearched = _addAliasToQuery(query, entity, columnsToBeSearched)
   } // else --> resolve localized texts via localized view (default)
 
   const useContains = isContainsPredicateSupported(query)
   let expression
 
   if (useContains) {
-    const funcCols = columnsToBeSearched.filter(col => col.func)
-    const refCols = columnsToBeSearched.filter(col => !col.func)
-    expression = [searchToContains(cqnSearchPhrase, refCols)]
-    if (funcCols.length) expression.push('or', ...searchToLike(cqnSearchPhrase, funcCols))
+    const namedColumns = columnsToBeSearched.filter(col => !col.func)
+    expression = searchToContains(cqnSearchPhrase, namedColumns)
+
+    // func columns handling
+    if (columnsToBeSearched.length > namedColumns.length) {
+      const funcColumns = columnsToBeSearched.filter(col => col.func)
+      expression = [expression, 'or', ...searchToLike(cqnSearchPhrase, funcColumns)]
+    }
   } else {
     // No CONTAINS optimization possible. The search implementation for localized
     // texts falls back to the LIKE predicate.
     expression = searchToLike(cqnSearchPhrase, columnsToBeSearched)
   }
+
   // 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)
   return query
 }
 
-const _getLocalizedAssociation = entity => {
-  const associations = entity.associations
-  return associations && associations.localized
-}
+const _getLocalizedAssociation = entity => entity.associations && entity.associations.localized
 
 // The inner join modifies the original SELECT ... FROM query and adds ambiguity,
 // therefore add the table/entity name (as a preceding element) to the columns ref
 // to prevent a SQL ambiguity error.
-const _addAliasToColumns = (query, entity, columnsToBeSearched) => {
+const _addAliasToQuery = (query, entity, columnsToBeSearched) => {
+  const SELECT = query.SELECT
   const localizedEntityName = _getLocalizedAssociation(entity).target
   const elements = entity.elements
   const entityName = entity.name
-  const _addAliasToColumn = (entityName, localizedEntityName, elements) => column => {
-    const columnRef = column.ref
-    if (!columnRef) return column
+  const getEntityName = columnRef => {
     const columnName = columnRef[0]
-    const localizedElement = elements[columnName].localized
+    const localizedElement = !!elements[columnName].localized
     const targetEntityName = localizedElement ? localizedEntityName : entityName
-    return { ref: [targetEntityName, columnName] }
-  }
-
-  query.SELECT.columns = query.SELECT.columns.map(_addAliasToColumn(entityName, localizedEntityName, elements))
-  const columns = columnsToBeSearched.map(_addAliasToColumn(entityName, localizedEntityName, elements))
-
-  if (query.SELECT.groupBy) {
-    query.SELECT.groupBy = query.SELECT.groupBy.map(_addAliasToColumn(entityName, localizedEntityName, elements))
+    return targetEntityName
   }
 
-  return columns
+  SELECT.columns = addAliasToExpression(SELECT.columns, getEntityName)
+  columnsToBeSearched = addAliasToExpression(columnsToBeSearched, getEntityName)
+  SELECT.groupBy = addAliasToExpression(SELECT.groupBy, getEntityName)
+  SELECT.where = addAliasToExpression(SELECT.where, getEntityName)
+  return columnsToBeSearched
 }
 
 module.exports = search2cqn4sql

package/libx/_runtime/hana/searchToContains.js

@@ -25,7 +25,7 @@
  * @returns {import("../types/api").searchContainsExp} The `CONTAINS` CQN expression
  */
 const searchToContains = (cqnSearchPhrase, columns) => {
-  // serialize CQN search phrase
+  // serialize the CQN search phrase
   const searchString = cqnSearchPhrase.reduce((searchStringAccumulator, currentValue) => {
     // Multiple search terms separated by an space are automatically
     // interpreted as an AND operator. Therefore, it is not mandatory

package/libx/_runtime/messaging/AMQPWebhookMessaging.js

@@ -61,7 +61,7 @@ class AMQPWebhookMessaging extends MessagingService {
           // In case of AMQP and Solace, the `failed` callback must be called
           // with an error, otherwise there are problems with the redelivery count.
           failed(new Error('processing failed'))
-          LOG._error && LOG.error(e)
+          LOG.error('ERROR occured in asynchronous event processing:', e)
         }
       })
     }