@cap-js/sqlite 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -4,6 +4,10 @@
 - The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - This project adheres to [Semantic Versioning](http://semver.org/).
 
+## Version 0.2.0 - 2023-05-03
+
+- Continuous improvements
+
 ## Version 0.1.0 - 2023-04-04
 
 - Initial release

package/README.md

@@ -76,7 +76,7 @@ cds repl --profile better-sqlite
 var { server } = await cds.test('bookshop')
 var { Books, Authors } = cds.entities
 await INSERT.into (Books) .entries ({ title: 'Unwritten Book' })
-await INSERT.into (Authors) .entries ({ name: 'Upcomming Author' })
+await INSERT.into (Authors) .entries ({ name: 'Upcoming Author' })
 await SELECT `from ${Books} { title as book, author.name as author, genre.name as genre }`
 await SELECT `from ${Authors} { books.title as book, name as author, books.genre.name as genre }`
 await SELECT `from ${Books} { title as book, author[ID<170].name as author, genre.name as genre }`
@@ -174,7 +174,7 @@ The combination of the above-mentioned improvements commonly leads to significan
 
 ## Known Limitations & Changes
 
-- Node v14 is no longer supported → will be dropped anyways with upcomming cds7.
+- Node v14 is no longer supported → will be dropped anyways with upcoming cds7.
 - JOINs and UNIONs by CQN are no longer supported → use plain SQL instead.
 * CQNs with subqueries require table aliases to refer to elements of outer queries.
 * CQNs with an empty columns array now throws an error.

package/lib/db/DatabaseService.js

@@ -43,16 +43,17 @@ class DatabaseService extends cds.Service {
     const pool = this.pools[tenant] ??= new Pool (this.pools._factory, tenant)
     const dbc = this.dbc = await pool.acquire()
     this._release = (dbc) => pool.release(dbc)
-    // Setting session context variables
-    await this.set({
-      get '$user.id'(){ return _set (this, '$user.id', ctx.user?.id || 'anonymous') },
-      get '$user.locale'(){ return _set (this, '$user.locale', ctx.locale || cds.env.i18n.default_language) },
-      get '$valid.from'(){ return _set (this, '$valid.from', ctx._?.['VALID-FROM'] || ctx._?.['VALID-AT'] || '1970-01-01T00:00:00Z') },
-      get '$valid.to'(){ return _set (this, '$valid.to', ctx._?.['VALID-TO'] || _validTo4(ctx._?.['VALID-AT']) || '9999-11-11T22:22:22Z') },
-    })
-    // Run BEGIN
-    try { await this.send('BEGIN') }
-    catch (e) { this._release(dbc); throw e }
+    try {
+      // Setting session context variables
+      await this.set({
+        get '$user.id'(){ return _set (this, '$user.id', ctx.user?.id || 'anonymous') },
+        get '$user.locale'(){ return _set (this, '$user.locale', ctx.locale || cds.env.i18n.default_language) },
+        get '$valid.from'(){ return _set (this, '$valid.from', ctx._?.['VALID-FROM']?.toISOString() || ctx._?.['VALID-AT']?.toISOString()  || '1970-01-01T00:00:00Z') },
+        get '$valid.to'(){ return _set (this, '$valid.to', ctx._?.['VALID-TO']?.toISOString()  || _validTo4(ctx._?.['VALID-AT'])?.toISOString()  || '9999-11-11T22:22:22Z') },
+      })
+      // Run BEGIN
+      await this.send('BEGIN') 
+    } catch (e) { this._release(dbc); throw e }
     return this
   }
 

package/lib/db/sql/SQLService.js

@@ -1,4 +1,5 @@
 const cds = require('../../../cds'), DEBUG = cds.debug('sql|db')
+const { resolveView } = require('@sap/cds/libx/_runtime/common/utils/resolveView')
 const DatabaseService = require('../DatabaseService')
 const cqn4sql = require('./cqn4sql')
 const { target_name4 } = require('./utils')
@@ -11,7 +12,8 @@ class SQLService extends DatabaseService {
     this.on([ 'INSERT', 'UPSERT', 'UPDATE', 'DELETE' ], require('./workarounds').input) // REVISIT should be replaced by correct input processing eventually
     this.on([ 'INSERT', 'UPSERT', 'UPDATE', 'DELETE' ], require('./deep').onDeep)
     this.on([ 'SELECT' ], this.onSELECT)
-    this.on([ 'INSERT', 'UPSERT' ], this.onINSERT)
+    this.on([ 'INSERT' ], this.onINSERT)
+    this.on([ 'UPSERT' ], this.onUPSERT)
     this.on([ 'UPDATE' ], this.onUPDATE)
     this.on([ 'DELETE', 'CREATE ENTITY', 'DROP ENTITY' ], this.onSIMPLE)
     this.on([ 'BEGIN', 'COMMIT', 'ROLLBACK' ], this.onEVENT)
@@ -35,7 +37,6 @@ class SQLService extends DatabaseService {
     return cqn.SELECT.one || query.SELECT.from.ref?.[0].cardinality?.max === 1 ? rows[0] || null : rows
   }
 
-  /** Handler for INSERT & UPSERT, which support bulk queries */
   async onINSERT ({ query, data }) {
     const { sql, entries, cqn } = this.cqn2sql (query, data)
     if(!sql) return // Do nothing when there is nothing to be done
@@ -44,6 +45,14 @@ class SQLService extends DatabaseService {
     return new this.class.InsertResults (cqn, results)
   }
 
+  async onUPSERT ({ query, data }) {
+    const { sql, entries } = this.cqn2sql (query, data)
+    if(!sql) return // Do nothing when there is nothing to be done
+    const ps = await this.prepare(sql)
+    const results = entries ? await Promise.all(entries.map(e => ps.run(e))) : await ps.run()
+    return results.reduce((lastValue, currentValue) => lastValue += currentValue.changes, 0)
+  }
+
   /** Handler for UPDATE */
   async onUPDATE (req) {
     return this.onSIMPLE(req)
@@ -127,10 +136,21 @@ class SQLService extends DatabaseService {
   }
   cqn2sql(q,values) {
     const cqn = this.cqn4sql(q)
-    return (new this.class.CQN2SQL) .render (cqn, values)
+
+    const cmd = cqn.cmd || Object.keys(cqn)[0]
+    if (cmd in { INSERT:1, DELETE: 1, UPSERT: 1, UPDATE: 1 }) {
+      let resolvedCqn = resolveView(cqn, this.model, this)
+      if (resolvedCqn && resolvedCqn[cmd]._transitions?.[0].target) {
+        resolvedCqn = resolvedCqn || cqn
+        resolvedCqn.target = resolvedCqn?.[cmd]._transitions[0].target || cqn.target
+      }
+      return (new this.class.CQN2SQL(this.context)) .render (resolvedCqn, values)
+    }
+    return (new this.class.CQN2SQL(this.context)) .render (cqn, values)
   }
   cqn4sql(q) {
-    if (!this.model?.definitions[target_name4(q)]) return _unquirked(q)
+    // REVISIT: move this check to cqn4sql?
+    if (!q.SELECT?.from?.join && !this.model?.definitions[target_name4(q)]) return _unquirked(q)
     return cqn4sql (q, this.model)
   }
 

package/lib/db/sql/cqn2sql.js

@@ -14,7 +14,8 @@ const DEBUG = (()=>{
 
 class CQN2SQLRenderer {
 
-  constructor() {
+  constructor(context) {
+    this.context = cds.context || context
     this.class = new.target // for IntelliSense
     this.class._init() // is a noop for subsequent calls
   }
@@ -55,15 +56,21 @@ class CQN2SQLRenderer {
   CREATE(q) {
     const { target } = q, { query } = target
     const name = this.name(target.name)
-    return this.sql = !query
+    // Don't allow place holders inside views
+    delete this.values
+    this.sql = (!query || target['@cds.persistence.table'])
     ? `CREATE TABLE ${name} ( ${this.CREATE_elements(target.elements)} )`
     : `CREATE VIEW ${name} AS ${this.SELECT(cqn4sql(query))}`
+    this.values = []
+    return
   }
 
   CREATE_elements(elements) {
     let sql = ''
     for (let e in elements) {
-      const s = this.CREATE_element(elements[e])
+      const definition = elements[e]
+      if(definition.isAssociation) continue
+      const s = this.CREATE_element(definition)
       if (s) sql += `${s}, `
     }
     return sql.slice(0, -2)
@@ -71,7 +78,7 @@ class CQN2SQLRenderer {
 
   CREATE_element(element) {
     const type = this.type4(element)
-    if (type) return element.name + ' ' + type
+    if (type) return this.quote(element.name) + ' ' + type
   }
 
   type4 (element) {
@@ -95,10 +102,12 @@ class CQN2SQLRenderer {
     Composition: () => false,
     array: () => 'NCLOB',
     // HANA types
+    /* Disabled as these types are linked to normal cds types
+    'cds.hana.TINYINT': () => 'REAL',
     'cds.hana.REAL': () => 'REAL',
     'cds.hana.CHAR': e => `CHAR(${e.length || 1})`,
-    'cds.hana.ST_POINT': () => 'CHAR',
-    'cds.hana.ST_GEOMETRY': () => 'CHAR',
+    'cds.hana.ST_POINT': () => 'ST_POINT',
+    'cds.hana.ST_GEOMETRY': () => 'ST_GEO',*/
   }
 
 
@@ -316,11 +325,16 @@ class CQN2SQLRenderer {
   UPSERT(q) {
     let { UPSERT } = q, sql = this.INSERT ({__proto__:q, INSERT:UPSERT })
     let keys = q.target?.keys; if (!keys) return this.sql = sql // REVISIT: We should converge q.target and q._target
-    const updates = this.columns.filter(c => !(c in keys)) .map (c => `${c} = excluded.${c}`)
-    const conflict = updates.length
-    ? ` ON CONFLICT(${ Object.keys(keys) }) DO UPDATE SET ` + updates
-    : ` ON CONFLICT(${ Object.keys(keys) }) DO NOTHING`
-    return this.sql = `${sql} WHERE true ${conflict}` // REVISIT: Why do we have that "WHERE true" in here?
+    keys = Object.keys(keys).filter(k => !keys[k].isAssociation)
+
+    let updateColumns = q.UPSERT.entries ? Object.keys(q.UPSERT.entries[0]) : this.columns
+    updateColumns = updateColumns.filter(c => !keys.includes(c)).map (c => `${this.quote(c)} = excluded.${this.quote(c)}`)
+
+    keys = keys.map(k => this.quote(k))
+    const conflict = updateColumns.length
+    ? ` ON CONFLICT(${ keys }) DO UPDATE SET ` + updateColumns
+    : ` ON CONFLICT(${ keys }) DO NOTHING`
+    return this.sql = `${sql} WHERE true ${conflict}`
   }
 
 
@@ -385,7 +399,7 @@ class CQN2SQLRenderer {
 
   xpr({ xpr }) {
     return xpr.map((x,i) => {
-      if (x in {LIKE:1,like:1} && is_regexp(xpr[i+1]?.val)) return 'regexp'
+      if (x in {LIKE:1,like:1} && is_regexp(xpr[i+1]?.val)) return this.operator('regexp')
       if (typeof x === 'string') return this.operator(x,i,xpr)
       if (x.xpr) return `(${this.xpr(x)})`
       else return this.expr(x)
@@ -409,6 +423,7 @@ class CQN2SQLRenderer {
 
   val({ val }) {
     switch (typeof val) {
+      case 'function':  throw new Error('Function values not supported.')
       case 'undefined': return 'NULL'
       case 'boolean':   return val
       case 'number':    return val // REVISIT for HANA
@@ -418,6 +433,7 @@ class CQN2SQLRenderer {
         if (Buffer.isBuffer(val)) val = val.toString('base64')
         else val = this.regex(val) || this.json(val)
     }
+    if(!this.values) return this.string(val)
     this.values.push(val)
     return '?'
   }
@@ -425,7 +441,7 @@ class CQN2SQLRenderer {
   static Functions = require('./func')
   func({ func, args }) {
     args = (args||[]).map(e => e === '*' ? e : { __proto__:e, toString:(x=e)=>this.expr(x) })
-    return this.class.Functions[func]?.(...args) || `${func}(${args})`
+    return this.class.Functions[func]?.apply(this.class.Functions, args) || `${func}(${args})`
   }
 
   list({ list }) {
@@ -465,12 +481,9 @@ class CQN2SQLRenderer {
     const inputConverterKey = this.class._convertInput
     // Ensure that missing managed columns are added
     const requiredColumns = !elements ? [] : Object.keys(elements)
-      .filter(e => (elements[e]?.[annotation] || (!isUpdate && elements[e]?.default)) && !columns.find(c => c.name === e))
+      .filter(e => (elements[e]?.[annotation] || (!isUpdate && elements[e]?.default && !elements[e].virtual)) && !columns.find(c => c.name === e))
       .map(name => ({name,sql:'NULL'}))
 
-    // try to call cds.context less frequent, and have a default
-    const ctx = cds.context || { timestamp: new Date, user: cds.User.anonymous }
-
     return [...columns,...requiredColumns].map(({name,sql}) => {
       const element = elements?.[name] || {}
       let extract = sql ?? `value->>'$.${name}'`
@@ -479,11 +492,11 @@ class CQN2SQLRenderer {
       switch (managed) {
         case '$user.id':
         case '$user':
-          managed = this.string(ctx.user.id)
+          managed = this.string(this.context.user.id)
           break
         case '$now':
           // REVISIT fix for date precision
-          managed = this.string(ctx.timestamp.toISOString())
+          managed = this.string(this.context.timestamp.toISOString())
           break
         default:
           managed = undefined
@@ -491,8 +504,7 @@ class CQN2SQLRenderer {
       if(!isUpdate) {
         const d = element.default
         if(d && (d.val !== undefined || d.ref?.[0] === '$now')) {
-          const defaultValue = d.val ?? (cds.context?.timestamp || new Date()).toISOString()
-          extract = `(CASE WHEN json_type(value,'$.${name}') IS NULL THEN ${typeof defaultValue === 'string' ? this.string(defaultValue) : defaultValue} ELSE ${extract} END)`
+          extract = `(CASE WHEN json_type(value,'$.${name}') IS NULL THEN ${this.defaultValue(d.val)} ELSE ${extract} END)`
         }
       }
       return {
@@ -501,6 +513,10 @@ class CQN2SQLRenderer {
       }
     })
   }
+
+  defaultValue(defaultValue = (this.context.timestamp).toISOString()) {
+    return typeof defaultValue === 'string' ? this.string(defaultValue) : defaultValue
+  }
 }
 
 // REVISIT: Workaround for JSON.stringify to work with buffers

package/lib/db/sql/cqn4sql.js

@@ -26,24 +26,22 @@ const {pseudos} = require('../../ql/pseudos')
  *
  * @param {object} query
  * @param {object} model
- * @param {object} context
  * @returns {object} transformedQuery the transformed query
  */
-function cqn4sql(query, model = cds.context?.model || cds.model, skipInfer = false) {
+function cqn4sql(query, model = cds.context?.model || cds.model) {
+  const inferred = infer(query, model)
   if(query.SELECT?.from.args && !query.joinTree)
-    return infer(query, model)
-
-  let inferred
-  // do not infer again - e.g. for subquery in from
-  if(skipInfer)
-    inferred = query
-  else
-    inferred = infer(query, model)
+    return inferred
 
   const transformedQuery = cds.ql.clone(inferred)
-
-  if(inferred.INSERT || inferred.UPSERT) return inferred // nothing to do
   const kind = inferred.cmd || Object.keys(inferred)[0]
+  if(inferred.INSERT || inferred.UPSERT) {
+    const {as} = transformedQuery[kind].into
+    transformedQuery[kind].into = {ref: [inferred.target.name]}
+    if(as)
+      transformedQuery[kind].into.as = as
+    return transformedQuery
+  }
   const _ = inferred[kind]
   if (_) {
     const { from, entity, where } = _
@@ -445,7 +443,7 @@ function cqn4sql(query, model = cds.context?.model || cds.model, skipInfer = fal
         where = subqueryFollowingExists(recent = where, i).SELECT.where
         i = where.indexOf('exists')
       }
-      const existsIndex = recent.lastIndexOf('exists')
+      const existsIndex = recent.indexOf('exists')
       recent.splice (existsIndex, 2, ...where.map (
         (x) => {
           return replaceAliasWithSubqueryAlias(x)
@@ -838,7 +836,11 @@ function cqn4sql(query, model = cds.context?.model || cds.model, skipInfer = fal
           } else if(token.xpr) {
             result.xpr = getTransformedTokenStream(token.xpr, $baseLink)
           } else if(token.func && token.args) {
-            result.args = getTransformedTokenStream(token.args, $baseLink)
+            result.args = token.args.map(t => {
+              if(!t.val) // this must not be touched
+                return getTransformedTokenStream([t], $baseLink)[0]
+              return t
+            })
           }
 
           transformedWhere.push(result)
@@ -1175,6 +1177,7 @@ function cqn4sql(query, model = cds.context?.model || cds.model, skipInfer = fal
             // REVISIT: this whole section needs a refactoring, it is too complex and some edge cases may still be not considered...
             const refLinkFaker = (thing) => {
               const {ref} = thing
+              const assocHost = getParentEntity(assocRefLink.definition)
               Object.defineProperty(thing, '$refLinks', {
                 value: [],
                 writable: true,
@@ -1186,7 +1189,7 @@ function cqn4sql(query, model = cds.context?.model || cds.model, skipInfer = fal
                 const target = getParentEntity(prev)
                 thing.$refLinks[i] = {definition, target, alias: definition.name}
                 return prev?.elements?.[res] || prev?._target?.elements[res] || pseudos.elements[res]
-              }, getParentEntity(assocRefLink.definition))
+              }, assocHost)
             };
 
             // comparison in on condition needs to be expanded...
@@ -1272,12 +1275,18 @@ function cqn4sql(query, model = cds.context?.model || cds.model, skipInfer = fal
       }
       return result
     }
+    /**
+     * Recursively calculates the containing entity for a given element.
+     *
+     * @param {CSN.element} element
+     * @returns {CSN.definition} the entity containing the given element
+     */
     function getParentEntity(element) {
       if(!element.kind) // pseudo element
         return element
       if(element.kind === 'entity')
         return element
-      else return getParentEntity(element.parent)
+      else return model.definitions[localized(getParentEntity(element.parent))]
     }
   }
 
@@ -1372,7 +1381,7 @@ function cqn4sql(query, model = cds.context?.model || cds.model, skipInfer = fal
     const SELECT = {
       from: {
         ref: [
-          nextDefinition.target || nextDefinition.name
+          localized(assocTarget(nextDefinition) || nextDefinition)
         ],
         as: next.alias
       },
@@ -1397,9 +1406,8 @@ function cqn4sql(query, model = cds.context?.model || cds.model, skipInfer = fal
   function localized(definition) {
     if(!isLocalized(definition))
       return definition.name
-    const locale = cds.context?.locale || 'en'
-    const view = model.definitions[`localized${locale in _translations ? `.${locale}` : ''}.${definition.name}`]
-    return view?.name || model.definitions[`localized.${definition.name}`]?.name || definition.name
+    const view = model.definitions[`localized.${definition.name}`]
+    return view?.name || definition.name
   }
 
   /**
@@ -1414,6 +1422,16 @@ function cqn4sql(query, model = cds.context?.model || cds.model, skipInfer = fal
     return inferred.SELECT?.localized && definition['@cds.localized'] !== false
   }
 
+  /**
+   * Get the csn definition of the target of a given association
+   *
+   * @param assoc
+   * @returns the csn definition of the association target or null if it is not an association
+   */
+  function assocTarget(assoc) {
+    return model.definitions[assoc.target] || null
+  }
+
   /**
    * Calculate the flat name for a deeply nested element:
    * @example `entity E { struct: { foo: String} }` => `getFullName(foo)` => `struct_foo`
@@ -1455,7 +1473,5 @@ module.exports = cqn4sql
 function hasLogicalOr(tokenStream) {
   return tokenStream.some(t => t in {'OR': true, 'or': true})
 }
-// revisit don't do sqlite specific stuff here
-const _translations = cds.env.i18n.for_sqlite.reduce((all, l) => ((all[l] = true), all), {})
 const idOnly = (ref) => ref.id || ref
 const is_regexp = x => x?.constructor?.name === 'RegExp' // NOTE: x instanceof RegExp doesn't work in repl

package/lib/db/sql/deep.js

@@ -1,5 +1,4 @@
 const cds = require('@sap/cds')
-const { getDBTable } = require('@sap/cds/libx/_runtime/common/utils/resolveView')
 const { compareJson } = require('@sap/cds/libx/_runtime/cds-services/services/utils/compareJson')
 const { target_name4 } = require('./utils')
 
@@ -17,7 +16,11 @@ async function onDeep (req, next) {
   if (!hasDeep(query, target)) return next()
   const beforeData = query.INSERT ? [] : await this.run(getExpandForDeep(query, target, true))
   const queries = getDeepQueries(query, beforeData, target)
-  const res = await Promise.all(queries.map (q => this.run(q)))
+  const res = await Promise.all(queries.map (query => {
+    if (query.INSERT) return this.onINSERT({query})
+    if (query.UPDATE) return this.onUPDATE({query})
+    if (query.DELETE) return this.onSIMPLE({query})
+  }))
   return res[0] ?? 0 // TODO what todo with multiple result responses?
 }
 
@@ -61,14 +64,22 @@ const getColumnsFromDataOrKeys = (data, target) => {
   }
 }
 
-const _calculateExpandColumns = (compositions, data, expandColumns = [], elementMap = new Map()) => {
+const _calculateExpandColumns = (target, data, expandColumns = [], elementMap = new Map()) => {
+  const compositions = target.compositions || {}
+
+  if(expandColumns.length === 0) {
+    // REVISIT: ensure that all keys are included in the expand columns
+    expandColumns.push(...getColumnsFromDataOrKeys(data, target))
+  }
+
   for (const compName in compositions) {
     let compositionData
-    if (data === null) {
+    if (data === null || (Array.isArray(data) && !data.length)) {
       compositionData = null
     } else {
       compositionData = data[compName]
     }
+
     // ignore not provided compositions as nothing happens with them (expect deep delete)
     if (compositionData === undefined) {
       // fill columns in case
@@ -90,37 +101,30 @@ const _calculateExpandColumns = (compositions, data, expandColumns = [], element
         ref: [composition.name],
         expand: getColumnsFromDataOrKeys(compositionData, composition._target)
       }
-      if (expandColumns.length === 0) {
-        expandColumns.push(...getColumnsFromDataOrKeys(data, composition.parent))
-      }
 
       expandColumns.push(expandColumn)
     }
 
-    const targetCompositions = composition._target.compositions
-
     // expand deep
-    if (targetCompositions) {
-      // Make a copy and do not share the same map among brother compositions
-      // as we're only interested in deep recursions, not wide recursions.
-      const newElementMap = new Map(elementMap)
-      newElementMap.set(fqn, (seen && seen + 1) || 1)
-
-      if (composition.is2many) {
-        // expandColumn.expand = getColumnsFromDataOrKeys(compositionData, composition._target)
-        if (compositionData === null || compositionData.length === 0) {
-          // deep delete, get all subitems until recursion depth
-          _calculateExpandColumns(targetCompositions, compositionData, expandColumn.expand, newElementMap)
-          return
-        }
+    // Make a copy and do not share the same map among brother compositions
+    // as we're only interested in deep recursions, not wide recursions.
+    const newElementMap = new Map(elementMap)
+    newElementMap.set(fqn, (seen && seen + 1) || 1)
+
+    if (composition.is2many) {
+      // expandColumn.expand = getColumnsFromDataOrKeys(compositionData, composition._target)
+      if (compositionData === null || compositionData.length === 0) {
+        // deep delete, get all subitems until recursion depth
+        _calculateExpandColumns(composition._target, null, expandColumn.expand, newElementMap)
+        continue
+      }
 
-        for (const row of compositionData) {
-          _calculateExpandColumns(targetCompositions, row, expandColumn.expand, newElementMap)
-        }
-      } else {
-        // to one
-        _calculateExpandColumns(targetCompositions, compositionData, expandColumn.expand, newElementMap)
+      for (const row of compositionData) {
+        _calculateExpandColumns(composition._target, row, expandColumn.expand, newElementMap)
       }
+    } else {
+      // to one
+      _calculateExpandColumns(composition._target, compositionData, expandColumn.expand, newElementMap)
     }
   }
 }
@@ -133,10 +137,8 @@ const getExpandForDeep = (query, target) => {
   const cqn = SELECT.from(from)
   if (where) cqn.SELECT.where = where
 
-  const compositions = target.compositions || {}
-
   const columns = []
-  _calculateExpandColumns(compositions, data, columns)
+  _calculateExpandColumns(target, data, columns)
   cqn.columns(columns)
   return cqn
 }
@@ -175,16 +177,10 @@ const _getDeepQueries = (diff, target) => {
 
       if (target.elements[prop] && _hasPersistenceSkip(target.elements[prop]._target)) {
         delete diffEntry[prop]
-      } else if (propData && propData._op) {
-        // to-one can also contain deep, so call recursively
-        subQueries.push(..._getDeepQueries([propData], target.elements[prop]._target))
-        delete diffEntry[prop]
-      } else if (Array.isArray(propData)) {
-        // REVISIT can be arrayed too
-        propData.forEach(subEntry => {
-          if (subEntry._op) {
+      } else if (target.compositions?.[prop]) {
+        const arrayed = Array.isArray(propData) ? propData : [propData]
+        arrayed.forEach(subEntry => {
             subQueries.push(..._getDeepQueries([subEntry], target.elements[prop]._target))
-          }
         })
         delete diffEntry[prop]
       }
@@ -198,16 +194,17 @@ const _getDeepQueries = (diff, target) => {
       delete diffEntry._old
     }
 
-    // first calculate subqueriesand rm their properties, then build root query
+    // first calculate subqueries and rm their properties, then build root query
     if (op === 'create') {
-      queries.push(INSERT.into(getDBTable(target)).entries(diffEntry))
+      queries.push(INSERT.into(target).entries(diffEntry))
     } else if (op === 'delete') {
-      queries.push(DELETE.from(getDBTable(target)).where(diffEntry))
+      queries.push(DELETE.from(target).where(diffEntry))
     } else if (op === 'update') {
       // TODO do we need the where here?
       const keys = target.keys
-      const cqn = UPDATE(getDBTable(target)).with(diffEntry)
+      const cqn = UPDATE(target).with(diffEntry)
       for (const key in keys) {
+        if (keys[key].virtual) continue
         if (!keys[key].isAssociation) {
           cqn.where(key + '=', diffEntry[key])
         }

package/lib/db/sql/func.js

@@ -4,14 +4,15 @@ const StandardFunctions = {
 
   // String and Collection Functions
   // length     : (x) => `length(${x})`,
-  search: (ref, arg) => {
+  search: function(ref, arg) {
     if (!('val' in arg)) throw `SQLite only supports single value arguments for $search`
     const refs = ref.list || [ref], {toString} = ref
-    return '(' + refs.map(ref2 => `ifnull(instr(lower(${toString(ref2)}),lower(${arg})),0)`).join(' or ') + ')'
+    return '(' + refs.map(ref2 => this.contains(this.tolower(toString(ref2)),this.tolower(arg))).join(' or ') + ')'
   },
   concat     : (...args) => args.join('||'),
   contains   : (...args) => `ifnull(instr(${args}),0)`,
   count      : (x)   => `count(${x||'*'})`,
+  countdistinct : (x)   => `count(distinct ${x||'*'})`,
   indexof    : (x,y) => `instr(${x},${y}) - 1`, // sqlite instr is 1 indexed
   startswith : (x,y) => `instr(${x},${y}) = 1`, // sqlite instr is 1 indexed
   endswith   : (x,y) => `instr(${x},${y}) = length(${x}) - length(${y}) +1`,

package/lib/db/sql/workarounds.js

@@ -1,4 +1,3 @@
-const { resolveView } = require('@sap/cds/libx/_runtime/common/utils/resolveView')
 const cds = require('@sap/cds')
 const propagateForeignKeys = require('@sap/cds/libx/_runtime/common/utils/propagateForeignKeys')
 const { enrichDataWithKeysFromWhere } = require('@sap/cds/libx/_runtime/common/utils/keys')
@@ -38,7 +37,7 @@ const generateUUIDandPropagateKeys = (target, data, event) => {
 
 const input = async function (req, next) {
   // REVISIT dummy handler until we have input processing
-  if (!req.target || !this.model) return next()
+  if (!req.target || !this.model || req.target._unresolved) return next()
 
   if (req.event === "UPDATE") {
     // REVISIT for deep update we need to inject the keys first
@@ -56,15 +55,6 @@ const input = async function (req, next) {
     }
   }
 
-  const cmd = req.query.cmd || Object.keys(req.query)[0]
-
-  const resolved = resolveView(req.query, this.model, this)
-
-  if (resolved && resolved[cmd]._transitions?.[0].target) {
-    req.query = resolved || req.query
-    req.target = resolved?.[cmd]._transitions[0].target
-  }
-
   return next()
 }
 

package/lib/db/sqlite/SQLiteService.js

@@ -96,6 +96,11 @@ class SQLiteService extends SQLService {
       Double:  expr => `nullif(quote(${expr}),'NULL')->'$'`,
       struct:  expr => `${expr}->'$'`, // Association + Composition inherits from struct
       array:   expr => `${expr}->'$'`,
+      // REVISIT: Timestamp should not loos precision
+      Date:       e => `strftime('%Y-%m-%d',${e})`,
+      Time:       e => `strftime('%H:%M:%S',${e})`,
+      DateTime:   e => `strftime('%Y-%m-%dT%H:%M:%SZ',${e})`,
+      Timestamp:  e => `strftime('%Y-%m-%dT%H:%M:%fZ',${e})`,
     }
 
     // Used for SQL function expressions

package/lib/ql/cds.infer.js

@@ -129,12 +129,14 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
    * @param {object} arg the arg which shall be augmented
    * @param {$refLink} $baseLink environment where the first `ref` step shall be resolved in.
    *                             For infix filter / expand columns
-   * @param {boolean} expand whether the `arg` is part of a `column.expand`
+   * @param {boolean} expandOrExists whether the `arg` is part of a `column.expand` /
+   *                                 preceded by an `exists`.
+   *                                 In those cases, unmanaged association paths are allowed .
    */
-  function attachRefLinksToArg(arg, $baseLink = null, expand = false) {
+  function attachRefLinksToArg(arg, $baseLink = null, expandOrExists = false) {
     const { ref, xpr } = arg;
     if(xpr)
-      xpr.forEach(t => attachRefLinksToArg(t, $baseLink, expand))
+      xpr.forEach(t => attachRefLinksToArg(t, $baseLink, expandOrExists))
     if (!ref)
       return;
     init$refLinks(arg);
@@ -150,10 +152,10 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
           if (e.target) { // only fk access in infix filter
             const nextStep = ref[1]?.id || ref[1];
             // no unmanaged assoc in infix filter path
-            if (!expand && e.on)
-              throw new Error(`"${ e.name }" in path "${ arg.ref.join('.') }" must not be an unmanaged association`);
+            if (!expandOrExists && e.on)
+              throw new Error(`"${ e.name }" in path "${ arg.ref.map(idOnly).join('.') }" must not be an unmanaged association`);
             // no non-fk traversal in infix filter
-            if (!expand && nextStep && !(nextStep in e.foreignKeys))
+            if (!expandOrExists && nextStep && !(nextStep in e.foreignKeys))
               throw new Error(`Only foreign keys of "${ e.name }" can be accessed in infix filter`);
           }
           arg.$refLinks.push({ definition: e, target: e._target || e });
@@ -179,8 +181,22 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
 
       // link refs in where
       if (step.where) { // REVISIT: why do we need to walk through these so early?
-        if (arg.$refLinks[i].definition.kind === 'entity' || arg.$refLinks[i].definition._target)
-          step.where.forEach(each => (each.ref || each.xpr) && attachRefLinksToArg(each, arg.$refLinks[i]));
+        if (arg.$refLinks[i].definition.kind === 'entity' || arg.$refLinks[i].definition._target) {
+          let existsPredicate = false
+          const walkTokenStream = (token) => {
+            if (token === 'exists') { // no joins for infix filters along `exists <path>`
+              existsPredicate = true;
+            } else if(token.xpr) {
+              // don't miss an exists within an expression
+              token.xpr.forEach(walkTokenStream)
+            }
+            else {
+              attachRefLinksToArg(token, arg.$refLinks[i], existsPredicate)
+              existsPredicate = false
+            }
+          }
+          step.where.forEach(walkTokenStream);
+        }
         else
           throw new Error('A filter can only be provided when navigating along associations');
       }
@@ -314,7 +330,6 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
         }
       }
       where.forEach(walkTokenStream);
-
     }
     if (groupBy) // link $refLinks
       groupBy.forEach(token => inferQueryElement(token, false));
@@ -341,7 +356,7 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
      * In some cases, no joins must be created for non-assoc path traversals:
      * - for infix filters in `exists assoc[parent.foo='bar']` -> part of semi join
      */
-    function inferQueryElement(column, insertIntoQueryElements = true, $baseLink = null, inExists = false, inInline = false) {
+    function inferQueryElement(column, insertIntoQueryElements = true, $baseLink = null, inExists = false) {
       if (column.param)
         return; // parameter references are only resolved into values on execution e.g. :val, :1 or ?
       if (column.args)
@@ -364,6 +379,7 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
       const firstStepIsSelf
         = !firstStepIsTableAlias && column.ref.length > 1 && [ '$self', '$projection' ].includes(column.ref[0]);
       const nameSegments = [];
+      const skipNameStack = [];
       let pseudoPath = false;
       column.ref.forEach((step, i) => {
         const id = step.id || step;
@@ -377,8 +393,6 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
             const { definition, target } = $baseLink;
             const elements = definition.elements || definition._target?.elements;
             if (elements && id in elements) {
-              if (!inExists && isStepJoinRelevant(definition, id, inInline ? null : $baseLink))
-                Object.defineProperty(column, 'isJoinRelevant', { value: true });
               column.$refLinks.push({ definition: elements[id], target });
             }
             else {
@@ -415,8 +429,6 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
           const elements = definition.elements || definition._target?.elements;
           if (elements && id in elements) {
             const $refLink = { definition: elements[id], target: column.$refLinks[i - 1].target };
-            if (!inExists && isStepJoinRelevant(definition, id))
-              Object.defineProperty(column, 'isJoinRelevant', { value: true });
             column.$refLinks.push($refLink);
           }
           else if (firstStepIsSelf) {
@@ -436,8 +448,19 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
             stepNotFoundInPredecessor(id, notFoundIn);
           }
           const foreignKeyAlias = Array.isArray(definition.keys)
-            ? definition.keys.find(k => k.ref[0] === id )?.as : null;
-          nameSegments.push(foreignKeyAlias || id);
+            ? definition.keys.find(k =>{
+              if(k.ref[0] === id) {
+                skipNameStack.push(...k.ref.slice(1))
+                return true
+              }
+              return false
+            })?.as : null;
+          if(foreignKeyAlias)
+            nameSegments.push(foreignKeyAlias);
+          else if(skipNameStack[0] === id)
+            skipNameStack.shift()
+          else
+            nameSegments.push(id)
         }
 
         if (step.where) {
@@ -455,6 +478,9 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
             else if (token.ref || token.xpr) {
               inferQueryElement(token, false, column.$refLinks[i], skipJoinsForFilter);
             }
+            else if (token.func) {
+              token.args?.forEach(arg => inferQueryElement(arg, false, column.$refLinks[i], skipJoinsForFilter));
+            }
           });
         }
 
@@ -503,9 +529,11 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
           return;
         }
       }
-
-      if (!inExists && column.isJoinRelevant)
+      // check if we need to merg the column `ref` into the join tree of the query
+      if (!inExists && isColumnJoinRelevant(column)) {
+        Object.defineProperty(column, 'isJoinRelevant', { value: true });
         joinTree.mergeColumn(column);
+      }
 
 
       function resolveInline(col, namePrefix = col.as || col.flatName) {
@@ -623,10 +651,53 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
       }
     }
 
-    function isStepJoinRelevant(definition, id, inInfixFilter = null) {
-      return (definition.on || Array.isArray(definition.keys) &&
-            /* infix filter in column always join relevant, even if fk access */
-            (inInfixFilter || !definition.keys.some(fk => fk.as === id || fk.ref[fk.ref.length - 1] === id)));
+    /**
+     * Checks whether or not the `ref` of the given column is join relevant.
+     * A `ref` is considered join relevant if it includes an association traversal and:
+     *    - the association is unmanaged
+     *    - a non-foreign key access is performed
+     *    - an infix filter is applied at the association
+     *
+     * @param {object} column the column with the `ref` to check for join relevance
+     * @returns {boolean} true if the column ref needs to be merged into a join tree
+     */
+    function isColumnJoinRelevant(column) {
+      let fkAccess = false;
+      let assoc = null
+      for(let i = 0; i<column.ref.length; i++) {
+        const ref = column.ref[i];
+        const link = column.$refLinks[i];
+        if(link.definition.on) {
+          if(!column.ref[i+1]) {
+            if(column.expand && assoc)
+              return true;
+              // if unmanaged assoc is exposed, ignore it
+            return false;
+          }
+          return true;
+        }
+        if(assoc && assoc.keys?.some(key => key.ref[0] === ref)) {
+          fkAccess = true
+          continue;
+        }
+        if(link.definition.target && link.definition.keys) {
+          if(column.ref[i+1] || assoc)
+            fkAccess = false;
+          else
+            fkAccess = true
+          assoc = link.definition;
+          if(ref.where) {
+            // always join relevant except for expand assoc
+            if(column.expand && !column.ref[i+1])
+              return false;
+            return true;
+          }
+        }
+      }
+
+      if(!assoc) return false
+      if(fkAccess) return false
+      else return true
     }
 
     /**

package/lib/ql/join-tree.js

@@ -139,7 +139,6 @@ class JoinTree {
       }
       i += 1;
     }
-
     return true;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js/sqlite",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "CDS database service for SQLite",
   "homepage": "https://cap.cloud.sap/",
   "keywords": [
@@ -10,7 +10,6 @@
   ],
   "author": "SAP SE (https://www.sap.com)",
   "license": "SEE LICENSE",
-  "homepage": "https://cap.cloud.sap/",
   "main": "index.js",
   "files": [
     "cds.js",
@@ -30,23 +29,27 @@
     "pg:up": "docker-compose -f etc/pg-stack.yml up -d",
     "prettier": "npx prettier --write .",
     "test": "jest --silent",
+    "test:all": "npm run test:none && npm run test:sqlite && npm run test:pg",
+    "test:none": "DB=none npm run test",
+    "test:sqlite": "DB=sqlite npm run test",
+    "test:pg": "npm run pg:up && DB=pg npm run test",
     "lint": "npx eslint . && npx prettier --check ."
   },
   "dependencies": {
     "better-sqlite3": "^8"
   },
   "peerDependencies": {
-    "@sap/cds": "*"
+    "@sap/cds": ">=6.8.0"
   },
   "devDependencies": {
-    "@capire/sflight": "sap-samples/cap-sflight",
     "@cap-js/sqlite": ".",
+    "@capire/sflight": "sap-samples/cap-sflight",
     "axios": ">=1.3",
     "chai": "^4.3.7",
     "chai-as-promised": "^7.1.1",
     "chai-subset": "^1.6.0",
     "express": "^4",
-    "pg": "^8",
-    "jest": "^29"
+    "jest": "^29",
+    "pg": "^8"
   }
 }