@cap-js/db-service 1.1.0 → 1.2.1

package/CHANGELOG.md

@@ -4,6 +4,30 @@
 - The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - This project adheres to [Semantic Versioning](http://semver.org/).
 
+## Version 1.2.1 - 2023-09-08
+
+### Fixed
+
+- Association expansion in infix filters. #213
+
+## Version 1.2.0 - 2023-09-06
+
+### Added
+
+- support for calculated elements on read. #113 #123
+- support for managed associations with default values. #193
+- introduced new operator `==` which translates to `IS NOT DISTINCT FROM`. #164
+
+### Fixed
+
+- resolved a type error which occured in some cases for deeply nested `expand`s. #173
+- path expression traversing non-foreign-key fields within infix filters are now properly rejected for `exists` predicates. #181
+- CQL functions: In the `args` of the `concat` function an `xpr` is now wrapped in parentheses. #196
+- Make `UPDATE` and `ofarray` typed column compatible. #184
+- Ensure that `INSERT` with `rows` always inserts into the correct column. #193
+- Allow `DateTime` columns to compare against their returned value. #206
+- Deep Insert using backlink associations as key #199.
+
 ## Version 1.1.0 - 2023-08-01
 
 ### Fixed

package/lib/InsertResults.js

@@ -17,7 +17,8 @@ module.exports = class InsertResult {
    * @param {unknown[]} results
    */
   constructor(query, results) {
-    this.query = query
+    // Storing query as non-enumerable property to avoid polluting trace output
+    Object.defineProperty(this, 'query', { value: query })
     this.results = results
   }
 

package/lib/SQLService.js

@@ -18,6 +18,7 @@ const cqn4sql = require('./cqn4sql')
  */
 
 class SQLService extends DatabaseService {
+
   init() {
     this.on(['SELECT'], this.transformStreamFromCQN)
     this.on(['UPDATE'], this.transformStreamIntoCQN)
@@ -82,7 +83,7 @@ class SQLService extends DatabaseService {
     if (rows.length)
       if (cqn.SELECT.expand) rows = rows.map(r => (typeof r._json_ === 'string' ? JSON.parse(r._json_) : r._json_ || r))
     if (cqn.SELECT.count) rows.$count = await this.count(query, rows)
-    return cqn.SELECT.one || query.SELECT.from.ref?.[0].cardinality?.max === 1 ? rows[0] : rows
+    return cqn.SELECT.one || query.SELECT.from?.ref?.[0].cardinality?.max === 1 ? rows[0] : rows
   }
 
   /**
@@ -91,7 +92,7 @@ class SQLService extends DatabaseService {
    */
   async onINSERT({ query, data }) {
     const { sql, entries, cqn } = this.cqn2sql(query, data)
-    if (!sql) return // Do nothing when there is nothing to be done
+    if (!sql) return // Do nothing when there is nothing to be done // REVISIT: fix within mtxs
     const ps = await this.prepare(sql)
     const results = entries ? await Promise.all(entries.map(e => ps.run(e))) : await ps.run()
     return new this.class.InsertResults(cqn, results)
@@ -103,10 +104,11 @@ class SQLService extends DatabaseService {
    */
   async onUPSERT({ query, data }) {
     const { sql, entries } = this.cqn2sql(query, data)
-    if (!sql) return // Do nothing when there is nothing to be done
+    if (!sql) return // Do nothing when there is nothing to be done // REVISIT: When does this happen?
     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)
+    // 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)
   }
 
   /**
@@ -129,21 +131,15 @@ class SQLService extends DatabaseService {
    * @type {Handler}
    */
   async onSTREAM(req) {
-    const { sql, values, entries } = this.cqn2sql(req.query)
+    const { one, sql, values } = this.cqn2sql(req.query)
     // writing stream
     if (req.query.STREAM.into) {
-      const stream = entries[0]
-      stream.on('error', () => stream.removeAllListeners('error'))
-      values.unshift(stream)
       const ps = await this.prepare(sql)
       return (await ps.run(values)).changes
     }
     // reading stream
     const ps = await this.prepare(sql)
-    let result = await ps.all(values)
-    if (result.length === 0) return
-
-    return Object.values(result[0])[0]
+    return ps.stream(values, one)
   }
 
   /**
@@ -171,7 +167,12 @@ class SQLService extends DatabaseService {
    */
   async onPlainSQL({ query, data }, next) {
     if (typeof query === 'string') {
-      DEBUG?.(query)
+      // REVISIT: this is a hack the target of $now might not be a timestamp or date time
+      // Add input converter to CURRENT_TIMESTAMP inside views using $now
+      if(/^CREATE VIEW.* CURRENT_TIMESTAMP[( ]/is.test(query)) {
+        query = query.replace(/CURRENT_TIMESTAMP/gi, 'ISO(CURRENT_TIMESTAMP)')
+      }
+      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) && typeof data[0] === 'object') return await Promise.all(data.map(exec))
@@ -200,8 +201,9 @@ class SQLService extends DatabaseService {
       const [max, offset = 0] = one ? [1] : _ ? [_.rows?.val, _.offset?.val] : []
       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' }],
+      columns: [{ func: 'count', as: 'COUNT' }],
       localized: false,
       expand: false,
       limit: 0,
@@ -209,10 +211,14 @@ class SQLService extends DatabaseService {
     })
     const { sql, values } = this.cqn2sql(cq)
     const ps = await this.prepare(sql)
-    const { count } = await ps.get(values)
-    return count
+    const { count, COUNT } = await ps.get(values)
+    return count ?? COUNT
   }
 
+  /**
+   * Helper class for results of INSERTs.
+   * Subclasses may override this.
+   */
   static InsertResults = require('./InsertResults')
 
   /**
@@ -229,28 +235,22 @@ class SQLService extends DatabaseService {
   }
 
   /**
-   * @param {import('@sap/cds/apis/cqn').Query} q
+   * @param {import('@sap/cds/apis/cqn').Query} query
    * @param {unknown} values
    * @returns {typeof SQLService.CQN2SQL}
    */
-  cqn2sql(q, values) {
-    const cqn = this.cqn4sql(q)
-
-    // REVISIT: disable this for queries like (SELECT 1)
-    // Will return multiple rows with objects inside
-    // Only enable expand when the query is inferred
-    if (cqn.SELECT && cqn.elements) cqn.SELECT.expand = cqn.SELECT.expand ?? 'root'
-
-    const cmd = cqn.cmd || Object.keys(cqn)[0]
-    if (cmd in { INSERT: 1, DELETE: 1, UPSERT: 1, UPDATE: 1 } || cqn.STREAM?.into) {
-      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)
+  cqn2sql(query, values) {
+    let q = this.cqn4sql(query)
+    if (q.SELECT && q.elements) q.SELECT.expand = 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) {
+      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
+      if (target) q.target = target // REVISIT: Why isn't that done in resolveView?
     }
-    return new this.class.CQN2SQL(this.context).render(cqn, values)
+    let cqn2sql = new this.class.CQN2SQL(this)
+    return cqn2sql.render(q, values)
   }
 
   /**
@@ -258,18 +258,19 @@ class SQLService extends DatabaseService {
    * @returns {import('./infer/cqn').Query}
    */
   cqn4sql(q) {
-    // REVISIT: move this check to cqn4sql?
-    if (!q.SELECT?.from?.join && !this.model?.definitions[_target_name4(q)]) return _unquirked(q)
+    if (!q.SELECT?.from?.join && !q.SELECT?.from?.SELECT && !this.model?.definitions[_target_name4(q)]) return _unquirked(q)
     return cqn4sql(q, this.model)
   }
 
   /**
    * Returns a Promise which resolves to a prepared statement object with
    * `{run,get,all}` signature as specified in {@link PreparedStatement}.
+   * @abstract
+   * @param {string} sql The SQL String to be prepared
    * @returns {PreparedStatement}
    */
-  // eslint-disable-next-line no-unused-vars
-  async prepare(/*sql*/) {
+  async prepare(sql) {
+    sql
     throw '2b overridden by subclass'
   }
 
@@ -290,8 +291,10 @@ class SQLService extends DatabaseService {
  * @interface
  */
 class PreparedStatement {
+
   /**
    * Executes a prepared DML query, i.e., INSERT, UPDATE, DELETE, CREATE, DROP
+   * @abstract
    * @param {unknown|unknown[]} binding_params
    */
   async run(binding_params) {
@@ -300,6 +303,7 @@ class PreparedStatement {
   }
   /**
    * Executes a prepared SELECT query and returns a single/first row only
+   * @abstract
    * @param {unknown|unknown[]} binding_params
    * @returns {Promise<unknown>}
    */
@@ -309,6 +313,7 @@ class PreparedStatement {
   }
   /**
    * Executes a prepared SELECT query and returns an array of all rows
+   * @abstract
    * @param {unknown|unknown[]} binding_params
    * @returns {Promise<unknown[]>}
    */
@@ -316,6 +321,15 @@ class PreparedStatement {
     binding_params
     return [{}]
   }
+  /**
+   * Executes a prepared SELECT query and returns a stream of the result
+   * @abstract
+   * @param {unknown|unknown[]} binding_params
+   * @returns {ReadableStream<string|Buffer>} A stream of the result
+   */
+  async stream(binding_params) {
+    binding_params
+  }
 }
 SQLService.prototype.PreparedStatement = PreparedStatement
 
@@ -329,29 +343,26 @@ const _target_name4 = q => {
     q.CREATE?.entity ||
     q.DROP?.entity ||
     q.STREAM?.from ||
-    q.STREAM?.into ||
-    undefined
-  if (target?.SET?.op === 'union') throw new cds.error('”UNION” based queries are not supported')
+    q.STREAM?.into
+  if (target?.SET?.op === 'union') throw new cds.error('UNION-based queries are not supported')
   if (!target?.ref) return target
   const [first] = target.ref
   return first.id || first
 }
 
 const _unquirked = q => {
-  if (typeof q.INSERT?.into === 'string') q.INSERT.into = { ref: [q.INSERT.into] }
-  if (typeof q.UPSERT?.into === 'string') q.UPSERT.into = { ref: [q.UPSERT.into] }
-  if (typeof q.UPDATE?.entity === 'string') q.UPDATE.entity = { ref: [q.UPDATE.entity] }
-  if (typeof q.DELETE?.from === 'string') q.DELETE.from = { ref: [q.DELETE.from] }
-  if (typeof q.CREATE?.entity === 'string') q.CREATE.entity = { ref: [q.CREATE.entity] }
-  if (typeof q.DROP?.entity === 'string') q.DROP.entity = { ref: [q.DROP.entity] }
+  if (!q) return q
+  else if (typeof q.SELECT?.from === 'string') q.SELECT.from = { ref: [q.SELECT.from] }
+  else if (typeof q.INSERT?.into === 'string') q.INSERT.into = { ref: [q.INSERT.into] }
+  else if (typeof q.UPSERT?.into === 'string') q.UPSERT.into = { ref: [q.UPSERT.into] }
+  else if (typeof q.UPDATE?.entity === 'string') q.UPDATE.entity = { ref: [q.UPDATE.entity] }
+  else if (typeof q.DELETE?.from === 'string') q.DELETE.from = { ref: [q.DELETE.from] }
+  else if (typeof q.CREATE?.entity === 'string') q.CREATE.entity = { ref: [q.CREATE.entity] }
+  else if (typeof q.DROP?.entity === 'string') q.DROP.entity = { ref: [q.DROP.entity] }
   return q
 }
 
-const sqls = new (class extends SQLService {
-  get factory() {
-    return null
-  }
-})()
+const sqls = new class extends SQLService { get factory() { return null } }
 cds.extend(cds.ql.Query).with(
   class {
     forSQL() {
@@ -359,6 +370,7 @@ cds.extend(cds.ql.Query).with(
       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
     }

package/lib/common/DatabaseService.js

@@ -1,16 +1,16 @@
+const SessionContext = require('./session-context')
+const ConnectionPool = require('./generic-pool')
 const infer = require('../infer')
-const cds = require('@sap/cds')
-
-function Pool(factory, tenant) {
-  const pool = createPool({ __proto__: factory, create: factory.create.bind(undefined, tenant) }, factory.options)
-  pool._trackedConnections = []
-  return pool
-}
-const { createPool } = require('@sap/cds-foss').pool
+const cds = require('@sap/cds/lib')
 
 /** @typedef {unknown} DatabaseDriver */
 
 class DatabaseService extends cds.Service {
+  /**
+   * Dictionary of connection pools per tenant
+   */
+  pools = { _factory: this.factory }
+
   /**
    * Return a pool factory + options property as expected by
    * https://github.com/coopernurse/node-pool#createpool.
@@ -20,120 +20,89 @@ class DatabaseService extends cds.Service {
   get factory() {
     throw '2b overriden in subclass'
   }
-  pools = { _factory: this.factory }
-
-  /**
-   * @returns {boolean} whether this service is multi tenant enabled
-   */
-  get isMultitenant() {
-    return 'multiTenant' in this.options ? this.options.multiTenant : cds.env.requires.multitenancy
-  }
-
-  /**
-   * @typedef {Object} DefaultSessionVariables
-   * @property {string} '$user.id'
-   * @property {string} '$user.locale'
-   * @property {string} '$valid.from'
-   * @property {string} '$valid.to'
-   */
 
   /**
-   * Set one or more session context variables
-   * @example
-   * ```js
-   * const tx = cds.db.tx()
-   * tx.set({
-   *   '$user.name': 'Alice',
-   *   '$user.role': 'admin'
-   * })
-   * ```
-   * @param {unknown|DefaultSessionVariables} variables
+   * Set one or more session context variables like so:
+   *
+   *     const tx = cds.db.tx()
+   *     tx.set({ foo: 'bar' })
+   *
+   * This is used in this.begin() for standard properties
+   * like `$user.id` or `$user.locale`.
    */
+  // eslint-disable-next-line no-unused-vars
   set(variables) {
-    variables
     throw '2b overridden by subclass'
   }
 
   /**
-   * @param {import('@sap/cds/apis/cqn').Query} q
-   * @param {import('@sap/cds/apis/csn').CSN} m
-   * @returns {import('../infer/cqn').Query}
-   */
-  infer(q, m = this.model) {
-    return infer(q, m)
-  }
-
-  /**
-   * @returns {Promise<DatabaseService>}
+   * Acquires a pooled connection and starts a session, including setting
+   * session context like `$user.id` or `$user.locale`, and starting a
+   * transaction with `BEGIN`
+   * @returns this
    */
   async begin() {
+    // We expect tx.begin() being called for an txed db service
     const ctx = this.context
-    if (!ctx) return this.tx().begin()
-    const tenant = this.isMultitenant && ctx.tenant
-    const pool = (this.pools[tenant] ??= new Pool(this.pools._factory, tenant))
-    const connections = pool._trackedConnections
-    let dbc
-    try {
-      /** @type {DatabaseDriver} */
-      dbc = this.dbc = await pool.acquire()
-    } catch (err) {
-      // TODO: add acquire timeout error check
-      err.stack += `\nActive connections:${connections.length}\n${connections.map(c => c._beginStack.stack).join('\n')}`
-      throw err
-    }
-    this._beginStack = new Error('begin called from:')
-    connections.push(this)
-    /**
-     * @param {DatabaseDriver} dbc
-     */
-    this._release = async dbc => {
-      await pool.release(dbc)
-      connections.splice(connections.indexOf(this), 1)
-    }
+    if (!ctx) return this.tx().begin() // REVISIT: Is this correct? When does this happen?
+
+    // REVISIT: tenant should be undefined if !this.isMultitenant
+    let isMultitenant = 'multiTenant' in this.options ? this.options.multiTenant : cds.env.requires.multitenancy
+    let tenant = isMultitenant && ctx.tenant
+
+    // Setting this.pool as used in this.acquire() and this.release()
+    this.pool = this.pools[tenant] ??= new ConnectionPool(this.pools._factory, tenant)
+
+    // Acquire a pooled connection
+    this.dbc = await this.acquire()
+
+    // Begin a session...
     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'] ?? ctx._?.['VALID-AT'] ?? '1970-01-01T00:00:00.000Z')
-        },
-        get '$valid.to'() {
-          return _set(
-            this,
-            '$valid.to',
-            ctx._?.['VALID-TO'] ?? _validTo4(ctx._?.['VALID-AT']) ?? '9999-11-11T22:22:22.000Z',
-          )
-        },
-      })
-      // Run BEGIN
+      await this.set(new SessionContext(ctx))
       await this.send('BEGIN')
     } catch (e) {
-      this._release(dbc)
+      this.release()
       throw e
     }
     return this
   }
 
+  /**
+   * Commits a transaction and releases the connection to the pool.
+   */
   async commit() {
-    const dbc = this.dbc
-    if (!dbc) return
+    if (!this.dbc) return
     await this.send('COMMIT')
-    this._release(dbc) // only release on successful commit as otherwise released on rollback
+    this.release() // only release on successful commit as otherwise released on rollback
   }
 
+  /**
+   * Rolls back a transaction and releases the connection to the pool.
+   */
   async rollback() {
-    const dbc = this.dbc
-    if (!dbc) return
-    try {
-      await this.send('ROLLBACK')
-    } finally {
-      this._release(dbc)
-    }
+    if (!this.dbc) return
+    else
+      try {
+        await this.send('ROLLBACK')
+      } finally {
+        this.release()
+      }
+  }
+
+  /**
+   * Acquires a connection from this.pool, stored into this.dbc
+   * This is for subclasses to intercept, if required.
+   */
+  async acquire() {
+    return await this.pool.acquire()
+  }
+
+  /**
+   * Releases own connection, i.e. tix.dbc, from this.pool
+   * This is for subclasses to intercept, if required.
+   */
+  async release() {
+    return this.pool.release(this.dbc)
   }
 
   // REVISIT: should happen automatically after a configurable time
@@ -142,18 +111,24 @@ class DatabaseService extends cds.Service {
    */
   async disconnect(tenant) {
     const pool = this.pools[tenant]
-    if (pool) delete this.pools[tenant]
-    else return
+    if (!pool) return
     await pool.drain()
     await pool.clear()
+    delete this.pools[tenant]
   }
 
   /**
-   * Runs a Query on the database service
-   * @param {import("@sap/cds/apis/cqn").Query} query
-   * @param {unknown} data
-   * @param  {...unknown} etc
-   * @returns {Promise<unknown>}
+   * Infers the given query with this DatabaseService instance's model.
+   * In general `this.model` is the same then `cds.model`
+   * @param {CQN} query - the query to infer
+   * @returns {CQN} the inferred query
+   */
+  infer(query) {
+    return infer(query, this.model)
+  }
+
+  /**
+   * DatabaseServices also support passing native query strings to underlying databases.
    */
   run(query, data, ...etc) {
     // Allow db.run('...',1,2,3,4)
@@ -162,33 +137,12 @@ class DatabaseService extends cds.Service {
   }
 
   /**
-   * Generated the database url for the given tenant
-   * @param {string} tenant
-   * @returns {string}
+   * @returns {string} A url-like string used to print log output,
+   * e.g., in cds.deploy()
    */
-  url4(tenant) {
-    tenant
-    let { url } = this.options?.credentials || this.options || {}
-    return url
+  url4(/*tenant*/) {
+    return this.options.credentials?.url || this.options.url
   }
-
-  /**
-   * Old name of url4
-   * @deprecated
-   * @param {string} tenant
-   * @returns {string}
-   */
-  getDbUrl(tenant) {
-    return this.url4(tenant)
-  } // REVISIT: Remove after cds v6.7
-}
-
-const _set = (context, variable, value) => {
-  Object.defineProperty(context, variable, { value, configurable: true })
-  return value
-}
-const _validTo4 = validAt => {
-  return validAt?.replace(/(\dZ?)$/, d => parseInt(d[0]) + 1 + d[1] || '')
 }
 
 DatabaseService.prototype.isDatabaseService = true

package/lib/common/generic-pool.js

@@ -0,0 +1,34 @@
+const { createPool } = require('@sap/cds-foss').pool
+
+class ConnectionPool {
+  constructor(factory, tenant) {
+    let bound_factory = { __proto__: factory, create: factory.create.bind(null, tenant) }
+    return _track_connections4(createPool(bound_factory, factory.options))
+  }
+}
+
+// REVISIT: Is that really neccessary ?!
+function _track_connections4(pool) {
+  const { acquire, release } = pool
+  return Object.assign(pool, {
+    async acquire() {
+      const connections = (this._trackedConnections ??= new Set())
+      try {
+        let dbc = await acquire.call(this)
+        connections.add((dbc._beginStack = new Error('begin called from:')))
+        return dbc
+      } catch (err) {
+        // TODO: add acquire timeout error check
+        err.stack += `\nActive connections:${connections.size}\n${[...connections].map(e => e.stack).join('\n')}`
+        throw err
+      }
+    },
+
+    release(dbc) {
+      this._trackedConnections?.delete(dbc._beginStack)
+      return release.call(this, dbc)
+    },
+  })
+}
+
+module.exports = ConnectionPool

package/lib/common/session-context.js

@@ -0,0 +1,32 @@
+const cds = require('@sap/cds/lib')
+
+class SessionContext {
+  constructor(ctx) {
+    Object.defineProperty(this, 'ctx', { value: ctx })
+  }
+  get '$user.id'() {
+    return (super['$user.id'] = this.ctx.user?.id || 'anonymous')
+  }
+  get '$user.locale'() {
+    return (super['$user.locale'] = this.ctx.locale || cds.env.i18n.default_language)
+  }
+  // REVISIT: should be decided in spec meeting for definitive name
+  get $now() {
+    return (super.$now = (this.ctx.timestamp || new Date()).toISOString())
+  }
+}
+
+class TemporalSessionContext extends SessionContext {
+  get '$valid.from'() {
+    return (super['$valid.from'] = this.ctx._?.['VALID-FROM'] ?? this.ctx._?.['VALID-AT'] ?? new Date().toISOString())
+  }
+  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] || ''))
+  }
+}
+
+// REVISIT: only set temporal context if required!
+module.exports = TemporalSessionContext

package/lib/cql-functions.js

@@ -31,7 +31,8 @@ const StandardFunctions = {
    * @param  {...string} args
    * @returns {string}
    */
-  concat: (...args) => args.join('||'),
+  concat: (...args) => args.map(a => a.xpr ? `(${a})` : a).join(' || '),
+
   /**
    * Generates SQL statement that produces a boolean value indicating whether the first string contains the second string
    * @param  {...string} args
@@ -139,6 +140,11 @@ const StandardFunctions = {
   round: (x, p) => `round(${x}${p ? `,${p}` : ''})`,
 
   // Date and 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 produces the year of a given timestamp
    * @param {string} x
@@ -241,6 +247,13 @@ const StandardFunctions = {
       )
     ) * 86400
   )`,
+
+  /**
+   * Generates SQL statement that calls the session_context function with the given parameter
+   * @param {string} x session variable name or SQL expression
+   * @returns {string}
+   */
+  session_context: x => `session_context('${x.val}')`,
 }
 
 const HANAFunctions = {