Merge branch 'main' into sqlite-compliance-tests

Author: johannes-vogel

.github/workflows/release-please.yml

@@ -26,46 +26,28 @@ jobs:
 
       ## debug info
       - run: echo '${{ toJSON(steps.release.outputs) }} '
-      # Run tests
-      - run: npm install -g @sap/cds-dk
-      # Run tests
-      - run: npm ci
-        if: ${{ steps.release.outputs.releases_created }}
-      # hana express setup
-      - id: hxe
-        if: ${{ steps.release.outputs.releases_created }}
-        uses: ./.github/actions/hxe
-        with:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      # testing hana/sqlite/postgres/db-service
-      - run: npm test -ws
-        if: ${{ steps.release.outputs.releases_created }}
-        env:
-          FORCE_COLOR: true
-          TAG: ${{ steps.hxe.outputs.TAG }}
-          IMAGE_ID: ${{ steps.hxe.outputs.IMAGE_ID }}
 
       # Publish packages
       - name: Publish db-service
         if: ${{ steps.release.outputs.db-service--release_created }}
-        run: npm publish --workspace db-service --access public
+        run: npm publish --workspace db-service --access public --tag next
         env:
           NODE_AUTH_TOKEN: ${{secrets.npm_token}}
 
       - name: Publish sqlite
         if: ${{ steps.release.outputs.sqlite--release_created }}
-        run: npm publish --workspace sqlite --access public
+        run: npm publish --workspace sqlite --access public --tag next
         env:
           NODE_AUTH_TOKEN: ${{secrets.npm_token}}
 
       - name: Publish postgres
         if: ${{ steps.release.outputs.postgres--release_created }}
-        run: npm publish --workspace postgres --access public
+        run: npm publish --workspace postgres --access public --tag next
         env:
           NODE_AUTH_TOKEN: ${{secrets.npm_token}}
 
       - name: Publish SAP HANA
         if: ${{ steps.release.outputs.hana--release_created }}
-        run: npm publish --workspace hana --access public
+        run: npm publish --workspace hana --access public --tag next
         env:
           NODE_AUTH_TOKEN: ${{secrets.npm_token}}

.github/workflows/release.yml

@@ -27,7 +27,7 @@ jobs:
         uses: martinbeentjes/npm-get-version-action@3cf273023a0dda27efcd3164bdfb51908dd46a5b
       - name: Create a GitHub release
         # v1.15.0
-        uses: ncipollo/release-action@36e78ab6296394ce36f72f6488e68c2353b50514
+        uses: ncipollo/release-action@fa4749311e8d6997e78065947cc502ba74a057d6
         with:
           tag: 'v${{ steps.package-version.outputs.current-version}}'
           name: 'Release v${{ steps.package-version.outputs.current-version}}'

.github/workflows/test.yml

@@ -30,9 +30,8 @@ jobs:
         with:
           node-version: ${{ matrix.node }}
           cache: 'npm'
-
+      - run: npm add cds-9.0.0.tgz cds-dk-9.0.1.tgz cds-compiler-6.0.2.tgz --save-dev
       - run: npm ci
-      - run: npm install -g @sap/cds-dk
       - run: npm run lint
       - id: hxe
         uses: ./.github/actions/hxe

.release-please-manifest.json

@@ -1,6 +1,6 @@
 {
-  "db-service": "1.20.0",
-  "sqlite": "1.11.0",
-  "postgres": "1.14.0",
-  "hana": "1.9.0"
+  "db-service": "2.0.0",
+  "sqlite": "2.0.0",
+  "postgres": "2.0.0",
+  "hana": "2.0.0"
 }

cds-9.0.0.tgz

@@ -4,6 +4,26 @@
 - The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - This project adheres to [Semantic Versioning](http://semver.org/).
 
+## [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
+
+* 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)
 
 

cds-compiler-6.0.2.tgz

@@ -404,8 +404,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)

cds-dk-9.0.1.tgz

@@ -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]