@sap/cds 5.6.2 → 5.7.2

package/libx/_runtime/common/utils/cqn2cqn4sql.js

@@ -1,5 +1,6 @@
 const cds = require('../../cds')
 const { SELECT, INSERT, DELETE, UPDATE } = cds.ql
+const Query = require('../../../../lib/ql/Query')
 
 const { resolveView } = require('./resolveView')
 const { ensureNoDraftsSuffix } = require('./draft')
@@ -9,7 +10,9 @@ const { getEntityNameFromCQN } = require('./entityFromCqn')
 const getError = require('../../common/error')
 const { rewriteAsterisks } = require('./rewriteAsterisks')
 const { getPathFromRef, getEntityFromPath } = require('../../common/utils/path')
+const { addToWhere } = require('../../common/utils/cqn')
 const { removeIsActiveEntityRecursively } = require('../../fiori/utils/where')
+const { addRefToWhereIfNecessary } = require('../../../odata/afterburner')
 
 const PARENT_ALIAS = '_parent_'
 const PARENT_ALIAS_REGEX = new RegExp('^' + PARENT_ALIAS + '\\d*$')
@@ -76,14 +79,15 @@ const _getEntityName = (fromClause, entity, i) => {
 }
 
 const convertPathExpressionToWhere = (fromClause, model, options) => {
+  if (!fromClause.ref) return
   if (fromClause.ref.length === 1) {
     const target = _getTargetFromRef(fromClause.ref[0])
     const alias = fromClause.as
-    const { where, cardinality } = fromClause.ref[0]
-    return { target, alias, where, cardinality }
+    const { where, cardinality, args } = fromClause.ref[0]
+    return { target, alias, where, cardinality, args }
   }
 
-  let previousSelect, previousEntityName, previousTableAlias, structParent
+  let previousSelect, previousEntityName, previousTableAlias, structParent, previousArgs
   let prefix = []
   let columns
   for (let i = 0; i < fromClause.ref.length; i++) {
@@ -111,6 +115,9 @@ const convertPathExpressionToWhere = (fromClause, model, options) => {
       currentSelect.where(_addAliasToExpression(fromClause.ref[i].where, tableAlias))
     }
 
+    // REVISIT: Only args in last segment are handled, intermediate ones are ignored
+    const currentArgs = fromClause.ref[i].args
+
     if (i !== fromClause.ref.length - 1) {
       currentSelect.columns([1])
     }
@@ -129,12 +136,14 @@ const convertPathExpressionToWhere = (fromClause, model, options) => {
     previousTableAlias = tableAlias
     previousSelect = currentSelect
     previousEntityName = currentEntityName
+    previousArgs = currentArgs
   }
 
   return {
     target: previousEntityName,
     alias: previousTableAlias,
     where: previousSelect && previousSelect.SELECT && previousSelect.SELECT.where,
+    args: previousArgs,
     columns
   }
 }
@@ -179,24 +188,31 @@ const _getOrderByForWindowFn = bottomTop => {
 
 const _getWindowXpr = (groupBy, bottomTop) => {
   const xpr = [{ func: 'ROW_NUMBER', args: [] }, 'OVER', '(']
-  xpr.push(
-    'PARTITION BY',
-    ...groupBy.reduce((acc, el, i) => {
-      if (i < groupBy.length - 1) {
-        acc.push(el)
-        acc.push(',')
-      } else {
-        acc.push(el)
-      }
+  if (groupBy)
+    xpr.push(
+      'PARTITION BY',
+      ...groupBy.reduce((acc, el, i) => {
+        if (i < groupBy.length - 1) {
+          acc.push(el)
+          acc.push(',')
+        } else {
+          acc.push(el)
+        }
 
-      return acc
-    }, [])
-  )
+        return acc
+      }, [])
+    )
   xpr.push('ORDER BY', _getOrderByForWindowFn(bottomTop))
   xpr.push(')')
   return { xpr: xpr, as: 'rowNumber' }
 }
 
+const _isNavCountFunc = el => el.func && el.func === 'count' && el.args[0] !== '*'
+
+const _isCountNavigation = columns => {
+  return columns.some(_isNavCountFunc)
+}
+
 const _isBottomTop = columns => {
   return columns.some(el => el.func && (el.func === 'topcount' || el.func === 'bottomcount'))
 }
@@ -205,6 +221,89 @@ const _getWindColumns = (columns, groupBy, bottomTop) => {
   return [].concat(columns, _getWindowXpr(groupBy, bottomTop))
 }
 
+const _convertCountNavigation = (SELECT, model) => {
+  const entityName = SELECT.from.ref[0].id || SELECT.from.ref[0]
+  const entity = model.definitions[entityName]
+
+  const newWhere = []
+  for (let i = 0; i < SELECT.where.length; i++) {
+    const element = SELECT.where[i]
+
+    if (!element.func) {
+      newWhere.push(element)
+      continue
+    }
+
+    const navigations = element.args[0].ref
+    const navigationName = navigations[0].id || navigations[0]
+    if (entity.elements[navigationName]) {
+      let currentEntity = entity
+      let topQuery
+      let lastQuery
+
+      for (let j = 0; j < navigations.length; j++) {
+        if (navigations[j].where) {
+          addRefToWhereIfNecessary(navigations[j].where, currentEntity)
+        }
+
+        const nextNavigation = navigations[j]
+        const nestedExistsQuery = _buildExistsQuery(
+          currentEntity,
+          nextNavigation,
+          j > 0 ? `ALIAS_${j - 1}` : currentEntity.name,
+          `ALIAS_${j}`
+        )
+        if (!topQuery) {
+          topQuery = nestedExistsQuery
+        }
+
+        const nestedNavigationName = nextNavigation.id || nextNavigation
+        if (j === navigations.length - 1) {
+          nestedExistsQuery.columns('count(1) as counted')
+          if (lastQuery) {
+            lastQuery.where([nestedExistsQuery, SELECT.where[i + 1], SELECT.where[i + 2]])
+            newWhere.push('exists', topQuery)
+          } else {
+            newWhere.push(nestedExistsQuery, SELECT.where[i + 1], SELECT.where[i + 2])
+          }
+        } else {
+          if (lastQuery) {
+            lastQuery.where('exists', nestedExistsQuery)
+          }
+        }
+        lastQuery = nestedExistsQuery
+        currentEntity = currentEntity.elements[nestedNavigationName]._target
+      }
+      i += 2
+    }
+  }
+  SELECT.where = newWhere
+}
+
+const _addTableName = (where, tableName) => {
+  return where.map(ref => {
+    if (ref.ref) {
+      ref.ref.unshift(tableName)
+    }
+    return ref
+  })
+}
+
+const _buildExistsQuery = (entity, navigation, currentAlias, nextAlias) => {
+  const target = entity.elements[navigation.id || navigation].target
+
+  const existsQuery = cds.ql.SELECT.from(target)
+  existsQuery.SELECT.from.as = nextAlias
+
+  if (navigation && navigation.where) {
+    existsQuery.where(_addTableName(navigation.where, nextAlias))
+  }
+
+  const onCond = entity.elements[navigation.id || navigation]._relations.join(nextAlias, currentAlias)
+
+  return existsQuery.where(onCond)
+}
+
 const _createWindowCQN = (SELECT, model) => {
   const bottomTop = SELECT.columns.filter(el => _isBottomTop([el]))
   const columns = (SELECT.columns = [])
@@ -237,7 +336,7 @@ const _isAll = element => {
 }
 
 // eslint-disable-next-line complexity
-const _getLambdaSubSelect = (cqn, where, index, lambdaOp, model, options) => {
+const _getWhereExistsSubSelect = (cqn, where, index, model, options) => {
   const _unshiftRefsWithNavigation = nav => el => {
     if (el.ref) return { ref: [...nav, ...el.ref] }
     if (el.xpr) return { xpr: el.xpr.map(_unshiftRefsWithNavigation(nav)) }
@@ -254,10 +353,11 @@ const _getLambdaSubSelect = (cqn, where, index, lambdaOp, model, options) => {
   const ref = cqn.SELECT.from.ref || (cqn.SELECT.from.args && cqn.SELECT.from.args[0].ref)
   const queryTarget = getEntityFromPath(getPathFromRef(ref), model)
 
-  const nav = where[index].ref.map(el => (el.id ? el.id : el))
+  let nav = where[index].ref.map(el => (el.id ? el.id : el))
   const last = where[index].ref.slice(-1)[0]
   const navName = queryTarget.elements[nav[0]] ? nav[0] : nav[nav.length - 1]
   const navElement = queryTarget.elements[navName]
+
   const lastElement = nav.reduce((csn, segment) => {
     if (csn.items) return csn // arrayed not supported
     if (csn.elements) {
@@ -267,9 +367,14 @@ const _getLambdaSubSelect = (cqn, where, index, lambdaOp, model, options) => {
       return next
     }
   }, queryTarget)
-  if (lastElement.items)
-    /* arrayed */
+
+  if (lastElement.items) {
+    // > arrayed
     throw getError(501, `Condition expression with arrayed elements is not supported`)
+  }
+
+  if (nav[0] === outerAlias) nav = nav.slice(1)
+
   const condition = last.where
     ? nav.length > 1
       ? last.where.map(_unshiftRefsWithNavigation(nav.slice(1)))
@@ -290,8 +395,10 @@ const _getLambdaSubSelect = (cqn, where, index, lambdaOp, model, options) => {
         }
       }
     }
-    subSelect.where(condition)
+    // skip for where: [{ val: 1 }]
+    if (condition.length > 1) subSelect.where(condition)
   }
+
   subSelect.where(queryTarget._relations[navName].join(innerAlias, outerAlias))
   if (cds.env.effective.odata.structs) {
     flattenStructuredSelect(subSelect, model)
@@ -300,25 +407,76 @@ const _getLambdaSubSelect = (cqn, where, index, lambdaOp, model, options) => {
 
   // nested where exists needs recursive conversion
   options.lambdaIteration++
+
   return _convertSelect(subSelect, model, options)
 }
 
-const _convertLambda = (cqn, model, options) => {
-  const where = cqn.SELECT.where
-  if (where) _recurse(where)
-  function _recurse(where) {
-    where.forEach((element, index) => {
-      if (element.xpr) {
-        _recurse(element.xpr) // recursing into nested {xpr}
-      } else if (element === 'exists' && _isAny(where[index + 1])) {
-        where[index + 1] = _getLambdaSubSelect(cqn, where, index + 1, 'any', model, options)
-      } else if (element === 'not' && where[index + 1] === 'exists' && _isAll(where[index + 2])) {
-        where[index + 2] = _getLambdaSubSelect(cqn, where, index + 2, 'all', model, options)
+/*
+ * ensures that the where exists are fully expanded and have an infix filter
+ * example: where: ['exists', { ref: ['book', 'author'] }]
+ *       -> where: ['exists', { id: 'book', where: ['exists', { id: 'author', where: [{ val: 1 }] }] }]
+ */
+const _ensureExpandedNestedWhereExists = ({ ref }, aliases) => {
+  const acc = {}
+  let cur = acc
+  let alias
+  for (const r of ref) {
+    if (Array.isArray(cur)) {
+      if (cur.length > 1) {
+        // > element already has condition(s)
+        cur.push('and', 'exists', { ref: [{}] })
+        cur = cur[cur.length - 1].ref[0]
+      } else {
+        cur.unshift('exists')
+        cur[1] = { ref: [{}] }
+        cur = cur[1].ref[0]
       }
-    })
+    }
+    if (typeof r === 'string' && aliases.includes(r)) {
+      alias = r
+    } else {
+      // use Object.assign to preserve pointers
+      if (typeof r === 'string') Object.assign(cur, { id: r, where: [{ val: 1 }] })
+      else Object.assign(cur, r)
+      cur = cur.where
+    }
+  }
+  if (alias) return { ref: [alias, acc] }
+  return { ref: [acc] }
+}
+
+const _convertWhereExists = (where, cqn, model, options) => {
+  for (let i = 0; i < where.length; i++) {
+    const element = where[i]
+
+    // ensure where exists are fully expanded
+    if (
+      (element === 'exists' && where[i + 1].ref && where[i > 1 ? i - 1 : 0] !== 'not') ||
+      (element === 'not' && where[i + 1] === 'exists' && where[i + 2].ref)
+    ) {
+      const offset = element === 'not' ? 2 : 1
+      const aliases = cqn.SELECT.from.as
+        ? [cqn.SELECT.from.as]
+        : cqn.SELECT.from.join
+        ? cqn.SELECT.from.args.map(arg => arg.as)
+        : []
+      where[i + offset] = _ensureExpandedNestedWhereExists(where[i + offset], aliases)
+    }
+
+    if (element.xpr) {
+      _convertWhereExists(element.xpr) // > recursing into nested {xpr}
+    } else if (element === 'exists' && _isAny(where[i + 1])) {
+      where[i + 1] = _getWhereExistsSubSelect(cqn, where, i + 1, model, options)
+    } else if (element === 'not' && where[i + 1] === 'exists' && _isAll(where[i + 2])) {
+      where[i + 2] = _getWhereExistsSubSelect(cqn, where, i + 2, model, options)
+    }
   }
 }
 
+const convertWhereExists = (cqn, model, options) => {
+  if (cqn.SELECT.where) _convertWhereExists(cqn.SELECT.where, cqn, model, options)
+}
+
 const _getRefIndex = (where, index) => {
   if (
     where[index - 1].ref &&
@@ -342,8 +500,8 @@ const _getRefIndex = (where, index) => {
   }
 }
 
-const _convertNotEqual = container => {
-  const where = container.where
+const _convertNotEqual = (container, partName = 'where') => {
+  const where = container[partName]
 
   if (where) {
     let changed
@@ -360,13 +518,13 @@ const _convertNotEqual = container => {
       }
 
       if (el && el.SELECT) {
-        _convertNotEqual(el.SELECT)
+        _convertNotEqual(el.SELECT, partName)
       }
     })
 
     // delete undefined values
     if (changed) {
-      container.where = where.filter(el => el)
+      container[partName] = where.filter(el => el)
     }
   }
 
@@ -374,9 +532,9 @@ const _convertNotEqual = container => {
     container.columns.forEach(col => {
       if (typeof col === 'object') {
         if (col.SELECT) {
-          _convertNotEqual(col.SELECT)
+          _convertNotEqual(col.SELECT, partName)
         } else if (col.where) {
-          _convertNotEqual(col)
+          _convertNotEqual(col, partName)
         }
       }
     })
@@ -384,7 +542,7 @@ const _convertNotEqual = container => {
 }
 
 const _ifOrderByOrWhereSkip = (queryTarget, ref, model) => {
-  if (!queryTarget.elements[ref[0]]) return
+  if (!queryTarget || !queryTarget.elements[ref[0]]) return
   return ref.some(el => {
     if (typeof el !== 'string') return
     const orderbyTarget = queryTarget.elements[el]._isStructured
@@ -398,9 +556,12 @@ const _ifOrderByOrWhereSkip = (queryTarget, ref, model) => {
   })
 }
 
-const _skip = (queryTarget, ref, model) => {
-  if (ref.length === 1) return queryTarget && queryTarget.elements[ref[0]] && queryTarget.elements[ref[0]].virtual
-  return _ifOrderByOrWhereSkip(queryTarget, ref, model)
+const _skip = (queryTarget, ref, alias, model) => {
+  // we remove the alias, if it exists
+  const _ref = ref[0] === alias ? ref.slice(1) : ref
+  if (_ref.length === 1) return queryTarget && queryTarget.elements[_ref[0]] && queryTarget.elements[_ref[0]].virtual
+
+  return _ifOrderByOrWhereSkip(queryTarget, _ref, model)
 }
 
 const _convertOrderByIfSkip = (orderByCQN, index) => {
@@ -412,21 +573,22 @@ const _convertWhereIfSkip = (whereCQN, index) => {
   OPERATIONS.includes(whereCQN[index + 1]) ? whereCQN.splice(index + 1, 2) : whereCQN.splice(index - 2, 2)
 }
 
-const _convertOrderByOrWhereCQN = (orderByOrWhereCQN, target, model, processFn) => {
+const _convertOrderByOrWhereCQN = (orderByOrWhereCQN, target, model, alias, processFn) => {
   const queryTarget = model.definitions[ensureNoDraftsSuffix(target)]
 
   orderByOrWhereCQN.forEach((el, index) => {
-    if (el.ref && _skip(queryTarget, el.ref, model)) processFn(orderByOrWhereCQN, index)
+    if (el.ref && _skip(queryTarget, el.ref, alias, model)) processFn(orderByOrWhereCQN, index)
   })
 }
 
 const _convertOrderByOrWhereIfSkip = (cqn, target, model) => {
+  const alias = cqn.SELECT.from.as
   if (cqn.SELECT.orderBy && cqn.SELECT.orderBy.length > 1) {
-    _convertOrderByOrWhereCQN(cqn.SELECT.orderBy, target, model, _convertOrderByIfSkip)
+    _convertOrderByOrWhereCQN(cqn.SELECT.orderBy, target, model, alias, _convertOrderByIfSkip)
   }
 
   if (cqn.SELECT.where) {
-    _convertOrderByOrWhereCQN(cqn.SELECT.where, target, model, _convertWhereIfSkip)
+    _convertOrderByOrWhereCQN(cqn.SELECT.where, target, model, alias, _convertWhereIfSkip)
   }
 }
 
@@ -449,7 +611,7 @@ const _convertExpand = expand => {
 const _convertRefWhereInExpand = columns => {
   if (columns) {
     columns.forEach(col => {
-      if (col.expand) {
+      if (col.expand && typeof col.expand !== 'string') {
         _convertExpand(col.expand)
       }
     })
@@ -486,102 +648,115 @@ const _flattenXpr = cqn => {
   cqn.forEach(_flattenCQN)
 }
 
+const _convertPathExpression = (SELECT, model, options = {}) => {
+  const prevAlias = SELECT.from.as
+  for (const whereEl of SELECT.where || []) {
+    if (typeof whereEl === 'object' && whereEl.SELECT) _convertPathExpression(whereEl.SELECT, model)
+  }
+  const conversion = convertPathExpressionToWhere(SELECT.from, model, options)
+  if (!conversion) return
+  const { target, alias, where, cardinality, columns, args } = conversion
+
+  // REVISIT: It's not possible to just change the reference (i.e. SELECT.from.ref = [target])
+  // as many parts of our code base still refer to SELECT.from (e.g. authorization)
+  if (args) {
+    SELECT.from = { ref: [{ id: target, args }] }
+  } else {
+    SELECT.from = { ref: [target] }
+  }
+  if (alias) {
+    SELECT.from.as = alias
+    if (SELECT.where && alias !== prevAlias) {
+      SELECT.where = _addAliasToExpression(SELECT.where, alias)
+    }
+  }
+  if (columns) {
+    // TODO: use streaming as outer property
+    if (options.isStreaming) SELECT.columns = columns
+    else {
+      if (!SELECT.columns) {
+        // Okra always wants to have the key values, remove once we relax this requirement
+        if (model.definitions[target] && model.definitions[target].keys) {
+          SELECT.columns = Object.keys(model.definitions[target].keys)
+            .filter(k => !model.definitions[target].keys[k].isAssociation)
+            .map(k => ({ ref: [k] }))
+        } else SELECT.columns = []
+      }
+      SELECT.columns.push(...columns)
+    }
+  }
+  if (cardinality && cardinality.max === 1) {
+    SELECT.one = true
+  }
+  // TODO: REVISIT: We need to add alias to subselect in .where, .columns, .from, ... etc
+  if (where) {
+    if (options.isDraft) {
+      addToWhere({ SELECT }, where)
+    } else {
+      addToWhere({ SELECT }, removeIsActiveEntityRecursively(where))
+    }
+  }
+}
+
 // eslint-disable-next-line complexity
-const _convertSelect = (query, model, options) => {
-  const isDB = options.service instanceof cds.DatabaseService
-  const isDraft = options.draft
+const _convertSelect = (query, model, _options) => {
+  const options = Object.assign(
+    {
+      isDB: _options.service instanceof cds.DatabaseService,
+      isDraft: _options.draft,
+      isStreaming: query._streaming
+    },
+    _options
+  )
+  // ensure query is ql enabled
+  if (!(query instanceof Query)) Object.setPrototypeOf(query, Object.getPrototypeOf(SELECT()))
+  if (query.SELECT.from && query.SELECT.from.SELECT) {
+    if (query.SELECT._4odata) query.SELECT.from.SELECT._4odata = true
+    query.SELECT.from = _convertSelect(query.SELECT.from, model, options)
+  }
+
   // REVISIT: a temporary workaround for xpr from new parser
   if (cds.env.features.odata_new_parser) _flattenCQN(query)
 
   // lambda functions
-  _convertLambda(query, model, options)
+  convertWhereExists(query, model, options)
 
   // add 'or is null' in case of '!='
-  if (query.SELECT._4odata) _convertNotEqual(query.SELECT)
-
-  let searchOptions = query._searchOptions
-  const cqnSelectFromRef = query.SELECT.from.ref
-
-  // no path expression
-  if (!cqnSelectFromRef || (cqnSelectFromRef.length === 1 && !cqnSelectFromRef[0].where)) {
-    rewriteAsterisks(query, cqnSelectFromRef && model.definitions[cqnSelectFromRef[0]], isDB, isDraft)
-    // extract where clause if it is in column expand ref
-    _convertRefWhereInExpand(query.SELECT.columns)
-    // remove virtual and with skip annotated fields in orderby and where
-    _convertOrderByOrWhereIfSkip(query, getEntityNameFromCQN(query), model)
-
-    if (cqnSelectFromRef && query.SELECT.search && !options.suppressSearch) {
-      searchOptions = { ...searchOptions, ...{ targetName: cqnSelectFromRef[0] } }
-      search2cqn4sql(query, model, searchOptions)
-    }
-
-    if (query.SELECT.columns && cds.env.effective.odata.structs) {
-      flattenStructuredSelect(query, model)
-    }
-
-    // topcount with groupby
-    if (query.SELECT.columns && _isBottomTop(query.SELECT.columns)) {
-      _createWindowCQN(query.SELECT, model)
-    }
-
-    return query
+  if (query.SELECT._4odata) {
+    _convertNotEqual(query.SELECT, 'where')
+    _convertNotEqual(query.SELECT, 'having')
   }
 
-  // path expression handling
-  const { target, alias, where, cardinality, columns } = convertPathExpressionToWhere(query.SELECT.from, model, options)
-  rewriteAsterisks(query, model.definitions[target], isDB, isDraft, !!columns)
-  if (columns) {
-    if (query._streaming) query.SELECT.columns = columns
-    else query.SELECT.columns.push(...columns)
+  _convertPathExpression(query.SELECT, model, options)
+  rewriteAsterisks(query, model, options.isDB, options.isDraft)
+  if (query.SELECT.where && _isCountNavigation(query.SELECT.where)) {
+    _convertCountNavigation(query.SELECT, model)
   }
 
   // extract where clause if it is in column expand ref
   _convertRefWhereInExpand(query.SELECT.columns)
 
-  // remove virtual and with skip annotated fields in orderby and where
-  _convertOrderByOrWhereIfSkip(query, target, model)
-
-  const select = SELECT.from(target, query.SELECT.columns)
-
-  if (alias) {
-    select.SELECT.from.as = alias
-  }
-
-  // TODO: REVISIT: We need to add alias to subselect in .where, .columns, .from, ... etc
-  if (where) {
-    if (!isDraft) {
-      select.where(removeIsActiveEntityRecursively(where))
-    } else {
-      select.where(where)
-    }
-  }
+  // REVISIT: The following operations only work for _one_ entity.
+  // We must also enable them for joins etc.
+  const { entityName, alias } = getEntityNameFromCQN(query)
 
-  if (cardinality && cardinality.max === 1) {
-    query.SELECT.one = true
-  }
+  // remove virtual and with skip annotated fields in orderby and where
+  _convertOrderByOrWhereIfSkip(query, entityName, model)
 
-  if (query.SELECT.search) {
-    searchOptions = { ...searchOptions, ...{ targetName: target } }
-    search2cqn4sql(query, model, searchOptions)
+  if (query.SELECT.search && !options.suppressSearch) {
+    search2cqn4sql(query, model, { ...query._searchOptions, ...{ entityName, alias } })
   }
 
-  if (query.SELECT.where) {
-    select.where(_addAliasToExpression(query.SELECT.where, select.SELECT.from.as))
+  if (query.SELECT.columns && cds.env.effective.odata.structs) {
+    flattenStructuredSelect(query, model)
   }
 
-  // We add all previous properties ot the newly created query.
-  // Reason is to not lose the query API functionality
-  Object.assign(select.SELECT, query.SELECT, {
-    columns: select.SELECT.columns,
-    from: select.SELECT.from,
-    where: select.SELECT.where
-  })
-
-  if (select.SELECT.columns && cds.env.effective.odata.structs) {
-    flattenStructuredSelect(select, model)
+  // topcount with groupby
+  if (query.SELECT.columns && _isBottomTop(query.SELECT.columns)) {
+    _createWindowCQN(query.SELECT, model)
   }
 
-  return select
+  return query
 }
 
 const _convertInsert = (query, model, options) => {
@@ -732,5 +907,6 @@ const cqn2cqn4sql = (query, model, options = { suppressSearch: false }) => {
 
 module.exports = {
   cqn2cqn4sql,
+  convertWhereExists,
   convertPathExpressionToWhere
 }