@sap/cds-compiler 4.5.0 → 4.6.2

package/lib/render/toHdbcds.js

@@ -4,13 +4,14 @@ const {
   getLastPartOf, getLastPartOfRef,
   hasValidSkipOrExists, isBuiltinType, generatedByCompilerVersion, getNormalizedQuery,
   getRootArtifactName, getResultingName, getNamespace, forEachMember, getVariableReplacement, hasAnnotationValue,
-  pathName,
+  pathName, isMagicVariable,
 } = require('../model/csnUtils');
 const keywords = require('../base/keywords');
 const {
   renderFunc, createExpressionRenderer, getRealName, addContextMarkers, addIntermediateContexts,
   hasHanaComment, getHanaComment, funcWithoutParen, getSqlSnippets,
   cdsToSqlTypes, cdsToHdbcdsTypes, withoutCast, variableForDialect,
+  isVariableReplacementRequired,
 } = require('./utils/common');
 const {
   renderReferentialConstraint,
@@ -18,11 +19,11 @@ const {
 const DuplicateChecker = require('./DuplicateChecker');
 const { isDeprecatedEnabled, forEachDefinition } = require('../base/model');
 const { checkCSNVersion } = require('../json/csnVersion');
-const { makeMessageFunction } = require('../base/messages');
 const { timetrace } = require('../utils/timetrace');
 
 const { smartId, delimitedId } = require('../sql-identifier');
 const { ModelError, CompilerAssertion } = require('../base/error');
+const { pathId } = require('../model/csnRefs');
 
 const $PROJECTION = '$projection';
 const $SELF = '$self';
@@ -90,9 +91,10 @@ function renderStringForHdbcds( str ) {
  *
  * @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 filename: content
  */
-function toHdbcdsSource( csn, options ) {
+function toHdbcdsSource( csn, options, messageFunctions ) {
   timetrace.start('HDBCDS rendering');
   const plainNames = options.sqlMapping === 'plain';
   const quotedNames = options.sqlMapping === 'quoted';
@@ -100,7 +102,13 @@ function toHdbcdsSource( csn, options ) {
 
   const {
     info, warning, error, throwWithAnyError, message,
-  } = makeMessageFunction(csn, options, 'to.hdbcds');
+  } = messageFunctions;
+  if (options.tenantAsColumn) {
+    error('api-unexpected-option', null, { option: 'tenantAsColumn', module: 'to.hdbcds' });
+    throwWithAnyError();
+  }
+
+  const reportedMissingReplacements = Object.create(null);
 
   const exprRenderer = createExpressionRenderer({
     finalize: x => x,
@@ -733,7 +741,7 @@ function toHdbcdsSource( csn, options ) {
 
     // Add any path steps (possibly with parameters and filters) that may follow after that
     if (path.ref.length > 1)
-      result += `.${renderExpr({ ref: path.ref.slice(1) }, env)}`;
+      result += `.${renderTypeRef({ ref: path.ref.slice(1) }, env)}`;
 
     return result;
   }
@@ -1310,40 +1318,63 @@ function toHdbcdsSource( csn, options ) {
     return renderFunc(funcName, x, 'hana', a => renderArgs(a, '=>', this.env));
   }
 
+
   /**
+   * 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 renderMagicVariable( ref, env ) {
+    const magicReplacement = getVariableReplacement(ref, options);
+    if (magicReplacement !== null)
+      return renderStringForHdbcds(magicReplacement);
+
+    const name = pathName(ref);
+    const result = variableForDialect(options, name);
+    if (result)
+      return result;
+
+    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 renderStringForHdbcds(name);
+  }
+
+  /**
+   * 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 Expression with a ref property
    * @returns {string} Rendered expression
    * @todo no extra magic with x.param
    */
   function renderExpressionRef( x ) {
-    if (!x.param) {
-      const magicReplacement = getVariableReplacement(x.ref, options);
-      if (x.ref[0] === '$user' || x.ref[0] === '$tenant') {
-        if (magicReplacement !== null)
-          return renderStringForHdbcds(magicReplacement);
-
-        const name = pathName(x.ref);
-        const result = variableForDialect(options, name);
-        // Invalid second path step doesn't cause a return
-        if (result)
-          return result;
-      }
-      else if (x.ref[0] === '$at' || x.ref[0] === '$valid' || x.ref[0] === '$now') {
-        const name = pathName(x.ref);
-        const result = variableForDialect(options, name);
-        // Invalid second path step doesn't cause a return
-        if (result)
-          return result;
-      }
-      else if (x.ref[0] === '$session' && magicReplacement !== null) {
-        return renderStringForHdbcds(magicReplacement);
-      }
-    }
+    if (!x.param && isMagicVariable(pathId(x.ref[0])))
+      return renderMagicVariable(x.ref, this.env);
+
     const prefix = x.param ? ':' : '';
     const ref = x.ref.map((step, index) => renderPathStep(step, index, this.env.withSubPath([ 'ref', index ]))).join('.');
     return `${prefix}${ref}`;
   }
 
+  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}`;
+  }
+
   /**
    * Render function arguments or view parameters (positional if array, named if object/dict),
    * using 'sep' as separator for positional parameters

package/lib/render/toRename.js

@@ -1,10 +1,8 @@
 
 'use strict';
 
-const { makeMessageFunction } = require('../base/messages');
 const { checkCSNVersion } = require('../json/csnVersion');
 const { forEachDefinition } = require('../model/csnUtils');
-const { optionProcessor } = require('../optionProcessor');
 const { transformForRelationalDBWithCsn } = require('../transform/forRelationalDB');
 const { getIdentifierUtils } = require('./utils/sql');
 
@@ -25,25 +23,23 @@ const { getIdentifierUtils } = require('./utils/sql');
  * @todo clarify input parameters
  * @param {CSN.Model} inputCsn CSN?
  * @param {CSN.Options} options Transformation options
+ * @param {object} messageFunctions
  * @returns {object} A dictionary of name: rename statement
  */
-function toRename( inputCsn, options ) {
-  const { warning, throwWithError } = makeMessageFunction(inputCsn, options, 'to.rename');
+function toRename( inputCsn, options, messageFunctions ) {
+  const { warning, throwWithError } = messageFunctions;
 
   // Merge options with defaults.
+  // TODO: Use api/options.js if this ever becomes an official API.
   options = Object.assign({ sqlMapping: 'hdbcds', sqlDialect: 'hana' }, options);
-
-  // Verify options
-  optionProcessor.verifyOptions(options, 'toRename')
-    // eslint-disable-next-line cds-compiler/message-template-string
-    .forEach(complaint => warning(null, null, `${complaint}`));
   checkCSNVersion(inputCsn, options);
 
   // Let users know that this is internal
   warning(null, null, 'Generation of SQL rename statements is a beta feature and might change in the future');
 
   // FIXME: Currently, 'toRename' implies transformation for HANA (transferring the options to forRelationalDB)
-  const csn = transformForRelationalDBWithCsn(inputCsn, options, 'to.rename');
+  const csn = transformForRelationalDBWithCsn(inputCsn, options, messageFunctions);
+  messageFunctions.setModel(csn);
   const hdbcdsOrQuotedIdentifiers = getIdentifierUtils(csn, options);
   const plainIdentifiers = getIdentifierUtils(csn, { sqlDialect: 'hana', sqlMapping: 'plain' });
 

package/lib/render/toSql.js

@@ -4,13 +4,14 @@
 const {
   getLastPartOf, getLastPartOfRef,
   hasValidSkipOrExists, isBuiltinType, generatedByCompilerVersion, getNormalizedQuery,
-  forEachDefinition, getResultingName, getVariableReplacement, pathName,
+  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);
 
@@ -771,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 ';
@@ -787,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;
   }
@@ -1046,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;
   }
@@ -1469,52 +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) {
-      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] === '$tenant') {
-        if (magicReplacement !== null)
-          return renderStringForSql(magicReplacement, options.sqlDialect);
-
-        const name = pathName(x.ref);
-        const result = variableForDialect(options, name);
-        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') {
-        const name = pathName(x.ref);
-        const result = variableForDialect(options, name);
-        if (result)
-          return result;
-        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()}`;
@@ -1527,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 = pathName(x.ref);
-    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 = pathName(x.ref);
-    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}`;
   }
 
   /**

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
   },
 };
 
@@ -425,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
@@ -708,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"
+    }
+  ]
 }