@sap/cds 5.9.0 → 5.9.3

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

@@ -19,9 +19,18 @@ const { deleteCondition, readAndDeleteKeywords, removeIsActiveEntityRecursively
 const { getColumns } = require('../../cds-services/services/utils/columns')
 const { adaptStreamCQN } = require('../../cds-services/adapter/odata-v4/utils/stream')
 
+const _findSubselect = where => {
+  return where.find((e, i) => {
+    if (e.xpr) {
+      return _findSubselect(e.xpr)
+    }
+    return e.SELECT && where[i - 1] === 'exists'
+  })
+}
+
 const _findRootSubSelectFor = query => {
   if (query.SELECT.where) {
-    const subSelect = query.SELECT.where.find((e, i) => e.SELECT && query.SELECT.where[i - 1] === 'exists')
+    const subSelect = _findSubselect(query.SELECT.where)
     return subSelect ? _findRootSubSelectFor(subSelect) : query
   }
   return query
@@ -422,8 +431,8 @@ const _allActive = (req, columns, model) => {
     cqn.leftJoin(ensureDraftsSuffix(table.ref[0]) + ' as drafts').on(`${table.as}.${ids[0]} = drafts.${ids[0]}`)
 
     for (let i = 1; i < ids.length; i++) {
-      // REVISIT: this is extremely expensive as it repeatedly invokes the compiler's cds.parse.expr -> better extend plain CQN yourself here
-      cqn.and(`${table.as}.${ids[i]} = drafts.${ids[i]}`)
+      // this 'and' belongs to the join condition and is not a where and
+      cqn.and({ ref: [table.as, ids[i]] }, '=', { ref: ['drafts', ids[i]] })
     }
   }
 
@@ -557,27 +566,38 @@ const _alignAliasForUnion = (table, as, select) => {
   return select
 }
 
-const _findJoinInQuery = (query, parentAlias) => {
-  const targetAlias = query.SELECT.from.as
-  const isTargetRef = el => targetAlias && el.ref && el.ref.length > 1 && el.ref[0] === targetAlias
-  if (query.SELECT && query.SELECT.where)
-    return query.SELECT.where.reduce((links, el, idx, where) => {
-      if (el.ref && el.ref[0] === parentAlias && el.ref[el.ref.length - 1] !== 'IsActiveEntity') {
-        if (where[idx - 1] && where[idx - 1] === '=' && isTargetRef(where[idx - 2])) {
-          if (links.length) links.push('and')
-          links.push(el, '=', where[idx - 2])
-        }
-        if (where[idx + 1] && where[idx + 1] === '=' && isTargetRef(where[idx + 2])) {
-          if (links.length) links.push('and')
-          links.push(el, '=', where[idx + 2])
-        }
+const isTargetRef = (el, targetAlias) => targetAlias && el.ref && el.ref.length > 1 && el.ref[0] === targetAlias
+
+const _joinFromWhere = (where, parentAlias, targetAlias) => {
+  return where.reduce((links, el, idx, where) => {
+    if (el.xpr) {
+      const result = _joinFromWhere(el.xpr, parentAlias, targetAlias)
+      if (result.length) {
+        if (links.length) links.push('and')
+        links.push(...result)
       }
       return links
-    }, [])
-  return []
+    }
+
+    if (el.ref && el.ref[0] === parentAlias && el.ref[el.ref.length - 1] !== 'IsActiveEntity') {
+      if (where[idx - 1] && where[idx - 1] === '=' && isTargetRef(where[idx - 2], targetAlias)) {
+        if (links.length) links.push('and')
+        links.push(el, '=', where[idx - 2])
+      }
+      if (where[idx + 1] && where[idx + 1] === '=' && isTargetRef(where[idx + 2], targetAlias)) {
+        if (links.length) links.push('and')
+        links.push(el, '=', where[idx + 2])
+      }
+    }
+    return links
+  }, [])
 }
 
-const _isFiltered = where => where.some(element => !(element in ['(', ')']))
+const _findJoinInQuery = (query, parentAlias) => {
+  const targetAlias = query.SELECT.from.as
+  if (query.SELECT && query.SELECT.where) return _joinFromWhere(query.SELECT.where, parentAlias, targetAlias)
+  return []
+}
 
 const _isDraftField = element => element.ref && element.ref.length > 1 && element.ref[0] === 'DraftAdministrativeData'
 
@@ -597,6 +617,10 @@ const _isLogicalFunction = (where, index) => {
 const _getWhereForActive = where => {
   const activeWhere = []
   for (let i = 0; i < where.length; i++) {
+    if (where[i].xpr) {
+      activeWhere.push({ xpr: _getWhereForActive(where[i].xpr) })
+      continue
+    }
     if (_isDraftField(where[i])) {
       activeWhere.push({ val: null })
     } else if (_functionContainsDraftField(where[i])) {
@@ -721,10 +745,20 @@ const _getSiblingScenario = (req, columns, model, siblingIndex, nav) => {
   const draftAdminAlias = _isDraftAdminScenario(req) && req.query.SELECT.from.as
   const params = [...req.params].reverse()
   const _getSiblingQueryFromWhere = (query, queryIndex, parentQuery) => {
-    if (query.SELECT && query.SELECT.where) {
-      const indexExists = query.SELECT.where.indexOf('exists')
-      if (indexExists > -1 && queryIndex > 0) {
-        return _getSiblingQueryFromWhere(query.SELECT.where[indexExists + 1], queryIndex - 1, query)
+    if (query.SELECT && query.SELECT.where && queryIndex > 0) {
+      for (let i = 0; i < query.SELECT.where.length; i++) {
+        if (query.SELECT.where[i].xpr && queryIndex > 0) {
+          const sibilingQueryFromWhere = _getSiblingQueryFromWhere(
+            { SELECT: { where: query.SELECT.where[i].xpr } },
+            queryIndex - 1,
+            query
+          )
+          if (sibilingQueryFromWhere) return sibilingQueryFromWhere
+        }
+
+        if (query.SELECT.where[i] === 'exists' && queryIndex > 0) {
+          return _getSiblingQueryFromWhere(query.SELECT.where[i + 1], queryIndex - 1, query)
+        }
       }
     }
     const target = { name: query.SELECT.from.ref[0].id || query.SELECT.from.ref[0], as: query.SELECT.from.as }
@@ -741,9 +775,16 @@ const _getSiblingScenario = (req, columns, model, siblingIndex, nav) => {
   return _getSiblingQueryFromWhere(req.query, siblingIndex)
 }
 
-const _mergeSiblingIntoCQN = (cqn, { cqn: siblingCQN }, siblingIndex) => {
-  const _replaceWhereExists = (query, _siblingIndex) => {
-    if (query.SELECT && query.SELECT.where) {
+const _replaceWhereExists = (query, _siblingIndex, siblingCQN) => {
+  if (query.SELECT && query.SELECT.where) {
+    for (let i = 0; i < query.SELECT.where.length; i++) {
+      const whereElement = query.SELECT.where[i]
+      if (whereElement.xpr) {
+        const res = _replaceWhereExists({ SELECT: { where: whereElement.xpr } }, _siblingIndex, siblingCQN)
+        if (res) return res
+        continue
+      }
+
       const indexExists = query.SELECT.where.indexOf('exists')
       if (indexExists > -1) {
         if (_siblingIndex > 0) return _replaceWhereExists(query.SELECT.where[indexExists + 1], _siblingIndex - 1)
@@ -751,7 +792,10 @@ const _mergeSiblingIntoCQN = (cqn, { cqn: siblingCQN }, siblingIndex) => {
       }
     }
   }
-  return _replaceWhereExists(cqn, siblingIndex)
+}
+
+const _mergeSiblingIntoCQN = (cqn, { cqn: siblingCQN }, siblingIndex) => {
+  return _replaceWhereExists(cqn, siblingIndex, siblingCQN)
 }
 
 const _getDraftDoc = (req, draftName, draftWhere) => {
@@ -796,6 +840,11 @@ const _getOrderByEnrichedColumns = (orderBy, columns, entity) => {
 
 const _replaceDraftAlias = where => {
   where.forEach(element => {
+    if (element.xpr) {
+      _replaceDraftAlias(element.xpr)
+      return
+    }
+
     if (_isDraftField(element)) {
       element.ref[0] = 'filterAdmin'
     }
@@ -981,7 +1030,10 @@ const _validatedDraftOfWhichIAmOwner = (req, draftWhere, draftParameters, column
   _isValidDraftOfWhichIAmOwner(draftParameters.isActiveEntity) && _draftOfWhichIAmOwner(req, draftWhere, columns)
 
 const _draftInSubSelect = (where, req) => {
-  return where.some(({ SELECT }) => {
+  return where.some(({ SELECT, xpr }) => {
+    if (xpr) {
+      return _draftInSubSelect(xpr, req)
+    }
     if (SELECT && SELECT.where) {
       const isActiveEntity = readAndDeleteKeywords(['IsActiveEntity'], SELECT.where, false)
       if (isActiveEntity) {
@@ -1022,7 +1074,7 @@ const _generateCQN = (originalFrom, req, columns, model) => {
     return _draftAdminTable(req)
   }
 
-  if (!req.query.SELECT.where || !_isFiltered(req.query.SELECT.where)) {
+  if (!req.query.SELECT.where) {
     return _allActive(req, columns, model)
   }
 
@@ -1032,7 +1084,7 @@ const _generateCQN = (originalFrom, req, columns, model) => {
   if (
     draftParameters.isActiveEntity &&
     _isTrue(draftParameters.isActiveEntity.value.val) &&
-    !draftParameters.siblingIsActive &&
+    !(draftParameters.siblingIsActive && draftParameters.siblingIsActive.value.val === null) &&
     !draftParameters.hasDraftEntity
   ) {
     return _allActive(req, columns, model)

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

@@ -5,18 +5,14 @@ const { readAndDeleteKeywords } = require('../utils/where')
 const { cqn2cqn4sql } = require('../../common/utils/cqn2cqn4sql')
 const { isActiveEntityRequested } = require('../../../_runtime/fiori/utils/where')
 
-const _modifyCQN = (cqnDraft, where, context) => {
-  const whereDraft = [...where]
-  const result = readAndDeleteKeywords(['IsActiveEntity'], whereDraft)
-  cqnDraft.where(whereDraft)
-
-  if (result && result.value.val === false) {
-    const fromRef = cqnDraft.SELECT.from.ref
-    cqnDraft.SELECT.from.ref[fromRef.length - 1] = ensureDraftsSuffix(fromRef[fromRef.length - 1])
-  }
+const _modifyWhere = (where, context) => {
+  for (let i = 0; i < where.length; i++) {
+    const element = where[i]
 
-  for (let i = 0; i < cqnDraft.SELECT.where.length; i++) {
-    const element = cqnDraft.SELECT.where[i]
+    if (element.xpr) {
+      _modifyWhere(element.xpr, context)
+      continue
+    }
 
     if (element.SELECT) {
       const subCqnDraft = SELECT.from(
@@ -27,12 +23,25 @@ const _modifyCQN = (cqnDraft, where, context) => {
         [1]
       )
 
-      cqnDraft.SELECT.where[i] = subCqnDraft
+      where[i] = subCqnDraft
       _modifyCQN(subCqnDraft, element.SELECT.where, context)
     }
   }
 }
 
+const _modifyCQN = (cqnDraft, where, context) => {
+  const whereDraft = [...where]
+  const result = readAndDeleteKeywords(['IsActiveEntity'], whereDraft)
+  cqnDraft.where(whereDraft)
+
+  if (result && result.value.val === false) {
+    const fromRef = cqnDraft.SELECT.from.ref
+    cqnDraft.SELECT.from.ref[fromRef.length - 1] = ensureDraftsSuffix(fromRef[fromRef.length - 1])
+  }
+
+  _modifyWhere(cqnDraft.SELECT.where, context)
+}
+
 const _hasNavToNonDraftEnclosedAssoc = (pathSegments, definitions, excludeAssoc) => {
   if (pathSegments.length < 2) return false
   const entity = definitions[pathSegments[0]]
@@ -67,19 +76,22 @@ const _shouldReadOverDraft = (req, definitions) => {
   const rootEntityName = typeof firstFromRef === 'string' ? firstFromRef : firstFromRef.id
   const rootEntity = definitions[rootEntityName]
 
-  // read over the draft only if the root entity is draft-enabled and
-  // the navigation starts with a draft entity (IsActiveEntity=false)
-  if (!!rootEntity._isDraftEnabled && isActiveEntityRequested(firstFromRef.where)) return false
+  // read over the draft only if the root entity is draft-enabled
+  if (!rootEntity._isDraftEnabled) return false
 
-  // read over the draft if the navigation target is an association and
-  // only if it isn't annotated with @odata.draft.enclosed
-  const pathSegments = fromRef.map(path => (typeof path === 'string' ? path : path.id))
+  // read over the draft only if the navigation starts from a draft entity, e.g.,
+  // /Books(ID=1, IsActiveEntity=false)
+  if (isActiveEntityRequested(firstFromRef.where)) return false
 
+  const pathSegments = fromRef.map(path => (typeof path === 'string' ? path : path.id))
   const excludeAssoc = assoc => {
     if (assoc.name === 'DraftAdministrativeData' || assoc.name === 'SiblingEntity') return true
     return false
   }
 
+  // Read over the draft only if:
+  // - the navigation target is an association and
+  // - isn't annotated with the @odata.draft.enclosed annotation
   return _hasNavToNonDraftEnclosedAssoc(pathSegments, definitions, excludeAssoc)
 }
 
@@ -109,7 +121,7 @@ const _readOverDraftHandler = async function (req, next) {
 
   const hasDraftEntity = hasDraft(definitions, sqlQuery)
 
-  if (hasDraftEntity && sqlQuery.SELECT.where && sqlQuery.SELECT.where.length > 0) {
+  if (hasDraftEntity && sqlQuery.SELECT.where && sqlQuery.SELECT.where.length) {
     let cqnDraft = SELECT.from({
       ref: [...sqlQuery.SELECT.from.ref],
       as: sqlQuery.SELECT.from.as

package/libx/_runtime/fiori/utils/handler.js

@@ -93,6 +93,9 @@ const getUpdateDraftAdminCQN = ({ user }, draftUUID) => {
 const _addAlias = (where, tableName) => {
   // copy where
   return where.map(element => {
+    if (element.xpr) {
+      return { xpr: _addAlias(element.xpr, tableName) }
+    }
     if (element.ref && element.ref.length === 1) {
       // and copy ref
       return { ref: [tableName, element.ref[0]] }

package/libx/_runtime/fiori/utils/where.js

@@ -57,7 +57,9 @@ const _removeIsActiveEntityCondition = where => {
     } else if (where[i] === 'and' && where[i + 1] === '(' && _isActiveEntity(where[i + 2])) {
       i = i + 6
     } else if (where[i].xpr) {
-      newWhere.push({ xpr: _removeIsActiveEntityCondition(where[i].xpr) })
+      if (where[i].xpr.length) {
+        newWhere.push({ xpr: _removeIsActiveEntityCondition(where[i].xpr) })
+      }
       i++
     } else {
       newWhere.push(where[i])
@@ -65,7 +67,7 @@ const _removeIsActiveEntityCondition = where => {
     }
   }
 
-  if (newWhere[0] === 'and') {
+  if (newWhere[0] === 'and' || newWhere[0] === 'or') {
     newWhere.splice(0, 1)
   } else if (newWhere[0] === '(' && newWhere[1] === 'and') {
     newWhere.splice(0, 2)
@@ -90,32 +92,35 @@ const deleteCondition = (index, whereCondition, isXpr = false) => {
 }
 
 const readAndDeleteKeywords = (keywords, whereCondition, toDelete = true) => {
-  let index = whereCondition.findIndex(({ xpr }) => xpr)
-  if (index !== -1) {
-    const result = readAndDeleteKeywords(keywords, whereCondition[index].xpr, toDelete)
-    if (result) {
-      if (whereCondition[index].xpr.length === 0) {
-        deleteCondition(index, whereCondition, true)
+  let index = -1
+  for (let i = 0; i < whereCondition.length; i++) {
+    const entry = whereCondition[i]
+    if (entry.xpr) {
+      const result = readAndDeleteKeywords(keywords, entry.xpr, toDelete)
+      if (result) {
+        if (entry.xpr.length === 0) {
+          deleteCondition(i, whereCondition, true)
+        }
+        return result
+      }
+    } else if (entry.ref) {
+      const refLastIndex = entry.ref.length - 1
+
+      if (keywords.length === 1) {
+        if (entry.ref[refLastIndex] === keywords[0]) {
+          index = i
+          break
+        }
       }
-      return result
-    }
-  }
-
-  index = whereCondition.findIndex(({ ref }) => {
-    if (!ref) {
-      return false
-    }
-
-    const refLastIndex = ref.length - 1
-
-    if (keywords.length === 1) {
-      return ref[refLastIndex] === keywords[0]
-    }
 
-    if (keywords.length === 2 && ref.length >= 2) {
-      return ref[refLastIndex - 1] === keywords[0] && ref[refLastIndex] === keywords[1]
+      if (keywords.length === 2 && entry.ref.length >= 2) {
+        if (entry.ref[refLastIndex - 1] === keywords[0] && entry.ref[refLastIndex] === keywords[1]) {
+          index = i
+          break
+        }
+      }
     }
-  })
+  }
 
   if (index === -1) {
     return
@@ -135,6 +140,10 @@ const readAndDeleteKeywords = (keywords, whereCondition, toDelete = true) => {
 
 const removeIsActiveEntityRecursively = where => {
   for (const entry of where) {
+    if (entry.xpr) {
+      entry.xpr = removeIsActiveEntityRecursively(entry.xpr)
+      continue
+    }
     if (entry.SELECT && entry.SELECT.where && entry.SELECT.from.ref && !entry.SELECT.from.ref[0].endsWith('_drafts')) {
       entry.SELECT.where = removeIsActiveEntityRecursively(entry.SELECT.where)
 
@@ -153,6 +162,10 @@ const isActiveEntityRequested = where => {
   let i = 0
 
   while (where[i]) {
+    if (where[i].xpr) {
+      const isRequested = isActiveEntityRequested(where.xpr)
+      if (isRequested) return true
+    }
     if (
       where[i].ref &&
       where[i].ref[where[i].ref.length - 1] === 'IsActiveEntity' &&

package/libx/_runtime/hana/execute.js

@@ -280,11 +280,28 @@ function executeInsertCQN(model, dbc, query, user, locale, txTimestamp) {
   }
 
   return _executeSimpleSQL(dbc, sql, values).then(affectedRows => {
+    const entriesOrRows = query.INSERT.entries || query.INSERT.rows
+    const affectedRowsCount = Array.isArray(affectedRows)
+      ? affectedRows.reduce((sum, rows) => sum + rows, 0)
+      : affectedRows
+    if (entriesOrRows && entriesOrRows.length !== affectedRowsCount) {
+      LOG._warn &&
+        LOG.warn(
+          `INSERT input deviates from affected rows (input: ${entriesOrRows.length}, affectedRows: ${affectedRowsCount})`,
+          {
+            sql,
+            args: values && values.length,
+            values,
+            query
+          }
+        )
+      throw new Error('Possible data loss by INSERT into HANA db. Please, update a corresponding HANA driver.')
+    }
     // InsertResult needs an object per row with its values
     // query.INSERT.values -> one row
     if (query.INSERT.values) return [{ affectedRows: 1, values: [values] }]
     // query.INSERT.entries or .rows -> multiple rows
-    if (query.INSERT.entries || query.INSERT.rows) return values.map(v => ({ affectedRows: 1, values: v }))
+    if (entriesOrRows) return values.map(v => ({ affectedRows: 1, values: v }))
     // INSERT into SELECT
     return [{ affectedRows }]
   })

package/libx/_runtime/hana/search2cqn4sql.js

@@ -37,8 +37,11 @@ const search2cqn4sql = (query, entity, options) => {
   if (resolveLocalizedDataAtRuntime) {
     const onCondition = entity._relations[localizedAssociation.name].join(localizedAssociation.target, entity.name)
 
+    // REVISIT this is dirty but works for now
     // replace $user_locale placeholder with the user locale or the HANA session context
-    onCondition[onCondition.length - 2] = { val: locale || "SESSION_CONTEXT('LOCALE')" }
+    if (onCondition[0].xpr) {
+      onCondition[0].xpr[onCondition[0].xpr.length - 1] = { val: locale || "SESSION_CONTEXT('LOCALE')" }
+    } else onCondition[onCondition.length - 2] = { val: locale || "SESSION_CONTEXT('LOCALE')" }
 
     // inner join the target table with the _texts table (the _texts table contains
     // the translated texts)

package/libx/_runtime/remote/utils/client.js

@@ -339,12 +339,10 @@ const _cqnToReqOptions = (query, kind, model, target) => {
   const queryObject = cds.odata.urlify(query, { kind, model })
   const reqOptions = {
     method: queryObject.method,
-    url: encodeURI(
-      queryObject.path
-        // ugly workaround for Okra not allowing spaces in ( x eq 1 )
-        .replace(/\( /g, '(')
-        .replace(/ \)/g, ')')
-    )
+    url: queryObject.path
+      // ugly workaround for Okra not allowing spaces in ( x eq 1 )
+      .replace(/\( /g, '(')
+      .replace(/ \)/g, ')')
   }
   if (queryObject.method !== 'GET' && queryObject.method !== 'HEAD') {
     reqOptions.data = kind === 'odata-v2' ? convertV2PayloadData(queryObject.body, target) : queryObject.body

package/libx/_runtime/sqlite/convertAssocToOneManaged.js

@@ -17,29 +17,36 @@ const _getConvertibleEntries = req => {
   return [...orders, ...groups, ...filters, ...havings]
 }
 
-// REVISIT once sql can handle structured keys properly, this handler should not be required anymore
-const _handler = function (req) {
-  // do simple checks upfront and exit early
-  if (!req.query || typeof req.query === 'string') return
-  if (!req.query.SELECT.orderBy && !req.query.SELECT.groupBy && !req.query.SELECT.where && !req.query.SELECT.having) {
-    return
-  }
-
-  if (!req.target || !req.target.elements) return
+const _convert = (refEntries, req) => {
+  for (const refEntry of refEntries) {
+    if (refEntry.xpr) {
+      _convert(refEntry.xpr, req)
+      continue
+    }
 
-  for (const refEntry of _getConvertibleEntries(req)) {
     if (!refEntry.ref || refEntry.ref.length < 2) {
       // only check refs in format {ref: ['assoc', 'id']}
       continue
     }
-
     const element = req.target.elements[refEntry.ref[0]]
     if (!element || !element.is2one) return
-
     _convertRefForAssocToOneManaged(element, refEntry)
   }
 }
 
+// REVISIT once sql can handle structured keys properly, this handler should not be required anymore
+const _handler = function (req) {
+  // do simple checks upfront and exit early
+  if (!(req.query && req.query.SELECT) || typeof req.query === 'string') return
+  if (!req.query.SELECT.orderBy && !req.query.SELECT.groupBy && !req.query.SELECT.where && !req.query.SELECT.having) {
+    return
+  }
+
+  if (!req.target || !req.target.elements) return
+
+  _convert(_getConvertibleEntries(req), req)
+}
+
 _handler._initial = true
 
 module.exports = _handler

package/libx/odata/cqn2odata.js

@@ -83,14 +83,10 @@ function _args(args) {
 
     if (hasValidProps(cur, 'func', 'args')) {
       res.push(`${cur.func}(${_args(cur.args)})`)
-    }
-
-    if (hasValidProps(cur, 'ref')) {
-      res.push(cur.ref.join('/'))
-    }
-
-    if (hasValidProps(cur, 'val')) {
-      res.push(formatVal(cur.val))
+    } else if (hasValidProps(cur, 'ref')) {
+      res.push(_format(cur))
+    } else if (hasValidProps(cur, 'val')) {
+      res.push(_format(cur))
     }
   }
 
@@ -98,13 +94,13 @@ function _args(args) {
 }
 
 const _in = (column, /* in */ collection, target, kind, isLambda) => {
-  const ref = isLambda ? [LAMBDA_VARIABLE, ...column.ref].join('/') : column.ref.join('/')
+  const ref = _format(column, null, target, kind, isLambda)
   // { val: [ 1, 2, 3 ] } or { list: [ { val: 1}, { val: 2}, { val: 3} ] }
   const values = collection.val || collection.list
   if (values && values.length) {
     // REVISIT: what about OData `in` operator?
-    const expressions = values.map(value => `${ref} eq ${_format(value, ref, target, kind, isLambda)}`)
-    return expressions.join(' or ')
+    const expressions = values.map(value => `${ref}%20eq%20${_format(value, ref, target, kind, isLambda)}`)
+    return expressions.join('%20or%20')
   }
 }
 
@@ -119,9 +115,10 @@ const _odataV2Func = (func, args) => {
 }
 
 const _format = (cur, element, target, kind, isLambda) => {
-  if (typeof cur !== 'object') return formatVal(cur, element, target, kind)
-  if (hasValidProps(cur, 'ref')) return isLambda ? [LAMBDA_VARIABLE, ...cur.ref].join('/') : cur.ref.join('/')
-  if (hasValidProps(cur, 'val')) return formatVal(cur.val, element, target, kind)
+  if (typeof cur !== 'object') return encodeURIComponent(formatVal(cur, element, target, kind))
+  if (hasValidProps(cur, 'ref'))
+    return encodeURIComponent(isLambda ? [LAMBDA_VARIABLE, ...cur.ref].join('/') : cur.ref.join('/'))
+  if (hasValidProps(cur, 'val')) return encodeURIComponent(formatVal(cur.val, element, target, kind))
   if (hasValidProps(cur, 'xpr')) return `(${_xpr(cur.xpr, target, kind, isLambda)})`
   // REVISIT: How to detect the types for all functions?
   if (hasValidProps(cur, 'func', 'args')) {
@@ -156,7 +153,7 @@ function _xpr(expr, target, kind, isLambda) {
       } else if (isOrIsNotValue) {
         // REVISIT: "is" only used for null values?
         const operator = isOrIsNotValue[1] /* 'is not' */ ? 'ne' : 'eq'
-        res.push(...[operator, formatVal(isOrIsNotValue[2])])
+        res.push(...[operator, _format({ val: isOrIsNotValue[2] })])
       } else if (cur === 'between') {
         // ref gt low.val and ref lt high.val
         const between = [expr[i - 1], 'gt', expr[i + 1], 'and', expr[i - 1], 'lt', expr[i + 3]]
@@ -188,7 +185,7 @@ function _xpr(expr, target, kind, isLambda) {
     }
   }
 
-  return res.join(' ')
+  return res.join('%20')
 }
 
 const _keysOfWhere = (where, kind, target) => {
@@ -202,11 +199,11 @@ const _keysOfWhere = (where, kind, target) => {
   const res = []
   for (const cur of where) {
     if (hasValidProps(cur, 'ref')) {
-      res.push(cur.ref.join('/'))
+      res.push(_format(cur))
     } else if (hasValidProps(cur, 'val')) {
       // find previous ref
       const element = res[res.length - 2]
-      res.push(formatVal(cur.val, element, target, kind))
+      res.push(_format(cur, element, target, kind))
     } else if (cur === 'and') {
       res.push(',')
     } else {
@@ -267,15 +264,15 @@ const _parseColumnsV2 = (columns, prefix = []) => {
 
       if (hasValidProps(column, 'expand')) {
         const parsed = _parseColumnsV2(column.expand, [refName])
-        expand.push(refName, ...parsed.expand)
+        expand.push(encodeURIComponent(refName), ...parsed.expand)
         select.push(...parsed.select)
       } else {
-        select.push(refName)
+        select.push(encodeURIComponent(refName))
       }
     }
 
     if (column === '*') {
-      select.push(`${prefix.join('/')}/*`)
+      select.push(encodeURIComponent(`${prefix.join('/')}/*`))
     }
   }
 
@@ -288,7 +285,7 @@ const _parseColumns = columns => {
 
   for (const column of columns) {
     if (hasValidProps(column, 'ref')) {
-      let refName = column.ref.join('/')
+      let refName = _format(column)
       if (hasValidProps(column, 'expand')) {
         // REVISIT: incomplete, see test Foo?$expand=invoices($count=true;$expand=item($search="some"))
         if (!columns.some(c => !c.expand)) select.push(refName)
@@ -350,16 +347,16 @@ function $orderBy(orderBy) {
 
   for (const cur of orderBy) {
     if (hasValidProps(cur, 'ref', 'sort')) {
-      res.push(cur.ref.join('/') + ' ' + cur.sort)
+      res.push(_format(cur) + '%20' + cur.sort)
       continue
     }
 
     if (hasValidProps(cur, 'ref')) {
-      res.push(cur.ref.join('/'))
+      res.push(_format(cur))
     }
 
     if (hasValidProps(cur, 'func', 'sort')) {
-      res.push(`${cur.func}(${_args(cur.args)})` + ' ' + cur.sort)
+      res.push(`${cur.func}(${_args(cur.args)})` + '%20' + cur.sort)
       continue
     }
 
@@ -382,7 +379,7 @@ function parseSearch(search) {
 
     if (hasValidProps(cur, 'val')) {
       // search term must not be formatted
-      res.push(`"${cur.val}"`)
+      res.push(`"${encodeURIComponent(cur.val)}"`)
     }
 
     if (typeof cur === 'string') {
@@ -398,7 +395,7 @@ function parseSearch(search) {
 }
 
 function $search(search, kind) {
-  const expr = parseSearch(search).join(' ').replace('( ', '(').replace(' )', ')')
+  const expr = parseSearch(search).join('%20').replace('(%20', '(').replace('%20)', ')')
 
   if (expr) {
     // odata-v2 may support custom query option "search"