Merge branch 'main' into renovate/hdb-2.x

Author: johannes-vogel

db-service/lib/cqn4sql.js

@@ -5,7 +5,14 @@ cds.infer.target ??= q => q._target || q.target // instanceof cds.entity ? q._ta
 
 const infer = require('./infer')
 const { computeColumnsToBeSearched } = require('./search')
-const { prettyPrintRef, isCalculatedOnRead, isCalculatedElement, getImplicitAlias, defineProperty, getModelUtils } = require('./utils')
+const {
+  prettyPrintRef,
+  isCalculatedOnRead,
+  isCalculatedElement,
+  getImplicitAlias,
+  defineProperty,
+  getModelUtils,
+} = require('./utils')
 
 /**
  * For operators of <eqOps>, this is replaced by comparing all leaf elements with null, combined with and.
@@ -95,6 +102,7 @@ function cqn4sql(originalQuery, model) {
     const from = queryProp.from
 
     const transformedProp = { __proto__: queryProp } // IMPORTANT: don't lose anything you might not know of
+    const queryNeedsJoins = inferred.joinTree && !inferred.joinTree.isInitial
 
     // Transform the existing where, prepend table aliases, and so on...
     if (where) {
@@ -104,7 +112,47 @@ function cqn4sql(originalQuery, model) {
     // Transform the from clause: association path steps turn into `WHERE EXISTS` subqueries.
     // The already transformed `where` clause is then glued together with the resulting subqueries.
     const { transformedWhere, transformedFrom } = getTransformedFrom(from || entity, transformedProp.where)
-    const queryNeedsJoins = inferred.joinTree && !inferred.joinTree.isInitial
+
+    // build a subquery for DELETE / UPDATE queries with path expressions and match the primary keys
+    if (queryNeedsJoins && (inferred.UPDATE || inferred.DELETE)) {
+      const prop = inferred.UPDATE ? 'UPDATE' : 'DELETE'
+      const subquery = {
+        SELECT: {
+          from: { ...(from || entity) },
+          columns: [], // primary keys of the query target will be added later
+          where: [...where],
+        },
+      }
+      // The alias of the original query is now the alias for the subquery
+      // so that potential references in the where clause to the alias match.
+      // Hence, replace the alias of the original query with the next
+      // available alias, so that each alias is unique.
+      const uniqueSubqueryAlias = getNextAvailableTableAlias(transformedFrom.as)
+      transformedFrom.as = uniqueSubqueryAlias
+
+      // calculate the primary keys of the target entity, there is always exactly
+      // one query source for UPDATE / DELETE
+      const queryTarget = Object.values(inferred.sources)[0].definition
+      const primaryKey = { list: [] }
+      for (const k of Object.keys(queryTarget.elements)) {
+        const e = queryTarget.elements[k]
+        if (e.key === true && !e.virtual && e.isAssociation !== true) {
+          subquery.SELECT.columns.push({ ref: [e.name] })
+          primaryKey.list.push({ ref: [transformedFrom.as, e.name] })
+        }
+      }
+
+      const transformedSubquery = cqn4sql(subquery, model)
+
+      // replace where condition of original query with the transformed subquery
+      // correlate UPDATE / DELETE query with subquery by primary key matches
+      transformedQuery[prop].where = [primaryKey, 'in', transformedSubquery]
+
+      if (prop === 'UPDATE') transformedQuery.UPDATE.entity = transformedFrom
+      else transformedQuery.DELETE.from = transformedFrom
+
+      return transformedQuery
+    }
 
     if (inferred.SELECT) {
       transformedQuery = transformSelectQuery(queryProp, transformedFrom, transformedWhere, transformedQuery)
@@ -130,45 +178,7 @@ function cqn4sql(originalQuery, model) {
     }
 
     if (queryNeedsJoins) {
-      if (inferred.UPDATE || inferred.DELETE) {
-        const prop = inferred.UPDATE ? 'UPDATE' : 'DELETE'
-        const subquery = {
-          SELECT: {
-            from: { ...transformedFrom },
-            columns: [], // primary keys of the query target will be added later
-            where: [...transformedProp.where],
-          },
-        }
-        // The alias of the original query is now the alias for the subquery
-        // so that potential references in the where clause to the alias match.
-        // Hence, replace the alias of the original query with the next
-        // available alias, so that each alias is unique.
-        const uniqueSubqueryAlias = getNextAvailableTableAlias(transformedFrom.as)
-        transformedFrom.as = uniqueSubqueryAlias
-
-        // calculate the primary keys of the target entity, there is always exactly
-        // one query source for UPDATE / DELETE
-        const queryTarget = Object.values(inferred.sources)[0].definition
-        const primaryKey = { list: [] }
-        for (const k of Object.keys(queryTarget.elements)) {
-          const e = queryTarget.elements[k]
-          if (e.key === true && !e.virtual && e.isAssociation !== true) {
-            subquery.SELECT.columns.push({ ref: [e.name] })
-            primaryKey.list.push({ ref: [transformedFrom.as, e.name] })
-          }
-        }
-
-        const transformedSubquery = cqn4sql(subquery, model)
-
-        // replace where condition of original query with the transformed subquery
-        // correlate UPDATE / DELETE query with subquery by primary key matches
-        transformedQuery[prop].where = [primaryKey, 'in', transformedSubquery]
-
-        if (prop === 'UPDATE') transformedQuery.UPDATE.entity = transformedFrom
-        else transformedQuery.DELETE.from = transformedFrom
-      } else {
-        transformedQuery[kind].from = translateAssocsToJoins(transformedQuery[kind].from)
-      }
+      transformedQuery[kind].from = translateAssocsToJoins(transformedQuery[kind].from)
     }
   }
 
@@ -1668,8 +1678,7 @@ function cqn4sql(originalQuery, model) {
   function getTransformedFrom(from, existingWhere = []) {
     const transformedWhere = []
     let transformedFrom = copy(from) // REVISIT: too expensive!
-    if (from.$refLinks)
-      defineProperty(transformedFrom, '$refLinks', [...from.$refLinks])
+    if (from.$refLinks) defineProperty(transformedFrom, '$refLinks', [...from.$refLinks])
     if (from.args) {
       transformedFrom.args = []
       from.args.forEach(arg => {

db-service/test/bookshop/db/schema.cds

@@ -467,3 +467,23 @@ entity Third as projection on Second {
   *,
   first: redirected to FirstRedirected on $self.ID = first.BUBU
 };
+
+entity Car {
+    key ID: Integer;
+    make: String;
+    model: String;
+    doors: Association to many Door on doors.car = $self;
+}
+
+entity Door {
+    key ID: Integer;
+    description: String;
+    car: Association to Car;
+    windows: Association to many Window on windows.door = $self
+}
+
+entity Window {
+    key ID: Integer;
+    description: String;
+    door: Association to Door;
+}

db-service/test/cqn4sql/DELETE.test.js

@@ -107,6 +107,44 @@ describe('DELETE', () => {
     ]
     expect(query.DELETE).to.deep.equal(expected.DELETE)
   })
+  it('DELETE with where exists expansion and path expression via multiple assocs', () => {
+    const forNodeModel = cds.compile.for.nodejs(JSON.parse(JSON.stringify(cds.model)))
+    const { DELETE } = cds.ql
+    let d = DELETE.from('bookshop.Books:author as author').where(`books.genre.name = 'Fiction'`)
+    const query = cqn4sql(d, forNodeModel)
+
+    // this is the final exists subquery
+    const subquery = cds.ql`
+     SELECT author.ID from bookshop.Authors as author
+      left join bookshop.Books as books on books.author_ID = author.ID
+      left join bookshop.Genres as genre on genre.ID = books.genre_ID
+     where exists (
+      SELECT 1 from bookshop.Books as $B where $B.author_ID = author.ID
+     ) and genre.name = 'Fiction' 
+    `
+    const expected = JSON.parse(`{
+      "DELETE": {
+          "from": {
+            "ref": [
+              "bookshop.Authors"
+            ],
+            "as": "author2"
+          }
+        }
+      }`)
+    expected.DELETE.where = [
+      {
+        list: [
+          {
+            ref: ['author2', 'ID'],
+          },
+        ],
+      },
+      'in',
+      subquery,
+    ]
+    expect(query.DELETE).to.deep.equal(expected.DELETE)
+  })
 
   it('in a list with exactly one val, dont transform to key comparison', () => {
     const query = {

db-service/test/cqn4sql/UPDATE.test.js

@@ -168,6 +168,25 @@ describe('UPDATE', () => {
       }`)
     expect(query.UPDATE).to.deep.equal(expected.UPDATE)
   })
+
+  it('supports multiple path expressions in where clause', () => {
+    const q = UPDATE('bookshop.Window as Window').set({ description: 'sliding window' }).where('door.car.make =', 'BMW')
+    const res = cqn4sql(q, model)
+
+    const innerSelect = cds.ql`SELECT from bookshop.Window as Window
+      left join bookshop.Door as door on door.ID = Window.door_ID
+      left join bookshop.Car as car on car.ID = door.car_ID
+      { Window.ID }
+      where car.make = 'BMW'`
+
+    const expected = UPDATE.entity({ ref: ['bookshop.Window'] }).alias('Window2')
+    expected.UPDATE.where = [
+      { list: [{ ref: ['Window2', 'ID'] }] },
+      'in',
+      innerSelect,
+    ]
+    expect (JSON.parse(JSON.stringify(res))).to.deep.equal(JSON.parse(JSON.stringify(expected)))
+  })
 })
 describe('UPDATE with path expression', () => {
   let model

package-lock.json

@@ -112,7 +112,7 @@ cds.test = Object.setPrototypeOf(function () {
     }
 
     // Clean cache
-    delete cds.services._pending.db
+    delete cds.services._pending?.db
     delete cds.services.db
     delete cds.db
     delete cds.model