@sap/cds-compiler 5.6.0 → 5.7.0

package/lib/render/toHdbcds.js

@@ -1266,7 +1266,7 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
     // we can't quote functions with parens, issue warning if it is a reserved keyword
     if (!funcWithoutParen(x, 'hana') && keywords.hdbcds.includes(uppercaseAndUnderscore(funcName)))
       warning(null, this.env.path, { id: uppercaseAndUnderscore(funcName) }, 'The identifier $(ID) is a SAP HANA keyword');
-    return renderFunc(funcName, x, 'hana', a => renderArgs(a, '=>', this.env));
+    return renderFunc(funcName, x, a => renderArgs(a, '=>', this.env), { options });
   }
 
 

package/lib/render/toSql.js

@@ -122,8 +122,10 @@ function toSqlDdl( csn, options, messageFunctions ) {
       return `CAST(${this.renderExpr(withoutCast(x))} AS ${typeRef})`;
     },
     val: renderExpressionLiteral,
-    enum() {
-      // FIXME: We can't do enums yet because they are not resolved (and we don't bother finding their value by hand)
+    enum(x) {
+      // visitExpr first checks for `#`, then `val`:
+      if (x.val !== undefined)
+        return renderExpressionLiteral(x);
       error('expr-unexpected-enum', this.env.path, 'Enum values are not yet supported for conversion to SQL');
       return '';
     },
@@ -135,7 +137,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
       return renderWindowFunction(smartFuncId(prepareIdentifier(x.func), options.sqlDialect), x, this.env);
     },
     func(x) {
-      return renderFunc(smartFuncId(prepareIdentifier(x.func), options.sqlDialect), x, options.sqlDialect, a => renderArgs(a, '=>', this.env, null));
+      return renderFunc(smartFuncId(prepareIdentifier(x.func), options.sqlDialect), x, a => renderArgs(a, '=>', this.env, null), { messageFunctions, options, path: this.env.path });
     },
     xpr(x) {
       const env = this.env.withSubPath([ 'xpr' ]);

package/lib/render/utils/common.js

@@ -3,6 +3,7 @@
 'use strict';
 
 const { ModelError } = require('../../base/error');
+const { standardDatabaseFunctions } = require('./standardDatabaseFunctions');
 
 const functionsWithoutParams = {
   hana: {
@@ -27,13 +28,25 @@ const { implicitAs } = require('../../model/csnRefs');
  *
  * @param {string} funcName Name of the function
  * @param {object} node Content of the function
- * @param {string} dialect One of 'hana', 'cap' or 'sqlite' - only 'hana' is relevant atm
  * @param {(a: string) => string} renderArgs Function to render function arguments
+ * @param {object} utils Utility object containing options, path, and message functions
  * @returns {string} Function string
  */
-function renderFunc( funcName, node, dialect, renderArgs ) {
-  if (funcWithoutParen( node, dialect ))
+function renderFunc( funcName, node, renderArgs, utils ) {
+  const { options, path, messageFunctions } = utils || {};
+  const { sqlDialect } = options;
+  if (funcWithoutParen( node, sqlDialect ))
     return funcName;
+  const rewriteStandardFunctions = options.transformation !== 'hdbcds' && sqlDialect !== 'plain' && options.standardDatabaseFunctions;
+  if (rewriteStandardFunctions) {
+    // we check function arguments for correctness
+    const { error } = messageFunctions;
+    const that = { renderArgs, error, path };
+    if (standardDatabaseFunctions[sqlDialect]?.[funcName])
+      return standardDatabaseFunctions[sqlDialect][funcName].call(that, node);
+    else if (standardDatabaseFunctions.common[funcName])
+      return standardDatabaseFunctions.common[funcName].call(that, node);
+  }
   return `${funcName}(${renderArgs( node )})`;
 }
 
@@ -682,13 +695,13 @@ function visitExpr( x ) {
       return result;
     }).join(', ')})`;
   }
-  else if (x.val !== undefined) {
-    return this.val(x);
-  }
   else if (x['#']) {
     // Enum symbol
     return this.enum(x);
   }
+  else if (x.val !== undefined) {
+    return this.val(x);
+  }
   else if (x.ref) {
     // Reference: Array of path steps, possibly preceded by ':'
     return this.ref(x);

package/lib/render/utils/standardDatabaseFunctions.js

@@ -0,0 +1,576 @@
+'use strict';
+
+/**
+ * List of functions for which we provide a mapping to the respective SQL dialect.
+ * All functions are lowercase, the caller may treat the function name case-insensitive.
+ *
+ * The `this` context within the functions hold the `renderArgs` function.
+ */
+const oDataFunctions = {
+  // https://www.sqlite.org/lang_corefunc.html
+  sqlite: {
+    contains(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'contains', args, 2);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+      return `(ifnull(instr(${x}, ${y}),0) <> 0)`;
+    },
+    startswith(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'startswith', args, 2);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+      return `coalesce((instr(${x}, ${y}) = 1), false)`;
+    }, // instr is 1 indexed
+    endswith(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'endswith', args, 2);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+      return `coalesce((substr(${x}, length(${x}) + 1 - length(${y})) = ${y}), false)`;
+    },
+    indexof(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'indexof', args, 2);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+      return `(instr(${x}, ${y}) - 1)`; // instr is 1 indexed
+    },
+    matchespattern(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'matchespattern', args, 2);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+      return `cast((${x} regexp ${y}) as INTEGER)`; // this is a udf, sqlite always returns a REAL w/o the cast
+    },
+    year(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'year', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `cast(strftime('%Y', ${x}) as Integer)`;
+    },
+    month(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'month', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `cast(strftime('%m', ${x}) as Integer)`;
+    },
+    day(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'day', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `cast(strftime('%d', ${x}) as Integer)`;
+    },
+    hour(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'hour', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `cast(strftime('%H', ${x}) as Integer)`;
+    },
+    minute(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'minute', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `cast(strftime('%M', ${x}) as Integer)`;
+    },
+    second(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'second', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `cast(strftime('%S', ${x}) as Integer)`;
+    },
+    // REVISIT: currently runtimes normalize to milliseconds
+    //          we could allow this to be more precise
+    fractionalseconds(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'fractionalseconds', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `cast(substr(strftime('%f', ${x}), length(strftime('%f', ${x})) - 3) as REAL)`;
+    },
+    // The date(), time(), and datetime() functions all return text, and so their strftime() equivalents are exact.
+    time(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'time', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `time(${x})`;
+    },
+    date(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'date', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `date(${x}) `;
+    },
+    // this could also be a negative number
+    // also, parts of the EDM.duration are optional which complicates
+    // the implementation on SQL level. As the parameter may be an element
+    // reference, we must do splitting  and casting in the SQL as well as
+    // considering the case where the duration is negative.
+    // --> We do not support this function.
+    // totalseconds(signature) {
+    //   const { args } = signature;
+    //   checkArgs.call(this, 'totalseconds', args, 1);
+    //   let x = this.renderArgs({ ...signature, args: [ args[0] ] });
+    //   const isNegative = x.startsWith("'-"); // Check for leading '-'
+    //   x = isNegative ? x.replace('-', '') : x; // remove for easier processing
+    //   const sql = `((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)`;
+    //   return isNegative ? `-(${sql})` : sql;
+    // },
+  },
+  // https://www.postgresql.org/docs/current/functions-string.html
+  // https://www.postgresql.org/docs/current/functions-math.html
+  postgres: {
+    contains(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'contains', args, 2);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+      return `(coalesce(strpos(${x}, ${y}),0) > 0)`;
+    },
+    startswith(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'startswith', args, 2);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+      return `coalesce((strpos(${x}, ${y}) = 1), false)`; // strpos is 1 indexed
+    },
+    endswith(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'endswith', args, 2);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+      return `coalesce((substr(${x}, (length(${x}) + 1) - length(${y})) = ${y}), false)`;
+    },
+    indexof(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'indexof', args, 2);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+      return `(strpos(${x}, ${y}) - 1)`; // strpos is 1 indexed
+    },
+    matchespattern(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'matchespattern', args, 2);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+      return `regexp_like(${x}, ${y})`;
+    },
+    // TODO: PG docu recommends to use the "EXTRACT" function for improved precision
+    // https://www.postgresql.org/docs/current/functions-datetime.html#FUNCTIONS-DATETIME-EXTRACT
+    year(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'year', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `cast(date_part('year', ${x}) as Integer)`;
+    },
+    month(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'month', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `cast(date_part('month', ${x}) as Integer)`;
+    },
+    day(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'day', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `cast(date_part('day', ${x}) as Integer)`;
+    },
+    hour(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'hour', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `cast(date_part('hour', ${x}) as Integer)`;
+    },
+    minute(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'minute', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `cast(date_part('minute', ${x}) as Integer)`;
+    },
+    second(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'second', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `cast(floor(date_part('second', ${x})) as Integer)`;
+    },
+    // REVISIT: currently runtimes normalize to milliseconds
+    //          we could allow this to be more precise
+    fractionalseconds(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'fractionalseconds', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `CAST(date_part('second', ${x}) - floor(date_part('second', ${x})) AS DECIMAL(3,3))`;
+    },
+    time(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'time', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `to_char(${x}, 'HH24:MI:SS')`;
+    },
+    date(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'date', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `to_char(${x}, 'YYYY-MM-DD')`;
+    },
+  },
+  // https://help.sap.com/docs/HANA_SERVICE_CF/7c78579ce9b14a669c1f3295b0d8ca16/f12b86a6284c4aeeb449e57eb5dd3ebd.html?locale=en-US
+  hana: {
+    contains(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'contains', args, 2, 3);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+      if (signature.args.length > 2) {
+        const z = this.renderArgs({ ...signature, args: [ args[2] ] });
+        // While CONTAINS() looks like a function because of its syntax,
+        // it is classified as a predicate because it is designed to evaluate a condition
+        // and return a Boolean result.
+        return `CONTAINS(${x}, ${y}, ${z})`;
+      }
+
+      return `(CASE WHEN coalesce(locate(${this.renderArgs(signature)}),0)>0 THEN TRUE ELSE FALSE END)`;
+    },
+    startswith(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'startswith', args, 2);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+      return `(CASE WHEN locate(${x}, ${y}) = 1 THEN TRUE ELSE FALSE END)`;
+    }, // locate is 1 indexed
+    endswith(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'endswith', args, 2);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+      return `(CASE WHEN substring(${x}, (length(${x}) + 1) - length(${y})) = ${y} THEN TRUE ELSE FALSE END)`;
+    },
+    indexof(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'indexof', args, 2);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+      return `(locate(${x}, ${y}) - 1)`; // locate is 1 indexed
+    },
+    matchespattern(signature) {
+      // case … when only works as column expression (not in where)
+      // in the where clause, only "${x} LIKE_REGEXPR ${y}" works
+      const { args } = signature;
+      checkArgs.call(this, 'matchespattern', args, 2);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+      return `(CASE WHEN ${x} LIKE_REGEXPR ${y} THEN TRUE ELSE FALSE END)`;
+    },
+    year(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'year', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `year(${x})`;
+    },
+    month(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'month', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `month(${x})`;
+    },
+    day(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'day', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `dayofmonth(${x})`;
+    },
+    hour(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'hour', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `hour(${x})`;
+    },
+    minute(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'minute', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `minute(${x})`;
+    },
+    second(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'second', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `to_integer(second(${x}))`;
+    },
+    // REVISIT: currently runtimes normalize to milliseconds
+    //          we could allow this to be more precise
+    fractionalseconds(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'fractionalseconds', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `(to_decimal(second(${x}),5,3) - to_integer(second(${x})))`;
+    },
+    time(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'time', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `cast(to_time(${x}) AS NVARCHAR)`;
+    },
+    date(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'date', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `cast(to_date(${x}) AS NVARCHAR)`;
+    },
+  },
+  // https://www.h2database.com/html/functions.html
+  h2: {
+    contains(signature) {
+      const args = [ ...signature.args ];
+      checkArgs.call(this, 'contains', args, 2);
+      // defined as { LOCATE(searchString, string [, startInt]) }
+      args.reverse();
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+      return `(coalesce(locate(${x}, ${y}),0) > 0)`;
+    },
+    startswith(signature) {
+      const args = [ ...signature.args ];
+      checkArgs.call(this, 'startswith', args, 2);
+      // defined as { LOCATE(searchString, string [, startInt]) }
+      args.reverse();
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+      return `coalesce((locate(${x}, ${y}) = 1), false)`; // locate is 1 indexed
+    },
+    endswith(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'endswith', args, 2);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+      return `coalesce((substring(${x} FROM (char_length(${x}) + 1) - char_length(${y})) = ${y}), false)`;
+    },
+    substring(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'substring', args, 2, 3);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+      const z = args[2]
+        ? this.renderArgs({ ...signature, args: [ args[2] ] })
+        : null;
+      return z
+        ? `substring(${x} FROM CASE WHEN ${y} < 0 THEN char_length(${x}) + ${y} + 1 ELSE ${y} + 1 END FOR ${z})`
+        : `substring(${x} FROM CASE WHEN ${y} < 0 THEN char_length(${x}) + ${y} + 1 ELSE ${y} + 1 END)`;
+    },
+    // char_length is preferred over length -> REVISIT: returns a BIGINT, is this ok?
+    // https://www.h2database.com/html/functions.html#char_length
+    length(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'length', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `cast(char_length(${x}) as Integer)`;
+    },
+    indexof(signature) {
+      const args = [ ...signature.args ];
+      checkArgs.call(this, 'indexof', args, 2);
+      // defined as { LOCATE(searchString, string [, startInt]) }
+      args.reverse();
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+      return `(locate(${x}, ${y}) - 1)`; // locate is 1 indexed
+    },
+    matchespattern(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'matchespattern', args, 2);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+      return `regexp_like(${x}, ${y})`;
+    },
+    year(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'year', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `extract(YEAR FROM ${x})`;
+    },
+    month(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'month', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `extract(MONTH FROM ${x})`;
+    },
+    day(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'day', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `extract(DAY FROM ${x})`;
+    },
+    hour(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'hour', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `extract(HOUR FROM ${x})`;
+    },
+    minute(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'minute', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `extract(MINUTE FROM ${x})`;
+    },
+    second(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'second', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `extract(SECOND FROM ${x})`;
+    },
+    // REVISIT: currently runtimes normalize to milliseconds
+    //          we could allow this to be more precise
+    fractionalseconds(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'fractionalseconds', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `cast(extract(MILLISECOND FROM ${x}) / 1000.0 AS NUMERIC(3,3))`;
+    },
+    time(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'time', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `cast(cast(${x} AS TIME) AS VARCHAR)`;
+    },
+    date(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'date', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `cast(cast(${x} AS DATE) AS VARCHAR)`;
+    },
+  },
+  common: {
+    concat(signature) {
+      const separator = '||';
+      const args = signature.args.reduce((acc, current, index) => {
+        if (index > 0)
+          acc.push(separator);
+
+        acc.push(current);
+        return acc;
+      }, []);
+      const res = this.renderArgs({ signature, ...{ args: [ args ] } });
+      return `(${res})`;
+    },
+    ceiling(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'ceiling', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `ceil(${x})`;
+    },
+    floor(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'floor', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `floor(${x})`;
+    },
+    trim(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'trim', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `trim(${x})`;
+    },
+    // SAP HANA, sqlite and postgres share the same implementation
+    substring(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'substring', args, 2, 3);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      const y = this.renderArgs({ ...signature, args: [ args[1] ] });
+      const z = args[2]
+        ? this.renderArgs({ ...signature, args: [ args[2] ] })
+        : null;
+      return 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)`;
+    },
+    min(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'min', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `min(${x})`;
+    },
+    max(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'max', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `max(${x})`;
+    },
+    sum(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'sum', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `sum(${x})`;
+    },
+    count(signature) {
+      const { args } = signature;
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `count(${x || '*'})`;
+    },
+    countdistinct(signature) {
+      const { args } = signature;
+      return `count(distinct ${args.length > 0 ? this.renderArgs(signature) : "'*'"})`;
+    },
+    average(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'average', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `avg(${x})`;
+    },
+    length(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'length', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `length(${x})`;
+    },
+    tolower(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'tolower', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `lower(${x})`;
+    },
+    toupper(signature) {
+      const { args } = signature;
+      checkArgs.call(this, 'toupper', args, 1);
+      const x = this.renderArgs({ ...signature, args: [ args[0] ] });
+      return `upper(${x})`;
+    },
+    // eslint-disable-next-line no-unused-vars
+    maxdatetime(signature) {
+      return "'9999-12-31T23:59:59.999Z'";
+    },
+    // eslint-disable-next-line no-unused-vars
+    mindatetime(signature) {
+      return "'0001-01-01T00:00:00.000Z'";
+    },
+  },
+};
+
+// TODO: add support for the common SAP HANA Functions
+const hanaFunctions = {
+  sqlite: {},
+  postgres: {},
+  hana: { /* no-op */ },
+  h2: {},
+  common: {},
+};
+
+function checkArgs( funcName, receivedArgs, expectedLength, alternativeLength = null ) {
+  const expectedMismatch = receivedArgs.length < expectedLength;
+  const alternativeMismatch = expectedMismatch && (!alternativeLength || alternativeLength && receivedArgs.length < alternativeLength);
+  if (expectedMismatch && alternativeMismatch) {
+    this.error('def-missing-argument', [ ...this.path, 'args' ], {
+      '#': alternativeLength ? 'alternative' : 'std',
+      n: expectedLength,
+      m: alternativeLength,
+      literal: receivedArgs.length,
+      name: funcName,
+    });
+  }
+};
+
+module.exports.standardDatabaseFunctions = {
+  sqlite: { ...oDataFunctions.sqlite, ...hanaFunctions.sqlite },
+  postgres: { ...oDataFunctions.postgres, ...hanaFunctions.postgres },
+  hana: { ...oDataFunctions.hana, ...hanaFunctions.hana },
+  h2: { ...oDataFunctions.h2, ...hanaFunctions.h2 },
+  common: { ...oDataFunctions.common },
+};

package/lib/transform/addTenantFields.js

@@ -331,7 +331,8 @@ function addTenantFields( csn, options, messageFunctions ) {
    * Type references are followed, but only without sibling `elements` or `items`.
    */
   function typeDependency( assoc ) {
-    if (!assoc || !(assoc = effectiveType( assoc )))
+    assoc = assoc ? effectiveType( assoc ) : assoc;
+    if (!assoc)
       return '';
     const assocDep = typeCache.get( assoc );
     if (assocDep != null)