@sap/cds 5.4.6 → 5.5.0

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

@@ -1,8 +1,8 @@
-const expandCqnToJoin = require('./expandCQNToJoin')
+const { hasExpand, createJoinCQNFromExpanded } = require('./expandCQNToJoin')
 const rawToExpanded = require('./rawToExpanded')
 
 module.exports = {
-  hasExpand: expandCqnToJoin.hasExpand,
-  createJoinCQNFromExpanded: expandCqnToJoin.createJoinCQNFromExpanded,
+  hasExpand,
+  createJoinCQNFromExpanded,
   rawToExpanded
 }

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

@@ -1,15 +1,17 @@
 const EXPAND = Symbol.for('sap.cds.expand')
 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 { DRAFT_COLUMNS } = require('../../common/constants/draft')
 
 class RawToExpanded {
-  constructor(configs, queries, one) {
+  constructor(configs, queries, one, rootEntity) {
     this._one = one
     this._toManyResults = { expand: {} }
     this._result = []
     this._configs = configs
     this._queries = queries
+    this._rootEntity = rootEntity
   }
 
   /**
@@ -66,20 +68,40 @@ class RawToExpanded {
    * @returns {object}
    * @private
    */
+  // eslint-disable-next-line complexity
   _parseRaw({ mappings, toManyTree, conversionMapper, entry }) {
     let isEntityNull
 
     const row = {}
 
+    const rootIsActiveEntity = this._rootEntity._isDraftEnabled
+      ? mappings.IsActiveEntity
+        ? entry[mappings.IsActiveEntity] === null
+          ? null
+          : !!entry[mappings.IsActiveEntity]
+        : 'IsActiveEntity' in entry
+        ? entry.IsActiveEntity === null
+          ? null
+          : !!entry.IsActiveEntity
+        : null
+      : null
+
     // A raw row contains more elements than the config. Iterating over config is faster.
     for (const key in mappings) {
       // To many entries have been already processed and cached
       const mapping = mappings[key]
       if (mapping[TO_MANY]) {
-        row[key] = this._getResultCache(toManyTree.concat(key))[mapping[GET_KEY_VALUE](false, entry)] || []
+        let expandedItems = this._getResultCache(toManyTree.concat(key))[mapping[GET_KEY_VALUE](false, entry)] || []
+
+        // the expanded items may include the actives of the deleted drafts -> filter out
+        if (rootIsActiveEntity !== null) {
+          if (mapping[TO_ACTIVE]) expandedItems = expandedItems.filter(ele => ele.IsActiveEntity === true)
+          else expandedItems = expandedItems.filter(ele => ele.IsActiveEntity === rootIsActiveEntity)
+        }
 
-        // Will be true in case of 1:1 expands
+        row[key] = expandedItems
       } else if (typeof mapping === 'object') {
+        // > Will be true in case of 1:1 expands
         // check if the expanded entry doesn't exists
         if (this._isExpandEmpty(mapping, entry)) {
           row[key] = null
@@ -92,9 +114,15 @@ class RawToExpanded {
           entry: entry
         })
 
-        row[key] = parsed || null
-        // No expand convert the result directly.
+        // the expanded items may include the actives of the deleted drafts -> filter out
+        if (rootIsActiveEntity === null || key === 'DraftAdministrativeData') {
+          row[key] = parsed || null
+        } else if (rootIsActiveEntity !== null) {
+          if (mapping[TO_ACTIVE]) row[key] = parsed && parsed.IsActiveEntity !== false ? parsed : null
+          else row[key] = parsed && parsed.IsActiveEntity === rootIsActiveEntity ? parsed : null
+        }
       } else {
+        // > No expand convert the result directly.
         const rawValue = entry[mapping]
         // Assume a DB will not return undefined, but always null
         row[key] = this._convertValue(rawValue, conversionMapper.get(mapping))
@@ -195,10 +223,11 @@ class RawToExpanded {
  * @param {Array} configs - Array of instructions how to combine and expand the 1 to N results
  * @param {Array} queries - Same amount of queries as configs. Contains one query for each to many expand.
  * @param {boolean} one - SELECT.one has been used
+ * @param {object} rootEntity - the root entity
  * @returns {Promise<Array>} The complete expanded result set.
  */
-const rawToExpanded = (configs, queries, one) => {
-  return new RawToExpanded(configs, queries, one).toExpanded().catch(err => {
+const rawToExpanded = (configs, queries, one, rootEntity) => {
+  return new RawToExpanded(configs, queries, one, rootEntity).toExpanded().catch(err => {
     Promise.all(queries).catch(() => {})
     throw err
   })

package/libx/_runtime/db/generic/index.js

@@ -2,7 +2,7 @@
 const rewrite = require('./rewrite')
 const input = require('./input')
 const integrity = require('./integrity')
-const { removeVirtuals: virtual } = require('./virtual')
+const { convertVirtuals: virtual } = require('./virtual')
 // on
 const CREATE = require('./create')
 const READ = require('./read')

package/libx/_runtime/db/generic/input.js

@@ -31,7 +31,7 @@ const _processComplexCategory = ({ row, key, val, category, req }) => {
 
   // propagate keys
   if (category === 'propagateForeignKeys') {
-    propagateForeignKeys(key, row, categoryArgs.foreignKeyPropagations)
+    propagateForeignKeys(key, row, categoryArgs.foreignKeyPropagations, { onlyWriteCompositionEffective: true })
     return
   }
 
@@ -60,10 +60,10 @@ const _processComplexCategory = ({ row, key, val, category, req }) => {
   }
 }
 
-const _processCategory = ({ row, key, val, category, req, element, suppressErrorPropagation }) => {
+const _processCategory = ({ category, row, key, element, val, req }) => {
   // use args only inside this if (sonar type error warning)
   if (typeof category === 'object') {
-    _processComplexCategory({ row, key, val, category, req })
+    _processComplexCategory({ category, row, key, val, req })
     return
   }
 
@@ -75,7 +75,6 @@ const _processCategory = ({ row, key, val, category, req, element, suppressError
 
   // not null without default (for better error message)
   if (category === '!default' && val == null && req.event === 'CREATE') {
-    if (suppressErrorPropagation) return
     req.error(400, 'ASSERT_NOT_NULL', key, [key])
     return
   }
@@ -87,19 +86,18 @@ const _processCategory = ({ row, key, val, category, req, element, suppressError
 
   // check for forbidden deep operations for association
   if (category === 'associationEffective' && (req.event === 'CREATE' || req.event === 'UPDATE')) {
-    if (suppressErrorPropagation) return
     checkIfAssocDeep(element, val, req)
   }
 }
 
 const processorFn =
   req =>
-  (row, key, element, plain, isRoot, pathSegments, suppressErrorPropagation = false) => {
+  ({ row, key, element, plain }) => {
     const categories = plain.categories
     const val = row[key]
 
     for (const category of categories) {
-      _processCategory({ row, key, val, category, req, element, suppressErrorPropagation })
+      _processCategory({ category, row, key, element, val, req })
     }
   }
 

package/libx/_runtime/db/generic/integrity.js

@@ -48,7 +48,7 @@ async function beforeDelete(req) {
   const dependents = getDependents(target, this.model)
   if (!dependents) return
 
-  const keys = Object.keys(target.keys).filter(k => _isPrimitiveKey(target.elements[k]))
+  const keys = Object.keys(target.keys).filter(k => _isPrimitiveKey(target.elements[k]) && k !== 'IsActiveEntity')
   let select = SELECT(keys).from(req.target.name)
   if (req.query.DELETE.where) {
     select = select.where(req.query.DELETE.where)

package/libx/_runtime/db/generic/rewrite.js

@@ -1,6 +1,7 @@
 const cqn2cqn4sql = require('../../common/utils/cqn2cqn4sql')
 const generateAliases = require('../utils/generateAliases')
 const rewriteAsterisk = require('../../common/utils/rewriteAsterisk')
+const { restoreLink } = require('../../common/utils/resolveView')
 
 const _isLinked = req => {
   if (req.query.INSERT && req.query.INSERT.entries) {
@@ -11,15 +12,6 @@ const _isLinked = req => {
   }
 }
 
-const _restoreLink = req => {
-  if (req.query.INSERT && req.query.INSERT.entries) {
-    if (Array.isArray(req.query.INSERT.entries)) req.data = req.query.INSERT.entries[0]
-    else req.data = req.query.INSERT.entries
-  } else if (req.query.UPDATE && req.query.UPDATE.data) {
-    req.data = req.query.UPDATE.data
-  }
-}
-
 function handler(req) {
   // REVISIT: req.target._unresolved for join queries
   if (!this.model || typeof req.query === 'string' /* || !req.target || req.target._unresolved */) {
@@ -39,7 +31,7 @@ function handler(req) {
 
   // REVISIT: should not be necessary
   // restore link to req.data
-  if (linked) _restoreLink(req)
+  if (linked) restoreLink(req)
 
   if (streaming) req.query._streaming = streaming
   if (validationQuery) req.query._validationQuery = validationQuery

package/libx/_runtime/db/generic/update.js

@@ -2,6 +2,7 @@
 // const UpdateResult = require('../result/UpdateResult')
 
 const { allKeysAreProvided } = require('../../cds-services/services/utils/handlerUtils')
+const onlyKeysRemain = require('../../common/utils/onlyKeysRemain')
 
 const _enrichKeysFromOldData = (req, oldData) => {
   const data = req.data && (Array.isArray(req.data) ? req.data : [req.data])
@@ -27,7 +28,7 @@ const _addKeysToQuery = req => {
 }
 
 const _targetKeys = target => {
-  return Object.values(target.keys)
+  return Object.values(target.keys || {})
     .filter(k => !(k.is2one || k.is2many))
     .map(k => ({ ref: [k.name] }))
 }
@@ -47,20 +48,27 @@ module.exports = async function (req) {
 
   if (req.target && !req.target._unresolved && req.target._isSingleton) {
     if (!allKeysAreProvided(req)) {
-      const readKeysCQN = {
-        SELECT: Object.assign({ columns: _targetKeys(req.target), one: true }, req.target.query.SELECT)
-      }
+      // REVISIT: There can also be renaming... we better use resolveView here.
+      const targetKeys = _targetKeys(req.target)
+      const readKeysCQN =
+        req.target.query && req.target.query.SELECT
+          ? {
+              SELECT: Object.assign({ columns: targetKeys, one: true }, req.target.query.SELECT)
+            }
+          : SELECT.from(req.target).columns(targetKeys)
 
       // REVISIT: avoid additional read
       const current = await this._read(this.model, this.dbc, readKeysCQN, req)
       _enrichKeysFromOldData(req, current)
     }
 
-    if (!req.query.UPDATE.where) {
+    if (!req.query.UPDATE.where && req.target.keys) {
       _addKeysToQuery(req)
     }
   }
 
+  if (onlyKeysRemain(req)) return
+
   try {
     const result = await this._update(this.model, this.dbc, req.query, req)
     return result

package/libx/_runtime/db/generic/virtual.js

@@ -1,80 +1,44 @@
 /*
- * handler for filtering virtual fields by READ
+ * handler for converting virtual fields to { val: null, as: 'myVirtualField' } by READ
  */
 
-const _filter = (columns, target, model, remove = true, virtuals = []) => {
-  if (!target) return virtuals
-  let i = 0
-  while (i < columns.length) {
-    const col = columns[i]
+const { ensureNoDraftsSuffix } = require('../../common/utils/draft')
+
+const _convert = (columns, target, model) => {
+  if (!target) return
+  for (const col of columns) {
     const element = col.ref && target.elements[col.ref[col.ref.length - 1]]
     if (element) {
       if (element.virtual) {
-        if (remove) {
-          columns.splice(i, 1)
-          i--
-        }
-        virtuals.push(element.name)
+        col.as = col.as || col.ref[col.ref.length - 1]
+        delete col.ref
+        col.val = (element.default && element.default.val) || null
       }
       if (col.expand && element.isAssociation) {
-        const _virtuals = _filter(col.expand, model.definitions[element.target], model, remove)
-        if (_virtuals.length) virtuals.push({ name: element.name, virtuals: _virtuals })
+        _convert(col.expand, model.definitions[element.target], model)
       }
     }
-    i++
   }
-  return virtuals
 }
 
-const _find = (columns, target, model) => _filter(columns, target, model, false)
-
-const _handleVirtuals = (req, model, remove) => {
+const convertVirtuals = function (req, _model) {
+  const model = this.model || _model
   // target.name ensures it is not a union or join
-  if (typeof req.query === 'string' || !req.target || typeof req.target.name !== 'string' || !model) return []
-  const target = (!req.target._unresolved && req.target) || model.definitions[req.target.name.replace(/_drafts$/, '')]
+  if (typeof req.query === 'string' || !req.target || typeof req.target.name !== 'string' || !model) return
+  const target = (!req.target._unresolved && req.target) || model.definitions[ensureNoDraftsSuffix(req.target.name)]
   const columns = (req.query && req.query.SELECT && req.query.SELECT.columns) || []
-  if (!target) return []
-  if (!remove && !columns.length && target && target.elements) {
-    for (const el in target.elements) {
-      columns.push({ ref: [el] })
-    }
-  }
-  const _handlerFn = (!remove && _find) || _filter
-  return _handlerFn(columns, target, model)
-}
-
-const getVirtuals = (req, model) => _handleVirtuals(req, model)
-
-const removeVirtuals = function (req, model) {
-  return _handleVirtuals(req, this.model || model, true)
-}
-
-const postProcessVirtuals = (virtuals, result) => {
-  if (!result) return
-  result = result.value && Object.keys(result).filter(k => !k.match(/^\W/)).length === 1 ? result.value : result
-  const rows = Array.isArray(result) ? result : [result]
-  for (const virtual of virtuals) {
-    for (const row of rows) {
-      if (typeof row !== 'object') continue
-      if (virtual.name && row[virtual.name]) postProcessVirtuals(virtual.virtuals, row[virtual.name])
-      else if (!(virtual in row)) row[virtual] = null
+  _convert(columns, target, model)
+  if (req.query.SELECT.from && req.query.SELECT.from.SET) {
+    for (const arg of req.query.SELECT.from.SET.args) {
+      const target = model.definitions[ensureNoDraftsSuffix(arg._target.name)]
+      const columns = (arg.SELECT && arg.SELECT.columns) || []
+      _convert(columns, target, model, true)
     }
   }
 }
 
-const getVirtualFromTarget = ({ target }) => {
-  const virtuals = []
-  for (const k in target.elements) {
-    if (target.elements[k].virtual) virtuals.push(k)
-  }
-  return virtuals
-}
-
-removeVirtuals._initial = true
+convertVirtuals._initial = true
 
 module.exports = {
-  removeVirtuals,
-  getVirtualFromTarget,
-  postProcessVirtuals,
-  getVirtuals
+  convertVirtuals
 }

package/libx/_runtime/db/query/delete.js

@@ -3,7 +3,8 @@ const { timestampToISO } = require('../data-conversion/timestamp')
 const { hasDeepDelete, getDeepDeleteCQNs } = require('../../common/composition')
 
 const deleteFn = executeDeleteCQN => async (model, dbc, query, req) => {
-  const ts = timestampToISO(req.timestamp)
+  const { user, locale, timestamp } = req
+  const isoTs = timestampToISO(timestamp)
 
   let result
   if (hasDeepDelete(model && model.definitions, query)) {
@@ -11,17 +12,19 @@ const deleteFn = executeDeleteCQN => async (model, dbc, query, req) => {
 
     // the delete chunks, i.e., how many deletes can be processed in parallel
     const chunks = []
-    for (const each of cqns) chunks.push(each.length)
+    for (const each of cqns) {
+      if (each.length) chunks.push(each.length)
+    }
 
     cqns = getFlatArray(cqns)
 
     if (cqns.length === 0) return 0
 
-    const results = await processCQNs(executeDeleteCQN, cqns, model, dbc, req.user, req.user.locale, ts, chunks)
+    const results = await processCQNs(executeDeleteCQN, cqns, model, dbc, user, locale, isoTs, chunks)
     // return number of affected rows of "root cqn"
     result = results[results.length - 1]
   } else {
-    result = await executeDeleteCQN(model, dbc, query, req.user, req.user.locale, ts)
+    result = await executeDeleteCQN(model, dbc, query, user, locale, isoTs)
   }
 
   return result

package/libx/_runtime/db/query/insert.js

@@ -1,20 +1,22 @@
-const { hasDeepInsert, getDeepInsertCQNs } = require('../../common/composition')
+const { hasDeepInsert, getDeepInsertCQNs, cleanEmptyCompositionsOfMany } = require('../../common/composition')
 const { getFlatArray, processCQNs } = require('../utils/deep')
 const { timestampToISO } = require('../data-conversion/timestamp')
 
 const insert = executeInsertCQN => async (model, dbc, query, req) => {
-  const ts = timestampToISO(req.timestamp)
+  const { user, locale, timestamp } = req
+  const isoTs = timestampToISO(timestamp)
 
   if (hasDeepInsert(model && model.definitions, query)) {
     const cqns = getFlatArray(getDeepInsertCQNs(model && model.definitions, query))
 
     // return array of individual results
     if (cqns.length === 0) return []
-    const results = await processCQNs(executeInsertCQN, cqns, model, dbc, req.user, req.user.locale, ts)
+    const results = await processCQNs(executeInsertCQN, cqns, model, dbc, user, locale, isoTs)
     return getFlatArray(results)
   }
 
-  return executeInsertCQN(model, dbc, query, req.user, req.user.locale, ts)
+  cleanEmptyCompositionsOfMany(model && model.definitions, query)
+  return executeInsertCQN(model, dbc, query, user, locale, isoTs)
 }
 
 module.exports = insert

package/libx/_runtime/db/query/read.js

@@ -21,52 +21,45 @@ function _createCountQuery(query) {
       subCountQuery.SELECT.columns = [{ val: 1 }]
     })
   }
+  if (query.SELECT._4odata) _query.SELECT._4odata = true
   return _query
 }
 
 const read = (executeSelectCQN, executeStreamCQN) => (model, dbc, query, req) => {
+  const { user, locale, timestamp } = req
+  const isoTs = timestampToISO(timestamp)
+
   if (query._streaming) {
     if (!query.SELECT || (query.SELECT && (!query.SELECT.columns || query.SELECT.columns.length !== 1))) {
       req.reject(400)
     }
-    return executeStreamCQN(model, dbc, query, req.user, req.user.locale, timestampToISO(req.timestamp))
+    return executeStreamCQN(model, dbc, query, user, locale, isoTs)
   }
 
+  // needed in case of expand
+  query._rootEntity = req.target
+
   if (query.SELECT.count) {
     if (query.SELECT.limit) {
       const countQuery = _createCountQuery(query)
-      const countResultPromise = executeSelectCQN(
-        model,
-        dbc,
-        countQuery,
-        req.user,
-        req.user.locale,
-        timestampToISO(req.timestamp)
-      )
+      const countResultPromise = executeSelectCQN(model, dbc, countQuery, user, locale, isoTs)
       if (query.SELECT.limit.rows && query.SELECT.limit.rows.val === 0) {
         // We don't need to perform our result query
         return countResultPromise.then(countResult => _arrayWithCount([], countResult[0]._counted_))
       } else {
-        const resultPromise = executeSelectCQN(
-          model,
-          dbc,
-          query,
-          req.user,
-          req.user.locale,
-          timestampToISO(req.timestamp)
-        )
+        const resultPromise = executeSelectCQN(model, dbc, query, user, locale, isoTs)
         return Promise.all([countResultPromise, resultPromise]).then(([countResult, result]) =>
           _arrayWithCount(result, countResult[0]._counted_)
         )
       }
     } else {
-      return executeSelectCQN(model, dbc, query, req.user, req.user.locale, timestampToISO(req.timestamp)).then(
-        result => _arrayWithCount(result, result.length)
+      return executeSelectCQN(model, dbc, query, user, locale, isoTs).then(result =>
+        _arrayWithCount(result, result.length)
       )
     }
   }
 
-  return executeSelectCQN(model, dbc, query, req.user, req.user.locale, timestampToISO(req.timestamp))
+  return executeSelectCQN(model, dbc, query, user, locale, isoTs)
 }
 
 module.exports = read

package/libx/_runtime/db/query/run.js

@@ -21,7 +21,10 @@ const run = (insert, read, update, deleet, cqn, sql) => (model, dbc, query, req,
     return update(model, dbc, query, req)
   }
 
-  return cqn(model, dbc, query, req.user, req.user.locale, timestampToISO(req.timestamp))
+  const { user, locale, timestamp } = req
+  const isoTs = timestampToISO(timestamp)
+
+  return cqn(model, dbc, query, user, locale, isoTs)
 }
 
 module.exports = run

package/libx/_runtime/db/query/update.js

@@ -48,14 +48,15 @@ const _getFilteredCqns = (cqns, model) => {
 }
 
 const update = (executeUpdateCQN, executeSelectCQN) => async (model, dbc, query, req) => {
-  const ts = timestampToISO(req.timestamp)
+  const { user, locale, timestamp } = req
+  const isoTs = timestampToISO(timestamp)
 
   if (hasDeepUpdate(model && model.definitions, query)) {
     // REVISIT: _activeData gets set in case of draftActivate for performance, but this is a layer violation
     let selectData = req._ && req._.query && req._.query._activeData
     if (!selectData) {
       // REVISIT: avoid additional read
-      selectData = await selectDeepUpdateData(model && model.definitions, query, req)
+      selectData = await selectDeepUpdateData(model && model.definitions, query, req, false, false, cds.db)
     } else {
       selectData = [selectData]
     }
@@ -70,14 +71,14 @@ const update = (executeUpdateCQN, executeSelectCQN) => async (model, dbc, query,
     cqns = _getFilteredCqns(getFlatArray(cqns), model)
 
     if (cqns.length === 0) return 0
-    const results = await processCQNs(executeUpdateCQN, cqns, model, dbc, req.user, req.user.locale, ts, chunks)
+    const results = await processCQNs(executeUpdateCQN, cqns, model, dbc, user, locale, isoTs, chunks)
     // return number of affected rows of "root cqn", if an update, 1 otherwise (as not update of root but its children)
     if (cqns[0].UPDATE) return results[0]
     return 1
   }
 
   // REVISIT: don't invoke setters if not needed
-  return executeUpdateCQN(model, dbc, query, req.user, req.user.locale, ts)
+  return executeUpdateCQN(model, dbc, query, user, locale, isoTs)
 }
 
 module.exports = update

package/libx/_runtime/db/sql-builder/ExpressionBuilder.js

@@ -1,6 +1,16 @@
+const cds = require('../../cds')
+
 const BaseBuilder = require('./BaseBuilder')
 const { flattenStructuredWhereHaving } = require('../../common/utils/structured')
 
+const SQLITE_DATETIME_FUNCTIONS = new Set(['year', 'month', 'day', 'second', 'hour', 'minute'])
+const OPERATORS = new Set(['=', '!=', '<>', '<', '>', '<=', '>='])
+
+function _fillAfterDot(val) {
+  const [beforeDot, afterDot = ''] = val.split('.')
+  return `${beforeDot}.${afterDot.padEnd(3, '0')}`
+}
+
 /**
  * ExpressionBuilder is used to take a part of a CQN object as an input and to build an object representing an expression
  * with SQL string and values to be used with a prepared statement.
@@ -127,7 +137,30 @@ class ExpressionBuilder extends BaseBuilder {
    * @returns {number}
    * @private
    */
+  // eslint-disable-next-line complexity
   _reseverdKeyWords(objects, i) {
+    if (objects[i] === 'not' && objects[i + 1].func) {
+      objects[i + 1].func = `not ${objects[i + 1].func}`
+      return 1
+    }
+    if (objects[i].func || (objects[i + 2] && objects[i + 2].func)) {
+      // sqlite requires leading 0 for numbers in datetime functions
+      const f = objects[i].func ? i : OPERATORS.has(objects[i + 1]) ? i + 2 : i - 2
+      const v = objects[i].val ? i : OPERATORS.has(objects[i + 1]) ? i + 2 : i - 2
+      if (objects[f] && SQLITE_DATETIME_FUNCTIONS.has(objects[f].func) && cds.db && cds.db.kind === 'sqlite') {
+        if (objects[v] && objects[v].val !== undefined && typeof objects[v].val === 'number') {
+          objects[v] = { val: `${objects[v].val < 10 ? 0 : ''}${objects[v].val}` }
+          if (objects[f].func === 'second') objects[v].val = _fillAfterDot(objects[v].val)
+        }
+      }
+      // odata indexof function returns the zero-based character position of the first occurrence
+      if (this._options._4odata && objects[i].func && objects[i].func === 'indexof') {
+        if (objects[i + 2] && objects[i + 2].val !== undefined) objects[i + 2].val++
+        else if (objects[i - 2] && objects[i - 2].val !== undefined) this._outputObj.sql[i - 2]++
+      }
+      return 0
+    }
+
     if ((objects[i + 1] === '=' || objects[i + 1] === '!=') && objects[i + 2] && objects[i + 2].val === null) {
       this._addNullOrNotNull(objects[i], objects[i + 1])
       return 3
@@ -304,8 +337,8 @@ class ExpressionBuilder extends BaseBuilder {
 
   _xprOutputFromElement(element) {
     this._options.objectKey = 'xpr'
-
-    this._addToOutputObj(new ExpressionBuilder(element, this._options, this._csn).build(), true)
+    // new instance of subclass builder
+    this._addToOutputObj(new this.constructor(element, this._options, this._csn).build(), true)
   }
 
   /**

package/libx/_runtime/db/sql-builder/FunctionBuilder.js

@@ -6,7 +6,8 @@ const cqn2sqlFunc = {
   indexof: 'locate',
   day: 'dayofmonth',
   date: 'to_date',
-  time: 'to_time'
+  time: 'to_time',
+  average: 'avg'
 }
 
 /**
@@ -66,6 +67,7 @@ class FunctionBuilder extends BaseBuilder {
   _handleFunction() {
     const functionName = this._functionName()
     const args = this._functionArgs()
+
     if (!args) {
       // > arg-less func such as current_date
       this._outputObj.sql.push(functionName)
@@ -89,12 +91,24 @@ class FunctionBuilder extends BaseBuilder {
       return
     }
 
+    if (functionName === 'countdistinct') {
+      this._handleCountdistinct(args)
+      return
+    }
+
     this._outputObj.sql.push(functionName, '(')
     if (typeof args === 'string') this._outputObj.sql.push(args)
     else this._addFunctionArgs(args)
     this._outputObj.sql.push(')')
   }
 
+  _handleCountdistinct(args) {
+    this._outputObj.sql.push('count', '(', 'DISTINCT')
+    if (typeof args === 'string') this._outputObj.sql.push(args)
+    else this._addFunctionArgs(args)
+    this._outputObj.sql.push(')')
+  }
+
   _handleContains(args) {
     this._handleLikewiseFunc(args)
   }
@@ -165,7 +179,8 @@ class FunctionBuilder extends BaseBuilder {
         res.push(sql)
         this._outputObj.values.push(...values)
       } else if (arg.func) {
-        const { sql, values } = new FunctionBuilder(arg, this._options, this._csn).build()
+        // new instance of subclass builder
+        const { sql, values } = new this.constructor(arg, this._options, this._csn).build()
         res.push(sql)
         this._outputObj.values.push(...values)
       } else if (arg.xpr) {