@sap/cds-compiler 4.4.4 → 4.6.0

package/lib/render/toSql.js

@@ -4,13 +4,14 @@
 const {
   getLastPartOf, getLastPartOfRef,
   hasValidSkipOrExists, isBuiltinType, generatedByCompilerVersion, getNormalizedQuery,
-  forEachDefinition, getResultingName, getVariableReplacement,
+  forEachDefinition, getResultingName,
+  getVariableReplacement, isMagicVariable, pathName,
 } = require('../model/csnUtils');
 const { forEach, forEachValue, forEachKey } = require('../utils/objectUtils');
 const {
   renderFunc, cdsToSqlTypes, getHanaComment, hasHanaComment,
   getSqlSnippets, createExpressionRenderer, withoutCast,
-  variableForDialect,
+  variableForDialect, isVariableReplacementRequired,
 } = require('./utils/common');
 const {
   getDeltaRenderer,
@@ -20,7 +21,6 @@ const {
 } = require('./utils/sql');
 const DuplicateChecker = require('./DuplicateChecker');
 const { checkCSNVersion } = require('../json/csnVersion');
-const { makeMessageFunction } = require('../base/messages');
 const { timetrace } = require('../utils/timetrace');
 const { isBetaEnabled, isDeprecatedEnabled } = require('../base/model');
 const { smartFuncId } = require('../sql-identifier');
@@ -28,6 +28,7 @@ const { sortCsn } = require('../json/to-csn');
 const { manageConstraints, manageConstraint } = require('./manageConstraints');
 const { renderUniqueConstraintString, renderUniqueConstraintDrop, renderUniqueConstraintAdd } = require('./utils/unique');
 const { ModelError, CompilerAssertion } = require('../base/error');
+const { pathId } = require('../model/csnRefs');
 
 class SqlRenderEnvironment {
   indent = '';
@@ -99,13 +100,14 @@ class SqlRenderEnvironment {
  *
  * @param {CSN.Model} csn HANA transformed CSN
  * @param {CSN.Options} options Transformation options
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
  * @returns {object} Dictionary of artifact-type:artifacts, where artifacts is a dictionary of name:content
  */
-function toSqlDdl( csn, options ) {
+function toSqlDdl( csn, options, messageFunctions ) {
   timetrace.start('SQL rendering');
   const {
     error, warning, info, throwWithAnyError,
-  } = makeMessageFunction(csn, options, 'to.sql');
+  } = messageFunctions;
   const { quoteSqlId, prepareIdentifier, renderArtifactName } = getIdentifierUtils(csn, options);
   const reportedMissingReplacements = Object.create(null);
 
@@ -608,7 +610,7 @@ function toSqlDdl( csn, options ) {
       result += renderTechnicalConfiguration(art.technicalConfig, childEnv);
 
 
-    if (options.sqlDialect === 'hana') {
+    if (options.sqlDialect === 'hana' && options.withHanaAssociations) {
       const associations = Object.keys(art.elements)
         .map(name => renderAssociationElement(name, art.elements[name], childEnv))
         .filter(s => s !== '')
@@ -761,7 +763,6 @@ function toSqlDdl( csn, options ) {
    * is not an association.
    * Any change to the cardinality rendering must be reflected in A2J mapAssocToJoinCardinality() as well.
    *
-   * @todo Duplicate check
    * @param {string} elementName Name of the element to render
    * @param {CSN.Element} elm CSN element
    * @param {SqlRenderEnvironment} env Render environment
@@ -772,6 +773,10 @@ function toSqlDdl( csn, options ) {
     let result = '';
     if (elm.target) {
       result += env.indent;
+      const on = (!options.tenantAsColumn || elm.target['@cds.tenant.independent'])
+        ? elm.on
+        : [ { ref: [ 'tenant' ] }, '=', { ref: [ elementName, 'tenant' ] },
+          'and', { xpr: elm.on } ];
       if (elm.cardinality) {
         if (isBetaEnabled(options, 'hanaAssocRealCardinality') && elm.cardinality.src && elm.cardinality.src === 1)
           result += 'ONE TO ';
@@ -788,7 +793,7 @@ function toSqlDdl( csn, options ) {
       }
       result += ' JOIN ';
       result += `${renderArtifactName(elm.target)} AS ${quoteSqlId(elementName)} ON (`;
-      result += `${renderExpr(elm.on, env.withSubPath([ 'on' ]))})`;
+      result += `${renderExpr(on, env.withSubPath([ 'on' ]))})`;
     }
     return result;
   }
@@ -905,12 +910,11 @@ function toSqlDdl( csn, options ) {
    *
    * Returns the source as a string.
    *
-   * @todo Misleading name, should be something like 'renderQueryFrom'. All the query parts should probably also be rearranged.
    * @param {object} source Query source
    * @param {SqlRenderEnvironment} env Render environment
    * @returns {string} Rendered view source
    */
-  function renderViewSource( source, env ) {
+  function renderQuerySource( source, env ) {
     // Sub-SELECT
     if (source.SELECT || source.SET) {
       let result = `(${renderQuery(source, env.withIncreasedIndent())})`;
@@ -922,12 +926,12 @@ function toSqlDdl( csn, options ) {
     // JOIN
     else if (source.join) {
       // One join operation, possibly with ON-condition
-      let result = `${renderViewSource(source.args[0], env.withSubPath([ 'args', 0 ]))}`;
+      let result = `${renderQuerySource(source.args[0], env.withSubPath([ 'args', 0 ]))}`;
       for (let i = 1; i < source.args.length; i++) {
         result = `(${result} ${source.join.toUpperCase()} `;
         if (options.sqlDialect === 'hana')
           result += renderJoinCardinality(source.cardinality);
-        result += `JOIN ${renderViewSource(source.args[i], env.withSubPath([ 'args', i ]))}`;
+        result += `JOIN ${renderQuerySource(source.args[i], env.withSubPath([ 'args', i ]))}`;
         if (source.on)
           result += ` ON ${renderExpr(source.on, env.withSubPath([ 'on' ]))}`;
 
@@ -1048,7 +1052,7 @@ function toSqlDdl( csn, options ) {
 
     // Add any path steps (possibly with parameters and filters) that may follow after that
     if (path.ref.length > 1)
-      result += `${sep}${renderExpr({ ref: path.ref.slice(1) }, env)}`;
+      result += `${sep}${renderTypeRef({ ref: path.ref.slice(1) }, env)}`;
 
     return result;
   }
@@ -1150,7 +1154,7 @@ function toSqlDdl( csn, options ) {
       .map(name => renderAssociationElement(name, art.elements[name], childEnv))
       .filter(s => s !== '')
       .join(',\n');
-    if (associations !== '' && options.sqlDialect === 'hana') {
+    if (associations !== '' && options.sqlDialect === 'hana' && options.withHanaAssociations) {
       result += `${env.indent}\nWITH ASSOCIATIONS (\n${associations}\n`;
       result += `${env.indent})`;
     }
@@ -1257,7 +1261,7 @@ function toSqlDdl( csn, options ) {
       })
       .filter(s => s !== '')
       .join(',\n')}\n`;
-    result += `${env.indent}FROM ${renderViewSource( select.from, env.withSubPath([ 'from' ]))}`;
+    result += `${env.indent}FROM ${renderQuerySource( select.from, env.withSubPath([ 'from' ]))}`;
     if (select.where)
       result += `\n${env.indent}WHERE ${renderExpr(select.where, env.withSubPath([ 'where' ]))}`;
 
@@ -1335,23 +1339,15 @@ function toSqlDdl( csn, options ) {
   function renderTypeReference( elm, env ) {
     let result = '';
 
-    // Anonymous structured type: Not supported with SQL (but shouldn't happen anyway after forHana flattened them)
     if (!elm.type && !elm.value) {
-      if (!elm.elements)
+      // Anonymous structured type: Not supported with SQL, but doesn't happen anyway after flattening.
+      if (options.testMode)
         throw new ModelError(`to.sql(): Missing type of: ${JSON.stringify(env.path)}`);
-
-      // TODO: Signal is not covered by tests
-      error(null, env.path,
-            'Anonymous structured types are not supported for conversion to SQL');
       return result;
     }
-
-    // Association type
-    if (elm.target) {
-      // TODO: Signal is not covered by tests
-      // We can't do associations yet
-      error(null, env.path,
-            'Association and composition types are not yet supported for conversion to SQL');
+    else if (elm.target) {
+      if (options.testMode)
+        throw new ModelError(`to.sql(): Unexpected association in: ${JSON.stringify(env.path)}`);
       return result;
     }
 
@@ -1370,7 +1366,6 @@ function toSqlDdl( csn, options ) {
     if (elm.value) {
       if (!elm.value.stored)
         throw new CompilerAssertion('Found calculated element on-read in rendering; should have been replaced!');
-      // TODO: Properly implement calculated elements on-write:
       // The SQL standard 2016 describes the syntax in section 11.3 - 11.4
       // of the SQL Foundation spec (for 2003 in 5WD-02-Foundation-2003-09.pdf). Summarized:
       //   <generation clause> ::= GENERATED ALWAYS AS '(' <value expression> ')'
@@ -1383,7 +1378,6 @@ function toSqlDdl( csn, options ) {
     return result;
   }
 
-
   /**
    * Render the name of a builtin CDS type
    *
@@ -1481,49 +1475,54 @@ function toSqlDdl( csn, options ) {
     }
   }
 
+
   /**
-   * @param {object} x
+   * Render a magic variable.  Values are determined in following order:
+   *   1. User defined replacement in options.variableReplacements
+   *   2. Predefined fallback values
+   *   3. Rendering of the variable as a string (i.e. its name) + warning
+   *
+   * @param {CSN.Path} ref
    * @param {object} env
    * @return {string}
    */
-  function renderExpressionRef( x, env ) {
-    if (!x.param && !x.global) {
-      const magicReplacement = getVariableReplacement(x.ref, options);
+  function renderMagicVariable( ref, env ) {
+    const magicReplacement = getVariableReplacement(ref, options);
+    if (magicReplacement !== null)
+      return renderStringForSql(magicReplacement, options.sqlDialect);
 
-      if (x.ref[0] === '$user') {
-        if (magicReplacement !== null)
-          return renderStringForSql(magicReplacement, options.sqlDialect);
+    const name = pathName(ref);
+    const result = variableForDialect(options, name);
+    if (result)
+      return result;
 
-        const result = render$user(x);
-        // Invalid second path step doesn't cause a return
-        if (result)
-          return result;
-      }
-      else if (x.ref[0] === '$at' || x.ref[0] === '$valid') {
-        const result = render$at(x);
-        // Invalid second path step doesn't cause a return
-        if (result)
-          return result;
-      }
-      else if (x.ref[0] === '$session' && magicReplacement !== null) {
-        return renderStringForSql(magicReplacement, options.sqlDialect);
-      }
-      else if (x.ref[0] === '$now') { // TODO: Can there be cases where $now is followed by something?
-        switch (options.sqlDialect) {
-          case 'plain':
-          case 'sqlite':
-          case 'hana':
-            return 'CURRENT_TIMESTAMP';
-          case 'h2':
-          case 'postgres':
-            return 'current_timestamp';
-          default:
-            return quoteSqlId(x.ref[0]);
-        }
-      }
+    if (isVariableReplacementRequired(name)) {
+      reportedMissingReplacements[name] = true;
+      error('ref-undefined-var', env.path, { '#': 'value', id: name, option: 'variableReplacements' });
+    }
+    else if (!reportedMissingReplacements[name]) {
+      reportedMissingReplacements[name] = true;
+      warning('ref-unsupported-variable', env.path, { name, option: 'variableReplacements' },
+              'Variable $(NAME) is not supported. Use option $(OPTION) to specify a value for $(NAME)');
     }
+
+    return renderStringForSql(name, options.sqlDialect);
+  }
+
+  /**
+   * Must not be used for type refs, as something like `$user` will be interpreted as a magic
+   * variable and not definition name.
+   *
+   * @param {object} x
+   * @param {object} env
+   * @return {string}
+   */
+  function renderExpressionRef( x, env ) {
+    if (!x.param && isMagicVariable(pathId(x.ref[0])))
+      return renderMagicVariable(x.ref, env);
+
     // FIXME: We currently cannot distinguish whether '$parameters' was quoted or not - we
-    // assume that it was not if the path has length 2 (
+    //        assume that it was not if the path has length 2
     if (firstPathStepId(x.ref) === '$parameters' && x.ref.length === 2) {
       // Parameters must be uppercased and unquoted in SQL
       return `:${x.ref[1].toUpperCase()}`;
@@ -1536,43 +1535,10 @@ function toSqlDdl( csn, options ) {
       .join('.');
   }
 
-  /**
-   * @param {object} x
-   * @returns {string|null} Null in case of an invalid second path step
-   */
-  function render$user( x ) {
-    if (x.ref.length > 2 || typeof x.ref[1] !== 'string')
-      return null; // `$user` can only have two path steps
-
-    const name = `$user.${x.ref[1]}`;
-    const result = variableForDialect(options, name);
-    if (result)
-      return result;
-
-    if (!reportedMissingReplacements[name]) {
-      reportedMissingReplacements[name] = true;
-      warning('ref-unsupported-variable', null, { name, option: 'variableReplacements' },
-              'Variable $(NAME) is not supported. Use option $(OPTION) to specify a value for $(NAME)');
-    }
-    return `'${name}'`;
-  }
-
-  /**
-   * @param {object} x
-   * @returns {string|null} Null in case of an invalid second path step
-   */
-  function render$at( x ) {
-    if (x.ref.length > 2 || typeof x.ref[1] !== 'string')
-      return null; // `$at` can only have two path steps
-
-    const name = `$at.${x.ref[1]}`;
-    const config = variableForDialect(options, name);
-    if (config)
-      return config;
-
-    if (options.testMode)
-      throw new CompilerAssertion(`render$at: unhandled sqlDialect '${options.sqlDialect}' when rendering ${x.ref.join('.')}`);
-    return null;
+  function renderTypeRef( x, env ) {
+    const prefix = x.param ? ':' : '';
+    const ref = x.ref.map((step, index) => renderPathStep(step, index, env.withSubPath([ 'ref', index ]))).join('.');
+    return `${prefix}${ref}`;
   }
 
   /**
@@ -1586,22 +1552,10 @@ function toSqlDdl( csn, options ) {
   function renderPathStep( s, idx, env ) {
     // Simple id or absolute name
     if (typeof (s) === 'string') {
-      // TODO: When is this actually executed and not handled already in renderExpr?
-      const magicForHana = {
-        '$user.id': 'SESSION_CONTEXT(\'APPLICATIONUSER\')',
-        '$user.locale': 'SESSION_CONTEXT(\'LOCALE\')',
-      };
       // Some magic for first path steps
-      if (idx === 0) {
-        // HANA-specific translation of '$now' and '$user'
-        // FIXME: this is all not enough: we might need an explicit select item alias
-        if (options.sqlDialect === 'hana' && magicForHana[s])
-          return magicForHana[s];
-
-        // Ignore initial $projection and initial $self
-        if (s === '$projection' || s === '$self')
-          return '';
-      }
+      // Ignore initial $projection and initial $self
+      if (idx === 0 && (s === '$projection' || s === '$self'))
+        return '';
       return quoteSqlId(s);
     }
     // ID with filters or parameters

package/lib/render/utils/common.js

@@ -262,12 +262,14 @@ const cdsToSqlTypes = {
     'cds.UUID': 'NVARCHAR',  // changed to cds.String earlier
     'cds.hana.ST_POINT': 'CHAR', // CHAR is implicit fallback used in toSql - make it explicit here
     'cds.hana.ST_GEOMETRY': 'CHAR', // CHAR is implicit fallback used in toSql - make it explicit here
+    'cds.Vector': 'NVARCHAR', // Not supported; see #11725
   },
   hana: {
     'cds.hana.SMALLDECIMAL': 'SMALLDECIMAL',
     'cds.DateTime': 'SECONDDATE',
     'cds.hana.ST_POINT': 'ST_POINT',
     'cds.hana.ST_GEOMETRY': 'ST_GEOMETRY',
+    'cds.Vector': 'REAL_VECTOR', // FIXME: test me
   },
   sqlite: {
     'cds.Date': 'DATE_TEXT',
@@ -277,6 +279,7 @@ const cdsToSqlTypes = {
     'cds.Binary': 'BINARY_BLOB',
     'cds.hana.BINARY': 'BINARY_BLOB',
     'cds.hana.SMALLDECIMAL': 'SMALLDECIMAL',
+    'cds.Vector': 'BINARY_BLOB', // Not supported; see #11725
   },
   plain: {
     'cds.Binary': 'VARBINARY',
@@ -298,6 +301,7 @@ const cdsToSqlTypes = {
     'cds.Binary': 'BYTEA',
     'cds.Double': 'FLOAT8',
     'cds.UInt8': 'INTEGER', // Not equivalent
+    'cds.Vector': 'VARCHAR', // Not supported; see #11725
   },
 };
 
@@ -344,30 +348,39 @@ function getDefaultTypeLengths( sqlDialect ) {
  */
 const variablesToSql = {
   fallback: {
-    // no fallback for $user.id and $user.tenant -> warning in call-site
+    // no fallback for $user.id and $tenant -> warning in call-site
     '$user.locale': '\'en\'',
-    // $at.* are handled in all dialects -> there is no need for a fallback
+    // $at.*/$now are handled in all dialects -> there is no need for a fallback
   },
   hana: {
     '$user.id': "SESSION_CONTEXT('APPLICATIONUSER')",
     '$user.locale': "SESSION_CONTEXT('LOCALE')",
-    '$user.tenant': "SESSION_CONTEXT('TENANT')",
+    $tenant: "SESSION_CONTEXT('APPLICATIONTENANT')",
     '$at.from': "TO_TIMESTAMP(SESSION_CONTEXT('VALID-FROM'))",
     '$at.to': "TO_TIMESTAMP(SESSION_CONTEXT('VALID-TO'))",
+    '$valid.from': "TO_TIMESTAMP(SESSION_CONTEXT('VALID-FROM'))",
+    '$valid.to': "TO_TIMESTAMP(SESSION_CONTEXT('VALID-TO'))",
+    $now: 'CURRENT_TIMESTAMP',
   },
   postgres: {
     '$user.id': "current_setting('cap.applicationuser')",
     '$user.locale': "current_setting('cap.locale')",
-    '$user.tenant': "current_setting('cap.tenant')",
+    $tenant: "current_setting('cap.tenant')",
     '$at.from': "current_setting('cap.valid_from')::timestamp",
     '$at.to': "current_setting('cap.valid_to')::timestamp",
+    '$valid.from': "current_setting('cap.valid_from')::timestamp",
+    '$valid.to': "current_setting('cap.valid_to')::timestamp",
+    $now: 'current_timestamp',
   },
   'better-sqlite': {
     '$user.id': "session_context( '$user.id' )",
     '$user.locale': "session_context( '$user.locale' )",
-    '$user.tenant': "session_context( '$user.tenant' )",
+    $tenant: "session_context( '$tenant' )",
     '$at.from': "session_context( '$valid.from' )",
     '$at.to': "session_context( '$valid.to' )",
+    '$valid.from': "session_context( '$valid.from' )",
+    '$valid.to': "session_context( '$valid.to' )",
+    $now: 'CURRENT_TIMESTAMP',
   },
   sqlite: {
     // For sqlite, we render the string-format-time (strftime) function.
@@ -377,17 +390,26 @@ const variablesToSql = {
     '$at.from': "strftime('%Y-%m-%dT%H:%M:%S.000Z', 'now')",
     // + 1ms compared to $at.from
     '$at.to': "strftime('%Y-%m-%dT%H:%M:%S.001Z', 'now')",
+    '$valid.from': "strftime('%Y-%m-%dT%H:%M:%S.000Z', 'now')",
+    '$valid.to': "strftime('%Y-%m-%dT%H:%M:%S.001Z', 'now')",
+    $now: 'CURRENT_TIMESTAMP',
   },
   plain: {
     '$at.from': 'current_timestamp',
     '$at.to': 'current_timestamp',
+    '$valid.from': 'current_timestamp',
+    '$valid.to': 'current_timestamp',
+    $now: 'CURRENT_TIMESTAMP',
   },
   h2: {
     '$user.id': '@applicationuser',
     '$user.locale': '@locale',
-    '$user.tenant': '@tenant',
+    $tenant: '@tenant',
     '$at.from': '@valid_from',
     '$at.to': '@valid_to',
+    '$valid.from': '@valid_from',
+    '$valid.to': '@valid_to',
+    $now: 'current_timestamp',
   },
 };
 
@@ -407,6 +429,18 @@ function variableForDialect( options, variable ) {
   return variablesToSql[dialect]?.[variable] || variablesToSql.fallback[variable] || null;
 }
 
+/**
+ * Whether a replacement is required for the given variable (e.g. '$user.id').
+ * Some variables such as `$user.id` are not required to have replacement values, even if
+ * there is no proper fallback via `variableForDialect(…)` (for example in sqlDialect 'plain').
+ *
+ * @param {string} name
+ * @return {boolean}
+ */
+function isVariableReplacementRequired( name ) {
+  const notRequired = [ '$user.id', '$user.locale', '$tenant' ];
+  return !notRequired.includes(name);
+}
 
 /**
  * Get the element matching the column
@@ -690,6 +724,7 @@ module.exports = {
   cdsToSqlTypes,
   cdsToHdbcdsTypes,
   variableForDialect,
+  isVariableReplacementRequired,
   hasHanaComment,
   getHanaComment,
   findElement,

package/lib/transform/.eslintrc.json

@@ -1,5 +1,13 @@
 {
   "rules": {
     "no-shadow": "off"
-  }
+  },
+  "overrides": [
+    {
+      "files": [
+        "addTenantFields.js"
+      ],
+      "extends": "../../.eslintrc-ydkjsi.json"
+    }
+  ]
 }