@sap/cds-compiler 4.0.2 → 4.2.2

package/lib/render/toCdl.js

@@ -126,7 +126,7 @@ function csnToCdl( csn, options ) {
     return result;
 
     function renderVocabulariesEntry( name, anno ) {
-      if (!anno._ignore) {
+      if (!anno.$ignore) {
         // This environment is passed down the call hierarchy, for dealing with
         // indentation and name resolution issues
         const env = createEnv({ path: [ 'vocabularies', name ] });
@@ -303,6 +303,19 @@ function csnToCdl( csn, options ) {
    * @return {string}
    */
   function renderAnnotateStatement( ext, env ) {
+    // Special case: Super annotate has both "returns" and "elements".
+    // Render as separate `annotate`s, but keep the order.
+    if (ext.elements && ext.returns) {
+      const [ , second ] = Object.keys(ext).filter(key => key === 'elements' || key === 'returns');
+
+      // The first of 'elements' or 'returns' gets all other properties as well.
+      // The second only gets one property (itself).
+      let result = renderAnnotateStatement({ ...ext, [second]: undefined }, env);
+      result += renderAnnotateStatement({ annotate: ext.annotate, [second]: ext[second] }, env);
+
+      return result;
+    }
+
     // Top-level annotations of the artifact
     let result = renderAnnotationAssignmentsAndDocComment(ext, env);
     // Note: Not renderDefinitionReference, because we don't care if there
@@ -512,8 +525,15 @@ function csnToCdl( csn, options ) {
       result += renderParameters(art, env);
     if (art.includes)
       result += renderIncludes(art.includes, env);
-    result += ` ${renderElements(art, env)}`;
+
+    if (art.elements)
+      result += ` ${renderElements(art, env)}`;
+    else if (art.actions)
+      // if there are no elements, but actions, CDL syntax requires braces.
+      result += ' { }';
+
     result += `${renderActionsAndFunctions(art, env)};\n`;
+
     return result;
   }
 
@@ -565,7 +585,7 @@ function csnToCdl( csn, options ) {
    * Returns the resulting source string.
    *
    * @param {string} elementName
-   * @param {CSN.Element|CSN.Enum} element
+   * @param {CSN.Element} element
    * @param {CdlRenderEnvironment} env
    */
   function renderElement( elementName, element, env ) {
@@ -1037,7 +1057,7 @@ function csnToCdl( csn, options ) {
       result += `${env.indent}}`;
     }
 
-    if (isLeadingQuery)
+    if (isLeadingQuery && query.actions)
       result += renderActionsAndFunctions(query, env);
 
     if (select.where)
@@ -1148,14 +1168,14 @@ function csnToCdl( csn, options ) {
    */
   function renderActionsAndFunctions( art, env ) {
     let result = '';
-    const childEnv = env.withIncreasedIndent();
-    for (const name in art.actions)
-      result += renderActionOrFunction(name, art.actions[name], childEnv.withSubPath([ 'actions', name ]));
-
-    // Even if we have seen actions/functions, they might all have been ignored
-    if (result !== '')
-      result = ` actions {\n${result}${env.indent}}`;
-
+    if (art.actions) {
+      const childEnv = env.withIncreasedIndent();
+      for (const name in art.actions)
+        result += renderActionOrFunction(name, art.actions[name], childEnv.withSubPath([ 'actions', name ]));
+      result = (result === '')
+        ? ' actions { }'
+        : ` actions {\n${result}${env.indent}}`;
+    }
     return result;
   }
 
@@ -1229,14 +1249,31 @@ function csnToCdl( csn, options ) {
   function renderTypeOrAnnotation( artifactName, art, env, artType ) {
     let result = renderAnnotationAssignmentsAndDocComment(art, env);
     result += `${env.indent + (artType || art.$syntax || art.kind )} ${renderArtifactName(artifactName, env)}`;
-    if (art.includes)
+
+    const type = renderTypeReferenceAndProps(art, env);
+    const isDirectStruct = type?.startsWith('{');
+    if (art.includes?.length && isDirectStruct)
+      // We can only render includes, if the type is directly structured. Otherwise,  we would
+      // render e.g. `type T : Include : T2;`, which is invalid.  We use `extend` in such cases.
       result += renderIncludes(art.includes, env);
 
-    if (!art.type && art.elements) // For nicer output, no colon if unnamed structure is used.
-      result += ` ${renderTypeReferenceAndProps(art, env)}`;
-    else
-      result += ` : ${renderTypeReferenceAndProps(art, env)}`;
+    if (type) {
+      // For nicer output, no colon if unnamed structure is used.
+      result += (!art.type && art.elements) ? ` ${type}` : ` : ${type}`;
+    }
+    else {
+      msg.warning('syntax-missing-type', env.path, { name: artifactName },
+                  'Missing type for definition $(NAME); can\'t be represented in CDL');
+    }
+
     result += ';\n';
+
+    if (art.includes?.length && !isDirectStruct) {
+      // If we're not a directly structured type, render the `includes` as `extend`
+      // statements directly below the type definition.
+      result += renderExtendStatement(artifactName, { includes: art.includes }, env);
+    }
+
     return result;
   }
 
@@ -1247,8 +1284,9 @@ function csnToCdl( csn, options ) {
    *
    * @param {CSN.Artifact} artifact
    * @param {CdlRenderEnvironment} env
-   * @param {object} [config={}] - `typeRefOnly`   Whether to only render type defs, no arrayed/structured/enum.
-   *                             - `noAnnoCollect` Do not collect annotations of sub-elements.
+   * @param {object} [config={}]
+   * @param {boolean} [config.typeRefOnly] Whether to only render type defs, no arrayed/structured/enum.
+   * @param {boolean} [config.noAnnoCollect] Do not collect annotations of sub-elements.
    * @return {string}
    */
   function renderTypeReferenceAndProps( artifact, env, config = {} ) {
@@ -1310,8 +1348,9 @@ function csnToCdl( csn, options ) {
 
       if (artifact.notNull !== undefined && !artifact.on) // unmanaged associations can't be followed by "not null"
         result += renderNullability(artifact);
-      // DEFAULT not possible here.
 
+      if (artifact.default && !artifact.on)
+        result += ` default ${exprRenderer.renderExpr(artifact.default, env.withSubPath([ 'default' ]))}`;
       return result;
     }
 
@@ -1814,7 +1853,7 @@ function csnToCdl( csn, options ) {
     // Take the annotation assignment apart into <nameBeforeVariant>#<variantAndRest>
     const parts = name.split('#');
     const nameBeforeVariant = parts[0];
-    const variant = parts[1];
+    const variant = parts.length > 1 ? parts.slice(1).join('#') : undefined;
     const { parentheses } = config;
 
     let result = `${env.indent}@`;
@@ -1822,10 +1861,11 @@ function csnToCdl( csn, options ) {
       result += '(';
 
     result += quoteAnnotationPathIfRequired(nameBeforeVariant, env);
-    if (variant !== undefined)
+    if (variant !== undefined) {
       // Unfortunately, the compiler does not allow `.@` after the first variant identifier,
-      // so we're back at simple paths.
+      // nor multiple `#`, so we're back at simple paths that are possibly quoted.
       result += `#${quotePathIfRequired(variant, env)}`;
+    }
     result += ` : ${renderAnnotationValue(anno, env)}`;
 
     if (parentheses)

package/lib/render/toHdbcds.js

@@ -647,7 +647,7 @@ function toHdbcdsSource( csn, options ) {
     // Because we already emit an error that calc-on-write is not supported, just ignore nullability/default.
     if (!elm.value?.stored) {
       result += renderNullability(elm);
-      if (elm.default)
+      if (elm.default && !elm.target)
         result += ` default ${renderExpr(elm.default, env.withSubPath([ 'default' ]))}`;
     }
 
@@ -798,7 +798,7 @@ function toHdbcdsSource( csn, options ) {
 
       const key = (!env.skipKeys && (col.key || element?.key) ? 'key ' : '');
       result += key + renderExpr(withoutCast(col), env);
-      let alias = col.as || col.func;
+      let alias = col.as || (!col.args && col.func); // func: e.g. CURRENT_TIMESTAMP
       // HANA requires an alias for 'key' columns just for syntactical reasons
       // FIXME: This will not complain for non-refs (but that should be checked in forRelationalDB)
       // Explicit or implicit alias?

package/lib/render/toRename.js

@@ -5,15 +5,11 @@ const { makeMessageFunction } = require('../base/messages');
 const { checkCSNVersion } = require('../json/csnVersion');
 const { forEachDefinition } = require('../model/csnUtils');
 const { optionProcessor } = require('../optionProcessor');
-const { isBetaEnabled } = require('../base/model');
 const { transformForRelationalDBWithCsn } = require('../transform/forRelationalDB');
 const { getIdentifierUtils } = require('./utils/sql');
 
 
 /**
- * FIXME: Not yet supported, only in beta mode
- * FIXME: This is not up-to-date in regards to the changes to hdbcds/sql quoting etc.
- *
  * Generate SQL DDL rename statements for a migration, renaming existing tables and their
  * columns so that they match the result of "toHana" or "toSql" with the 'plain' option for names.
  * Expects the naming convention of the existing tables to be either 'quoted' or 'hdbcds' (default).
@@ -32,7 +28,7 @@ const { getIdentifierUtils } = require('./utils/sql');
  * @returns {object} A dictionary of name: rename statement
  */
 function toRename( inputCsn, options ) {
-  const { error, warning, throwWithError } = makeMessageFunction(inputCsn, options, 'to.rename');
+  const { warning, throwWithError } = makeMessageFunction(inputCsn, options, 'to.rename');
 
   // Merge options with defaults.
   options = Object.assign({ sqlMapping: 'hdbcds', sqlDialect: 'hana' }, options);
@@ -41,9 +37,8 @@ function toRename( inputCsn, options ) {
   optionProcessor.verifyOptions(options, 'toRename').forEach(complaint => warning(null, null, `${complaint}`));
   checkCSNVersion(inputCsn, options);
 
-  // Requires beta mode
-  if (!isBetaEnabled(options, 'toRename'))
-    error(null, null, 'Generation of SQL rename statements is not supported yet (only in beta mode)');
+  // 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');
@@ -102,7 +97,7 @@ function toRename( inputCsn, options ) {
         const beforeColumnName = hdbcdsOrQuotedIdentifiers.quoteSqlId(name);
         const afterColumnName = plainIdentifiers.quoteSqlId(name);
 
-        if (!e._ignore) {
+        if (!e.$ignore) {
           if (e.target)
             str = `  EXEC 'ALTER TABLE ${afterTableName} DROP ASSOCIATION ${beforeColumnName}';\n`;
           else if (beforeColumnName.toUpperCase() === `"${afterColumnName}"` ) // Basically a no-op - render commented out

package/lib/render/toSql.js

@@ -24,7 +24,8 @@ const { timetrace } = require('../utils/timetrace');
 const { isBetaEnabled, isDeprecatedEnabled } = require('../base/model');
 const { smartFuncId } = require('../sql-identifier');
 const { sortCsn } = require('../json/to-csn');
-const { manageConstraints } = require('./manageConstraints');
+const { manageConstraints, manageConstraint } = require('./manageConstraints');
+const { renderUniqueConstraintString, renderUniqueConstraintDrop, renderUniqueConstraintAdd } = require('./utils/unique');
 const { ModelError, CompilerAssertion } = require('../base/error');
 
 class SqlRenderEnvironment {
@@ -105,6 +106,7 @@ function toSqlDdl( csn, options ) {
     error, warning, info, throwWithAnyError,
   } = makeMessageFunction(csn, options, 'to.sql');
   const { quoteSqlId, prepareIdentifier, renderArtifactName } = getIdentifierUtils(csn, options);
+  let reportedMissingUserReplacement = false;
 
   const exprRenderer = createExpressionRenderer({
     // FIXME: For the sake of simplicity, we should get away from all this uppercasing in toSql
@@ -175,6 +177,7 @@ function toSqlDdl( csn, options ) {
     hdbview: Object.create(null),
     hdbconstraint: Object.create(null),
     deletions: Object.create(null),
+    constraintDeletions: [],
     migrations: Object.create(null),
   };
 
@@ -240,8 +243,10 @@ function toSqlDdl( csn, options ) {
   const sqlVersionLine = `-- ${generatedByCompilerVersion()}\n`;
 
   // Handle hdbKinds separately from alterTable case
-  // eslint-disable-next-line no-unused-vars
-  const { deletions, migrations: _, ...hdbKinds } = mainResultObj;
+  const {
+    // eslint-disable-next-line no-unused-vars
+    deletions, constraintDeletions, migrations: _, ...hdbKinds
+  } = mainResultObj;
   for (const hdbKind of Object.keys(hdbKinds)) {
     for (const name in mainResultObj[hdbKind]) {
       if (options.src === 'sql') {
@@ -260,14 +265,15 @@ function toSqlDdl( csn, options ) {
   }
 
   // add `ALTER TABLE ADD CONSTRAINT` statements per default for `to.sql` w/ dialect `hana` / `postgres`
-  // TODO `ALTER TABLE ADD CONSTRAINT` statements also for sqlite constraints
   if (!options.constraintsInCreateTable && options.src === 'sql' && (options.sqlDialect === 'hana' || options.sqlDialect === 'postgres' /* || options.sqlDialect === 'sqlite' */)) {
+    const constraints = Object.create(null);
     const alterStmts = manageConstraints(csn, options);
 
     forEachKey(alterStmts, (constraintName) => {
-      sql[constraintName] = `${options.testMode ? '' : sqlVersionLine}${alterStmts[constraintName]}`;
+      if (!csn.unchangedConstraints?.has(constraintName))
+        constraints[constraintName] = `${options.testMode ? '' : sqlVersionLine}${alterStmts[constraintName]}`;
     });
-    mainResultObj.sql = sql;
+    mainResultObj.constraints = constraints;
   }
 
   if (options.src === 'sql')
@@ -333,8 +339,12 @@ function toSqlDdl( csn, options ) {
   function renderArtifactExtensionInto( artifactName, artifact, ext, resultObj, env ) {
     // Property kind is always omitted for elements and can be omitted for
     // top-level type definitions, it does not exist for extensions.
-    if (artifactName && !ext.query)
-      renderExtendInto(artifactName, artifact.elements, ext.elements, resultObj, env, extensionsDuplicateChecker);
+    if (artifactName && !ext.query) {
+      if (ext.constraint)
+        renderConstraintExtendInto(artifactName, ext, resultObj);
+      else
+        renderExtendInto(artifactName, artifact.elements, ext.elements, resultObj, env, extensionsDuplicateChecker);
+    }
 
     if (!artifactName)
       throw new ModelError(`Undefined artifact name: ${artifactName}`);
@@ -421,6 +431,24 @@ function toSqlDdl( csn, options ) {
       }
     }
 
+    if (migration.removeConstraints) {
+      const constraintTypes = [ 'unique', 'referential' ];
+      constraintTypes.forEach((constraintType) => {
+        if (migration.removeConstraints[constraintType]) {
+          const entries = Object.entries(migration.removeConstraints[constraintType]);
+          const optionsWithDrop = { ...options, drop: true };
+          let renderer;
+          if (constraintType === 'referential')
+            renderer = constraint => manageConstraint(constraint, csn, optionsWithDrop, '', quoteSqlId);
+          else
+            renderer = (constraint, constraintName) => renderUniqueConstraintDrop(constraint, renderArtifactName(`${artifactName}_${constraintName}`), tableName, quoteSqlId);
+          entries.forEach(( [ constraintName, constraint ]) => {
+            addConstraintDeletion(resultObj, constraint.parentTable, renderer(constraint, constraintName));
+          });
+        }
+      });
+    }
+
     // Change column types (unsupported in sqlite)
     if (migration.change) {
       changeElementsDuplicateChecker.addArtifact(tableName, undefined, artifactName);
@@ -431,7 +459,7 @@ function toSqlDdl( csn, options ) {
         const eltStrOld = getEltStr(def.old, eltName, 'migration');
         const eltStrNew = getEltStr(def.new, eltName, 'migration');
         if (eltStrNew === eltStrOld)
-          return; // Prevent spurious migrations, where the column DDL does not change.
+          continue; // Prevent spurious migrations, where the column DDL does not change.
 
         const annosIncompat = [];
         sqlSnippetAnnos
@@ -550,16 +578,11 @@ function toSqlDdl( csn, options ) {
     // OR create a unique index for HDI
     const uniqueConstraints = art.$tableConstraints && art.$tableConstraints.unique;
     for (const cn in uniqueConstraints) {
-      const c = uniqueConstraints[cn];
-      const cnName = renderArtifactName(`${artifactName}_${cn}`);
-      const refs = c.map(cpath => quoteSqlId(cpath.ref[0])).join(', ');
-      if (options.src === 'hdi') {
-        resultObj.hdbindex[`${artifactName}.${cn}`]
-          = `UNIQUE INVERTED INDEX ${cnName} ON ${tableName} (${refs})`;
-      }
-      else {
-        result += `,\n${childEnv.indent}CONSTRAINT ${cnName} UNIQUE (${refs})`;
-      }
+      const constraint = renderUniqueConstraintString(uniqueConstraints[cn], renderArtifactName(`${artifactName}_${cn}`), tableName, quoteSqlId, options);
+      if (options.src === 'hdi')
+        resultObj.hdbindex[`${artifactName}.${cn}`] = constraint;
+      else
+        result += `,\n${childEnv.indent}${constraint}`;
     }
     result += `${env.indent}\n)`;
 
@@ -591,6 +614,21 @@ function toSqlDdl( csn, options ) {
     resultObj.hdbtable[artifactName] = result;
   }
 
+  /**
+   * Render an extended entity constraint into the appropriate dictionaries of 'resultObj'.
+   * Only SAP HANA SQL is currently supported.
+   *
+   * @param {string} artifactName Name of the artifact to render
+   * @param {object} ext Constraint comprising the extension
+   * @param {object} resultObj Result collector
+   */
+  function renderConstraintExtendInto( artifactName, { constraint, constraintName, constraintType }, resultObj ) {
+    const result = constraintType === 'unique' ? renderUniqueConstraintAdd(constraint, renderArtifactName(`${artifactName}_${constraintName}`), renderArtifactName(constraint.parentTable), quoteSqlId, options)
+      : manageConstraint(constraint, csn, options, '', quoteSqlId);
+
+    addMigration(resultObj, artifactName, false, [ result ]);
+  }
+
 
   /**
    * Render an extended entity into the appropriate dictionaries of 'resultObj'.
@@ -632,6 +670,9 @@ function toSqlDdl( csn, options ) {
     resultObj.migrations[artifactName].push(...migrations);
   }
 
+  function addConstraintDeletion( resultObj, artifactName, deletionSql ) {
+    resultObj.constraintDeletions.push(deletionSql);
+  }
   function addDeletion( resultObj, artifactName, deletionSql ) {
     resultObj.deletions[artifactName] = deletionSql;
   }
@@ -1064,7 +1105,7 @@ function toSqlDdl( csn, options ) {
       result = env.indent + renderExpr(withoutCast(col), env);
       if (col.as)
         result += ` AS ${quoteSqlId(col.as)}`;
-      else if (col.func)
+      else if (col.func && !col.args) // e.g. CURRENT_TIMESTAMP
         result += ` AS ${quoteSqlId(col.func)}`;
     }
     return result;
@@ -1338,15 +1379,11 @@ function toSqlDdl( csn, options ) {
    * @returns {string} Rendered type
    */
   function renderBuiltinType( typeName ) {
-    const forHanaRenamesToEarly = {
-      'cds.UTCDateTime': 'cds.DateTime',
-      'cds.UTCTimestamp': 'cds.Timestamp',
-      'cds.LocalDate': 'cds.Date',
-      'cds.LocalTime': 'cds.Time',
-    };
-    const tName = forHanaRenamesToEarly[typeName] || typeName;
     const types = cdsToSqlTypes[options.sqlDialect];
-    return types && types[tName] || cdsToSqlTypes.standard[tName] || 'CHAR';
+    const result = types && types[typeName] || cdsToSqlTypes.standard[typeName];
+    if (!result && options.testMode)
+      throw new CompilerAssertion(`Expected to find a type mapping for ${typeName}`);
+    return result || 'CHAR';
   }
 
   /**
@@ -1466,9 +1503,8 @@ function toSqlDdl( csn, options ) {
           case 'hana':
             return 'CURRENT_TIMESTAMP';
           case 'h2':
-            return 'current_timestamp';
           case 'postgres':
-            return '(current_timestamp at time zone \'UTC\')';
+            return 'current_timestamp';
           default:
             return quoteSqlId(x.ref[0]);
         }
@@ -1498,19 +1534,28 @@ function toSqlDdl( csn, options ) {
       if (options.sqlDialect === 'hana')
         return 'SESSION_CONTEXT(\'APPLICATIONUSER\')';
       else if (options.sqlDialect === 'postgres')
-        return 'current_setting(\'CAP.APPLICATIONUSER\')';
+        return 'current_setting(\'cap.applicationuser\')';
       else if (options.betterSqliteSessionVariables && options.sqlDialect === 'sqlite')
         return 'session_context( \'$user.id\' )';
-      warning(null, null, 'The "$user" variable is not supported. Use option "variableReplacements" to specify a value for "$user.id"');
+      else if (options.sqlDialect === 'h2')
+        return '@applicationuser';
+
+      if (!reportedMissingUserReplacement) {
+        warning(null, null, 'The "$user" variable is not supported. Use option "variableReplacements" to specify a value for "$user.id"');
+        reportedMissingUserReplacement = true;
+      }
       return '\'$user.id\'';
     }
     else if (x.ref[1] === 'locale') {
       if (options.sqlDialect === 'hana')
         return 'SESSION_CONTEXT(\'LOCALE\')';
       else if (options.sqlDialect === 'postgres')
-        return 'current_setting(\'CAP.LOCALE\')';
+        return 'current_setting(\'cap.locale\')';
       else if (options.betterSqliteSessionVariables && options.sqlDialect === 'sqlite')
         return 'session_context( \'$user.locale\' )';
+      else if (options.sqlDialect === 'h2')
+        return '@locale';
+
       return '\'en\''; // default language
     }
     // Basically: Second path step was invalid, do nothing - should not happen.
@@ -1542,8 +1587,9 @@ function toSqlDdl( csn, options ) {
         case 'hana':
           return 'TO_TIMESTAMP(SESSION_CONTEXT(\'VALID-FROM\'))';
         case 'postgres':
-          return '(to_timestamp(current_setting(\'CAP.VALID_FROM\'), \'YYYY-MM-DD HH24:MI:SS.FF6\') at time zone \'UTC\')';
+          return 'current_setting(\'cap.valid_from\')::timestamp';
         case 'h2':
+          return '@valid_from';
         case 'plain':
           return 'current_timestamp';
         default:
@@ -1563,8 +1609,9 @@ function toSqlDdl( csn, options ) {
         case 'hana':
           return 'TO_TIMESTAMP(SESSION_CONTEXT(\'VALID-TO\'))';
         case 'postgres':
-          return '(to_timestamp(current_setting(\'CAP.VALID_TO\'), \'YYYY-MM-DD HH24:MI:SS.FF6\') at time zone \'UTC\')';
+          return 'current_setting(\'cap.valid_to\')::timestamp';
         case 'h2':
+          return '@valid_to';
         case 'plain':
           return 'current_timestamp';
         default:

package/lib/render/utils/common.js

@@ -146,7 +146,7 @@ function addContextMarkers( csn, killList ) {
   const contextsToCreate = Object.create(null);
   forEachDefinition(csn, (art, artifactName) => {
     const namespace = getNamespace(csn, artifactName);
-    if (namespace && !(art._ignore || hasValidSkipOrExists(art))) {
+    if (namespace && !(art.$ignore || hasValidSkipOrExists(art))) {
       const parts = namespace.split('.');
       contextsToCreate[parts[0]] = true;
 
@@ -204,7 +204,7 @@ function addMissingChildContexts( csn, artifactName, killList ) {
   const possibleNames = Object.keys(csn.definitions).filter(name => name.startsWith(`${artifactName}.`)).sort((a, b) => a.length - b.length);
   for (const name of possibleNames) {
     const artifact = csn.definitions[name];
-    if (!artifact._ignore && !hasValidSkipOrExists(artifact))
+    if (!artifact.$ignore && !hasValidSkipOrExists(artifact))
       addPossibleGaps(name.slice(artifactName.length + 1).split('.'), artifactName);
   }
 
@@ -258,16 +258,14 @@ const cdsToSqlTypes = {
     'cds.DateTime': 'TIMESTAMP', // cds-compiler#2758
     'cds.Timestamp': 'TIMESTAMP',
     'cds.Boolean': 'BOOLEAN',
-    'cds.UUID': 'NVARCHAR',  // changed to cds.String earlier
     // (TODO: do it later; TODO: why not CHAR or at least VARCHAR?)
+    '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
   },
   hana: {
     'cds.hana.SMALLDECIMAL': 'SMALLDECIMAL',
-    'cds.LocalDate': 'DATE',
-    'cds.LocalTime': 'TIME',
     'cds.DateTime': 'SECONDDATE',
-    'cds.UTCDateTime': 'SECONDDATE',
-    'cds.UTCTimestamp': 'TIMESTAMP',
     'cds.hana.ST_POINT': 'ST_POINT',
     'cds.hana.ST_GEOMETRY': 'ST_GEOMETRY',
   },
@@ -275,7 +273,7 @@ const cdsToSqlTypes = {
     'cds.Date': 'DATE_TEXT',
     'cds.Time': 'TIME_TEXT',
     'cds.Timestamp': 'TIMESTAMP_TEXT',
-    'cds.DateTime': 'TIMESTAMP_TEXT',
+    'cds.DateTime': 'DATETIME_TEXT',
     'cds.Binary': 'BINARY_BLOB',
     'cds.hana.BINARY': 'BINARY_BLOB',
     'cds.hana.SMALLDECIMAL': 'SMALLDECIMAL',
@@ -310,6 +308,10 @@ const cdsToHdbcdsTypes = {
   'cds.Int16': 'cds.hana.SMALLINT',
   'cds.Int32': 'cds.Integer',
   'cds.Int64': 'cds.Integer64',
+  'cds.Timestamp': 'cds.UTCTimestamp',
+  'cds.DateTime': 'cds.UTCDateTime',
+  'cds.Date': 'cds.LocalDate',
+  'cds.Time': 'cds.LocalTime',
 };
 
 /**
@@ -360,7 +362,7 @@ function findElement( elements, column ) {
 function addIntermediateContexts( csn, killList ) {
   for (const artifactName in csn.definitions) {
     const artifact = csn.definitions[artifactName];
-    if ((artifact.kind === 'context') && !artifact._ignore) {
+    if ((artifact.kind === 'context') && !artifact.$ignore) {
       // If context A.B.C and entity A exist, we still need generate context A_B.
       // But if no entity A exists, A.B is just a namespace.
       // For case 1 and 2, getParentContextName returns undefined - we then use the namespace as our "off-limits"

package/lib/render/utils/unique.js

@@ -0,0 +1,52 @@
+'use strict';
+
+/**
+ * Render the "CONSTRAINT <XY>;" for HDI or SQL.
+ *
+ * @param {object} constraint The constraint to add
+ * @param {string} constraintName Name of the constraint - needs to be escaped on caller side
+ * @param {string} tableName Name of the table with the constraint - needs to be escaped on caller side
+ * @param {function} quoteSqlId Usual rendering function
+ * @param {object} options Options
+ * @returns {string}
+ */
+function renderUniqueConstraintString( constraint, constraintName, tableName, quoteSqlId, options ) {
+  const c = constraint.paths;
+  const refs = c.map(cpath => quoteSqlId(cpath.ref[0])).join(', ');
+  if (options.src === 'hdi')
+    return `UNIQUE INVERTED INDEX ${constraintName} ON ${tableName} (${refs})`;
+
+  return `CONSTRAINT ${constraintName} UNIQUE (${refs})`;
+}
+/**
+ * Render the "ALTER TABLE XY DROP CONSTRAINT <Z>;"
+ *
+ * @param {object} constraint The constraint to drop
+ * @param {string} constraintName Name of the constraint - needs to be escaped on caller side
+ * @param {string} tableName Name of the table with the constraint - needs to be escaped on caller side
+ * @param {function} quoteSqlId Usual rendering function
+ * @returns {string}
+ */
+function renderUniqueConstraintDrop( constraint, constraintName, tableName, quoteSqlId ) {
+  return `ALTER TABLE ${tableName} DROP CONSTRAINT ${quoteSqlId(constraintName)};`;
+}
+
+/**
+ * Render the "ALTER TABLE XY ADD CONSTRAINT <Z>;"
+ *
+ * @param {object} constraint The constraint to add
+ * @param {string} constraintName Name of the constraint - needs to be escaped on caller side
+ * @param {string} tableName Name of the table with the constraint - needs to be escaped on caller side
+ * @param {function} quoteSqlId Usual rendering function
+ * @param {object} options Options
+ * @returns {string}
+ */
+function renderUniqueConstraintAdd( constraint, constraintName, tableName, quoteSqlId, options ) {
+  return `ALTER TABLE ${tableName} ADD ${renderUniqueConstraintString(constraint, constraintName, tableName, quoteSqlId, options)};`;
+}
+
+module.exports = {
+  renderUniqueConstraintString,
+  renderUniqueConstraintDrop,
+  renderUniqueConstraintAdd,
+};