@cap-js/db-service 1.20.2 → 2.0.1

package/CHANGELOG.md

@@ -4,22 +4,40 @@
 - The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - This project adheres to [Semantic Versioning](http://semver.org/).
 
-## [1.20.2](https://github.com/cap-js/cds-dbs/compare/db-service-v1.20.1...db-service-v1.20.2) (2025-05-28)
+## [2.0.1](https://github.com/cap-js/cds-dbs/compare/db-service-v2.0.0...db-service-v2.0.1) (2025-05-27)
 
 
 ### Fixed
 
-* close dependency ranges to cds^8 ([#1214](https://github.com/cap-js/cds-dbs/issues/1214)) ([a4156e8](https://github.com/cap-js/cds-dbs/commit/a4156e8db4bba8688457fe635d76aa0f1ac38d1e))
+* **`search`:** do not search on non-projected elements ([#1198](https://github.com/cap-js/cds-dbs/issues/1198)) ([73d9e67](https://github.com/cap-js/cds-dbs/commit/73d9e67b1bc7d7727c04b4577cb73f4daaed852b))
+* add shortcut for empty UPDATE.data ([#1203](https://github.com/cap-js/cds-dbs/issues/1203)) ([cf991ff](https://github.com/cap-js/cds-dbs/commit/cf991ff8179efee6a4621d2a2bd8bf6265e58893))
+* hierarchies in quoted mode ([3465cba](https://github.com/cap-js/cds-dbs/commit/3465cbab579d4560d12d3b230c55b746d4d3f5a5))
+* only sort by locale if locale is set ([#1193](https://github.com/cap-js/cds-dbs/issues/1193)) ([3465cba](https://github.com/cap-js/cds-dbs/commit/3465cbab579d4560d12d3b230c55b746d4d3f5a5))
 
-## [1.20.1](https://github.com/cap-js/cds-dbs/compare/db-service-v1.20.0...db-service-v1.20.1) (2025-05-27)
+
+### Changed
+
+* remove stream_compat ([#1139](https://github.com/cap-js/cds-dbs/issues/1139)) ([#1144](https://github.com/cap-js/cds-dbs/issues/1144)) ([1b8b2d9](https://github.com/cap-js/cds-dbs/commit/1b8b2d9539cd97be2cef088c98d88ef9ec7dd1bf))
+
+## [2.0.0](https://github.com/cap-js/cds-dbs/compare/db-service-v1.20.0...db-service-v2.0.0) (2025-05-07)
+
+
+### ⚠ BREAKING CHANGES
+
+* update peer dependency to @sap/cds@9 ([#1178](https://github.com/cap-js/cds-dbs/issues/1178))
 
 
 ### Fixed
 
-* **`search`:** do not search on non-projected elements ([#1198](https://github.com/cap-js/cds-dbs/issues/1198)) ([1461673](https://github.com/cap-js/cds-dbs/commit/14616730ba8c27e8ffa30c5962b881badfab991c))
-* current_utctimestamp as default ([#1161](https://github.com/cap-js/cds-dbs/issues/1161)) ([c0cccad](https://github.com/cap-js/cds-dbs/commit/c0cccad921c45db96e14f0e2afeced6af69da4a2))
-* exists within expression is properly detected ([#1156](https://github.com/cap-js/cds-dbs/issues/1156)) ([febe175](https://github.com/cap-js/cds-dbs/commit/febe1755186d291b92edbdf69cebbab68a53d0af))
-* resilience for query re-use scenarios ([#1175](https://github.com/cap-js/cds-dbs/issues/1175)) ([fe9abd5](https://github.com/cap-js/cds-dbs/commit/fe9abd5e4c5e9153c0afad9164f240ae2eadf581))
+* Adopt to recurse `DistanceTo` cqn format ([#1093](https://github.com/cap-js/cds-dbs/issues/1093)) ([246e0b3](https://github.com/cap-js/cds-dbs/commit/246e0b38840f7e132ea49cae335b6be7a55354b3))
+* current_utctimestamp as default ([#1161](https://github.com/cap-js/cds-dbs/issues/1161)) ([7c6b2f5](https://github.com/cap-js/cds-dbs/commit/7c6b2f5a6837afbeb1e24daef9a49e25cf7e92f0))
+* exists within expression is properly detected ([#1156](https://github.com/cap-js/cds-dbs/issues/1156)) ([5a7b50c](https://github.com/cap-js/cds-dbs/commit/5a7b50cb02776cf6052c79bd276421dd87161882))
+* resilience for query re-use scenarios ([#1175](https://github.com/cap-js/cds-dbs/issues/1175)) ([2352767](https://github.com/cap-js/cds-dbs/commit/2352767465ea88db77dc89bcaa76e268583146e1))
+
+
+### Changed
+
+* update peer dependency to @sap/cds@9 ([#1178](https://github.com/cap-js/cds-dbs/issues/1178)) ([0507edd](https://github.com/cap-js/cds-dbs/commit/0507edd4e1dcb98983b1fb65ade1344d978b7524))
 
 ## [1.20.0](https://github.com/cap-js/cds-dbs/compare/db-service-v1.19.1...db-service-v1.20.0) (2025-04-17)
 

package/lib/InsertResults.js

@@ -26,9 +26,9 @@ module.exports = class InsertResult {
    * Lazy access to auto-generated keys.
    */
   get [iterator]() {
-    // For INSERT.as(SELECT.from(...)) return a dummy iterator with correct length
+    // For INSERT.from(SELECT.from(...)) return a dummy iterator with correct length
     const { INSERT } = this.query
-    if (INSERT.as) {
+    if (INSERT.from || INSERT.as) {
       return (super[iterator] = function* () {
         for (let i = 0; i < this.affectedRows; i++) yield {}
       })
@@ -81,7 +81,7 @@ module.exports = class InsertResult {
    */
   get affectedRows() {
     const { INSERT: _ } = this.query
-    if (_.as) return (super.affectedRows = this.affectedRows4(this.results[0] || this.results))
+    if (_.from || _.as) return (super.affectedRows = this.affectedRows4(this.results[0] || this.results))
     else return (super.affectedRows = _.entries?.length || _.rows?.length || this.results.length || 1)
   }
 

package/lib/SQLService.js

@@ -11,6 +11,20 @@ const BINARY_TYPES = {
   'cds.hana.BINARY': 1
 }
 
+/**
+ * Checks if parameter is an object that at least contains one property.
+ *
+ * @param {*} obj 
+ * @returns Boolean
+ */
+const _hasProps = (obj) => { 
+  if (!obj) return false
+  for (const p in obj) {
+    return true
+  }
+  return false
+}
+
 /** @typedef {import('@sap/cds/apis/services').Request} Request */
 
 /**
@@ -57,24 +71,18 @@ class SQLService extends DatabaseService {
     return super.init()
   }
 
-  _changeToStreams(columns, rows, one, compat) {
+  _changeToStreams(columns, rows, one) {
     if (!rows || !columns) return
     if (!Array.isArray(rows)) rows = [rows]
-    if (!rows.length || !Object.keys(rows[0]).length) return
-
-    // REVISIT: remove after removing stream_compat feature flag
-    if (compat) {
-      rows[0][Object.keys(rows[0])[0]] = this._stream(Object.values(rows[0])[0])
-      return
-    }
+    if (!rows.length || !Object.keys(rows[0]).length) return   
 
     let changes = false
     for (let col of columns) {
       const name = col.as || col.ref?.[col.ref.length - 1] || (typeof col === 'string' && col)
       if (col.element?.isAssociation) {
-        if (one) this._changeToStreams(col.SELECT.columns, rows[0][name], false, compat)
+        if (one) this._changeToStreams(col.SELECT.columns, rows[0][name], false)
         else
-          changes = rows.some(row => !this._changeToStreams(col.SELECT.columns, row[name], false, compat))
+          changes = rows.some(row => !this._changeToStreams(col.SELECT.columns, row[name], false))
       } else if (col.element?.type === 'cds.LargeBinary') {
         changes = true
         if (one) rows[0][name] = this._stream(rows[0][name])
@@ -141,23 +149,7 @@ class SQLService extends DatabaseService {
         if (expand) rows = rows.map(r => (typeof r._json_ === 'string' ? JSON.parse(r._json_) : r._json_ || r))
 
       if (!iterator) {
-        // REVISIT: remove after removing stream_compat feature flag
-        if (cds.env.features.stream_compat) {
-          if (query._streaming) {
-            if (!rows.length) return
-            this._changeToStreams(cqn.SELECT.columns, rows, true, true)
-            const result = rows[0]
-
-            // stream is always on position 0. Further properties like etag are inserted later.
-            let [key, val] = Object.entries(result)[0]
-            result.value = val
-            delete result[key]
-
-            return result
-          }
-        } else {
-          this._changeToStreams(cqn.SELECT.columns, rows, query.SELECT.one, false)
-        }
+         this._changeToStreams(cqn.SELECT.columns, rows, query.SELECT.one)
       } else if (objectMode) {
         const converter = (row) => this._changeToStreams(cqn.SELECT.columns, row, true)
         const changeToStreams = new Transform({
@@ -216,8 +208,8 @@ class SQLService extends DatabaseService {
   async onUPDATE(req) {
     // noop if not a touch for @cds.on.update
     if (
-      !req.query.UPDATE.data &&
-      !req.query.UPDATE.with &&
+      !_hasProps(req.query.UPDATE.data) &&
+      !_hasProps(req.query.UPDATE.with) &&
       !Object.values(req.target?.elements || {}).some(e => e['@cds.on.update'])
     )
       return 0
@@ -404,8 +396,6 @@ class SQLService extends DatabaseService {
     let kind = q.kind || Object.keys(q)[0]
     if (kind in { INSERT: 1, DELETE: 1, UPSERT: 1, UPDATE: 1 }) {
       q = resolveView(q, this.model, this) // REVISIT: before resolveView was called on flat cqn obtained from cqn4sql -> is it correct to call on original q instead?
-      let target = q[kind]._transitions?.[0].target
-      if (target) q._target = target // REVISIT: Why isn't that done in resolveView?
     }
     let cqn2sql = new this.class.CQN2SQL(this)
     return cqn2sql.render(q, values)
@@ -495,16 +485,16 @@ class PreparedStatement {
 }
 SQLService.prototype.PreparedStatement = PreparedStatement
 
+/** @param {import('@sap/cds').ql.Query} q */
 const _target_name4 = q => {
-  const target =
-    q._target_ref ||
-    q.SELECT?.from ||
-    q.INSERT?.into ||
-    q.UPSERT?.into ||
-    q.UPDATE?.entity ||
-    q.DELETE?.from ||
-    q.CREATE?.entity ||
-    q.DROP?.entity
+  const target = q._subject
+    || q.SELECT?.from
+    || q.INSERT?.into
+    || q.UPSERT?.into
+    || q.UPDATE?.entity
+    || q.DELETE?.from
+    || q.CREATE?.entity
+    || q.DROP?.entity
   if (target?.SET?.op === 'union') throw new cds.error('UNION-based queries are not supported')
   if (!target?.ref) return target
   const [first] = target.ref

package/lib/cql-functions.js

@@ -1,5 +1,7 @@
 'use strict'
 
+const cds = require('@sap/cds')
+
 // OData: https://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part2-url-conventions.html#sec_CanonicalFunctions
 const StandardFunctions = {
   /**
@@ -18,10 +20,15 @@ const StandardFunctions = {
     } catch {
       val = sub[2] || sub[3] || ''
     }
-    arg.val = arg.__proto__.val = val
+    arg.val = val
     const refs = ref.list
-    const { toString } = ref
-    return '(' + refs.map(ref2 => this.contains(this.tolower(toString(ref2)), this.tolower(arg))).join(' or ') + ')'
+    return `(${refs.map(ref => this.expr({
+      func: 'contains',
+      args: [
+        { func: 'tolower', args: [ref] },
+        { func: 'tolower', args: [arg] },
+      ]
+    })).join(' or ')})`
   },
 
   // ==============================
@@ -141,7 +148,7 @@ const StandardFunctions = {
    * @returns {string} - SQL statement
    */
   now: function () {
-    return this.session_context({ val: '$now' })
+    return this.expr({ func: 'session_context', args: [{ val: '$now' }] })
   },
 
   /**
@@ -184,6 +191,226 @@ const HANAFunctions = {
    * @returns {string} - SQL statement
    */
   current_timestamp: p => (p ? `current_timestamp(${p})` : 'current_timestamp'),
+
+  /**
+   * Generates SQL statement for the hierarchy function
+   * @param {string} [p] - 
+   * @returns {string} - SQL statement
+   */
+  HIERARCHY: function (args) {
+    let uniqueCounter = this._with?.length ?? 0
+    let src = args.xpr[1]
+
+    // Ensure that the orderBy column are exposed by the source for hierarchy sorting
+    const orderBy = args.xpr.find((_, i, arr) => /ORDER/i.test(arr[i - 2]) && /BY/i.test(arr[i - 1]))
+
+    const passThroughColumns = src.SELECT.columns.map(c => ({ ref: ['Source', this.column_name(c)] }))
+    src.as = 'H' + (uniqueCounter++)
+    src = this.expr(this.with(src))
+
+    let recursive = cds.ql(`
+SELECT
+  1 as HIERARCHY_LEVEL,
+  NODE_ID as HIERARCHY_ROOT_ID
+ FROM ${src} AS Source
+WHERE parent_ID IS NULL
+UNION ALL
+SELECT
+  Parent.HIERARCHY_LEVEL + 1,
+  Parent.HIERARCHY_ROOT_ID
+ FROM ${src} AS Source
+JOIN H${uniqueCounter} AS Parent ON Source.PARENT_ID=Parent.NODE_ID
+ORDER BY HIERARCHY_LEVEL DESC${orderBy ? `,${orderBy}` : ''}`)
+    recursive.as = 'H' + (uniqueCounter++)
+    recursive.SET.args[0].SELECT.columns = [...recursive.SET.args[0].SELECT.columns, ...passThroughColumns]
+    recursive.SET.args[1].SELECT.columns = [...recursive.SET.args[1].SELECT.columns, ...passThroughColumns]
+    recursive = this.expr(this.with(recursive))
+
+    let ranked = cds.ql(`
+SELECT
+  HIERARCHY_LEVEL,
+  row_number() over () as HIERARCHY_RANK,
+  HIERARCHY_ROOT_ID
+ FROM ${recursive} AS Source`)
+    ranked.as = 'H' + (uniqueCounter++)
+    ranked.SELECT.columns = [...ranked.SELECT.columns, ...passThroughColumns]
+    ranked = this.expr(this.with(ranked))
+
+    let Hierarchy = cds.ql(`
+SELECT
+  HIERARCHY_LEVEL,
+  HIERARCHY_RANK,
+  (SELECT HIERARCHY_RANK FROM ${ranked} AS Ranked WHERE Ranked.NODE_ID = Source.PARENT_ID) AS HIERARCHY_PARENT_RANK,
+  (SELECT HIERARCHY_RANK FROM ${ranked} AS Ranked WHERE Ranked.NODE_ID = Source.HIERARCHY_ROOT_ID) AS HIERARCHY_ROOT_RANK,
+  coalesce(
+    (SELECT MIN(HIERARCHY_RANK) FROM ${ranked} AS Ranked WHERE Ranked.HIERARCHY_RANK > Source.HIERARCHY_RANK AND Ranked.HIERARCHY_LEVEL <= Source.HIERARCHY_LEVEL),
+    (SELECT MAX(HIERARCHY_RANK) + 1 FROM ${ranked})
+  ) - Source.HIERARCHY_RANK AS HIERARCHY_TREE_SIZE
+ FROM ${ranked} AS Source`)
+    Hierarchy.as = 'H' + (uniqueCounter++)
+    Hierarchy.SELECT.columns = [...Hierarchy.SELECT.columns, ...passThroughColumns]
+    Hierarchy = this.expr(this.with(Hierarchy))
+
+    return Hierarchy
+  },
+
+  /**
+   * Generates SQL statement for the hierarchy_descendants function
+   * @param {string} [p] - 
+   * @returns {string} - SQL statement
+   */
+  HIERARCHY_DESCENDANTS: function (args) {
+    // Find Hierarchy function call source query
+    const passThroughColumns = args.xpr[1].args[0].xpr[1].SELECT.columns.map(c => ({ ref: [this.column_name(c)] }))
+    // REVISIT: currently only supports func: HIERARCHY as source
+    const src = this.expr(args.xpr[1])
+
+    let uniqueCounter = this._with?.length ?? 0
+
+    let alias = args.xpr.find((_, i, arr) => /AS/i.test(arr[i - 1]))
+    const where = args.xpr.find((a, i, arr) => a.xpr && /WHERE/i.test(arr[i - 1]) && /START/i.test(arr[i - 2]))
+    const distance = args.xpr.find((a, i, arr) => typeof a.val === 'number' && (/DISTANCE/i.test(arr[i - 1]) || /DISTANCE/i.test(arr[i - 2])))
+    const distanceFrom = args.xpr.find((a, i, arr) => /FROM/.test(a) && /DISTANCE/i.test(arr[i - 1]))
+
+    if (alias.startsWith('"') && alias.endsWith('"')) alias = alias.slice(1, -1).replace(/""/g, '"')
+
+    let HierarchyDescendants = cds.ql(`
+SELECT
+  HIERARCHY_LEVEL,
+  HIERARCHY_PARENT_RANK,
+  HIERARCHY_RANK,
+  HIERARCHY_ROOT_RANK,
+  HIERARCHY_TREE_SIZE,
+  0 as HIERARCHY_DISTANCE
+ FROM ${src} AS ![${alias}]
+UNION ALL
+SELECT
+  Source.HIERARCHY_LEVEL,
+  Source.HIERARCHY_PARENT_RANK,
+  Source.HIERARCHY_RANK,
+  Source.HIERARCHY_ROOT_RANK,
+  Source.HIERARCHY_TREE_SIZE,
+  Child.HIERARCHY_DISTANCE + 1
+ FROM ${src} AS Source
+JOIN H${uniqueCounter} AS Child ON Source.PARENT_ID=Child.NODE_ID`)
+    HierarchyDescendants.as = 'H' + uniqueCounter
+    HierarchyDescendants.SET.args[0].SELECT.where = where.xpr
+    HierarchyDescendants.SET.args[0].SELECT.columns = [...HierarchyDescendants.SET.args[0].SELECT.columns, ...passThroughColumns.map(r => ({ ref: [alias, r.ref[0]] }))]
+    HierarchyDescendants.SET.args[1].SELECT.columns = [...HierarchyDescendants.SET.args[1].SELECT.columns, ...passThroughColumns.map(r => ({ ref: ['Source', r.ref[0]] }))]
+
+    HierarchyDescendants = this.with(HierarchyDescendants)
+    HierarchyDescendants.as = 'HierarchyDescendants'
+
+    return this.expr({
+      SELECT: {
+        columns: [
+          { ref: ['HIERARCHY_LEVEL'] },
+          { ref: ['HIERARCHY_PARENT_RANK'] },
+          { ref: ['HIERARCHY_RANK'] },
+          { ref: ['HIERARCHY_ROOT_RANK'] },
+          { ref: ['HIERARCHY_TREE_SIZE'] },
+          {
+            SELECT: {
+              columns: [{ func: 'MAX', args: [{ ref: ['HIERARCHY_DISTANCE'] }] }],
+              from: HierarchyDescendants,
+              where: [{ ref: [HierarchyDescendants.as, 'HIERARCHY_RANK'] }, '=', { ref: [src, 'HIERARCHY_RANK'] }]
+            },
+            as: 'HIERARCHY_DISTANCE',
+          },
+          ...passThroughColumns,
+        ],
+        from: { ref: [src] },
+        where: [
+          { ref: ['HIERARCHY_RANK'] },
+          'IN',
+          {
+            SELECT: {
+              columns: [{ ref: ['HIERARCHY_RANK'] }],
+              from: HierarchyDescendants,
+              where: [{ ref: ['HIERARCHY_DISTANCE'] }, distanceFrom ? '>=' : '=', distance]
+            }
+          }
+        ]
+      }
+    })
+  },
+
+  /**
+   * Generates SQL statement for the hierarchy_ancestors function
+   * @param {string} [p] - 
+   * @returns {string} - SQL statement
+   */
+  HIERARCHY_ANCESTORS: function (args) {
+    // Find Hierarchy function call source query
+    const passThroughColumns = args.xpr[1].args[0].xpr[1].SELECT.columns.map(c => ({ ref: [this.column_name(c)] }))
+    // REVISIT: currently only supports func: HIERARCHY as source
+    const src = this.expr(args.xpr[1])
+
+    let uniqueCounter = this._with?.length ?? 0
+
+    let alias = args.xpr.find((_, i, arr) => /AS/i.test(arr[i - 1]))
+    const where = args.xpr.find((a, i, arr) => a.xpr && /WHERE/i.test(arr[i - 1]) && /START/i.test(arr[i - 2]))
+
+    if (alias.startsWith('"') && alias.endsWith('"')) alias = alias.slice(1, -1).replace(/""/g, '"')
+
+    let HierarchyAncestors = cds.ql(`
+SELECT
+  HIERARCHY_LEVEL,
+  HIERARCHY_PARENT_RANK,
+  HIERARCHY_RANK,
+  HIERARCHY_ROOT_RANK,
+  HIERARCHY_TREE_SIZE,
+  0 as HIERARCHY_DISTANCE
+ FROM ${src} AS ![${alias}]
+UNION ALL
+SELECT
+  Source.HIERARCHY_LEVEL,
+  Source.HIERARCHY_PARENT_RANK,
+  Source.HIERARCHY_RANK,
+  Source.HIERARCHY_ROOT_RANK,
+  Source.HIERARCHY_TREE_SIZE,
+  Child.HIERARCHY_DISTANCE - 1
+ FROM ${src} AS Source
+JOIN H${uniqueCounter} AS Child ON Source.NODE_ID=Child.PARENT_ID`)
+    HierarchyAncestors.as = 'H' + uniqueCounter
+    HierarchyAncestors.SET.args[0].SELECT.where = where.xpr
+    HierarchyAncestors.SET.args[0].SELECT.columns = [...HierarchyAncestors.SET.args[0].SELECT.columns, ...passThroughColumns.map(r => ({ ref: [alias, r.ref[0]] }))]
+    HierarchyAncestors.SET.args[1].SELECT.columns = [...HierarchyAncestors.SET.args[1].SELECT.columns, ...passThroughColumns.map(r => ({ ref: ['Source', r.ref[0]] }))]
+
+    HierarchyAncestors = this.with(HierarchyAncestors)
+    HierarchyAncestors.as = 'HierarchyAncestors'
+    return this.expr({
+      SELECT: {
+        columns: [
+          { ref: ['HIERARCHY_LEVEL'] },
+          { ref: ['HIERARCHY_PARENT_RANK'] },
+          { ref: ['HIERARCHY_RANK'] },
+          { ref: ['HIERARCHY_ROOT_RANK'] },
+          { ref: ['HIERARCHY_TREE_SIZE'] },
+          {
+            SELECT: {
+              columns: [{ func: 'MIN', args: [{ ref: ['HIERARCHY_DISTANCE'] }] }],
+              from: HierarchyAncestors,
+              where: [{ ref: [HierarchyAncestors.as, 'HIERARCHY_RANK'] }, '=', { ref: [src, 'HIERARCHY_RANK'] }]
+            },
+            as: 'HIERARCHY_DISTANCE',
+          },
+          ...passThroughColumns,
+        ],
+        from: { ref: [src] },
+        where: [
+          { ref: ['HIERARCHY_RANK'] },
+          'IN',
+          {
+            SELECT: {
+              columns: [{ ref: ['HIERARCHY_RANK'] }],
+              from: HierarchyAncestors,
+            }
+          }
+        ]
+      }
+    })
+  },
 }
 
 for (let each in HANAFunctions) HANAFunctions[each.toUpperCase()] = HANAFunctions[each]

package/lib/cqn2sql.js

@@ -82,6 +82,9 @@ class CQN2SQLRenderer {
     /** @type {unknown[]} */
     this.values = [] // prepare values, filled in by subroutines
     this[kind]((this.cqn = q)) // actual sql rendering happens here
+    if (this._with?.length) {
+      this.render_with()
+    }
     if (vars?.length && !this.values?.length) this.values = vars
     if (vars && Object.keys(vars).length && !this.values?.length) this.values = vars
     const sanitize_values = process.env.NODE_ENV === 'production' && cds.env.log.sanitize_values !== false
@@ -95,10 +98,28 @@ class CQN2SQLRenderer {
       DEBUG(this.sql, values)
     }
 
-
     return this
   }
 
+  render_with() {
+    const sql = this.sql
+    let recursive = false
+    const values = this.values
+    const prefix = this._with.map(q => {
+      const values = this.values = []
+      let sql
+      if ('SELECT' in q) sql = `${this.quote(q.as)} AS (${this.SELECT(q)})`
+      else if ('SET' in q) {
+        recursive = true
+        const { SET } = q
+        sql = `${this.quote(q.as)}(${SET.args[0].SELECT.columns?.map(c => this.quote(this.column_name(c))) || ''}) AS (${this.SELECT(SET.args[0])} ${SET.op?.toUpperCase() || 'UNION'} ${SET.all ? 'ALL' : ''} ${this.SELECT(SET.args[1])}${SET.orderBy ? ` ORDER BY ${this.orderBy(SET.orderBy)}` : ''})`
+      }
+      return { sql, values }
+    })
+    this.sql = `WITH${recursive ? ' RECURSIVE' : ''} ${prefix.map(p => p.sql)} ${sql}`
+    this.values = [...prefix.map(p => p.values).flat(), ...values]
+  }
+
   /**
    * Links the incoming query with the current service model
    * @param {import('./infer/cqn').Query} q
@@ -258,8 +279,275 @@ class CQN2SQLRenderer {
     return (this.sql = sql)
   }
 
-  SELECT_recurse() {
-    cds.error`Feature "recurse" queries not supported.`
+  SELECT_recurse(q) {
+    let { from, columns, where, orderBy, recurse, _internal } = q.SELECT
+
+    const requiredComputedColumns = { PARENT_ID: true, NODE_ID: true }
+    if (!_internal) requiredComputedColumns.RANK = true
+    const addComputedColumn = (name) => {
+      if (requiredComputedColumns[name]) return
+      requiredComputedColumns[name] = true
+    }
+
+    // The hierarchy functions will output the following columns. Which might clash with the entity columns
+    const reservedColumnNames = {
+      PARENT_ID: 1, NODE_ID: 1,
+      HIERARCHY_RANK: 1, HIERARCHY_DISTANCE: 1, HIERARCHY_LEVEL: 1, HIERARCHY_TREE_SIZE: 1
+    }
+    const availableComputedColumns = {
+      // Input computed columns
+      PARENT_ID: false,
+      NODE_ID: false,
+
+      // Output computed columns
+      RANK: { xpr: [{ ref: ['HIERARCHY_RANK'] }, '-', { val: 1, param: false }], as: 'RANK' },
+      Distance: { func: where?.length ? 'min' : 'max', args: [{ ref: ['HIERARCHY_DISTANCE'] }], as: 'Distance' },
+      DistanceFromRoot: { xpr: [{ ref: ['HIERARCHY_LEVEL'] }, '-', { val: 1, param: false }], as: 'DistanceFromRoot' },
+      DrillState: false,
+      LimitedDescendantCount: { xpr: [{ ref: ['HIERARCHY_TREE_SIZE'] }, '-', { val: 1, param: false }], as: 'LimitedDescendantCount' },
+    }
+
+    const columnsFiltered = columns
+      .filter(x => {
+        if (x.element?.isAssociation) return false
+        const name = this.column_name(x)
+        if (name === '$$RN$$') return false
+        // REVISIT: ensure that the selected column is one of the hierarchy computed columns by unifying their common definition
+        if (x.element?.['@Core.Computed'] && name in availableComputedColumns) {
+          addComputedColumn(name)
+          return false
+        }
+        return true
+      })
+    const columnsOut = []
+    const columnsIn = []
+    const target = q._target || q.target
+    for (const name in target.elements) {
+      const ref = { ref: [name] }
+      const element = target.elements[name]
+      if (element.virtual || element.value || element.isAssociation) continue
+      if (element['@Core.Computed'] && name in availableComputedColumns) continue
+      if (name.toUpperCase() in reservedColumnNames) ref.as = `$$${name}$$`
+      columnsIn.push(ref)
+      if (from.args || columnsFiltered.find(c => this.column_name(c) === name)) {
+        columnsOut.push(ref.as ? { ref: [ref.as], as: name } : ref)
+      }
+    }
+
+    const nodeKeys = []
+    const parentKeys = []
+    const association = target.elements[recurse.ref[0]]
+    association._foreignKeys.forEach(fk => {
+      nodeKeys.push(fk.childElement.name)
+      parentKeys.push(fk.parentElement.name)
+    })
+
+    columnsIn.push(
+      nodeKeys.length === 1
+        ? { ref: nodeKeys, as: 'NODE_ID' }
+        : { func: 'HIERARCHY_COMPOSITE_ID', args: nodeKeys.map(n => ({ ref: [n] })), as: 'NODE_ID' },
+      parentKeys.length === 1
+        ? { ref: parentKeys, as: 'PARENT_ID' }
+        : { func: 'HIERARCHY_COMPOSITE_ID', args: parentKeys.map(n => ({ ref: [n] })), as: 'PARENT_ID' },
+    )
+
+    if (orderBy) {
+      orderBy = orderBy.map(r => {
+        const col = r.ref.at(-1)
+        if (!columnsIn.find(c => this.column_name(c) === col)) {
+          columnsIn.push({ ref: [col] })
+        }
+        return { ...r, ref: [col] }
+      })
+    }
+
+    // In the case of join operations make sure to compute the hierarchy from the source table only
+    const stableFrom = getStableFrom(from)
+    const alias = stableFrom.as
+    const source = () => {
+      return ({
+      func: 'HIERARCHY',
+      args: [{ xpr: ['SOURCE', { SELECT: { columns: columnsIn, from: stableFrom } }, ...(orderBy ? ['SIBLING', 'ORDER', 'BY', `${this.orderBy(orderBy)}`] : [])] }],
+      as: alias
+    })
+  }
+
+    const expandedByNr = { list: [] } // DistanceTo(...,null)
+    const expandedByOne = { list: [] } // DistanceTo(...,1)
+    const expandedByZero = { list: [] } // not DistanceTo(...,null)
+    let expandedFilter = []
+    let distanceType = 'DistanceFromRoot'
+    let distanceVal
+
+    if (recurse.where) {
+      distanceType = 'Distance'
+      if (recurse.where[0] === 'and') recurse.where = recurse.where.slice(1)
+      expandedFilter = [...recurse.where]
+      collectDistanceTo(expandedFilter)
+    }
+
+    const direction = where?.length ? 'ANCESTORS' : 'DESCENDANTS'
+    // Ensure that the distance value is being computed
+    if (distanceType) addComputedColumn(distanceType)
+
+    let distanceClause = []
+    if (distanceType === 'Distance') {
+      const isOne = expandedByOne.list.length
+      distanceClause = ['DISTANCE', ...(
+        isOne
+          ? [{ val: 1 }]
+          : ['FROM', { val: 1 }]
+      )]
+      where = [{ ref: ['NODE_ID'] }, 'IN', isOne ? expandedByOne : expandedByNr]
+      expandedFilter = []
+    }
+
+    availableComputedColumns.DrillState = {
+      xpr: [ // When the node doesn't have children make it a leaf
+        'CASE', 'WHEN', { ref: ['HIERARCHY_TREE_SIZE'] }, '=', { val: 1, param: false }, 'THEN', { val: 'leaf', param: false },
+        ...(where?.length // When there is a where filter the final node will always be a leaf
+          ? ['WHEN', { func: where?.length ? 'min' : 'max', args: [{ ref: ['HIERARCHY_DISTANCE'] }] }, '=', { val: 0, param: false }, 'THEN', { val: 'leaf', param: false }]
+          : []
+        ), // When having expanded by 0 level nodes make sure they are collapsed
+        ...(expandedByZero.list.length
+          ? ['WHEN', { ref: ['NODE_ID'] }, 'IN', expandedByZero, 'THEN', { val: 'collapsed', param: false }]
+          : []
+        ), // When having expanded by null or one nodes compute them as expanded
+        ...(expandedByNr.list.length || expandedByOne.list.length
+          ? ['WHEN', { ref: ['NODE_ID'] }, 'IN', { list: [...expandedByNr.list, ...expandedByOne.list] }, 'THEN', { val: 'expanded', param: false }]
+          : []
+        ), // When having expanded by one level node make its children collapsed
+        ...(expandedByOne.list.length
+          ? ['WHEN', { ref: ['PARENT_ID'] }, 'IN', expandedByOne, 'THEN', { val: 'collapsed', param: false }]
+          : []
+        ), // When using DistanceFromRoot compute all entries within the levels as expanded
+        ...(distanceType === 'DistanceFromRoot' && distanceVal
+          ? [
+            'WHEN', { ref: ['HIERARCHY_LEVEL'] }, '<>', { val: distanceVal.val + 1 },
+            'THEN', { val: 'expanded', param: false },
+          ]
+          : []
+        ), // Default to expanded when default filter behavior is truthy
+        'ELSE', { val: (recurse.where && !expandedByZero.list.length) && distanceType ? 'collapsed' : 'expanded', param: false },
+        'END',
+      ],
+      as: 'DrillState'
+    }
+
+    for (const name in requiredComputedColumns) {
+      const def = availableComputedColumns[name]
+      if (def) columnsOut.push(def)
+    }
+    if (_internal) columnsOut.push({ ref: ['NODE_ID'] })
+
+    const graph = distanceType === 'DistanceFromRoot' && !where
+      ? { SELECT: { columns: columnsOut, from: source(), where: expandedFilter } }
+      : {
+        SELECT: {
+          columns: columnsOut,
+          from: {
+            func: `HIERARCHY_${direction}`,
+            args: [{
+              xpr: [
+                'SOURCE', source(), 'AS', this.quote(alias),
+                'START', 'WHERE', {
+                  xpr: where // Requires special where logic before being put into the args
+                    ? from.args
+                      ? [{ ref: ['NODE_ID'] }, 'IN', { SELECT: { columns: [columnsIn.find(c => c.as === 'NODE_ID')], from, where: where } }]
+                      : this.is_comparator?.({ xpr: where }) ?? true ? where : [...where, '=', { val: true, param: false }]
+                    : [{ ref: ['PARENT_ID'] }, '=', { val: null }]
+                },
+                ...distanceClause
+              ]
+            }]
+          },
+          where: expandedFilter.length ? expandedFilter : undefined,
+          orderBy: [{ ref: ['HIERARCHY_RANK'], sort: 'asc' }],
+          groupBy: [{ ref: ['NODE_ID'] },{ ref: ['PARENT_ID'] }, { ref: ['HIERARCHY_RANK'] }, { ref: ['HIERARCHY_LEVEL'] }, { ref: ['HIERARCHY_TREE_SIZE'] }, ...columnsOut.filter(c => c.ref)],
+        }
+      }
+
+    // Only apply result join if the columns contain a references which doesn't start with the source alias
+    if (from.args && columns.find(c => c.ref?.[0] === alias)) {
+      graph.as = alias
+      return this.from(setStableFrom(from, graph))
+    }
+
+    return `(${this.SELECT(graph)})${alias ? ` AS ${this.quote(alias)}` : ''} `
+
+    function collectDistanceTo(where, innot = false) {
+      for (let i = 0; i < where.length; i++) {
+        const c = where[i]
+        if (c === 'not') {
+          distanceType = 'DistanceFromRoot'
+          innot = true
+        }
+        else if (c.func === 'DistanceTo') {
+          const expr = c.args[0]
+          // { func: 'HIERARCHY_COMPOSITE_ID', args: nodeKeys.map(n => ({ val: cur[n] })) }
+          const to = c.args[1].val
+          const list = to === 1
+            ? expandedByOne
+            : innot
+              ? expandedByZero
+              : expandedByNr
+
+          if (!list._where) {
+            list._where = []
+            where.splice(i, 1,
+              ...(to === 1
+                ? [{ ref: ['PARENT_ID'] }, 'IN', list]
+                : [{ ref: ['NODE_ID'] }, 'IN', {
+                  SELECT: {
+                    _internal: true,
+                    columns: [{ ref: ['NODE_ID'], element: { '@Core.Computed': true } }],
+                    from: q.SELECT.from,
+                    recurse: {
+                      ref: recurse.ref,
+                      where: list._where,
+                    },
+                  },
+                  target,
+                }])
+            )
+            i += 2
+          } else {
+            // Remove current entry from where
+            if (where[i - 1] === 'not') {
+              where.splice(i - 2, 3)
+              i -= 3
+            } else {
+              where.splice(i - 1, 2)
+              i -= 2
+            }
+          }
+          list.list.push(expr)
+          list._where.push(c)
+        }
+        else if (c.ref?.[0] === 'DistanceFromRoot') {
+          distanceType = 'DistanceFromRoot'
+          where[i] = { ref: ['HIERARCHY_LEVEL'] }
+          i += 2
+          distanceVal = where[i]
+          where[i] = { val: where[i].val + 1 }
+        }
+      }
+    }
+
+    function getStableFrom(from) {
+      if (from.args) return getStableFrom(from.args[0])
+      return from
+    }
+
+    function setStableFrom(from, src) {
+      if (from.args) {
+        const ret = { ...from }
+        ret.args = [...ret.args]
+        ret.args[0] = setStableFrom(ret.args[0], src)
+        return ret
+      }
+      return src
+    }
   }
 
   /**
@@ -371,6 +659,18 @@ class CQN2SQLRenderer {
     }
     if (from.SELECT) return _aliased(`(${this.SELECT(from)})`)
     if (from.join) return `${this.from(from.args[0])} ${from.join} JOIN ${this.from(from.args[1])}${from.on ? ` ON ${this.where(from.on)}` : ''}`
+    if (from.func) return _aliased(this.func(from))
+  }
+
+  /**
+   * Renders a FROM clause into generic SQL
+   * @param {import('./infer/cqn').source} from
+   * @returns {string} SQL
+   */
+  with(query) {
+    this._with ??= []
+    this._with.push(query)
+    return { ref: [query.as] }
   }
 
   /**
@@ -426,7 +726,7 @@ class CQN2SQLRenderer {
    */
   orderBy(orderBy, localized) {
     return orderBy.map(c => {
-      const o = localized
+      const o = (localized && this.context.locale)
         ? this.expr(c) +
         (c.element?.[this.class._localized] ? ' COLLATE NOCASE' : '') +
         (c.sort?.toLowerCase() === 'desc' || c.sort === -1 ? ' DESC' : ' ASC')
@@ -489,7 +789,7 @@ class CQN2SQLRenderer {
         ? this.INSERT_rows(q)
         : INSERT.values
           ? this.INSERT_values(q)
-          : INSERT.as
+          : INSERT.from || INSERT.as
             ? this.INSERT_select(q)
             : cds.error`Missing .entries, .rows, or .values in ${q}`
   }
@@ -695,7 +995,7 @@ class CQN2SQLRenderer {
       c => c in elements && !elements[c].virtual && !elements[c].isAssociation,
     ))
     this.sql = `INSERT INTO ${this.quote(entity)}${alias ? ' as ' + this.quote(alias) : ''} (${columns.map(c => this.quote(c))}) ${this.SELECT(
-      this.cqn4sql(INSERT.as),
+      this.cqn4sql(INSERT.from || INSERT.as),
     )}`
     this.entries = [this.values]
     return this.sql
@@ -998,7 +1298,7 @@ class CQN2SQLRenderer {
     } else {
       cds.error`Invalid arguments provided for function '${func}' (${args})`
     }
-    const fn = this.class.Functions[func]?.apply(this.class.Functions, args) || `${func}(${args})`
+    const fn = this.class.Functions[func]?.apply(this, args) || `${func}(${args})`
     if (xpr) return `${fn} ${this.xpr({ xpr })}`
     return fn
   }

package/lib/cqn4sql.js

@@ -802,11 +802,7 @@ function cqn4sql(originalQuery, model) {
         })
     } else {
       outerAlias = transformedQuery.SELECT.from.as
-      const getInnermostTarget = q => (q._target ? getInnermostTarget(q._target) : q)
-      subqueryFromRef = [
-        ...(transformedQuery.SELECT.from.ref || /* subq in from */ [getInnermostTarget(transformedQuery).name]),
-        ...ref,
-      ]
+      subqueryFromRef = [transformedQuery._target.name, ...ref]
     }
 
     // this is the alias of the column which holds the correlated subquery

package/lib/infer/index.js

@@ -46,7 +46,7 @@ function infer(originalQuery, model) {
 
   let $combinedElements
 
-  const sources = inferTarget(_.from || _.into || _.entity, {})
+  const sources = inferTarget(_.into || _.from || _.entity, {}) // IMPORTANT: _.into has to go before _.from for INSERT.into().from(SELECT)
   const joinTree = new JoinTree(sources)
   const aliases = Object.keys(sources)
   const target = aliases.length === 1 ? getDefinitionFromSources(sources, aliases[0]) : originalQuery

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js/db-service",
-  "version": "1.20.2",
+  "version": "2.0.1",
   "description": "CDS base database service",
   "homepage": "https://github.com/cap-js/cds-dbs/tree/main/db-service#cds-base-database-service",
   "repository": {
@@ -27,7 +27,7 @@
     "generic-pool": "^3.9.0"
   },
   "peerDependencies": {
-    "@sap/cds": ">=7.9 <9"
+    "@sap/cds": ">=9"
   },
-  "license": "SEE LICENSE"
+  "license": "Apache-2.0"
 }