@sap/cds 5.4.6 → 5.5.0

package/libx/_runtime/db/expand/expandCQNToJoin.js

@@ -1,9 +1,7 @@
 const cds = require('../../cds')
 
-const getColumns = require('../utils/columns')
 const { getAllKeys } = require('../../cds-services/adapter/odata-v4/odata-to-cqn/utils')
 const { getOnCond } = require('../../common/utils/generateOnCond')
-const sqliteLocales = ['de', 'fr']
 
 const { getNavigationIfStruct } = require('../../common/utils/structured')
 const { ensureNoDraftsSuffix, ensureDraftsSuffix, ensureUnlocalized } = require('../../common/utils/draft')
@@ -12,6 +10,7 @@ const { filterKeys } = require('../../fiori/utils/handler')
 // Symbols are used to add extra information in response structure
 const GET_KEY_VALUE = Symbol.for('sap.cds.getKeyValue')
 const TO_MANY = Symbol.for('sap.cds.toMany')
+const TO_ACTIVE = Symbol.for('sap.cds.toActive')
 
 const SKIP_MAPPING = Symbol.for('sap.cds.skipMapping')
 const IDENTIFIER = Symbol.for('sap.cds.identifier')
@@ -19,15 +18,14 @@ const IS_ACTIVE = Symbol.for('sap.cds.isActive')
 const IS_UNION_DRAFT = Symbol.for('sap.cds.isUnionDraft')
 const { DRAFT_COLUMNS } = require('../../common/constants/draft')
 
-// REVISIT: remove everywhere
-const SYMBOL_FROM_ANNOTATION = Symbol.for('sap.cds.FROM_ANNOTATION')
+const { getCQNUnionFrom } = require('../../common/utils/union')
 
 class JoinCQNFromExpanded {
-  constructor(cqn, csn, useWindow, locale) {
-    this._useWindow = useWindow
+  constructor(cqn, csn, locale) {
     this._SELECT = Object.assign({}, cqn.SELECT)
     this._csn = csn
-    if (sqliteLocales.includes(locale)) {
+    // REVISIT: locale is only passed in case of sqlite -> bad coding
+    if (cds.env.i18n.for_sqlite.includes(locale)) {
       this._locale = locale
     }
     this.queries = []
@@ -93,24 +91,42 @@ class JoinCQNFromExpanded {
    * @private
    */
   _createJoinCQNFromExpanded(SELECT, toManyTree, defaultLanguage) {
+    const unionArgs = SELECT.from.args
+    const isJoinOfTwoUnions = unionArgs && unionArgs.every(a => a.SELECT)
+
     const unionTableRef = this._getUnionTable(SELECT)
     const unionTable = unionTableRef && unionTableRef.table
     const tableAlias = this._getTableAlias(SELECT, toManyTree, unionTable)
-    const readToOneCQN = this._getReadToOneCQN(SELECT, tableAlias)
-    const table = unionTable || this._getRef(SELECT).table
-    const isDraftTree = this._isDraftTree(table)
-    const entity = this._getEntityForTable(table)
 
-    if (unionTable) {
-      readToOneCQN[IS_UNION_DRAFT] = true
-    }
+    const readToOneCQN = this._getReadToOneCQN(SELECT, isJoinOfTwoUnions ? 'filterExpand' : tableAlias)
+
+    if (isJoinOfTwoUnions) {
+      // mappings
+      const mappings = this._getMappingObject(toManyTree)
+      const prefix = `${tableAlias}_`
+      SELECT.columns
+        .filter(c => c.as && c.as.startsWith(prefix) && c[SKIP_MAPPING] !== true)
+        .forEach(c => {
+          mappings[c.as.replace(prefix, '')] = c.as
+        })
+      // expand to one
+      const entity = this._csn.definitions[unionArgs[0].SELECT.from.SET.args[1].SELECT.from.ref[0]]
+      const givenColumns = readToOneCQN.columns
+      readToOneCQN.columns = []
+      this._expandedToFlat({ entity, givenColumns, readToOneCQN, tableAlias, toManyTree, defaultLanguage })
+    } else {
+      const table = unionTable || this._getRef(SELECT).table
+      const isDraftTree = this._isDraftTree(table)
+      const entity = this._getEntityForTable(table)
 
-    readToOneCQN[IS_ACTIVE] = isDraftTree ? this._isDraftTargetActive(table) : true
+      if (unionTable) readToOneCQN[IS_UNION_DRAFT] = true
 
-    const givenColumns = readToOneCQN.columns
-    readToOneCQN.columns = []
+      readToOneCQN[IS_ACTIVE] = isDraftTree ? this._isDraftTargetActive(table) : true
 
-    this._expandedToFlat({ entity, givenColumns, readToOneCQN, tableAlias, toManyTree, defaultLanguage })
+      const givenColumns = readToOneCQN.columns
+      readToOneCQN.columns = []
+      this._expandedToFlat({ entity, givenColumns, readToOneCQN, tableAlias, toManyTree, defaultLanguage })
+    }
 
     // Add at start, so that the deepest level is post processed first
     this.queries.push({
@@ -207,7 +223,7 @@ class JoinCQNFromExpanded {
     const cqn = Object.assign({}, SELECT, { from: Object.assign({}, SELECT.from) })
 
     if (Object.prototype.hasOwnProperty.call(cqn.from, 'join')) {
-      this._adaptJoin(tableAlias, cqn)
+      this._adaptJoin(tableAlias, cqn, cqn.from)
     } else {
       if (cqn.from.SET) {
         cqn.from.SET = Object.assign({}, cqn.from.SET, { args: this._adaptUnionArgs(cqn.from.SET.args) })
@@ -225,16 +241,19 @@ class JoinCQNFromExpanded {
       : column
   }
 
-  _adaptJoin(tableAlias, cqn) {
-    cqn.from.args = cqn.from.args.slice(0)
-
-    const index = cqn.from.args[0].ref ? 0 : cqn.from.args.length - 1
-    const target = Object.assign({}, cqn.from.args[index], { as: tableAlias })
-    const originalIdentifier = cqn.from.args[index].as || cqn.from.args[index].ref[0]
+  _adaptJoin(tableAlias, cqn, from) {
+    from.args = from.args.slice(0)
+    if (Object.prototype.hasOwnProperty.call(from.args[0], 'join')) {
+      this._adaptJoin(tableAlias, cqn, from.args[0])
+    } else {
+      const index = from.args[0].ref ? 0 : from.args.length - 1
+      const target = Object.assign({}, from.args[index], { as: tableAlias })
+      const originalIdentifier = from.args[index].as || from.args[index].ref[0]
 
-    cqn.from.args[index] = target
-    cqn.from.on = cqn.from.on.map(column => this._adaptTableNameInColumn(column, originalIdentifier, tableAlias))
-    cqn.columns = cqn.columns.map(column => this._adaptTableNameInColumn(column, originalIdentifier, tableAlias))
+      from.args[index] = target
+      from.on = from.on.map(column => this._adaptTableNameInColumn(column, originalIdentifier, tableAlias))
+      cqn.columns = cqn.columns.map(column => this._adaptTableNameInColumn(column, originalIdentifier, tableAlias))
+    }
   }
 
   _adaptUnionArgs(args) {
@@ -293,11 +312,6 @@ class JoinCQNFromExpanded {
     return cqn
   }
 
-  _addAliasAndDeleteSymbol(whereElement) {
-    this._addAlias(whereElement)
-    delete whereElement.ref[SYMBOL_FROM_ANNOTATION]
-  }
-
   _addAlias(whereElement) {
     whereElement.ref && whereElement.ref.splice(0, 1, Object.values(this._aliases)[0])
   }
@@ -318,10 +332,6 @@ class JoinCQNFromExpanded {
   _adaptAliasForWhere(where) {
     if (where) {
       for (const whereElement of where) {
-        if (whereElement.ref && whereElement.ref[SYMBOL_FROM_ANNOTATION] === true) {
-          this._addAliasAndDeleteSymbol(whereElement)
-        }
-
         if (whereElement.SELECT) {
           if (whereElement.SELECT.where) {
             this._adaptAliasForWhere(whereElement.SELECT.where)
@@ -473,17 +483,28 @@ class JoinCQNFromExpanded {
     for (const column of givenColumns) {
       let navigation
       if (column.expand) {
-        navigation = getNavigationIfStruct(entity, column.ref)
+        navigation = getNavigationIfStruct(entity, tableAlias === column.ref[0] ? column.ref.slice(1) : column.ref)
         if (this._skip(navigation && navigation._target)) continue
       }
 
-      // To many can only be build, once all other columns have been processed.
       if (this._isExpandToMany(column, entity, navigation)) {
-        mappings[column.ref[0]] = { [TO_MANY]: true }
+        // To many can only be build, once all other columns have been processed.
+        const trgt = column.ref[column.ref.length - 1]
+        mappings[trgt] = { [TO_MANY]: true }
+        if (entity._isDraftEnabled && entity.elements[trgt]._isAssociationStrict) mappings[trgt][TO_ACTIVE] = true
         toManyColumns.push({ parentAlias: tableAlias, column: column })
-
-        // Expands with to one target can be processed directly
       } else if (typeof column.expand === 'object') {
+        // Expands with to one target can be processed directly
+        const navProp = column.ref[column.ref.length - 1]
+        const navTarget = entity.elements[navProp]
+        if (
+          entity._isDraftEnabled &&
+          navTarget._isAssociationStrict &&
+          !navTarget['@odata.draft.enclosed'] &&
+          navTarget.name !== 'DraftAdministrativeData'
+        ) {
+          mappings[navProp] = { [TO_ACTIVE]: true }
+        }
         this._addJoinAndElements({
           column,
           entity,
@@ -529,15 +550,10 @@ class JoinCQNFromExpanded {
    */
   _getMappingObject(toManyTree) {
     let mappings = this.mappings
-
     for (const element of toManyTree) {
-      if (!mappings[element]) {
-        mappings[element] = {}
-      }
-
+      if (!mappings[element]) mappings[element] = {}
       mappings = mappings[element]
     }
-
     return mappings
   }
 
@@ -588,6 +604,7 @@ class JoinCQNFromExpanded {
    * @param args.defaultLanguage
    * @private
    */
+  // eslint-disable-next-line complexity
   _addJoinAndElements({ column, entity, readToOneCQN, toManyTree, parentAlias, defaultLanguage }) {
     const extendedToManyTree = toManyTree.concat(column.ref)
     const tableAlias = this._createAlias(extendedToManyTree.join(':'))
@@ -608,29 +625,52 @@ class JoinCQNFromExpanded {
       entity['@cds.localized'] === false ||
       (colTarget && this._csn.definitions[colTarget] && this._csn.definitions[colTarget]['@cds.localized'] === false)
 
-    // TODO: If draft union and composition target add union as to be joined
+    const join =
+      column.ref[0] === 'DraftAdministrativeData' || !entity.elements[column.ref[0]].notNull || this._isDraft
+        ? 'left'
+        : 'inner'
+
+    const args = [
+      readToOneCQN.from.SET ? this._unionToSubQuery(readToOneCQN) : readToOneCQN.from,
+      {
+        ref: [this._refFromRefByExpand(column.ref[0], colTarget, defaultLanguageThis, activeTableRequired)],
+        as: tableAlias
+      }
+    ]
+
     readToOneCQN.from = {
-      args: [
-        readToOneCQN.from.SET ? this._unionToSubQuery(readToOneCQN) : readToOneCQN.from,
-        {
-          ref: [this._refFromRefByExpand(column.ref[0], colTarget, defaultLanguageThis, activeTableRequired)],
-          as: tableAlias
+      join,
+      args,
+      on: null
+    }
+
+    const expandedEntity = this._getEntityForTable(target)
+    if (readToOneCQN[IS_UNION_DRAFT] && expandedEntity.drafts) {
+      const cols = column.expand.filter(c => !c.expand && !DRAFT_COLUMNS.includes(c.ref[0])).map(c => c.ref[0])
+      const ks = Object.keys(expandedEntity.keys).filter(
+        c => !expandedEntity.keys[c].isAssociation && !DRAFT_COLUMNS.includes(c)
+      )
+      const user = (cds.context && cds.context.user && cds.context.user.id) || 'anonymous'
+      const unionFrom = getCQNUnionFrom(cols, expandedEntity.name, expandedEntity.name + '.drafts', ks, user)
+      readToOneCQN.from.args[1] = {
+        SELECT: {
+          columns: cols,
+          from: unionFrom,
+          as: 'b'
         }
-      ],
-      join:
-        column.ref[0] === 'DraftAdministrativeData' || !entity.elements[column.ref[0]].notNull || this._isDraft
-          ? 'left'
-          : 'inner',
-      on: this._getOnCond(entity, column.ref, tableAlias, parentAlias, readToOneCQN)
+      }
     }
 
+    // note: set the on condition after the join kind and args are set
+    readToOneCQN.from.on = this._getOnCond(entity, column.ref, tableAlias, parentAlias, readToOneCQN)
+
     if (column.ref[0] !== 'DraftAdministrativeData') {
       this._addJoinKeyColumnsToUnion(readToOneCQN.from.args, readToOneCQN.from.on, parentAlias)
     }
 
     // special case of navigation to one requires additional LEFT JOIN and CASE for HasDraftEntity
     const compToOne = this._isNavigationToOne(readToOneCQN[IS_ACTIVE], entity.elements[column.ref[0]])
-    const index = column.expand.findIndex(col => col.ref[0] === 'HasDraftEntity')
+    const index = column.expand.findIndex(col => col.ref && col.ref[col.ref.length - 1] === 'HasDraftEntity')
 
     if (compToOne && index !== -1) {
       readToOneCQN.from = this._addJoinCompToOne(readToOneCQN.from, entity.elements[column.ref[0]], tableAlias)
@@ -659,25 +699,27 @@ class JoinCQNFromExpanded {
       }
     }
 
+    const givenColumns = column.expand.map(col => {
+      if (
+        activeTableRequired &&
+        col.ref &&
+        col.ref.length &&
+        (col.ref[0] === 'IsActiveEntity' || col.ref[0] === 'HasActiveEntity')
+      ) {
+        return {
+          val: col.ref[0] === 'IsActiveEntity',
+          as: col.ref[0],
+          cast: { type: 'cds.Boolean' }
+        }
+      }
+      return col
+    })
+
     this._expandedToFlat({
       entity: this._getEntityForTable(target),
-      givenColumns: column.expand.map(col => {
-        if (
-          activeTableRequired &&
-          col.ref &&
-          col.ref.length &&
-          (col.ref[0] === 'IsActiveEntity' || col.ref[0] === 'HasActiveEntity')
-        ) {
-          return {
-            val: col.ref[0] === 'IsActiveEntity',
-            as: col.ref[0],
-            cast: { type: 'cds.Boolean' }
-          }
-        }
-        return col
-      }),
-      readToOneCQN: readToOneCQN,
-      tableAlias: tableAlias,
+      givenColumns,
+      readToOneCQN,
+      tableAlias,
       toManyTree: extendedToManyTree,
       defaultLanguage: defaultLanguageThis
     })
@@ -774,10 +816,10 @@ class JoinCQNFromExpanded {
       return [{ ref: [tableAlias, 'DraftUUID'] }, '=', { ref: [parentAlias, 'DraftAdministrativeData_DraftUUID'] }]
     }
 
-    // No window function/ sub select
+    // No sub select
     const subSelectColumns = this._getSubSelectColumns(readToOneCQN)
 
-    const navigation = getNavigationIfStruct(entity, columns)
+    const navigation = getNavigationIfStruct(entity, tableAlias === columns[0] ? columns.slice(1) : columns)
     const onConditionOptions = {
       associationNames: columns,
       csn: this._csn,
@@ -903,7 +945,7 @@ class JoinCQNFromExpanded {
 
   _getIdentifier(column, tableAlias) {
     if (column.as) {
-      return column.as.startsWith(`${tableAlias}_`) ? column.ref[column.ref.length - 1] : column.as
+      return column.as.startsWith(`${tableAlias}_`) && column.ref ? column.ref[column.ref.length - 1] : column.as
     }
 
     return column.ref[column.ref.length - 1]
@@ -931,19 +973,16 @@ class JoinCQNFromExpanded {
     this._addKeysIfNeeded({ entity, readToOneCQN, tableAlias })
 
     for (const { column, parentAlias } of toManyColumns) {
-      this._createJoinCQNFromExpanded(
-        this._buildExpandedCQN({
-          column,
-          entity,
-          readToOneCQN,
-          toManyTree,
-          mappings,
-          parentAlias,
-          defaultLanguage
-        }),
-        toManyTree.concat([column.ref[0]]),
+      const select = this._buildExpandedCQN({
+        column,
+        entity,
+        readToOneCQN,
+        toManyTree,
+        mappings,
+        parentAlias,
         defaultLanguage
-      )
+      })
+      this._createJoinCQNFromExpanded(select, toManyTree.concat([column.ref[column.ref.length - 1]]), defaultLanguage)
     }
   }
 
@@ -1009,8 +1048,13 @@ class JoinCQNFromExpanded {
    * @returns {object}
    * @private
    */
+  // eslint-disable-next-line complexity
   _buildExpandedCQN({ column, entity, readToOneCQN, toManyTree, mappings, parentAlias, defaultLanguage }) {
-    const colTarget = ensureUnlocalized(entity.elements[column.ref[0]].target)
+    const isUnion = !!readToOneCQN.from.SET
+
+    const colRef = parentAlias === column.ref[0] ? column.ref.slice(1) : column.ref.slice(0)
+    const element = entity.elements[colRef[0]]
+    const colTarget = ensureUnlocalized(element.target)
     const defaultLanguageThis =
       defaultLanguage ||
       entity['@cds.localized'] === false ||
@@ -1018,25 +1062,24 @@ class JoinCQNFromExpanded {
 
     const expandActive =
       readToOneCQN[IS_ACTIVE] ||
-      (entity.elements[column.ref[0]].type === 'cds.Association' &&
-        !entity.elements[column.ref[0]]['@odata.draft.enclosed']) ||
+      (element.type === 'cds.Association' && !element['@odata.draft.enclosed']) ||
       !this._csn.definitions[colTarget]._isDraftEnabled
-    const ref = this._getJoinRef(entity.elements, column.ref[0], expandActive, defaultLanguageThis)
-    const tableAlias = this._createAlias(toManyTree.concat(column.ref).join(':'))
+    const ref = this._getJoinRef(entity.elements, colRef[0], expandActive, defaultLanguageThis)
+    const tableAlias = this._createAlias(toManyTree.concat(colRef).join(':'))
     const onConditionOptions = {
-      associationNames: column.ref[0],
+      associationNames: colRef[0],
       csn: this._csn,
       aliases: {
         select: tableAlias,
         join: 'filterExpand'
       }
     }
-    const on = getOnCond(entity.elements[column.ref[0]], onConditionOptions)
+    const on = getOnCond(element, onConditionOptions)
     const filterExpand = this._getFilterExpandCQN(readToOneCQN, on, parentAlias, entity.keys)
-    const expandedEntity = this._csn.definitions[ensureUnlocalized(entity.elements[column.ref[0]].target)]
-    const joinColumns = this._getJoinColumnsFromOnAddToMapping(mappings[column.ref[0]], parentAlias, on, entity)
+    const expandedEntity = this._csn.definitions[colTarget]
+    const joinColumns = this._getJoinColumnsFromOnAddToMapping(mappings[colRef[0]], parentAlias, on, entity)
 
-    const cqn = {
+    let cqn = {
       from: {
         join: 'inner',
         args: [{ ref: [ref], as: tableAlias }, filterExpand],
@@ -1065,11 +1108,52 @@ class JoinCQNFromExpanded {
       cqn.orderBy = this._copyOrderBy(column.orderBy, tableAlias, expandedEntity)
     }
 
-    if (column.limit && !this._useWindow) {
-      this._addLimitToCqn(cqn, column, tableAlias, expandedEntity)
+    if (column.limit) cqn.limit = column.limit
+
+    cqn = this._adaptWhereOrderBy(cqn, tableAlias)
+
+    if (isUnion) {
+      const cols = column.expand.filter(c => !c.expand && !DRAFT_COLUMNS.includes(c.ref[0])).map(c => c.ref[0])
+      // ensure the join columns are selected
+      for (const each of joinColumns) {
+        const col = each.ref[each.ref.length - 1]
+        if (!cols.includes(col)) cols.push(col)
+      }
+      // ensure the foreign keys are selected in case of expand to one
+      for (const each of cqn.columns) {
+        if (each.expand) {
+          const assoc = expandedEntity.associations[each.ref[0]]
+          if (assoc.is2one) {
+            const fks = Object.values(expandedEntity.elements).filter(ele => ele['@odata.foreignKey4'] === assoc.name)
+            cols.push(...fks.map(fk => fk.name))
+          }
+        }
+      }
+      const ks = Object.keys(expandedEntity.keys).filter(
+        c => !expandedEntity.keys[c].isAssociation && !DRAFT_COLUMNS.includes(c)
+      )
+      const user = (cds.context && cds.context.user && cds.context.user.id) || 'anonymous'
+      const unionFrom = getCQNUnionFrom(cols, ref.replace(/_drafts$/, ''), ref, ks, user)
+      for (const each of cqn.columns) {
+        if (!each.as) continue
+        // replace val with ref
+        if (each.as === 'IsActiveEntity' || each.as === 'HasActiveEntity') {
+          delete each.val
+          each.ref = [tableAlias, each.as]
+          each.as = tableAlias + '_' + each.as
+        }
+        // ensure the cast
+        if (each.as.match(/IsActiveEntity$/) || each.as.match(/HasActiveEntity$/) || each.as.match(/HasDraftEntity$/)) {
+          each.cast = { type: 'cds.Boolean' }
+        }
+      }
+      const cs = cqn.columns.filter(c => !c.expand && c.ref && c.ref[0] === tableAlias).map(c => ({ ref: [c.ref[1]] }))
+      const unionArgs = cqn.from.args
+      unionArgs[0].SELECT = { columns: cs, from: unionFrom, distinct: true }
+      delete unionArgs[0].ref
     }
 
-    return this._adaptWhereOrderBy(this._addWindowIfNeeded(cqn, column, tableAlias, expandedEntity), tableAlias)
+    return cqn
   }
 
   _getJoinRef(elements, column, isActive, defaultLanguage) {
@@ -1080,24 +1164,6 @@ class JoinCQNFromExpanded {
     return assoc.target + '_drafts'
   }
 
-  /**
-   * Solve limit by group with a sub select at the join clause.
-   *
-   * @param cqn
-   * @param column
-   * @param tableAlias
-   * @param expandedEntity
-   * @private
-   */
-  _addLimitToCqn(cqn, column, tableAlias, expandedEntity) {
-    const columns = this._getKeyColumnForTarget(tableAlias, cqn[IS_ACTIVE], expandedEntity)
-    const inSelect = this._getLimitInSelect(cqn, columns, column.limit, column.orderBy, expandedEntity)
-
-    cqn.from.on.push('and')
-    cqn.from.on.push({ list: columns })
-    cqn.from.on.push('IN', inSelect)
-  }
-
   /**
    * Get the list of key columns in ref format.
    * Add the table alias to avoid ambiguity issues.
@@ -1156,48 +1222,11 @@ class JoinCQNFromExpanded {
     })
   }
 
-  _getWindowRef(tableAlias, name) {
-    return { [IDENTIFIER]: name, ref: [tableAlias, name], as: `${tableAlias}_${name}` }
-  }
-
-  _getWindowVal(tableAlias, name, val) {
-    return { [IDENTIFIER]: name, val: val, as: `${tableAlias}_${name}` }
-  }
-
-  _draftColumnsToCQN(cqn, tableAlias, expandedEntity) {
-    return DRAFT_COLUMNS.map(name => {
-      if (name === 'IsActiveEntity') {
-        return this._getWindowVal(tableAlias, name, cqn[IS_ACTIVE])
-      }
-
-      if (cqn[IS_ACTIVE]) {
-        if (name === 'DraftAdministrativeData_DraftUUID') {
-          return this._getWindowVal(tableAlias, name, null)
-        }
-        if (name === 'HasActiveEntity') {
-          return this._getWindowVal(tableAlias, name, false)
-        }
-        if (name === 'HasDraftEntity') {
-          return this._getHasDraftEntityXpr(expandedEntity, tableAlias)
-        }
-      }
-
-      return this._getWindowRef(tableAlias, name)
-    })
-  }
-
-  _getHasDraftEntityXpr(expandedEntity, tableAlias, columns = []) {
+  _getHasDraftEntityXpr(expandedEntity, tableAlias) {
     const draftTable = ensureDraftsSuffix(expandedEntity.name)
     const where = filterKeys(expandedEntity.keys).reduce((res, keyName) => {
-      let keyAlias
-      if (this._useWindow) {
-        const element = columns.find(
-          col => col.as && col.ref && col.ref.length === 2 && col.ref[1] === keyName && col.ref[0] === tableAlias
-        )
-        keyAlias = element && element.as
-      }
       if (res.length !== 0) res.push('and')
-      res.push({ ref: [draftTable, keyName] }, '=', { ref: [tableAlias, keyAlias || keyName] })
+      res.push({ ref: [draftTable, keyName] }, '=', { ref: [tableAlias, keyName] })
       return res
     }, [])
     const hasDraftQuery = {
@@ -1214,124 +1243,6 @@ class JoinCQNFromExpanded {
     }
   }
 
-  _getWindowPartitions(on) {
-    const partitions = []
-
-    for (const element of on) {
-      if (
-        element.ref &&
-        element.ref[0] !== 'filterExpand' &&
-        element.ref[element.ref.length - 1] !== 'IsActiveEntity'
-      ) {
-        if (partitions.length !== 0) {
-          partitions.push(',')
-        }
-
-        partitions.push(element)
-      }
-    }
-
-    return partitions
-  }
-
-  _getWindowColumns(cqn, column, tableAlias, expandedEntity) {
-    const columns = cqn.columns
-      .filter(entry => entry.val || (entry.ref && !entry.expand && entry.ref[0] !== tableAlias))
-      .concat(
-        getColumns(expandedEntity)
-          .filter(col => !col.virtual)
-          .map(element => {
-            return this._getWindowRef(tableAlias, element.name)
-          })
-      )
-
-    if (expandedEntity._isDraftEnabled) {
-      columns.push(...this._draftColumnsToCQN(cqn, tableAlias, expandedEntity))
-    }
-
-    columns.push(
-      this._getWindowXpr(
-        this._getWindowPartitions(cqn.from.on),
-        this._copyOrderBy(column.orderBy || [], tableAlias, expandedEntity)
-      )
-    )
-
-    return columns
-  }
-
-  _getWhereForLimit(column) {
-    const offset = (column.limit.offset && column.limit.offset.val) || 0
-    return [
-      { ref: ['rowNumber'] },
-      '>',
-      { val: offset },
-      'and',
-      { ref: ['rowNumber'] },
-      '<',
-      { val: offset + column.limit.rows.val + 1 }
-    ]
-  }
-
-  _addWindowIfNeeded(cqn, column, tableAlias, expandedEntity) {
-    if (!this._useWindow || (!column.orderBy && !column.limit)) {
-      return cqn
-    }
-
-    const windowCQN = {
-      columns: cqn.columns.map(entry => {
-        if (entry.ref && entry.as) {
-          const newRef = entry.ref[0] === 'filterExpand' ? [entry.as] : [entry.ref[0], entry.as]
-          return Object.assign({}, entry, { [IDENTIFIER]: entry.ref[1], ref: newRef })
-        }
-
-        if (entry.val) {
-          const returnValue = { [IDENTIFIER]: entry.as, ref: [tableAlias, entry.as], as: entry.as }
-          if (SKIP_MAPPING in entry) {
-            returnValue[SKIP_MAPPING] = entry[SKIP_MAPPING]
-          }
-          return returnValue
-        }
-
-        return Object.assign({}, entry)
-      }),
-      from: {
-        SELECT: cqn
-      }
-    }
-
-    cqn.columns = this._getWindowColumns(cqn, column, tableAlias, expandedEntity)
-
-    if (column.limit) {
-      windowCQN.where = this._getWhereForLimit(column)
-    }
-
-    return windowCQN
-  }
-
-  _getOrderByForWindowFn(orderBy) {
-    return orderBy.reduce((arr, value, i) => {
-      arr.push(value)
-      if (i < orderBy.length - 1) {
-        arr.push(',')
-      }
-
-      return arr
-    }, [])
-  }
-
-  _getWindowXpr(columns, orderBy) {
-    const xpr = [{ func: 'ROW_NUMBER', args: [] }, 'OVER', '(']
-    if (columns.length > 0) {
-      xpr.push('PARTITION BY', ...columns)
-    }
-    if (orderBy.length !== 0) {
-      xpr.push('ORDER BY', ...this._getOrderByForWindowFn(orderBy))
-    }
-    xpr.push(')')
-
-    return { xpr: xpr, as: 'rowNumber' }
-  }
-
   _copyColumns(columns, alias) {
     return columns.map(element => {
       const column = {
@@ -1466,7 +1377,7 @@ class JoinCQNFromExpanded {
           const ele = struct.elements[k]
           const l = key + '_' + k
           if (ele._isStructured) value.push(...this._getValueFromEntry(entry, parentAlias, l, ele))
-          else value.push(entry[l])
+          else value.push(this._getValueFromEntry(entry, parentAlias, l))
         }
       }
     }
@@ -1594,20 +1505,17 @@ class JoinCQNFromExpanded {
     if (typeof isActive === 'boolean') {
       if (columnName === 'IsActiveEntity') {
         columns.push(this._createCalculatedBooleanColumn('IsActiveEntity', isActive))
-
         return
       }
-
-      if (columnName === 'HasActiveEntity') {
-        columns.push(this._createCalculatedBooleanColumn('HasActiveEntity', false))
-
-        return
-      }
-
-      if (isActive && columnName === 'HasDraftEntity') {
-        columns.push(this._getHasDraftEntityXpr(entity, tableAlias, columns))
-
-        return
+      if (isActive) {
+        if (columnName === 'HasActiveEntity') {
+          columns.push(this._createCalculatedBooleanColumn('HasActiveEntity', false))
+          return
+        }
+        if (columnName === 'HasDraftEntity') {
+          columns.push(this._getHasDraftEntityXpr(entity, tableAlias))
+          return
+        }
       }
     }
 
@@ -1681,13 +1589,12 @@ class JoinCQNFromExpanded {
  *
  * @param {object} cqn - CQN with expanded columns
  * @param {object} csn - Services CSN
- * @param {boolean} useWindow - If sub select or window function should be used for top/skip at expand
  * @param {string} locale
  * @returns {object}
  * @private
  */
-const createJoinCQNFromExpanded = (cqn, csn, useWindow, locale) => {
-  return new JoinCQNFromExpanded(cqn, csn, useWindow, locale).buildJoinQueries()
+const createJoinCQNFromExpanded = (cqn, csn, locale) => {
+  return new JoinCQNFromExpanded(cqn, csn, locale).buildJoinQueries()
 }
 
 /**