@cap-js/db-service 1.17.2 → 1.19.0

package/CHANGELOG.md

@@ -4,6 +4,35 @@
 - The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - This project adheres to [Semantic Versioning](http://semver.org/).
 
+## [1.19.0](https://github.com/cap-js/cds-dbs/compare/db-service-v1.18.0...db-service-v1.19.0) (2025-03-31)
+
+
+### Added
+
+* **forUpdate:** ignore locked ([#1074](https://github.com/cap-js/cds-dbs/issues/1074)) ([163480b](https://github.com/cap-js/cds-dbs/commit/163480b245b18a2829cd871c2f053c82bcc1abef))
+* support recursive cqn queries ([#1089](https://github.com/cap-js/cds-dbs/issues/1089)) ([f09b0f8](https://github.com/cap-js/cds-dbs/commit/f09b0f815c3788349f3d39419990cd1c00963b7d))
+
+
+### Fixed
+
+* assign more technical, implicit table aliases ([#1082](https://github.com/cap-js/cds-dbs/issues/1082)) ([1f8925a](https://github.com/cap-js/cds-dbs/commit/1f8925a5d4bcc0123f3abbee2c65ed77877da591))
+* consider `nulls first | last` on `orderBy` ([#1064](https://github.com/cap-js/cds-dbs/issues/1064)) ([c6bed60](https://github.com/cap-js/cds-dbs/commit/c6bed60f0d93b9f4a73c976727f30172707c60d9)), closes [#1062](https://github.com/cap-js/cds-dbs/issues/1062)
+
+## [1.18.0](https://github.com/cap-js/cds-dbs/compare/db-service-v1.17.2...db-service-v1.18.0) (2025-03-04)
+
+
+### Added
+
+* query modifiers on expand `ref` are propagated to subquery ([#1049](https://github.com/cap-js/cds-dbs/issues/1049)) ([39fbadf](https://github.com/cap-js/cds-dbs/commit/39fbadf25a874f810ac2795f2e6b0a46c3678058))
+* support query modifiers at leaf of from ref ([#1050](https://github.com/cap-js/cds-dbs/issues/1050)) ([500a666](https://github.com/cap-js/cds-dbs/commit/500a666a9a054dd72d6ec8ccba0c6a6ddc263cd3))
+
+
+### Fixed
+
+* `<expand>[@odata](https://github.com/odata).count` queries ([#966](https://github.com/cap-js/cds-dbs/issues/966)) ([6607a84](https://github.com/cap-js/cds-dbs/commit/6607a8404aa70f2f3f7c6c65c7e9b1c324a5230b))
+* align debug log format of stmt values ([#1052](https://github.com/cap-js/cds-dbs/issues/1052)) ([93af0fe](https://github.com/cap-js/cds-dbs/commit/93af0fe5f93a0c1b91f592417b31fdb6266fdd79))
+* expand + groupby may return null, dont attach `.element` ([#1042](https://github.com/cap-js/cds-dbs/issues/1042)) ([cf2e0a2](https://github.com/cap-js/cds-dbs/commit/cf2e0a215e89f9055e28d9f0984adf292e220aee))
+
 ## [1.17.2](https://github.com/cap-js/cds-dbs/compare/db-service-v1.17.1...db-service-v1.17.2) (2025-02-09)
 
 

package/lib/InsertResults.js

@@ -34,7 +34,7 @@ module.exports = class InsertResult {
       })
     }
 
-    const { target } = this.query
+    const target = this.query._target
     if (!target?.keys) return (super[iterator] = this.results[iterator])
     const keys = Object.keys(target.keys),
       [k1] = keys

package/lib/SQLService.js

@@ -25,7 +25,7 @@ class SQLService extends DatabaseService {
     this.on(['INSERT', 'UPSERT', 'UPDATE'], require('./deep-queries').onDeep)
     if (cds.env.features.db_strict) {
       this.before(['INSERT', 'UPSERT', 'UPDATE'], ({ query }) => {
-        const elements = query.target?.elements
+        const elements = query._target?.elements
         if (!elements) return
         const kind = query.kind || Object.keys(query)[0]
         const operation = query[kind]
@@ -120,10 +120,10 @@ class SQLService extends DatabaseService {
   async onSELECT({ query, data }) {
     // REVISIT: for custom joins, infer is called twice, which is bad
     //          --> make cds.infer properly work with custom joins and remove this
-    if (!query.target) {
+    if (!(query._target instanceof cds.entity)) {
       try { this.infer(query) } catch { /**/ }
     }
-    if (query.target && !query.target._unresolved) {
+    if (!query._target?._unresolved) { // REVISIT: use query._target instead
       // Will return multiple rows with objects inside
       query.SELECT.expand = 'root'
     }
@@ -267,7 +267,7 @@ class SQLService extends DatabaseService {
               )
             // Prepare and run deep query, à la CQL`DELETE from Foo[pred]:comp1.comp2...`
             const query = DELETE.from({ ref: [...from.ref, c.name] })
-            query.target = c._target
+            query._target = c._target
             return this.onDELETE({ query, depth, visited: [...visited], target: c._target })
           }),
         )
@@ -382,7 +382,7 @@ class SQLService extends DatabaseService {
     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?
+      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)

package/lib/common/session-context.js

@@ -23,8 +23,8 @@ class TemporalSessionContext extends SessionContext {
   get '$valid.to'() {
     return (super['$valid.to'] =
       this.ctx._?.['VALID-TO'] ??
-      this.ctx._?.['VALID-AT']?.replace(/(\dZ?)$/, d => parseInt(d[0]) + 1 + d[1] || '') ??
-      new Date().toISOString().replace(/(\dZ?)$/, d => parseInt(d[0]) + 1 + d[1] || ''))
+      this.ctx._?.['VALID-AT']?.replace(/\.(\d*)(Z?)$/, (_, d, z) => `.${parseInt(d) + 1}${z}`) ??
+      (new Date(Date.now() + 1)).toISOString())
   }
 }
 

package/lib/cql-functions.js

@@ -1,30 +1,16 @@
-const cds = require("@sap/cds")
+'use strict'
 
+// OData: https://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part2-url-conventions.html#sec_CanonicalFunctions
 const StandardFunctions = {
-  // OData: https://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part2-url-conventions.html#sec_CanonicalFunctions
-
-  // String and Collection Functions
-  /**
-   * Generates SQL statement that produces the length of a given string
-   * @param {string} x
-   * @returns {string}
-   */
-  length: x => `length(${x})`,
-  /**
-   * Generates SQL statement that produces the average of a given expression
-   * @param {string} x
-   * @returns {string}
-   */
-  average: x => `avg(${x})`,
   /**
    * Generates SQL statement that produces a boolean value indicating whether the search term is contained in the given columns
-   * @param {string} ref
-   * @param {string} arg
-   * @returns {string}
+   * @param {string} ref - The reference object containing column information
+   * @param {string} arg - The argument object containing the search value
+   * @returns {string} - SQL statement
    */
   search: function (ref, arg) {
-    if (!('val' in arg)) throw new Error(`Only single value arguments are allowed for $search`)
-    // only apply first search term, rest is ignored
+    if (!('val' in arg)) throw new Error('Only single value arguments are allowed for $search')
+    // Only apply first search term, rest is ignored
     const sub = /("")|("(?:[^"]|\\")*(?:[^\\]|\\\\)")|(\S*)/.exec(arg.val)
     let val
     try {
@@ -37,53 +23,50 @@ const StandardFunctions = {
     const { toString } = ref
     return '(' + refs.map(ref2 => this.contains(this.tolower(toString(ref2)), this.tolower(arg))).join(' or ') + ')'
   },
-  /**
-   * Generates SQL statement that produces a string with all provided strings concatenated
-   * @param  {...string} args
-   * @returns {string}
-   */
-  concat: (...args) => args.map(a => (a.xpr ? `(${a})` : a)).join(' || '),
+
+  // ==============================
+  // Aggregation Functions
+  // ==============================
 
   /**
-   * Generates SQL statement that produces a boolean value indicating whether the first string contains the second string
-   * @param  {...string} args
-   * @returns {string}
+   * Generates SQL statement that produces the average of a given expression
+   * @param {string} x - The expression to average
+   * @returns {string} - SQL statement
    */
-  contains: (...args) => `(ifnull(instr(${args}),0) > 0)`,
+  average: x => `avg(${x})`,
+
   /**
    * Generates SQL statement that produces the number of elements in a given collection
-   * @param {string} x
-   * @returns {string}
+   * @param {string} x - The collection input
+   * @returns {string} - SQL statement
    */
-  count: x => `count(${x || '*'})`,
+  count: x => `count(${x?.val || x || '*'})`,
+
   /**
    * Generates SQL statement that produces the number of distinct values of a given expression
-   * @param {string} x
-   * @returns {string}
-   */
-  countdistinct: x => `count(distinct ${x || cds.error`countdistinct requires a ref to be counted`})`,
-  /**
-   * Generates SQL statement that produces the index of the first occurrence of the second string in the first string
-   * @param {string} x
-   * @param {string} y
-   * @returns {string}
+   * @param {string} x - The expression input
+   * @returns {string} - SQL statement
    */
-  indexof: (x, y) => `instr(${x},${y}) - 1`, // sqlite instr is 1 indexed
+  countdistinct: x => `count(distinct ${x.val || x || '*'})`,
+
+  // ==============================
+  // String Functions
+  // ==============================
+
   /**
-   * Generates SQL statement that produces a boolean value indicating whether the first string starts with the second string
-   * @param {string} x
-   * @param {string} y
-   * @returns {string}
+   * Generates SQL statement that produces the length of a given string
+   * @param {string} x - The string input
+   * @returns {string} - SQL statement
    */
-  startswith: (x, y) => `coalesce(instr(${x},${y}) = 1,false)`, // sqlite instr is 1 indexed
-  // takes the end of the string of the size of the target and compares it with the target
+  length: x => `length(${x})`,
+
   /**
-   * Generates SQL statement that produces a boolean value indicating whether the first string ends with the second string
-   * @param {string} x
-   * @param {string} y
-   * @returns {string}
+   * Generates SQL statement that produces a string with all provided strings concatenated
+   * @param  {...string} args - The strings to concatenate
+   * @returns {string} - SQL statement
    */
-  endswith: (x, y) => `coalesce(substr(${x}, length(${x}) + 1 - length(${y})) = ${y},false)`,
+  concat: (...args) => args.map(a => (a.xpr ? `(${a})` : a)).join(' || '),
+
   /**
    * Generates SQL statement that produces the substring of a given string
    * @example
@@ -92,266 +75,115 @@ const StandardFunctions = {
    * @example
    * // returns 'b'
    * {func:'substring',args:[{val:'abc'},{val:1},{val:1}]}
-   * @param {string} x
-   * @param {string} y
-   * @param {string} z
-   * @returns {string}
+   * @param {string} x - The string input
+   * @param {string} y - The starting position
+   * @param {string} [z] - Optional length of the substring
+   * @returns {string} - SQL statement
    */
   substring: (x, y, z) =>
     z
-      ? `substr( ${x}, case when ${y} < 0 then length(${x}) + ${y} + 1 else ${y} + 1 end, ${z} )`
-      : `substr( ${x}, case when ${y} < 0 then length(${x}) + ${y} + 1 else ${y} + 1 end )`,
+      ? `substr(${x}, case when ${y} < 0 then length(${x}) + ${y} + 1 else ${y} + 1 end, ${z})`
+      : `substr(${x}, case when ${y} < 0 then length(${x}) + ${y} + 1 else ${y} + 1 end)`,
 
-  // String Functions
-  /**
-   * Generates SQL statement that matches the given string against a regular expression
-   * @param {string} x
-   * @param {string} y
-   * @returns {string}
-   */
-  matchesPattern: (x, y) => `(${x} regexp ${y})`,
-  /**
-   * Generates SQL statement that matches the given string against a regular expression
-   * @param {string} x
-   * @param {string} y
-   * @returns {string}
-   */
-  matchespattern: (x, y) => `(${x} regexp ${y})`,
   /**
    * Generates SQL statement that produces the lower case value of a given string
-   * @param {string} x
-   * @returns {string}
+   * @param {string} x - The string input
+   * @returns {string} - SQL statement
    */
   tolower: x => `lower(${x})`,
+
   /**
    * Generates SQL statement that produces the upper case value of a given string
-   * @param {string} x
-   * @returns {string}
+   * @param {string} x - The string input
+   * @returns {string} - SQL statement
    */
   toupper: x => `upper(${x})`,
+
   /**
    * Generates SQL statement that produces the trimmed value of a given string
-   * @param {string} x
-   * @returns {string}
+   * @param {string} x - The string input
+   * @returns {string} - SQL statement
    */
   trim: x => `trim(${x})`,
 
+  // ==============================
   // Arithmetic Functions
+  // ==============================
+
   /**
    * Generates SQL statement that produces the rounded up value of a given number
-   * @param {string} x
-   * @returns {string}
+   * @param {string} x - The number input
+   * @returns {string} - SQL statement
    */
   ceiling: x => `ceil(${x})`,
+
   /**
    * Generates SQL statement that produces the rounded down value of a given number
-   * @param {string} x
-   * @returns {string}
+   * @param {string} x - The number input
+   * @returns {string} - SQL statement
    */
   floor: x => `floor(${x})`,
+
   /**
    * Generates SQL statement that produces the rounded value of a given number
-   * @param {string} x
-   * @param {string} p precision
-   * @returns {string}
+   * @param {string} x - The number input
+   * @param {string} p - The precision
+   * @returns {string} - SQL statement
    */
   round: (x, p) => `round(${x}${p ? `,${p}` : ''})`,
 
+  // ==============================
   // Date and Time Functions
+  // ==============================
 
   /**
    * Generates SQL statement that produces current point in time (date and time with time zone)
-   * @returns {string}
+   * @returns {string} - SQL statement
    */
   now: function () {
     return this.session_context({ val: '$now' })
   },
-  /**
-   * Generates SQL statement that produces the year of a given timestamp
-   * @param {string} x
-   * @returns {string}
-   * /
-  year: x => `cast( strftime('%Y',${x}) as Integer )`,
-  /**
-   * Generates SQL statement that produces the month of a given timestamp
-   * @param {string} x
-   * @returns {string}
-   * /
-  month: x => `cast( strftime('%m',${x}) as Integer )`,
-  /**
-   * Generates SQL statement that produces the day of a given timestamp
-   * @param {string} x
-   * @returns {string}
-   * /
-  day: x => `cast( strftime('%d',${x}) as Integer )`,
-  /**
-   * Generates SQL statement that produces the hours of a given timestamp
-   * @param {string} x
-   * @returns {string}
-   * /
-  hour: x => `cast( strftime('%H',${x}) as Integer )`,
-  /**
-   * Generates SQL statement that produces the minutes of a given timestamp
-   * @param {string} x
-   * @returns {string}
-   * /
-  minute: x => `cast( strftime('%M',${x}) as Integer )`,
-  /**
-   * Generates SQL statement that produces the seconds of a given timestamp
-   * @param {string} x
-   * @returns {string}
-   * /
-  second: x => `cast( strftime('%S',${x}) as Integer )`,
 
-  // REVISIT: make precision configurable
   /**
-   * Generates SQL statement that produces the fractional seconds of a given timestamp
-   * @param {string} x
-   * @returns {string}
+   * Maximum date time value
+   * @returns {string} - SQL statement
    */
-  fractionalseconds: x => `cast( substr( strftime('%f', ${x}), length(strftime('%f', ${x})) - 3) as REAL)`,
+  maxdatetime: () => `'9999-12-31T23:59:59.999Z'`,
 
   /**
-   * maximum date time value
-   * @returns {string}
-   */
-  maxdatetime: () => "'9999-12-31T23:59:59.999Z'",
-  /**
-   * minimum date time value
-   * @returns {string}
+   * Minimum date time value
+   * @returns {string} - SQL statement
    */
-  mindatetime: () => "'0001-01-01T00:00:00.000Z'",
-
-  // odata spec defines the value format for totalseconds as a duration like: P12DT23H59M59.999999999999S
-  // P -> duration indicator
-  // D -> days, T -> Time seperator, H -> hours, M -> minutes, S -> fractional seconds
-  // By splitting the DT and calculating the seconds of the time separate from the day
-  // it possible to determine the full amount of seconds by adding them together as fractionals and multiplying
-  // the number of seconds in a day
-  // As sqlite is most accurate with juliandays it is better to do then then using actual second function
-  // while the odata specification states that the seconds has to be fractional which only julianday allows
-  /**
-   * Generates SQL statement that produces an OData compliant duration string like: P12DT23H59M59.999999999999S
-   * @param {string} x
-   * @returns {string}
-   */
-  totalseconds: x => `(
-    (
-      (
-        cast(substr(${x},2,instr(${x},'DT') - 2) as Integer)
-      ) + (
-        julianday(
-          '-4713-11-25T' ||
-          replace(
-          replace(
-          replace(
-            substr(${x},instr(${x},'DT') + 2),
-            'H',':'
-          ),'M',':'
-          ),'S','Z'
-          )
-        ) - 0.5
-      )
-    ) * 86400
-  )`
+  mindatetime: () => `'0001-01-01T00:00:00.000Z'`,
 }
 
 const HANAFunctions = {
-  // https://help.sap.com/docs/SAP_HANA_PLATFORM/4fe29514fd584807ac9f2a04f6754767/f12b86a6284c4aeeb449e57eb5dd3ebd.html
-
   /**
    * Generates SQL statement that calls the session_context function with the given parameter
-   * @param {string} x session variable name or SQL expression
-   * @returns {string}
+   * @param {string} x - The session variable name or SQL expression
+   * @returns {string} - SQL statement
    */
-    session_context: x => `session_context('${x.val}')`,
+  session_context: x => `session_context('${x.val}')`,
 
-  // Time functions
-  current_date: p => (p ? `current_date(${p})` : 'current_date'),
-  current_time: p => (p ? `current_time(${p})` : 'current_time'),
-  current_timestamp: p => (p ? `current_timestamp(${p})` : 'current_timestamp'),
-  /**
-   * Generates SQL statement that calculates the difference in 100nanoseconds between two timestamps
-   * @param {string} x left timestamp
-   * @param {string} y right timestamp
-   * @returns {string}
-   */
-  nano100_between: (x, y) => `(julianday(${y}) - julianday(${x})) * 864000000000`,
   /**
-   * Generates SQL statement that calculates the difference in seconds between two timestamps
-   * @param {string} x left timestamp
-   * @param {string} y right timestamp
-   * @returns {string}
+   * Generates SQL statement for the current date
+   * @returns {string} - SQL statement
    */
-  seconds_between: (x, y) => `(julianday(${y}) - julianday(${x})) * 86400`,
-  // Calculates the difference in full days using julian day
-  // Using the exact time of the day to determine whether 24 hours have passed or not to add the final day
-  // When just comparing the julianday values with each other there are leap seconds included
-  // Which on the day resolution are included as the individual days therefor ignoring them to match HANA
-  /**
-   * Generates SQL statement that calculates the difference in days between two timestamps
-   * @param {string} x left timestamp
-   * @param {string} y right timestamp
-   * @returns {string}
-   */
-  days_between: (x, y) => `(
-    cast ( julianday(${y}) as Integer ) - cast ( julianday(${x}) as Integer )
-  ) + (
-    case
-      when ( julianday(${y}) < julianday(${x}) ) then
-        (cast( strftime('%H%M%S%f0000', ${y}) as Integer ) < cast( strftime('%H%M%S%f0000', ${x}) as Integer ))
-      else
-        (cast( strftime('%H%M%S%f0000', ${y}) as Integer ) > cast( strftime('%H%M%S%f0000', ${x}) as Integer )) * -1
-    end
-  )`,
+  current_date: () => 'current_date',
 
-  // (y1 - y0) * 12 + (m1 - m0) + (t1 < t0) * -1
-  /* '%d%H%M%S%f' returns as a number like which results in an equal check to:
-  (
-    d1 < d0 ||
-    (d1 = d0 && h1 < h0) ||
-    (d1 = d0 && h1 = h0 && m1 < m0) ||
-    (d1 = d0 && h1 = h0 && m1 = m0 && s1 < s0) ||
-    (d1 = d0 && h1 = h0 && m1 = m0 && s1 = s0 && ms1 < ms0)
-  )
-  Which will remove the current month if the time of the month is below the time of the month of the start date
-  It should not matter that the number of days in the month is different as for a month to have passed
-  the time of the month would have to be higher then the time of the month of the start date
-
-  Also check whether the result will be positive or negative to make sure to not subtract an extra month
-  */
   /**
-   * Generates SQL statement that calculates the difference in months between two timestamps
-   * @param {string} x left timestamp
-   * @param {string} y right timestamp
-   * @returns {string}
+   * Generates SQL statement for the current time
+   * @param {string} [p] - Optional precision parameter
+   * @returns {string} - SQL statement
    */
-  months_between: (x, y) => `
-  (
-    (
-      ( cast( strftime('%Y', ${y}) as Integer ) - cast( strftime('%Y', ${x}) as Integer ) ) * 12
-    ) + (
-      cast( strftime('%m', ${y}) as Integer ) - cast( strftime('%m', ${x}) as Integer )
-    ) + (
-      (
-        case
-          when ( cast( strftime('%Y%m', ${y}) as Integer ) < cast( strftime('%Y%m', ${x}) as Integer ) ) then
-            (cast( strftime('%d%H%M%S%f0000', ${y}) as Integer ) > cast( strftime('%d%H%M%S%f0000', ${x}) as Integer ))
-          else
-            (cast( strftime('%d%H%M%S%f0000', ${y}) as Integer ) < cast( strftime('%d%H%M%S%f0000', ${x}) as Integer )) * -1
-        end
-      )
-    )
-  )`,
+  current_time: p => (p ? `current_time(${p})` : 'current_time'),
+
   /**
-   * Generates SQL statement that calculates the difference in years between two timestamps
-   * @param {string} x left timestamp
-   * @param {string} y right timestamp
-   * @returns {string}
+   * Generates SQL statement for the current timestamp
+   * @param {string} [p] - Optional precision parameter
+   * @returns {string} - SQL statement
    */
-  years_between(x, y) {
-    return `floor(${this.months_between(x, y)} / 12)`
-  },
+  current_timestamp: p => (p ? `current_timestamp(${p})` : 'current_timestamp'),
 }
 
 for (let each in HANAFunctions) HANAFunctions[each.toUpperCase()] = HANAFunctions[each]