@cap-js/db-service 1.4.0 → 1.5.0

package/CHANGELOG.md

@@ -4,6 +4,19 @@
 - The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - This project adheres to [Semantic Versioning](http://semver.org/).
 
+## [1.5.0](https://github.com/cap-js/cds-dbs/compare/db-service-v1.4.0...db-service-v1.5.0) (2023-12-06)
+
+
+### Added
+
+* Improved connection pool for HANAService ([#349](https://github.com/cap-js/cds-dbs/issues/349)) ([1c284e6](https://github.com/cap-js/cds-dbs/commit/1c284e69cccd76daad52249c0462bc62aa4d11a8))
+
+
+### Fixed
+
+* **localized:** `ref`s in subqueries in `from` are translated ([#366](https://github.com/cap-js/cds-dbs/issues/366)) ([cfe4897](https://github.com/cap-js/cds-dbs/commit/cfe489715db0854d30b90b7f13c024e6e90be497))
+* wrong odata count in filter with groupby ([#352](https://github.com/cap-js/cds-dbs/issues/352)) ([70690a1](https://github.com/cap-js/cds-dbs/commit/70690a1a13e72bfbb66f03bf315d3f2d48672bf6))
+
 ## [1.4.0](https://github.com/cap-js/cds-dbs/compare/db-service-v1.3.2...db-service-v1.4.0) (2023-11-20)
 
 

package/lib/SQLService.js

@@ -230,16 +230,15 @@ class SQLService extends DatabaseService {
       if (max === undefined || (n < max && (n || !offset))) return n + offset
     }
     // REVISIT: made uppercase count because of HANA reserved word quoting
-    const cq = cds.ql.clone(query, {
-      columns: [{ func: 'count', as: 'COUNT' }],
+    const cq = SELECT.one([{ func: 'count', as: 'COUNT' }]).from(
+      cds.ql.clone(query, {
       localized: false,
       expand: false,
-      limit: 0,
-      orderBy: 0,
-    })
-    const { sql, values } = this.cqn2sql(cq)
-    const ps = await this.prepare(sql)
-    const { count, COUNT } = await ps.get(values)
+        limit: undefined,
+        orderBy: undefined,
+      }),
+    )
+    const { count, COUNT } = await this.onSELECT({ query: cq })
     return count ?? COUNT
   }
 
@@ -280,12 +279,12 @@ class SQLService extends DatabaseService {
    */
   cqn2sql(query, values) {
     let q = this.cqn4sql(query)
-    if (q.SELECT && q.elements) q.SELECT.expand = q.SELECT.expand ?? 'root'
+    if (q.SELECT && 'elements' in q) q.SELECT.expand ??= 'root'
 
-    let cmd = q.cmd || Object.keys(q)[0]
-    if (cmd in { INSERT: 1, DELETE: 1, UPSERT: 1, UPDATE: 1 } || q.STREAM?.into) {
+    let kind = q.kind || Object.keys(q)[0]
+    if (kind in { INSERT: 1, DELETE: 1, UPSERT: 1, UPDATE: 1 } || q.STREAM?.into) {
       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[cmd]._transitions?.[0].target
+      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)

package/lib/common/DatabaseService.js

@@ -63,6 +63,7 @@ class DatabaseService extends cds.Service {
 
     // Acquire a pooled connection
     this.dbc = await this.acquire()
+    this.dbc.destroy = this.destroy.bind(this)
 
     // Begin a session...
     try {
@@ -110,8 +111,20 @@ class DatabaseService extends cds.Service {
    */
   async release() {
     if (!this.dbc) return
-    await this.pool.release(this.dbc)
+    const dbc = this.dbc
     this.dbc = undefined
+    await this.pool.release(dbc)
+  }
+
+  /**
+   * Destroys own connection, i.e. tix.dbc, from this.pool
+   * This is for subclasses to intercept, if required.
+   */
+  async destroy() {
+    if (!this.dbc) return
+    const dbc = this.dbc
+    this.dbc = undefined
+    await this.pool.destroy(dbc)
   }
 
   // REVISIT: should happen automatically after a configurable time

package/lib/cqn2sql.js

@@ -62,14 +62,14 @@ class CQN2SQLRenderer {
    * @returns {CQN2SQLRenderer|unknown}
    */
   render(q, vars) {
-    const cmd = q.cmd || Object.keys(q)[0] // SELECT, INSERT, ...
+    const kind = q.kind || Object.keys(q)[0] // SELECT, INSERT, ...
     /**
      * @type {string} the rendered SQL string
      */
     this.sql = '' // to have it as first property for debugging
     /** @type {unknown[]} */
     this.values = [] // prepare values, filled in by subroutines
-    this[cmd]((this.cqn = q)) // actual sql rendering happens here
+    this[kind]((this.cqn = q)) // actual sql rendering happens here
     if (vars?.length && !this.values?.length) this.values = vars
     const sanitize_values = process.env.NODE_ENV === 'production' && cds.env.log.sanitize_values !== false
     DEBUG?.(
@@ -208,9 +208,8 @@ class CQN2SQLRenderer {
     if (limit) sql += ` LIMIT ${this.limit(limit)}`
     // Expand cannot work without an inferred query
     if (expand) {
-      // REVISIT: Why don't we handle that as an error in SELECT_expand?
-      if (!q.elements) cds.error`Query was not inferred and includes expand. For which the metadata is missing.`
-      sql = this.SELECT_expand(q, sql)
+      if ('elements' in q) sql = this.SELECT_expand (q,sql)
+      else cds.error`Query was not inferred and includes expand. For which the metadata is missing.`
     }
     return (this.sql = sql)
   }
@@ -230,10 +229,12 @@ class CQN2SQLRenderer {
    * @param {string} sql
    * @returns {string} SQL
    */
-  SELECT_expand({ SELECT, elements }, sql) {
+  SELECT_expand(q, sql) {
+    if (!('elements' in q)) return sql
+
+    const SELECT = q.SELECT
     if (!SELECT.columns) return sql
-    if (!elements) return sql // REVISIT: Above we say this is an error condition, but here we say it's ok?
-    
+
     let cols = SELECT.columns.map(x => {
       const name = this.column_name(x)
       let col = `'${name}',${this.output_converter4(x.element, this.quote(name))}`
@@ -256,7 +257,7 @@ class CQN2SQLRenderer {
       }
       // REVISIT: json_merge is a user defined function, bad performance!
       obj = `json_merge(${chunks})`
-    } 
+    }
 
 
     return `SELECT ${SELECT.one || SELECT.expand === 'root' ? obj : `json_group_array(${obj.includes('json_merge') ? `json_insert(${obj})` : obj})`} as _json_ FROM (${sql})`

package/lib/cqn4sql.js

@@ -48,7 +48,7 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
   if (originalQuery.SELECT?.from.args && !originalQuery.joinTree) return inferred
 
   let transformedQuery = cds.ql.clone(inferred)
-  const kind = inferred.cmd || Object.keys(inferred)[0]
+  const kind = inferred.kind || Object.keys(inferred)[0]
 
   if (inferred.INSERT || inferred.UPSERT) {
     transformedQuery = transformQueryForInsertUpsert(kind)
@@ -415,7 +415,6 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
     return transformedColumns
 
     function handleSubquery(col) {
-      if (isLocalized(inferred.target)) col.SELECT.localized = true
       if (!col.SELECT.from.as) {
         const uniqueSubqueryAlias = inferred.joinTree.addNextAvailableTableAlias(
           getLastStringSegment(col.SELECT.from.ref[col.SELECT.from.ref.length - 1]),
@@ -830,7 +829,6 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
         one: column.$refLinks[column.$refLinks.length - 1].definition.is2one,
       },
     }
-    if (isLocalized(inferred.target)) subquery.SELECT.localized = true
     const expanded = transformSubquery(subquery)
     const correlated = _correlate({ ...expanded, as: columnAlias }, outerAlias)
     Object.defineProperty(correlated, 'elements', { value: subquery.elements, writable: true })
@@ -946,6 +944,7 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
       outerQueries.push(inferred)
       Object.defineProperty(q, 'outerQueries', { value: outerQueries })
     }
+    if (isLocalized(inferred.target)) q.SELECT.localized = true
     return cqn4sql(q, model)
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js/db-service",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "CDS base database service",
   "homepage": "https://github.com/cap-js/cds-dbs/tree/main/db-service#cds-base-database-service",
   "repository": {