@sap/cds 5.7.5 → 5.8.0

package/libx/_runtime/db/data-conversion/post-processing.js

@@ -90,7 +90,8 @@ const _extractRefs = (from, as) => {
   return [ref]
 }
 
-const _addMapperFunction = (elements, toService, key, type, from, includeAlias) => {
+// REVISIT: check why we need includeAlias for some draft cases (check AFC tests)
+const _addMapperFunction = (elements, toService, key, type, alias, includeAlias) => {
   if (!toService.has(type)) {
     return
   }
@@ -99,9 +100,8 @@ const _addMapperFunction = (elements, toService, key, type, from, includeAlias)
 
   // ambiguous cases will lead to SQL syntax errors anyway, so no need for a check
   elements.set(key, convertFunction)
-
-  if (includeAlias) {
-    elements.set(`${from.as}_${key}`, convertFunction)
+  if (includeAlias && alias) {
+    elements.set(`${alias}_${key}`, convertFunction)
   }
 }
 
@@ -109,13 +109,13 @@ const _filterUnique = (value, index, arr) => {
   return arr.indexOf(value) === index
 }
 
-const _addMapperFunction4struct = (elements, toService, parent, struct, from, includeAlias) => {
+const _addMapperFunction4struct = (elements, toService, parent, struct, alias, includeAlias) => {
   for (const k in struct.elements) {
     const current = struct.elements[k]
     if (current._isStructured) {
-      _addMapperFunction4struct(elements, toService, `${parent}_${k}`, current, from, includeAlias)
+      _addMapperFunction4struct(elements, toService, `${parent}_${k}`, current, alias, includeAlias)
     } else {
-      _addMapperFunction(elements, toService, `${parent}_${k}`, current.type, from, includeAlias)
+      _addMapperFunction(elements, toService, `${parent}_${k}`, current.type, alias, includeAlias)
     }
   }
 }
@@ -126,7 +126,6 @@ const _addMapperFunction4struct = (elements, toService, parent, struct, from, in
  * @param {Map} toService - Mapping instructions for data conversions based on CDS data types
  * @param {object} csn - Reflected CSN
  * @param {object} cqn - CQN that is used to query the DB.
- * @param {boolean} [includeAlias] - Include mapping for aliases. Defaults to false.
  * @returns {Map<any, any>}
  * @private
  */
@@ -142,13 +141,16 @@ const _getElementCombinations = (toService, csn, cqn, includeAlias = false) => {
     }
 
     const entity = csn.definitions[ensureUnlocalized(entityName)]
-
     for (const key in entity.elements) {
       const element = entity.elements[key]
       if (element._isStructured) {
-        _addMapperFunction4struct(elements, toService, key, element, from, includeAlias)
+        _addMapperFunction4struct(elements, toService, key, element, from.as, includeAlias)
       } else {
-        _addMapperFunction(elements, toService, key, element.type, from, includeAlias)
+        if ('SET' in cqn.SELECT.from) {
+          _addMapperFunction(elements, toService, key, element.type, cqn.SELECT.from.as, includeAlias)
+        } else {
+          _addMapperFunction(elements, toService, key, element.type, from.as, includeAlias)
+        }
       }
     }
   }
@@ -182,15 +184,17 @@ const _getMapperForListedElements = (toService, csn, cqn) => {
 
   for (const element of cqn.SELECT.columns) {
     if (element.ref) {
-      const identifier = element.ref[element.ref.length - 1]
+      const identifier = element.ref.length === 1 ? element.ref[0] : undefined
       const name = element.as ? element.as : identifier
 
       if (element.cast) {
         mapper.set(name, _getCastFunction(element.cast))
       } else if (elements.has(name)) {
         mapper.set(name, elements.get(name))
-      } else if (elements.has(identifier) && !cqn.SELECT.from.args) {
+      } else if (elements.has(identifier)) {
         mapper.set(name, elements.get(identifier))
+      } else if (elements.has(element.ref.join('_'))) {
+        mapper.set(name || element.ref[element.ref.length - 1], elements.get(element.ref.join('_')))
       }
     } else if (element.as && element.cast) {
       mapper.set(element.as, _getCastFunction(element.cast))
@@ -514,6 +518,9 @@ const getPropertyMapper = (csn, cqn) => {
   return new Map()
 }
 
+/*
+ * this module is required by cds-pg. -> in case of incompatible changes, we should let them know.
+ */
 module.exports = {
   getPropertyMapper,
   getPostProcessMapper,

package/libx/_runtime/db/expand/expand-v2.js

@@ -11,9 +11,10 @@ const _removeParentKeysFromRow = (row, prefix, keys) => {
   }
 }
 
-const _autoExpandNavsAndAttachToResult = async (entity, previousResult, depth) => {
+const _autoExpandNavsAndAttachToResult = async (entity, previousResult, depth, options) => {
   for (const nav in entity._associations) {
     const navigation = entity._associations[nav]
+    if (options.onlyCompositions && navigation._isAssociationEffective) continue
 
     // do not expand backlinks
     if (navigation._isBacklink) continue
@@ -26,7 +27,9 @@ const _autoExpandNavsAndAttachToResult = async (entity, previousResult, depth) =
       .on(entity._relations[navigation.name].join(childAlias, parentAlias))
 
     // set alias for expanded columns already
-    const childColumns = getColumns(navigation._target).map(c => ({ ref: [childAlias, c.name] }))
+    const childColumns = getColumns(navigation._target, { _4db: true, onlyKeys: options.onlyKeys }).map(c => ({
+      ref: [childAlias, c.name]
+    }))
     const parentKeys = Object.keys(entity.keys).filter(k => !entity.keys[k].isAssociation)
     // mark parent key with prefix in alias
     const parentKeysWithAlias = parentKeys.map(pk => ({ ref: [parentAlias, pk], as: `$$pk_${pk}` }))
@@ -69,16 +72,17 @@ const _autoExpandNavsAndAttachToResult = async (entity, previousResult, depth) =
 
     // expand next level if needed
     if (depth - 1 !== 0 && result.length && navigation._target._associations) {
-      await _autoExpandNavsAndAttachToResult(navigation._target, result, depth - 1)
+      await _autoExpandNavsAndAttachToResult(navigation._target, result, depth - 1, options)
     }
   }
 
   return previousResult
 }
 
-const _foreignKeysOfTopLevelNavs = entity => {
+const _foreignKeysOfTopLevelNavs = (entity, options) => {
   const requiredFks = new Set()
   for (const nav in entity._associations) {
+    if (options.onlyCompositions && entity._associations[nav]._isAssociationEffective) continue
     const onCond = entity._relations[nav].join('child', 'parent')
     for (const ele of onCond) {
       if (ele.ref && ele.ref[0] === 'parent') {
@@ -89,6 +93,15 @@ const _foreignKeysOfTopLevelNavs = entity => {
   return [...requiredFks]
 }
 
+const _addForeignKeys = (columns, entity, options) => {
+  const fks = _foreignKeysOfTopLevelNavs(entity, options)
+  fks.forEach(fk => {
+    if (!columns.some(c => c.ref[0] === fk)) {
+      columns.push({ ref: [fk] })
+    }
+  })
+}
+
 /**
  * 1. Creates flattened SQL statements for each expand layer
  * 2. Mixes in foreign keys if needed
@@ -98,18 +111,15 @@ const _foreignKeysOfTopLevelNavs = entity => {
  * @returns object
  */
 const expandV2 = async (model, dbc, query, user, locale, txTimestamp, executeSelectCQN) => {
+  const expandColumn = query.SELECT.columns.find(c => c.expand && typeof c.expand === 'string')
+  const options = Object.assign({ onlyKeys: false, onlyCompositions: false }, expandColumn._options)
   // remove expand columns from query without modifying
   const topLevelSelect = query.clone().columns(query.SELECT.columns.filter(c => !c.expand))
 
   const entity = model.definitions[topLevelSelect.SELECT.from.ref[0]]
 
   // ensure foreign keys are selected if needed
-  const fks = _foreignKeysOfTopLevelNavs(entity)
-  fks.forEach(fk => {
-    if (!topLevelSelect.SELECT.columns.some(c => c.ref[0] === fk)) {
-      topLevelSelect.SELECT.columns.push({ ref: [fk] })
-    }
-  })
+  _addForeignKeys(topLevelSelect.SELECT.columns, entity, options)
 
   const result = await executeSelectCQN(model, dbc, topLevelSelect, user, locale, txTimestamp)
 
@@ -119,9 +129,8 @@ const expandV2 = async (model, dbc, query, user, locale, txTimestamp, executeSel
 
   // _associations contains compositions and associations
   if (entity._associations) {
-    const expandColumn = query.SELECT.columns.find(c => c.expand && typeof c.expand === 'string')
     const depth = expandColumn.expand === '**' ? -1 : Number(expandColumn.expand.replace('*', ''))
-    await _autoExpandNavsAndAttachToResult(entity, Array.isArray(result) ? result : [result], depth)
+    await _autoExpandNavsAndAttachToResult(entity, Array.isArray(result) ? result : [result], depth, options)
   }
 
   return result

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

@@ -2,10 +2,15 @@ const cds = require('../../cds')
 
 const { getAllKeys } = require('../../cds-services/adapter/odata-v4/odata-to-cqn/utils')
 
+const { deepCopyObject } = require('../../common/utils/copy')
 const { getNavigationIfStruct } = require('../../common/utils/structured')
 const { ensureNoDraftsSuffix, ensureDraftsSuffix, ensureUnlocalized } = require('../../common/utils/draft')
-const { filterKeys } = require('../../fiori/utils/handler')
 const { isAsteriskColumn } = require('../../common/utils/rewriteAsterisks')
+const { getCQNUnionFrom } = require('../../common/utils/union')
+
+const { DRAFT_COLUMNS } = require('../../common/constants/draft')
+
+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')
@@ -16,12 +21,9 @@ const IDENTIFIER = Symbol.for('sap.cds.identifier')
 const IS_ACTIVE = Symbol.for('sap.cds.isActive')
 const IS_UNION_DRAFT = Symbol.for('sap.cds.isUnionDraft')
 
-const { DRAFT_COLUMNS } = require('../../common/constants/draft')
-
-const { getCQNUnionFrom } = require('../../common/utils/union')
-
 function getCqnCopy(readToOneCQN) {
-  const readToOneCQNCopy = JSON.parse(JSON.stringify(readToOneCQN))
+  // REVISIT: Use query.clone() instead
+  const readToOneCQNCopy = deepCopyObject(readToOneCQN)
   if (readToOneCQN[GET_KEY_VALUE] !== undefined) readToOneCQNCopy[GET_KEY_VALUE] = readToOneCQN[GET_KEY_VALUE]
   if (readToOneCQN[TO_MANY] !== undefined) readToOneCQNCopy[TO_MANY] = readToOneCQN[TO_MANY]
   if (readToOneCQN[TO_ACTIVE] !== undefined) readToOneCQNCopy[TO_ACTIVE] = readToOneCQN[TO_ACTIVE]

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

@@ -2,6 +2,9 @@ const { hasExpand, createJoinCQNFromExpanded } = require('./expandCQNToJoin')
 const rawToExpanded = require('./rawToExpanded')
 const expandV2 = require('./expand-v2')
 
+/*
+ * this module is required by cds-pg. -> in case of incompatible changes, we should let them know.
+ */
 module.exports = {
   hasExpand,
   createJoinCQNFromExpanded,

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

@@ -15,16 +15,6 @@ module.exports = async function (req) {
   }
 
   try {
-    // REVISIT: should be handled in protocol adapter
-    // execute validation query first to fail early
-    if (req.query._validationQuery) {
-      const validationResult = await this._read(this.model, this.dbc, req.query._validationQuery, req)
-
-      if (validationResult.length === 0) {
-        // > validation target (e.g., root of navigation) doesn't exist
-        req.reject(404)
-      }
-    }
     const results = await this._insert(this.model, this.dbc, req.query, req)
     return new InsertResult(req, results)
   } catch (err) {

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

@@ -12,6 +12,9 @@ const DELETE = require('./delete')
 const structured = require('./structured')
 const arrayed = require('./arrayed')
 
+/*
+ * this module is required by cds-pg. -> in case of incompatible changes, we should let them know.
+ */
 module.exports = {
   rewrite,
   virtual,

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

@@ -7,32 +7,10 @@
  *
  * @param req - cds.Request
  */
-module.exports = async function (req) {
+module.exports = function (req) {
   if (typeof req.query === 'string') {
     return this._execute.sql(this.dbc, req.query, req.data)
   }
 
-  // REVISIT: should be handled in protocol adapter
-  // execute validation query first to fail early
-  if (req.query._validationQuery) {
-    const validationResult = await this._read(this.model, this.dbc, req.query._validationQuery, req)
-
-    if (validationResult.length === 0) {
-      // > validation target (e.g., root of navigation) doesn't exist
-      req.reject(404)
-    }
-  }
-
-  const result = await this._read(this.model, this.dbc, req.query, req)
-
-  if (
-    req.query._validationQuery &&
-    req.query._validationQuery.__navToManyWithKeys &&
-    (!result || result.length === 0)
-  ) {
-    // > navigation to collection with key specified without result -> 404
-    req.reject(404)
-  }
-
-  return result
+  return this._read(this.model, this.dbc, req.query, req)
 }

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

@@ -1,5 +1,5 @@
 const { cqn2cqn4sql } = require('../../common/utils/cqn2cqn4sql')
-const generateAliases = require('../utils/generateAliases')
+const { generateAliases } = require('../utils/generateAliases')
 const { restoreLink } = require('../../common/utils/resolveView')
 
 const _isLinked = req => {
@@ -18,7 +18,6 @@ function handler(req) {
   }
 
   const streaming = req.query._streaming
-  const validationQuery = req.query._validationQuery
 
   // for restore link to req.data
   const linked = _isLinked(req)
@@ -31,7 +30,6 @@ function handler(req) {
   if (linked) restoreLink(req)
 
   if (streaming) req.query._streaming = streaming
-  if (validationQuery) req.query._validationQuery = validationQuery
 
   generateAliases(req.query)
 }

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

@@ -70,7 +70,7 @@ module.exports = async function (req) {
   if (onlyKeysRemain(req)) return
 
   try {
-    const result = await this._update(this.model, this.dbc, req.query, req)
+    const result = await this._update(this.model, this.dbc, req)
     return result
   } catch (err) {
     // REVISIT: db specifics

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

@@ -1,14 +1,14 @@
 const { getFlatArray, processCQNs } = require('../utils/deep')
 const { timestampToISO } = require('../data-conversion/timestamp')
-const { hasDeepDelete, getDeepDeleteCQNs } = require('../../common/composition')
+const { hasDeepDelete, getDeepDeleteCQNs, getSetNullParentForeignKeyCQNs } = require('../../common/composition')
 
-const deleteFn = executeDeleteCQN => async (model, dbc, query, req) => {
+const deleteFn = (executeDeleteCQN, executeUpdateCQN) => async (model, dbc, query, req) => {
   const { user, locale, timestamp } = req
   const isoTs = timestampToISO(timestamp)
 
   let result
-  if (hasDeepDelete(model && model.definitions, query)) {
-    let cqns = getDeepDeleteCQNs(model && model.definitions, query)
+  if (hasDeepDelete(model, query)) {
+    let cqns = await getDeepDeleteCQNs(model, req)
 
     // the delete chunks, i.e., how many deletes can be processed in parallel
     const chunks = []
@@ -25,6 +25,12 @@ const deleteFn = executeDeleteCQN => async (model, dbc, query, req) => {
     result = results[results.length - 1]
   } else {
     result = await executeDeleteCQN(model, dbc, query, user, locale, isoTs)
+    if (result) {
+      const updateCQNs = await getSetNullParentForeignKeyCQNs(model, req)
+      for (const cqn of updateCQNs) {
+        await executeUpdateCQN(model, dbc, cqn, user, locale, isoTs)
+      }
+    }
   }
 
   return result

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

@@ -6,8 +6,8 @@ const insert = executeInsertCQN => async (model, dbc, query, req) => {
   const { user, locale, timestamp } = req
   const isoTs = timestampToISO(timestamp)
 
-  if (hasDeepInsert(model && model.definitions, query)) {
-    const cqns = getFlatArray(getDeepInsertCQNs(model && model.definitions, query))
+  if (hasDeepInsert(model, query)) {
+    const cqns = getFlatArray(getDeepInsertCQNs(model, query))
 
     // return array of individual results
     if (cqns.length === 0) return []
@@ -15,7 +15,7 @@ const insert = executeInsertCQN => async (model, dbc, query, req) => {
     return getFlatArray(results)
   }
 
-  cleanEmptyCompositionsOfMany(model && model.definitions, query)
+  cleanEmptyCompositionsOfMany(model, query)
   return executeInsertCQN(model, dbc, query, user, locale, isoTs)
 }
 

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

@@ -1,5 +1,7 @@
 const { timestampToISO } = require('../data-conversion/timestamp')
 
+const { deepCopyObject } = require('../../common/utils/copy')
+
 function _arrayWithCount(a, count) {
   const _map = a.map
   const map = (..._) => _arrayWithCount(_map.call(a, ..._), count)
@@ -10,7 +12,8 @@ function _arrayWithCount(a, count) {
 }
 
 function _createCountQuery(query) {
-  let _query = JSON.parse(JSON.stringify(query)) // REVISIT: Use query.clone() instead
+  // REVISIT: Use query.clone() instead
+  let _query = { SELECT: deepCopyObject(query.SELECT) }
   delete _query.SELECT.orderBy // not necessary to keep that
   delete _query.SELECT.limit
   // Also change columns in sub queries

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

@@ -50,11 +50,11 @@ const _getFilteredCqns = (cqns, model) => {
   return cqns
 }
 
-const update = (executeUpdateCQN, executeSelectCQN) => async (model, dbc, query, req) => {
-  const { user, locale, timestamp } = req
+const update = executeUpdateCQN => async (model, dbc, req) => {
+  const { query, user, locale, timestamp } = req
   const isoTs = timestampToISO(timestamp)
 
-  if (hasDeepUpdate(model && model.definitions, query)) {
+  if (hasDeepUpdate(model, 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
 
@@ -62,10 +62,10 @@ const update = (executeUpdateCQN, executeSelectCQN) => async (model, dbc, query,
       selectData = [selectData]
     } else {
       // REVISIT: avoid additional read
-      selectData = await selectDeepUpdateData(model && model.definitions, query, req, false, false, cds.db)
+      selectData = await selectDeepUpdateData(cds.db, model, req)
     }
 
-    let cqns = getDeepUpdateCQNs(model && model.definitions, query, selectData)
+    let cqns = await getDeepUpdateCQNs(model, req, selectData)
 
     // the delete chunks, i.e., how many deletes can be processed in parallel
     const chunks = []

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

@@ -11,6 +11,10 @@ function _fillAfterDot(val) {
   return `${beforeDot}.${afterDot.padEnd(3, '0')}`
 }
 
+function _valButNoBuffer(arg) {
+  return arg && arg.val && typeof arg.val === 'object' && !(arg.val instanceof Buffer)
+}
+
 /**
  * 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.
@@ -87,9 +91,9 @@ class ExpressionBuilder extends BaseBuilder {
   }
 
   _isStructured(op1, comp, op2) {
-    if (op1.ref && comp === '=' && op2.val && typeof op2.val === 'object' && !(op2.val instanceof Buffer)) return true
+    if (op1.ref && comp === '=' && _valButNoBuffer(op2)) return true
     // also check reverse
-    if (op1.val && typeof op1.val === 'object' && comp === '=' && op2.ref && !(op1.val instanceof Buffer)) return true
+    if (_valButNoBuffer(op1) && comp === '=' && op2.ref) return true
   }
 
   _expressionObjectsToSQL(objects) {
@@ -379,4 +383,7 @@ class ExpressionBuilder extends BaseBuilder {
   }
 }
 
+/*
+ * this module is required by cds-pg. -> in case of incompatible changes, we should let them know.
+ */
 module.exports = ExpressionBuilder

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

@@ -214,4 +214,7 @@ class FunctionBuilder extends BaseBuilder {
   }
 }
 
+/*
+ * this module is required by cds-pg. -> in case of incompatible changes, we should let them know.
+ */
 module.exports = FunctionBuilder

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

@@ -9,6 +9,9 @@ const ReferenceBuilder = require('./ReferenceBuilder')
 const FunctionBuilder = require('./FunctionBuilder')
 const sqlFactory = require('./sqlFactory')
 
+/*
+ * this module is required by cds-pg. -> in case of incompatible changes, we should let them know.
+ */
 module.exports = {
   CreateBuilder,
   DropBuilder,

package/libx/_runtime/db/utils/columns.js

@@ -11,7 +11,7 @@ const { DRAFT_COLUMNS } = require('../../common/constants/draft')
  * @param entity - the csn entity
  * @returns {Array} - array of columns
  */
-const getColumns = (entity, { db, onlyKeys } = { db: true, onlyKeys: false }) => {
+const getColumns = (entity, { _4db, onlyKeys } = { _4db: true, onlyKeys: false }) => {
   // REVISIT is this correct or just a problem that occurs because of new structure we do not deal with yet?
   if (!(entity && entity.elements)) return []
   const columnNames = []
@@ -21,7 +21,7 @@ const getColumns = (entity, { db, onlyKeys } = { db: true, onlyKeys: false }) =>
     const element = elements[elementName]
     if (onlyKeys && !element.key) continue
     if (element.isAssociation) continue
-    if (db && entity._isDraftEnabled && DRAFT_COLUMNS.includes(elementName)) continue
+    if (_4db && entity._isDraftEnabled && DRAFT_COLUMNS.includes(elementName)) continue
     if (cds.env.effective.odata.structs && element.elements) {
       columnNames.push(...resolveStructured({ structName: elementName, structProperties: [] }, element.elements, false))
       continue
@@ -31,4 +31,7 @@ const getColumns = (entity, { db, onlyKeys } = { db: true, onlyKeys: false }) =>
   return columnNames.map(name => elements[name] || { name })
 }
 
+/*
+ * this module is required by cds-pg. -> in case of incompatible changes, we should let them know.
+ */
 module.exports = getColumns

package/libx/_runtime/db/utils/deep.js

@@ -28,20 +28,14 @@ async function processCQNs(processFn, cqns, model, dbc, user, locale, ts, chunks
   const results = new Array(cqns.length)
 
   const deletes = []
-  const updatesBeforeDelete = []
+  const updatesForDeletes = []
   const others = []
   for (let i = 0; i < cqns.length; i++) {
     if (cqns[i].DELETE) deletes.push(i)
-    else if (cqns[i].UPDATE && cqns[i].UPDATE._beforeDelete) updatesBeforeDelete.push(i)
+    else if (cqns[i].__4delete) updatesForDeletes.push(i)
     else others.push(i)
   }
 
-  // UPDATEs to SET null parent's foreign keys of one compositions
-  // which are otherwise violate foreign key constraints
-  if (updatesBeforeDelete.length) {
-    await _processChunk(processFn, model, dbc, cqns, user, locale, ts, updatesBeforeDelete, results)
-  }
-
   if (deletes.length > 0) {
     if (chunks) {
       let offset = 0
@@ -55,6 +49,10 @@ async function processCQNs(processFn, cqns, model, dbc, user, locale, ts, chunks
     }
   }
 
+  if (updatesForDeletes.length > 0) {
+    await _processChunk(processFn, model, dbc, cqns, user, locale, ts, updatesForDeletes, results)
+  }
+
   if (others.length > 0) {
     await _processChunk(processFn, model, dbc, cqns, user, locale, ts, others, results)
   }

package/libx/_runtime/db/utils/generateAliases.js

@@ -1,10 +1,9 @@
 const { ensureUnlocalized } = require('../../common/utils/draft')
-
 const ALIAS_PREFIX = 'ALIAS_'
-
-const cleanUpName = name => {
-  return ensureUnlocalized(name).replace(/\./g, '_')
-}
+const PARENT_ALIAS = '_parent_'
+const FOREIGN_ALIAS = '_foreign_'
+const PARENT_ALIAS_REGEX = new RegExp('^' + PARENT_ALIAS + '\\d*$')
+const cleanUpName = name => ensureUnlocalized(name).replace(/\./g, '_')
 
 const _redirectXpr = (xpr, aliasMap) => {
   if (!xpr) return
@@ -97,4 +96,55 @@ const generateAliases = query => {
   _generateAliases(query)
 }
 
-module.exports = generateAliases
+const _addParentAlias = (where, alias) => {
+  where.forEach(e => {
+    if (e.ref && e.ref[0].match(PARENT_ALIAS_REGEX)) {
+      e.ref[0] = alias
+    }
+  })
+}
+
+const _addAliasToElement = (expr, alias) => {
+  if (expr.ref) {
+    if (typeof alias === 'function') {
+      alias = alias(expr.ref)
+    }
+
+    return { ref: [alias, ...expr.ref] }
+  }
+
+  if (expr.list) {
+    return { list: expr.list.map(arg => _addAliasToElement(arg, alias)) }
+  }
+
+  if (expr.func) {
+    const args = expr.args.map(arg => _addAliasToElement(arg, alias))
+    return { ...expr, args }
+  }
+
+  if (expr.SELECT && expr.SELECT.where) {
+    // special case in lambda functions
+    _addParentAlias(expr.SELECT.where, alias)
+  }
+
+  if (expr.xpr) {
+    return { xpr: expr.xpr.map(xpr => _addAliasToElement(xpr, alias)) }
+  }
+
+  return expr
+}
+
+const addAliasToExpression = (expression, alias) => {
+  if (expression && alias) {
+    return expression.map(expr => _addAliasToElement(expr, alias))
+  }
+
+  return expression
+}
+
+module.exports = {
+  generateAliases,
+  addAliasToExpression,
+  PARENT_ALIAS,
+  FOREIGN_ALIAS
+}