@sap/cds 5.4.3 → 5.5.0

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

@@ -1,7 +1,10 @@
 const cds = require('../../cds')
 const { SELECT } = cds.ql
 
-const { DRAFT_COLUMNS, DRAFT_COLUMNS_MAP } = require('../../common/constants/draft')
+const cqn2cqn4sql = require('../../common/utils/cqn2cqn4sql')
+const { getElementDeep } = require('../../common/utils/csn')
+
+const { DRAFT_COLUMNS, DRAFT_COLUMNS_MAP, SCENARIO } = require('../../common/constants/draft')
 const {
   adaptStreamCQN,
   addColumnAlias,
@@ -10,20 +13,39 @@ const {
   ensureNoDraftsSuffix,
   ensureUnlocalized,
   getEnrichedCQN,
-  removeAnnotationWhere,
   removeDraftUUIDIfNecessary,
   replaceRefWithDraft,
   hasKeyInWhere,
-  filterKeys,
-  getKeyProperty
+  filterKeys
 } = require('../utils/handler')
 const { deleteCondition, readAndDeleteKeywords, removeIsActiveEntityRecursively } = require('../utils/where')
+
 const { getColumns } = require('../../cds-services/services/utils/columns')
-const cqn2cqn4sql = require('../../common/utils/cqn2cqn4sql')
-const { removeVirtuals, postProcessVirtuals } = require('../../db/generic/virtual')
 
-// REVISIT: remove everywhere
-const SYMBOL_FROM_ANNOTATION = Symbol.for('sap.cds.FROM_ANNOTATION')
+// append where with clauses from @restrict
+const _getWhereWithAppendedDraftRestrictions = (where = [], req, scenarioAlias, model) => {
+  if (req.query._draftRestrictions) {
+    for (const each of req.query._draftRestrictions) {
+      if (where.length) where.push('and')
+
+      // REVISIT: remove with cds^6
+      // adjust alias of @restrict where "exists (select ...)"
+      if (scenarioAlias && model)
+        each
+          .filter(e => e.SELECT && e.SELECT.from && e.SELECT.where)
+          .forEach(e => {
+            const entity = model.definitions[e.SELECT.from.ref[0]]
+            e.SELECT.where = e.SELECT.where.map(w => {
+              if (w.ref && w.ref.length === 1 && !entity.elements[w.ref[0]]) w.ref.unshift(scenarioAlias)
+              return w
+            })
+          })
+
+      where.push(...each)
+    }
+  }
+  return where
+}
 
 const _isTrue = val => val === true || val === 'true'
 
@@ -113,7 +135,8 @@ const _getDraftPropertiesDetermineDraft = (req, where, tableName, calcDraftUUID
 
   const hasDraftQuery = SELECT.from(tableName, [{ val: 1 }])
   if (where && where.length > 0) {
-    hasDraftQuery.where(removeAnnotationWhere(where))
+    // clone where to protect from later modification
+    hasDraftQuery.where([...where])
   }
 
   let draftUUIDColumn
@@ -158,13 +181,9 @@ function _copyCQNPartial(partial) {
 }
 
 function _copyArray(array) {
-  const copy = array.map(entry => {
+  return array.map(entry => {
     return typeof entry === 'object' && !(entry instanceof String) ? _copyCQNPartial(entry) : entry
   })
-  if (array[SYMBOL_FROM_ANNOTATION] === true) {
-    copy[SYMBOL_FROM_ANNOTATION] = true
-  }
-  return copy
 }
 
 const _whereContainsKeys = (req, whereDraft) => {
@@ -276,12 +295,12 @@ const _draftAdminTable = req => {
   }
 
   return {
-    cqn: getEnrichedCQN(cqn, req.query.SELECT, removeAnnotationWhere(req.query.SELECT.where)),
-    scenario: 'DRAFT_ADMIN'
+    cqn: getEnrichedCQN(cqn, req.query.SELECT, req.query.SELECT.where),
+    scenario: SCENARIO.DRAFT_ADMIN
   }
 }
 
-const _allInactive = (req, columns, model) => {
+const _allInactive = (req, columns) => {
   const table = {
     ref: [ensureDraftsSuffix(req.query.SELECT.from.ref[0])],
     as: req.query.SELECT.from.as || 'drafts'
@@ -292,17 +311,6 @@ const _allInactive = (req, columns, model) => {
     _getDefaultDraftProperties({ hasDraft: false, isActive: false, withDraftUUID: false })
   )
 
-  // determine name of primary key to use in HasActiveEntity expression
-  const pk = req.target['@assert.unique.locale']
-    ? req.target['@assert.unique.locale'].map(o => o['=']).find(k => k !== 'locale')
-    : getKeyProperty(req.target.keys)
-
-  const xpr = {
-    xpr: ['case', 'when', `active.${pk}`, 'IS NOT NULL', 'then', 'true', 'else', 'false', 'end'],
-    as: 'HasActiveEntity',
-    cast: { type: 'cds.Boolean' }
-  }
-
   const ids = filterKeys(req.target.keys)
   const isCount = columns.some(element => element.func === 'count')
 
@@ -311,7 +319,7 @@ const _allInactive = (req, columns, model) => {
   if (isCount) {
     cqn.columns(...outerMostColumns)
   } else {
-    cqn.columns(...outerMostColumns.filter(o => o.as !== 'HasActiveEntity'), xpr)
+    cqn.columns(...outerMostColumns.filter(o => o.as !== 'HasActiveEntity'), { ref: ['HasActiveEntity'] })
     cqn.leftJoin(ensureNoDraftsSuffix(table.ref[0]) + ' as active').on(`${table.as}.${ids[0]} = active.${ids[0]}`)
 
     for (let i = 1; i < ids.length; i++) {
@@ -321,9 +329,8 @@ const _allInactive = (req, columns, model) => {
   }
 
   cqn.where(req.query.SELECT.where)
-  removeAnnotationWhere(cqn.SELECT.where)
 
-  return { cqn: getEnrichedCQN(cqn, req.query.SELECT, []), scenario: 'ALL_INACTIVE' }
+  return { cqn: getEnrichedCQN(cqn, req.query.SELECT, []), scenario: SCENARIO.ALL_INACTIVE }
 }
 
 const _setRefAlias = (ref, as) => {
@@ -361,7 +368,7 @@ const _buildOrderBy = (query, columns, table) => {
   }
 }
 
-const _allActive = (req, columns) => {
+const _allActive = (req, columns, model) => {
   const { table } = _getTableName(req)
   if (!table.as) {
     table.as = 'active'
@@ -405,12 +412,20 @@ const _allActive = (req, columns) => {
     }
   }
 
+  const scenarioAlias = 'active'
+
+  req.query.SELECT.where = _getWhereWithAppendedDraftRestrictions(req.query.SELECT.where, req, scenarioAlias, model)
+
   if (req.query.SELECT.where) {
     _buildWhere(req.query.SELECT.where, table)
   }
+
   _buildOrderBy(req.query, cqn.SELECT.columns, table)
 
-  return { cqn: getEnrichedCQN(cqn, req.query.SELECT, req.query.SELECT.where, 'active'), scenario: 'ALL_ACTIVE' }
+  return {
+    cqn: getEnrichedCQN(cqn, req.query.SELECT, req.query.SELECT.where, scenarioAlias),
+    scenario: SCENARIO.ALL_ACTIVE
+  }
 }
 
 const _active = (req, draftWhere, columns) => {
@@ -420,7 +435,9 @@ const _active = (req, draftWhere, columns) => {
 
   const cqn = SELECT.from(table).columns(...outerMostColumns)
 
-  return { cqn: getEnrichedCQN(cqn, req.query.SELECT, draftWhere), scenario: 'ACTIVE' }
+  draftWhere = _getWhereWithAppendedDraftRestrictions(draftWhere, req)
+
+  return { cqn: getEnrichedCQN(cqn, req.query.SELECT, draftWhere), scenario: SCENARIO.ACTIVE }
 }
 
 const _activeWithoutDraft = (req, draftWhere, columns) => {
@@ -448,7 +465,9 @@ const _activeWithoutDraft = (req, draftWhere, columns) => {
     .columns(...outerMostColumns)
     .where(['not exists', subSelect])
 
-  return { cqn: getEnrichedCQN(cqn, req.query.SELECT, draftWhere), scenario: 'ACTIVE_WITHOUT_DRAFT' }
+  draftWhere = _getWhereWithAppendedDraftRestrictions(draftWhere, req)
+
+  return { cqn: getEnrichedCQN(cqn, req.query.SELECT, draftWhere), scenario: SCENARIO.ACTIVE_WITHOUT_DRAFT }
 }
 
 const _draftOfWhichIAmOwner = (req, draftWhere, columns) => {
@@ -468,9 +487,7 @@ const _draftOfWhichIAmOwner = (req, draftWhere, columns) => {
     ])
     .where(_inProcessByUserWhere(req.user.id))
 
-  removeAnnotationWhere(draftWhere)
-
-  return { cqn: getEnrichedCQN(cqn, req.query.SELECT, draftWhere), scenario: 'DRAFT_WHICH_OWNER' }
+  return { cqn: getEnrichedCQN(cqn, req.query.SELECT, draftWhere), scenario: SCENARIO.DRAFT_WHICH_OWNER }
 }
 
 const _activeWithDraftInProcess = (req, draftWhere, columns, isLocked) => {
@@ -503,7 +520,7 @@ const _activeWithDraftInProcess = (req, draftWhere, columns, isLocked) => {
     'and',
     {
       func: 'seconds_between',
-      args: [{ ref: ['filterAdmin', 'LastChangeDateTime'] }, { ref: ['CURRENT_TIMESTAMP'] }]
+      args: [{ ref: ['filterAdmin', 'LastChangeDateTime'] }, 'CURRENT_TIMESTAMP']
     },
     isLocked ? '<' : '>',
     { val: DRAFT_CANCEL_TIMEOUT_IN_SEC }
@@ -514,11 +531,13 @@ const _activeWithDraftInProcess = (req, draftWhere, columns, isLocked) => {
     subSelect
   )
 
+  subSelect.SELECT.where = _getWhereWithAppendedDraftRestrictions(subSelect.SELECT.where, req)
+
   const outerMostColumns = _getOuterMostColumns(columns, draftColumns)
 
   const cqn = SELECT.from(active.table).columns(outerMostColumns).where(['exists', subSelect])
 
-  return { cqn: getEnrichedCQN(cqn, req.query.SELECT, draftWhere), scenario: 'DRAFT_IN_PROCESS' }
+  return { cqn: getEnrichedCQN(cqn, req.query.SELECT, draftWhere), scenario: SCENARIO.DRAFT_IN_PROCESS }
 }
 
 const _alignAliasForUnion = (table, as, select) => {
@@ -535,37 +554,27 @@ const _alignAliasForUnion = (table, as, select) => {
   return select
 }
 
-const _isKeyElement = (element, keys) => element.ref && keys.includes(element.ref[element.ref.length - 1])
-const _valExists = (i, length, where) => i < length - 2 && where[i + 2].val
-
-const _findKeysInWhereAndAddToResult = (where, keys, result) => {
-  for (let i = 0, length = where.length; i < length; i++) {
-    const element = where[i]
-    if (_isKeyElement(element, keys) && _valExists(i, length, where)) {
-      result[element.ref[element.ref.length - 1]] = where[i + 2].val
-      i = i + 2
-    }
-  }
-}
-
-const _findKeysInQuery = (query, keys) => {
-  const result = {}
-  if (query.SELECT && query.SELECT.where) {
-    const indexExists = query.SELECT.where.indexOf('exists')
-    if (indexExists !== -1) {
-      return _findKeysInQuery(query.SELECT.where[indexExists + 1], keys)
-    }
-
-    _findKeysInWhereAndAddToResult(query.SELECT.where, keys, result)
-  }
-  return result
+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])
+        }
+      }
+      return links
+    }, [])
+  return []
 }
 
-const _isFiltered = where => {
-  return where.some(element => {
-    return !(element in ['(', ')']) && element[SYMBOL_FROM_ANNOTATION] !== true
-  })
-}
+const _isFiltered = where => where.some(element => !(element in ['(', ')']))
 
 const _isDraftField = element => element.ref && element.ref.length > 1 && element.ref[0] === 'DraftAdministrativeData'
 
@@ -613,40 +622,112 @@ const _getWhereForActive = where => {
   return activeWhere
 }
 
-const _siblingEntity = (req, columns, model) => {
-  const unlocalizedEntity = model.definitions[ensureUnlocalized(req.target.name)]
-  const keys = _findKeysInQuery(req.query, Object.keys(unlocalizedEntity.keys))
-  const isSiblingActive = !keys.IsActiveEntity
-
-  const targetTable = isSiblingActive ? ensureNoDraftsSuffix(req.target.name) : ensureDraftsSuffix(req.target.name)
-  const columnCqnPartial = columns.map(col => {
-    const colName = col.ref ? col.ref[col.ref.length - 1] : col
-    return { ref: ['target', colName], as: colName }
-  })
-  columnCqnPartial.push({ ref: ['draftAdmin', 'InProcessByUser'], as: 'draftAdmin_inProcessByUser' })
-  const cqn = SELECT.from(`${targetTable} as target`).columns(...columnCqnPartial)
+const _siblingEntity = ({ query, target, nav, params }, columns, model, draftAdminAlias, parentQuery, siblingIndex) => {
+  const parentLinks = parentQuery ? _findJoinInQuery(query, parentQuery.SELECT.from.as) : []
+  const keys = (nav[siblingIndex + 1].where && (params[siblingIndex] || params[0])) || {}
+  const siblingQuery = query.SELECT.where[query.SELECT.where.indexOf('exists') + 1]
+  const onCond = _findJoinInQuery(siblingQuery, target.as)
+  const siblingAlias = siblingQuery.SELECT.from.as
+  const subScenario = _siblingSubScenario(nav, siblingIndex, siblingQuery, target, params, model, onCond)
+  const isSiblingDraft = subScenario
+    ? subScenario.isSiblingActive || subScenario.scenario === 'ACTIVE' || subScenario.scenario === 'ALL_ACTIVE'
+    : keys.IsActiveEntity && keys.IsActiveEntity !== 'false'
+  const { table } = _getTableName({ query, target }, isSiblingDraft)
+  const cqn = SELECT.from(table)
+  if (siblingIndex === 0) {
+    const columnCqnPartial = columns.map(col => {
+      const colName = col.ref ? col.ref[col.ref.length - 1] : col
+      const ref = col.ref ? [table.as, ...col.ref] : [table.as, colName]
+      return Object.assign({}, col, { ref })
+    })
+    columnCqnPartial.push({ ref: ['draftAdmin', 'InProcessByUser'], as: 'draftAdmin_inProcessByUser' })
+    cqn.columns(...columnCqnPartial)
+  } else {
+    cqn.columns([{ val: 1 }])
+  }
 
-  if (isSiblingActive) {
+  if (isSiblingDraft) {
     cqn
-      .join(ensureDraftsSuffix(req.target.name), 'target_draft')
-      .on(
-        Object.keys(keys)
-          .map(k => `target.${k} = target_draft.${k}`)
-          .join(' AND ')
-      )
+      .join(ensureNoDraftsSuffix(target.name), siblingAlias)
+      .on(onCond)
       .join('DRAFT.DraftAdministrativeData', 'draftAdmin')
-      .on('target_draft.DraftAdministrativeData_DraftUUID = draftAdmin.DraftUUID')
+      .on(`${table.as}.DraftAdministrativeData_DraftUUID = draftAdmin.DraftUUID`)
   } else {
     cqn
+      .join(ensureDraftsSuffix(target.name), siblingAlias)
+      .on(onCond)
       .join('DRAFT.DraftAdministrativeData', 'draftAdmin')
-      .on('target.DraftAdministrativeData_DraftUUID = draftAdmin.DraftUUID')
+      .on(`${siblingAlias}.DraftAdministrativeData_DraftUUID = draftAdmin.DraftUUID`)
   }
 
   for (const key in keys) {
-    if (key !== 'IsActiveEntity') cqn.where([{ ref: ['target', key] }, '=', { val: keys[key] }])
+    if (key !== 'IsActiveEntity') cqn.where([{ ref: [table.as, key] }, '=', { val: keys[key] }])
+  }
+  if (subScenario) {
+    cqn.where(['exists', subScenario.cqn])
+  }
+  // in DraftAdminData scenario parent is linked via join
+  if (draftAdminAlias) {
+    cqn.where([{ ref: [draftAdminAlias, 'DraftUUID'] }, '=', { ref: ['draftAdmin', 'DraftUUID'] }])
+  } else if (parentLinks.length) {
+    cqn.where('(', ...parentLinks, ')')
+  }
+
+  return { cqn, scenario: SCENARIO.SIBLING_ENTITY, isSiblingActive: !isSiblingDraft }
+}
+
+function _siblingSubScenario(nav, siblingIndex, siblingQuery, target, params, model, onCond) {
+  if (nav[siblingIndex + 1].where) return
+  let subScenario
+  const subNav = nav.slice(siblingIndex + 1)
+  const subSiblingIndex = subNav.indexOf('SiblingEntity')
+  const subReq = { query: siblingQuery, target: model.definitions[target.name], params: [...params].reverse() }
+  if (subSiblingIndex > -1) {
+    subScenario = _getSiblingScenario(subReq, [{ val: 1 }], model, subSiblingIndex, subNav, params)
+    if (subSiblingIndex > 0) {
+      const subQuery = SELECT.from(siblingQuery.SELECT.from).columns([{ val: 1 }])
+      _mergeSiblingIntoCQN(subQuery, subScenario, subSiblingIndex - 1)
+      subQuery.where(onCond)
+      subScenario.cqn = subQuery
+    }
+  } else {
+    subReq.query = SELECT.from(siblingQuery.SELECT.from).columns([{ val: 1 }])
+    const existsIdx = siblingQuery.SELECT.where.indexOf('exists')
+    if (existsIdx > -1) subReq.query.where(siblingQuery.SELECT.where.slice(existsIdx, existsIdx + 2))
+    const subReqOrig = { query: { SELECT: { from: { ref: [...subNav].reverse() } } } }
+    subScenario = _generateCQN(subReqOrig, subReq, [{ val: 1 }], model)
+    subScenario.cqn.where(onCond)
+  }
+  return subScenario
+}
+
+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)
+      }
+    }
+    const target = { name: query.SELECT.from.ref[0].id || query.SELECT.from.ref[0], as: query.SELECT.from.as }
+    return _siblingEntity({ query, target, params, nav }, columns, model, draftAdminAlias, parentQuery, siblingIndex)
   }
+  return _getSiblingQueryFromWhere(req.query, siblingIndex)
+}
 
-  return { cqn, scenario: 'SIBLING_ENTITY', isSiblingActive: isSiblingActive }
+const _mergeSiblingIntoCQN = (cqn, { cqn: siblingCQN }, siblingIndex) => {
+  const _replaceWhereExists = (query, _siblingIndex) => {
+    if (query.SELECT && query.SELECT.where) {
+      const indexExists = query.SELECT.where.indexOf('exists')
+      if (indexExists > -1) {
+        if (_siblingIndex > 0) return _replaceWhereExists(query.SELECT.where[indexExists + 1], _siblingIndex - 1)
+        query.SELECT.where.splice(indexExists + 1, 1, siblingCQN)
+      }
+    }
+  }
+  return _replaceWhereExists(cqn, siblingIndex)
 }
 
 const _getDraftDoc = (req, draftName, draftWhere) => {
@@ -705,7 +786,7 @@ const _getUnionCQN = (req, draftName, columns, subSelect, draftWhere) => {
   const activeDocs = getEnrichedCQN(SELECT.from(req.target), req.query.SELECT, draftActiveWhere, undefined, false)
 
   _replaceDraftAlias(draftWhere)
-  const draftDocs = _getDraftDoc(req, draftName, removeAnnotationWhere(draftWhere))
+  const draftDocs = _getDraftDoc(req, draftName, draftWhere)
 
   const union = SELECT.from({ SET: { op: 'union', all: true, args: [draftDocs, activeDocs] } })
   if (req.query.SELECT.count) union.SELECT.count = true
@@ -730,17 +811,22 @@ const _getUnionCQN = (req, draftName, columns, subSelect, draftWhere) => {
   const enrichedColumns = _getOrderByEnrichedColumns(req.query.SELECT.orderBy, columns)
 
   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
+    const element = getElementDeep(req.target, col.ref)
+    if (element && element['@odata.foreignKey4']) columns.push({ ref: [...col.ref] })
+
     col.as = _poorMansAlias4(col)
     // add alias to outer order by
     const ob = req.query.SELECT.orderBy.find(ele => _poorMansAlias4(ele) === col.as)
     ob.ref = [col.as]
   }
 
-  draftDocs.columns(
+  const draftColumns = [
     ...addColumnAlias([...columns, ...enrichedColumns], req.query.SELECT.from.as || draftName),
     ..._filterDraftColumnsBySelected(DRAFT_COLUMNS_CASTED, req.query.SELECT.columns),
     'DraftAdministrativeData_DraftUUID'
-  )
+  ]
+  draftDocs.columns(draftColumns)
 
   const activeName = activeDocs.SELECT.from.as || (activeDocs.SELECT.from.ref && activeDocs.SELECT.from.ref[0])
 
@@ -751,19 +837,20 @@ const _getUnionCQN = (req, draftName, columns, subSelect, draftWhere) => {
     hasDraftWhere.push({ ref: [activeName, key] }, '=', { ref: [draftName, key] })
   }
 
-  activeDocs
-    .columns(
-      ...columns,
-      ...enrichedColumns,
-      ..._filterDraftColumnsBySelected(
-        _getDraftPropertiesDetermineDraft(req, hasDraftWhere, ensureDraftsSuffix(req.target.name), true),
-        req.query.SELECT.columns
-      )
+  const activeColumns = [
+    ...columns,
+    ...enrichedColumns,
+    ..._filterDraftColumnsBySelected(
+      _getDraftPropertiesDetermineDraft(req, hasDraftWhere, ensureDraftsSuffix(req.target.name), true),
+      req.query.SELECT.columns
     )
-    .where([
-      'not exists',
-      _alignAliasForUnion(ensureNoDraftsSuffix(req.target.name), req.query.SELECT.from.as, subSelect)
-    ])
+  ]
+  activeDocs.columns(activeColumns)
+
+  activeDocs.where([
+    'not exists',
+    _alignAliasForUnion(ensureNoDraftsSuffix(req.target.name), req.query.SELECT.from.as, subSelect)
+  ])
 
   // groupBy, orderBy and limit do not support partial CQNs
   if (req.query.SELECT.groupBy) {
@@ -802,6 +889,8 @@ const _excludeActiveDraftExists = (req, draftWhere, columns) => {
     subSelect.where([{ ref: [ensureNoDraftsSuffix(req.target.name), key] }, '=', { ref: [draftName, key] }])
   }
 
+  draftWhere = _getWhereWithAppendedDraftRestrictions(draftWhere, req)
+
   draftWhere = removeIsActiveEntityRecursively(draftWhere)
   const cqn = _getUnionCQN(req, draftName, columns, subSelect, draftWhere)
   cqn.SELECT.from.as = name
@@ -814,7 +903,7 @@ const _excludeActiveDraftExists = (req, draftWhere, columns) => {
     }
   }
 
-  return { cqn: cqn, scenario: 'UNION' }
+  return { cqn: cqn, scenario: SCENARIO.UNION }
 }
 
 const _readDraftParameters = where => {
@@ -858,37 +947,46 @@ const _validatedActive = (req, draftWhere, draftParameters, columns) =>
 const _validatedDraftOfWhichIAmOwner = (req, draftWhere, draftParameters, columns) =>
   _isValidDraftOfWhichIAmOwner(draftParameters.isActiveEntity) && _draftOfWhichIAmOwner(req, draftWhere, columns)
 
-const _draftInSubSelect = where => {
+const _draftInSubSelect = (where, req) => {
   return where.some(({ SELECT }) => {
     if (SELECT && SELECT.where) {
       const isActiveEntity = readAndDeleteKeywords(['IsActiveEntity'], SELECT.where, false)
       if (isActiveEntity) {
-        return _isFalse(isActiveEntity.value.val)
+        const isFalse = _isFalse(isActiveEntity.value.val)
+        if (isFalse) SELECT.where = _getWhereWithAppendedDraftRestrictions(SELECT.where, req)
+        return isFalse
       }
 
-      return _draftInSubSelect(SELECT.where)
+      return _draftInSubSelect(SELECT.where, req)
     }
 
     return false
   })
 }
 
-const _generateCQN = (reqOriginal, req, columns, serviceName, model) => {
-  // REVISIT: get rid of getUrlObject
-  if (req.getUrlObject && req.getUrlObject().path.endsWith('SiblingEntity')) {
-    return _siblingEntity(req, columns, model)
+const _isDraftAdminScenario = req =>
+  req.target.query && req.target.query._target && req.target.query._target.name === 'DRAFT.DraftAdministrativeData'
+
+// eslint-disable-next-line complexity
+const _generateCQN = (reqOriginal, req, columns, model) => {
+  const nav = [...reqOriginal.query.SELECT.from.ref].reverse() || []
+  const siblingIndex = nav.indexOf('SiblingEntity')
+  let siblingScenario
+  if (siblingIndex > -1) {
+    siblingScenario = _getSiblingScenario(req, columns, model, siblingIndex, nav)
+    if (siblingIndex === 0) {
+      return siblingScenario
+    } else {
+      _mergeSiblingIntoCQN(req.query, siblingScenario, siblingIndex - 1)
+    }
   }
 
-  if (
-    req.target.query &&
-    req.target.query._target &&
-    req.target.query._target.name === 'DRAFT.DraftAdministrativeData'
-  ) {
+  if (_isDraftAdminScenario(req)) {
     return _draftAdminTable(req)
   }
 
   if (!req.query.SELECT.where || !_isFiltered(req.query.SELECT.where)) {
-    return _allActive(req, columns)
+    return _allActive(req, columns, model)
   }
 
   if (req.query.SELECT.where.length === 1 && req.query.SELECT.where[0].xpr) {
@@ -908,8 +1006,11 @@ const _generateCQN = (reqOriginal, req, columns, serviceName, model) => {
   }
 
   if (!draftParameters.isActiveEntity) {
-    if (_draftInSubSelect(req.query.SELECT.where)) {
-      return _allInactive(req, columns, model)
+    // _draftInSubSelect adds draft restrictions in case check is truthy
+    // -> not nice but works for now and we don't need to go in recursively again
+    if (_draftInSubSelect(req.query.SELECT.where, req) || (siblingScenario && !siblingScenario.isSiblingActive)) {
+      // this is only the case when navigating into tree
+      return _allInactive(req, columns)
     }
     return _allActive(req, columns)
   }
@@ -936,52 +1037,39 @@ const _getColumns = ({ query: { SELECT } }, model) => {
       )
     : getColumns(model.definitions[ensureNoDraftsSuffix(SELECT.from.ref[0])], {
         onlyNames: true,
-        removeIgnore: true,
-        filterVirtual: true
+        removeIgnore: true
       })
 }
 
-const _isIsActiveEntity = element =>
-  element.ref &&
-  (element.ref[0] === 'IsActiveEntity' || (element.ref.length > 1 && element.ref[1] === 'IsActiveEntity'))
+const _isIsActiveEntity = element => element.ref && element.ref[element.ref.length - 1] === 'IsActiveEntity'
 
 const _adaptSubSelects = ({ SELECT: { from, where } }, scenario) => {
-  if (!where) {
-    return
-  }
-
-  let indexDel = -1
+  if (!where) return
 
   if (scenario === 'ALL_INACTIVE') {
     replaceRefWithDraft(from.ref)
   }
-  let _removeAnnotationWhere = false
 
-  for (let i = 0, len = where.length; i < len; i++) {
+  for (let i = 0; i < where.length; i++) {
     const element = where[i]
 
-    if (_isIsActiveEntity(element) && len > i + 2) {
-      if (scenario !== 'ALL_INACTIVE' && _isFalse(where[i + 2].val)) {
-        replaceRefWithDraft(from.ref)
-        _removeAnnotationWhere = true
-        // read from draft table because draft has draftUUID
-      } else if (scenario === 'DRAFT_ADMIN' && !_isFalse(where[i + 2].val)) {
+    if (_isIsActiveEntity(element) && where.length > i + 2) {
+      if (
+        (scenario !== 'ALL_INACTIVE' && _isFalse(where[i + 2].val)) ||
+        (scenario === SCENARIO.DRAFT_ADMIN && !_isFalse(where[i + 2].val))
+      ) {
         replaceRefWithDraft(from.ref)
-        _removeAnnotationWhere = true
       }
 
-      indexDel = i
-    }
-
-    if (element.SELECT) {
+      if (!_isIsActiveEntity(where[i + 2])) {
+        i = deleteCondition(i, where) - 1
+      } else {
+        i = i + 3 < where.length ? i + 2 : i + 3
+      }
+    } else if (element.SELECT) {
       _adaptSubSelects(element, scenario)
     }
   }
-
-  if (indexDel !== -1) {
-    deleteCondition(indexDel, where)
-  }
-  if (_removeAnnotationWhere) removeAnnotationWhere(where)
 }
 
 const _calculateDraftAdminColumns = (result, user) => {
@@ -1006,16 +1094,6 @@ const _adaptDraftColumnsForSiblingEntity = (result, isSiblingActive) => {
   result.HasActiveEntity = !isSiblingActive
 }
 
-const _addAlias = (whereElement, aliases) => {
-  if (whereElement.ref) {
-    const table = whereElement.ref[0].replace(/\./g, '_')
-    const alias = aliases.get(table)
-    if (alias) {
-      whereElement.ref.splice(0, 1, aliases.get(table))
-    }
-  }
-}
-
 const _collectAliases = (from, aliases) => {
   if (from) {
     if (from.ref && from.as) {
@@ -1034,39 +1112,13 @@ const _collectAliases = (from, aliases) => {
   }
 }
 
-const _adaptAliasForSubSelect = (subselect, aliases) => {
-  if (subselect.where) {
-    for (const whereElement of subselect.where) {
-      if (whereElement.ref) {
-        _addAlias(whereElement, aliases)
-      }
-
-      if (whereElement.SELECT) {
-        _adaptAliasForSubSelect(whereElement.SELECT, aliases)
-      }
-    }
-  }
-}
-
 const _adaptAnnotationAliases = cqn => {
   const aliases = new Map()
   _collectAliases(cqn.SELECT.from, aliases)
-
-  if (cqn.SELECT.where) {
-    for (const whereElement of cqn.SELECT.where) {
-      if (
-        whereElement.SELECT &&
-        whereElement.SELECT.from.ref &&
-        whereElement.SELECT.from.ref[SYMBOL_FROM_ANNOTATION] === true
-      ) {
-        _adaptAliasForSubSelect(whereElement.SELECT, aliases)
-      }
-    }
-  }
 }
 
 const calculateDraftTimeout = (scenario, result, deleteLastChangeDateTime) => {
-  if (scenario === 'DRAFT_ADMIN') {
+  if (scenario === SCENARIO.DRAFT_ADMIN) {
     if (!draftIsLocked(result[0].LastChangeDateTime)) {
       result[0].InProcessByUser = ''
     }
@@ -1090,12 +1142,12 @@ const calculateDraftTimeout = (scenario, result, deleteLastChangeDateTime) => {
 }
 
 const enhanceQueryForTimeoutIfNeeded = (scenario, columns = []) => {
-  if (scenario !== 'DRAFT_ADMIN') {
+  if (scenario !== SCENARIO.DRAFT_ADMIN) {
     const draftAdmin = columns.find(col => col.ref && col.ref[col.ref.length - 1] === 'DraftAdministrativeData')
     columns = (draftAdmin && draftAdmin.expand) || []
   }
-  const inProcessByUser = columns.find(col => col.ref[col.ref.length - 1] === 'InProcessByUser')
-  const lastChangeDateTime = columns.find(col => col.ref[col.ref.length - 1] === 'LastChangeDateTime')
+  const inProcessByUser = columns.find(col => col.ref && col.ref[col.ref.length - 1] === 'InProcessByUser')
+  const lastChangeDateTime = columns.find(col => col.ref && col.ref[col.ref.length - 1] === 'LastChangeDateTime')
   if (inProcessByUser && !lastChangeDateTime) {
     columns.push({ ref: [...inProcessByUser.ref.slice(0, inProcessByUser.ref.length - 1), 'LastChangeDateTime'] })
     return true
@@ -1107,7 +1159,11 @@ const enhanceQueryForTimeoutIfNeeded = (scenario, columns = []) => {
 const _getLocalizedEntity = (model, target, user) => {
   const prefix = 'localized'
   let localizedEntity
-  if (user.locale === 'de' || user.locale === 'fr') {
+  /*
+   * REVISIT: in case of not sqlite, model.definitions[`${prefix}.${user.locale}.${target.name}`] is undefined
+   * and the fallback lookup model.definitions[`${prefix}.${target.name}`] gets the entity -> bad coding
+   */
+  if (cds.env.i18n.for_sqlite.includes(user.locale)) {
     localizedEntity = model.definitions[`${prefix}.${user.locale}.${target.name}`]
   }
   return localizedEntity || model.definitions[`${prefix}.${target.name}`]
@@ -1118,12 +1174,10 @@ const _getLocalizedEntity = (model, target, user) => {
  *
  * @param req
  */
+// eslint-disable-next-line complexity
 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
-  if (req.query.SELECT.limit && req.query.SELECT.limit.rows && req.query.SELECT.limit.rows.val === 0) {
-    return Promise.resolve([])
-  }
 
   // REVISIT
   delete req.query._validationQuery
@@ -1134,18 +1188,22 @@ const _handler = async function (req) {
   // do not clone with Object.assign as that would skip all non-enumerable properties
   const reqClone = { __proto__: req, query: _copyCQNPartial(sqlQuery) }
 
+  // ensure draft restrictions are copied to new query
+  reqClone.query._draftRestrictions = req.query._draftRestrictions
+
   if (req.query._streaming) {
     adaptStreamCQN(reqClone.query)
     reqClone.query._streaming = true
     return cds.tx(req).run(reqClone.query)
   }
-  const virtuals = removeVirtuals(reqClone, this.model)
-  const cqnScenario = _generateCQN(req, reqClone, _getColumns(reqClone, this.model), this.name, this.model)
+
+  const cqnScenario = _generateCQN(req, reqClone, _getColumns(reqClone, this.model), this.model)
 
   if (!cqnScenario) {
     req.reject(400)
     return
   }
+
   const enhacnedWithLastChangeDateTime = enhanceQueryForTimeoutIfNeeded(
     cqnScenario.scenario,
     cqnScenario.cqn.SELECT.columns
@@ -1157,13 +1215,14 @@ const _handler = async function (req) {
 
   // 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).run(cqnScenario.cqn)
+
+  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 === 'DRAFT_ADMIN') {
+  if (cqnScenario.scenario === SCENARIO.DRAFT_ADMIN) {
     if (!result || (Array.isArray(result) && !result.length)) return result
 
     _calculateDraftAdminColumns(resultAsArray[0], req.user.id)
@@ -1171,12 +1230,9 @@ const _handler = async function (req) {
 
   calculateDraftTimeout(cqnScenario.scenario, resultAsArray, enhacnedWithLastChangeDateTime)
 
-  if (cqnScenario.scenario === 'SIBLING_ENTITY') {
+  if (cqnScenario.scenario === SCENARIO.SIBLING_ENTITY) {
     if (!result || (Array.isArray(result) && !result.length)) return result
-
-    if (resultAsArray[0].draftAdmin_inProcessByUser !== req.user.id) {
-      return []
-    }
+    if (resultAsArray[0].draftAdmin_inProcessByUser !== req.user.id) return []
 
     delete resultAsArray[0].draftAdmin_inProcessByUser
     _adaptDraftColumnsForSiblingEntity(resultAsArray[0], cqnScenario.isSiblingActive)
@@ -1187,7 +1243,7 @@ const _handler = async function (req) {
       row.DraftAdministrativeData && _calculateDraftAdminColumns(row.DraftAdministrativeData, req.user.id)
     })
   }
-  postProcessVirtuals(virtuals, resultAsArray)
+
   return result
 }