@cap-js/db-service 2.8.2 → 2.10.0

package/CHANGELOG.md

@@ -4,6 +4,41 @@
 - The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - This project adheres to [Semantic Versioning](http://semver.org/).
 
+## [2.10.0](https://github.com/cap-js/cds-dbs/compare/db-service-v2.9.0...db-service-v2.10.0) (2026-04-22)
+
+
+### Added
+
+* `cds.features.count_as_string` ([#1556](https://github.com/cap-js/cds-dbs/issues/1556)) ([00e0e60](https://github.com/cap-js/cds-dbs/commit/00e0e60d68edf0d42c1fce2fae3bb1286aca131e))
+* **cqn4sql:** support for enums ([#1527](https://github.com/cap-js/cds-dbs/issues/1527)) ([27c4279](https://github.com/cap-js/cds-dbs/commit/27c4279c495fce8344c785e4489e3116d1a52c55))
+* pql ([#1532](https://github.com/cap-js/cds-dbs/issues/1532)) ([943f76a](https://github.com/cap-js/cds-dbs/commit/943f76a3e4405eb91f0f4b929590212500c49c30))
+
+
+### Fixed
+
+* `$self` reference to func column in `having` ([#1539](https://github.com/cap-js/cds-dbs/issues/1539)) ([9eac576](https://github.com/cap-js/cds-dbs/commit/9eac5762fc4d254a1bc54bded1dd6a492299f576)), closes [#1528](https://github.com/cap-js/cds-dbs/issues/1528)
+* foreign key not included in wildcard select from subquery ([#1540](https://github.com/cap-js/cds-dbs/issues/1540)) ([0fde4ed](https://github.com/cap-js/cds-dbs/commit/0fde4eda21a389c68982f348e9e7c3680c00dcb3)), closes [#1127](https://github.com/cap-js/cds-dbs/issues/1127)
+* sqlite generated key is named lastInsertRowid ([#1501](https://github.com/cap-js/cds-dbs/issues/1501)) ([a4d3437](https://github.com/cap-js/cds-dbs/commit/a4d34378297c8afdb13abb7e664165012c36eb8f))
+
+## [2.9.0](https://github.com/cap-js/cds-dbs/compare/db-service-v2.8.2...db-service-v2.9.0) (2026-03-09)
+
+
+### Added
+
+* runtime views ([#1410](https://github.com/cap-js/cds-dbs/issues/1410)) ([5242675](https://github.com/cap-js/cds-dbs/commit/5242675c97472b86b81b3dc5fe0906141d276b02))
+* support calculated elements in hierarchies ([#1456](https://github.com/cap-js/cds-dbs/issues/1456)) ([97c6f66](https://github.com/cap-js/cds-dbs/commit/97c6f6661f0ac4043245e021f2bf182f4e5d406f))
+
+
+### Fixed
+
+* **`exists`:** detect join relevant path after exists ([#1412](https://github.com/cap-js/cds-dbs/issues/1412)) ([c5bad06](https://github.com/cap-js/cds-dbs/commit/c5bad06724ce6761379f91748490c6caac84153a)), closes [#1407](https://github.com/cap-js/cds-dbs/issues/1407)
+* **cqn2sql:** Relied on inconstistent behavior of cds.ql.cloned queries ([#1500](https://github.com/cap-js/cds-dbs/issues/1500)) ([f9cb201](https://github.com/cap-js/cds-dbs/commit/f9cb2011219a86ae22f22fcc105e597b23209adf))
+* enable expressions for `inline` ([#1512](https://github.com/cap-js/cds-dbs/issues/1512)) ([65f78e1](https://github.com/cap-js/cds-dbs/commit/65f78e1f3af83188462e9d44db67daa5d743ceb0))
+* path expressions for scoped queries ([#1507](https://github.com/cap-js/cds-dbs/issues/1507)) ([0f1e234](https://github.com/cap-js/cds-dbs/commit/0f1e234b373f26a6244c715c9ca9d4a207a0faed))
+* reject duplicated wildcards ([#1511](https://github.com/cap-js/cds-dbs/issues/1511)) ([b483062](https://github.com/cap-js/cds-dbs/commit/b483062e2ff5a8d0960dc2e7b71880af87ee8f78))
+* the combination of `iterator` and `SELECT.one` ([#1514](https://github.com/cap-js/cds-dbs/issues/1514)) ([4b28579](https://github.com/cap-js/cds-dbs/commit/4b2857920a7a57bcfc09a9b5fb765283cf8bd70b))
+* wildcard on inlined assoc ([#1513](https://github.com/cap-js/cds-dbs/issues/1513)) ([e520b97](https://github.com/cap-js/cds-dbs/commit/e520b97fd30394825b937b3613370c32c36c24a4))
+
 ## [2.8.2](https://github.com/cap-js/cds-dbs/compare/db-service-v2.8.1...db-service-v2.8.2) (2026-02-03)
 
 

package/lib/InsertResults.js

@@ -69,9 +69,12 @@ module.exports = class InsertResult {
     }
 
     // If no generated keys in entries/rows/values we might have database-generated keys
-    const rows = this.results.slice(0, this.affectedRows) // only up to # of root entries
     return (super[iterator] = function* () {
-      for (const each of rows) yield { [k1]: this.insertedRowId4(each) } // REVISIT: sqlite only returns a single lastID per row -> how is that with others?
+      for (const row of this.results) {
+        const affectedRows = this.affectedRows4(row) - 1
+        const lastInsertRowid = this.insertedRowId4(row)
+        for (let i = lastInsertRowid - affectedRows; i<=lastInsertRowid;i++) yield { [k1]: i }
+      }
     })
   }
 
@@ -99,7 +102,7 @@ module.exports = class InsertResult {
    * @returns {number}
    */
   insertedRowId4(result) {
-    return result.lastID
+    return result.lastInsertRowid
   }
 
   /**

package/lib/SQLService.js

@@ -1,10 +1,14 @@
-const cds = require('@sap/cds'),
-  DEBUG = cds.debug('sql|db')
+const cds = require('@sap/cds')
+const DEBUG = cds.log('sql|db')
 const { Readable, Transform } = require('stream')
 const { pipeline } = require('stream/promises')
-const { resolveView, getDBTable, getTransition } = require('@sap/cds/libx/_runtime/common/utils/resolveView')
 const DatabaseService = require('./common/DatabaseService')
 const cqn4sql = require('./cqn4sql')
+const { resolveTable } = require('./utils')
+
+// REVISIT: make string the default in next major
+const _count_as_string = cds.env.features.count_as_string
+const _count = _count_as_string ? { func: 'count', cast: { type: 'cds.String' } } : { func: 'count' }
 
 const BINARY_TYPES = {
   'cds.Binary': 1,
@@ -17,7 +21,7 @@ const BINARY_TYPES = {
  * @param {*} obj 
  * @returns Boolean
  */
-const _hasProps = (obj) => { 
+const _hasProps = (obj) => {
   if (!obj) return false
   for (const p in obj) {
     return true
@@ -74,7 +78,7 @@ class SQLService extends DatabaseService {
   _changeToStreams(columns, rows, one) {
     if (!rows || !columns) return
     if (!Array.isArray(rows)) rows = [rows]
-    if (!rows.length || !Object.keys(rows[0]).length) return   
+    if (!rows.length || !Object.keys(rows[0]).length) return
 
     let changes = false
     for (let col of columns) {
@@ -149,7 +153,7 @@ class SQLService extends DatabaseService {
         if (expand) rows = rows.map(r => (typeof r._json_ === 'string' ? JSON.parse(r._json_) : r._json_ || r))
 
       if (!iterator) {
-         this._changeToStreams(cqn.SELECT.columns, rows, query.SELECT.one)
+        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({
@@ -168,7 +172,7 @@ class SQLService extends DatabaseService {
         return SQLService._arrayWithCount(rows, await this.count(query, rows))
       }
 
-      return iterator !== false && isOne ? rows[0] : rows
+      return !iterator && isOne ? rows[0] : rows
     } catch (err) {
       // Ensure that iterators receive pre stream errors
       if (iterator) rows.emit('error', err)
@@ -198,7 +202,7 @@ class SQLService extends DatabaseService {
     const ps = await this.prepare(sql)
     const results = entries ? await Promise.all(entries.map(e => ps.run(e))) : await ps.run()
     // REVISIT: results isn't an array, when no entries -> how could that work? when do we have no entries?
-    return results.reduce((total, affectedRows) => (total += affectedRows.changes), 0)
+    return results.reduce((total, affectedRows) => total + affectedRows.changes, 0)
   }
 
   /**
@@ -230,7 +234,8 @@ class SQLService extends DatabaseService {
     // REVISIT: It's not yet 100 % clear under which circumstances we can rely on db constraints
     return (super.onDELETE = /* cds.env.features.assert_integrity === 'db' ? this.onSIMPLE : */ deep_delete)
     async function deep_delete(/** @type {Request} */ req) {
-      const transitions = getTransition(req.target, this, false, req.query.cmd || 'DELETE')
+      const resolve = this.resolve
+      const transitions = resolve.transitions(req.query)
       if (transitions.target !== transitions.queryTarget) {
         const keys = []
         const transitionsTarget = transitions.queryTarget.keys || transitions.queryTarget.elements
@@ -253,7 +258,7 @@ class SQLService extends DatabaseService {
         })
         return this.onDELETE({ query, target: transitions.target })
       }
-      const table = getDBTable(req.target)
+      const table = resolveTable(req.target)
       const { compositions } = table
       if (compositions) {
         // Transform CQL`DELETE from Foo[p1] WHERE p2` into CQL`DELETE from Foo[p1 and p2]`
@@ -295,7 +300,7 @@ class SQLService extends DatabaseService {
    * @type {Handler}
    */
   async onEVENT({ event }) {
-    DEBUG?.(event) // in the other cases above DEBUG happens in cqn2sql
+    if(DEBUG._debug) DEBUG.debug(event) // in the other cases above DEBUG happens in cqn2sql
     return await this.exec(event)
   }
 
@@ -305,7 +310,7 @@ class SQLService extends DatabaseService {
    */
   async onPlainSQL({ query, data }, next) {
     if (typeof query === 'string') {
-      DEBUG?.(query, data)
+      if(DEBUG._debug) DEBUG.debug(query, data)
       const ps = await this.prepare(query)
       const exec = this.hasResults(query) ? d => ps.all(d) : d => ps.run(d)
       if (Array.isArray(data) && Array.isArray(data[0])) return await Promise.all(data.map(exec))
@@ -325,24 +330,24 @@ class SQLService extends DatabaseService {
    * Derives and executes a query to fill in `$count` for given query
    * @param {import('@sap/cds/apis/cqn').SELECT} query - SELECT CQN
    * @param {unknown[]} ret - Results of the original query
-   * @returns {Promise<number>}
+   * @returns {Promise<number|string>}
    */
   async count(query, ret) {
     if (ret?.length) {
       const { one, limit: _ } = query.SELECT,
         n = ret.length
       const [max, offset = 0] = one ? [1] : _ ? [_.rows?.val, _.offset?.val] : []
-      if (max === undefined || (n < max && (n || !offset))) return n + offset
+      if (max === undefined || (n < max && (n || !offset))) return _count_as_string ? `${n + offset}` : n + offset
     }
 
     // Keep original query columns when potentially used insde conditions
     const { having, groupBy } = query.SELECT
     let columns = []
-    if((having?.length || groupBy?.length)) {
+    if (having?.length || groupBy?.length) {
       columns = query.SELECT.columns.filter(c => !c.expand)
     }
     if (columns.length === 0) columns.push({ val: 1 })
-    const cq = SELECT.one([{ func: 'count' }]).from(
+    const cq = SELECT.one([_count]).from(
       cds.ql.clone(query, {
         columns,
         localized: false,
@@ -360,7 +365,7 @@ class SQLService extends DatabaseService {
    * @param {import('@sap/cds/apis/cqn').SELECT} query - SELECT CQN
    * @param {function} callback - Function to be invoked for each row
    */
-  foreach (query, callback) {
+  foreach(query, callback) {
     return query.foreach(callback)
   }
 
@@ -390,40 +395,34 @@ class SQLService extends DatabaseService {
     })
   }
 
-  /** @param {unknown[]} args */
   constructor(...args) {
     super(...args)
-    /** @type {unknown} */
     this.class = new.target // for IntelliSense
   }
 
   /**
    * @param {import('@sap/cds/apis/cqn').Query} query
-   * @param {unknown} values
    * @returns {typeof SQLService.CQN2SQL}
    */
   cqn2sql(query, values) {
-    let q = this.cqn4sql(query)
-    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 cqn2sql = new this.class.CQN2SQL(this)
-    return cqn2sql.render(q, values)
+    const cqn2sql = new this.class.CQN2SQL(this)
+    const q = this.cqn4sql(query)
+    const sql = cqn2sql.render(q, values)
+    return sql
   }
 
   /**
    * @param {import('@sap/cds/apis/cqn').Query} q
    * @returns {import('./infer/cqn').Query}
    */
-  cqn4sql(q) {
+  cqn4sql(q, useTechnicalAlias=true) {
     if (
       !cds.env.features.db_strict &&
       !q.SELECT?.from?.join &&
       !q.SELECT?.from?.SELECT &&
       !this.model?.definitions[_target_name4(q)]
     ) return q
-    else return cqn4sql(q, this.model)
+    else return cqn4sql(q, this.model, useTechnicalAlias)
   }
 
   /**
@@ -512,31 +511,70 @@ const _target_name4 = q => {
   return first.id || first
 }
 
-const sqls = new (class extends SQLService {
-  get factory() {
-    return null
-  }
 
-  get model() {
-    return cds.model
+// Add support for cqn2pql if debug logging for pql is enabled, or if running in the REPL.
+const DEBUG_PQL = cds.log('pql')
+if (DEBUG_PQL._debug || cds.repl) {
+
+  // Add helper method to convert CQN to PQL, used below...
+  SQLService.prototype.cqn2pql = function cqn2pql (query, values) {
+    const CQN2PQL = cqn2pql.renderer ??= require('./cqn2pql')
+    return new CQN2PQL(this).render(query, values)
   }
-})()
-cds.extend(cds.ql.Query).with(
-  class {
-    forSQL() {
-      let cqn = (cds.db || sqls).cqn4sql(this)
-      return this.flat(cqn)
-    }
-    toSQL() {
-      if (this.SELECT) this.SELECT.expand = 'root' // Enforces using json functions always for top-level SELECTS
-      let { sql, values } = (cds.db || sqls).cqn2sql(this)
-      return { sql, values } // skipping .cqn property
+
+  // Add support for logging generated PQL if debug logging for pql is enabled.
+  if (DEBUG_PQL._debug) {
+    const $super = SQLService.prototype.cqn2sql
+    SQLService.prototype.cqn2sql = function (query, values) {
+      const q2 = this.cqn4sql(query, false) // FIXME: calling cqn4sql twice per query is utterly expensive, isn't it ?!?
+      const pql = this.cqn2pql(q2, values)
+      DEBUG_PQL.debug(pql.sql, pql.values ?? '')
+      return $super.call(this, query, values)
     }
-    toSql() {
-      return this.toSQL().sql
+  }
+
+  // If running in the REPL, extend cds.ql.Query with helpers to inspect queries. 
+  if (cds.repl) {
+
+    cds.extend(cds.ql.Query).with(
+      class {
+        forSQL() {
+          const cqn = db.srv.cqn4sql(this)
+          return this.flat(cqn)
+        }
+        forSql() { return this.forSQL() }
+        toSQL() {
+          if (this.SELECT) this.SELECT.expand = 'root' // Enforces using json functions always for top-level SELECTS
+          const { sql, values } = db.srv.cqn2sql(this)
+          return { sql, values } // skipping .cqn property
+        }
+        toSql() {
+          const { sql } = this.toSQL()
+          return sql
+        }
+        toPQL() {
+          const { sql, values } = db.srv.cqn2pql(this)
+          return { sql, values } // skipping .cqn property
+        }
+        toPql() {
+          const { sql } = this.toPQL()
+          return sql
+        }
+      }
+    )
+
+    /** 
+     * Dummy SQL service used in extensions to cds.ql above, 
+     * if no real SQL service is available yet through cds.db. 
+     */
+    class db extends SQLService {
+      /** @returns {SQLService} */ 
+      static get srv() { return cds.db || (this.singleton ??= new this) }
+      get factory() { return null }
+      get model() { return cds.model }
     }
-  },
-)
+  }
+}
 
 Object.assign(SQLService, { _target_name4 })
 module.exports = SQLService

package/lib/cql-functions.js

@@ -293,7 +293,7 @@ SELECT
     (SELECT MAX(HIERARCHY_RANK) + 1 FROM ${ranked})
   ) - Source.HIERARCHY_RANK AS HIERARCHY_TREE_SIZE
  FROM ${ranked} AS Source`)
-    Hierarchy.as = 'H' + (uniqueCounter++)
+    Hierarchy.as = `H${uniqueCounter}`
     Hierarchy.SELECT.columns = [...Hierarchy.SELECT.columns, ...passThroughColumns]
     Hierarchy = this.expr(this.with(Hierarchy))
 

package/lib/cqn2pql.js

@@ -0,0 +1,116 @@
+const cds = require('@sap/cds')
+
+const CQN2SQL = require('./cqn2sql.js').class
+
+class CQN2PQLRenderer extends CQN2SQL {
+
+  SELECT(q) {
+    this.values = undefined // inline all values
+    return (this.sql = super.SELECT(q)
+      .replaceAll('\n FROM', '\nFROM')
+      .replaceAll(/([^ ]) (FROM|WHERE|GROUP BY|HAVING|ORDER BY|LIMIT) /g, (a, b, c) => `${b}\n${c} `)
+    )
+  }
+
+  SELECT_columns(q) {
+    return super.SELECT_columns(q).map((c, i) => `${(i % 5 === 0) ? '\n  ' : ' '}${c}${/ as /i.test(c) ? '\n' : ''}`).join(',')
+  }
+
+  column_expr(x, q) {
+    // omit alias when target is a single source
+    if (q.SELECT.from.ref && x?.ref) x.ref = x.ref.slice(-1)
+    return super.column_expr(x, q)
+  }
+
+  SELECT_expand(q, sql) { return sql }
+
+  INSERT_entries(q) {
+    super.INSERT_entries(q)
+    this.sql = this.sql
+      .replaceAll(/AS (.*?)([, ])(?=[^\n])/ig, (a, b, c) => `AS ${b}${c}\n${c === ',' ? ' ' : ''}`)
+      .replaceAll(/ *= */ig, ' = ')
+      .replaceAll('value AS "$$value$$"', 'value')
+      .replaceAll(' WHERE ', '\nWHERE ')
+      .replaceAll(' SELECT ', '\nSELECT')
+      .replaceAll('(SELECT ', '(SELECT\n  ')
+      .replaceAll('))', ')\n)')
+  }
+
+  INSERT_rows(q) {
+    super.INSERT_rows(q)
+    this.sql = this.sql.replaceAll('SELECT', '\nSELECT')
+  }
+
+  UPSERT(q) {
+    super.UPSERT(q)
+    this.sql = this.sql
+      .replaceAll('INSERT', 'UPSERT')
+      .replaceAll(/AS (.*?)([, ])(?=[^\n])/ig, (a, b, c) => `AS ${b}${c}\n${c === ',' ? ' ' : ''}`)
+      .replaceAll(/ *= */ig, ' = ')
+      .replaceAll('value AS "$$value$$"', 'value')
+      .replaceAll(' WHERE ', '\nWHERE ')
+      .replaceAll(' SELECT ', '\nSELECT')
+      .replaceAll('(SELECT ', '(SELECT\n  ')
+      .replaceAll('))', ')\n)')
+  }
+
+  expr(x) {
+    const wrap = x.cast ? sql => `cast(${sql} as ${this.type4(x.cast)})` : sql => sql
+    if (typeof x === 'string') throw cds.error`Unsupported expr: ${x}`
+    if (x.param) return wrap(this.param(x))
+    if ('ref' in x) return wrap(this.ref(x))
+    if ('val' in x) return wrap(this.val(x))
+    if ('func' in x) return wrap(this.func(x))
+    if ('xpr' in x) return wrap(this.xpr(x))
+    if ('list' in x) return wrap(this.list(x))
+    if ('SELECT' in x) return wrap(`(\n    ${this.SELECT(x).replaceAll('\n', '\n    ')}\n  )`)
+    else throw cds.error`Unsupported expr: ${x}`
+  }
+
+  quote(s) { return s }
+
+  managed(columns, elements) {
+    const keys = ObjectKeys(elements).filter(e => elements[e].key && !elements[e].isAssociation)
+    const keyZero = keys[0]
+
+    const ret = super.managed(columns, elements)
+
+    ret.forEach(c => {
+      const { name, insert, update, onInsert, onUpdate } = c
+      const element = elements?.[name]
+      c.upsert = keyZero && (
+        // upsert requires the keys to be provided for the existance join (default values optional)
+        element?.key
+          // If both insert and update have the same managed definition exclude the old value check
+          || (onInsert && onUpdate && insert === update)
+          ? `${insert} as ${name}`
+          : `!OLD.${keyZero} ? ${
+          // If key of old is null execute insert
+          insert
+          } : ${
+          // Else execute managed update or keep old if no new data if provided
+          onUpdate ? update : `(${this.managed_default(name, `OLD.${name}`, update)})`
+          } as ${name}`
+      )
+      if (c.upsert) c.upsert = '\n  ' + c.upsert
+    })
+    return ret
+  }
+
+  managed_default(name, managed, src) {
+    return `!${src} ? ${managed} : ${src}`
+  }
+
+  managed_extract(name) {
+    const { UPSERT, INSERT } = this.cqn
+    const extract = !(INSERT?.entries || UPSERT?.entries) && (INSERT?.rows || UPSERT?.rows)
+      ? `value[${this.columns.indexOf(name)}]`
+      : `value[${JSON.stringify(name)}]`
+    const sql = extract
+    return { extract, sql }
+  }
+}
+
+const ObjectKeys = o => (o && [...ObjectKeys(o.__proto__), ...Object.keys(o)]) || []
+
+module.exports = CQN2PQLRenderer