@sap/cds-compiler 4.1.2 → 4.2.4

package/lib/json/from-csn.js

@@ -72,8 +72,9 @@
  *     What "kind" values are possible in a definition. The root "definitions" properties allows
  *     more kinds than e.g. definitions inside "elements".
  *
- * @property {string|string[]}  [onlyWith]
- *     Defines that the property *must* be used with these properties.
+ * @property {string|string[]|Object}  [onlyWith]
+ *     Defines that the property *must* be used with one of these properties.
+ *     If an object, it maps the kind value to a string or array of strings.
  *
  * @property {number}           [minLength]
  *     Minimum number of elements that an array must have.
@@ -255,12 +256,14 @@ const schema = compileSchema( {
     requires: [ 'extend', 'annotate' ],
   },
   enum: {
+    type: enumDict,
     dictionaryOf: definition,
     defaultKind: 'enum',
     validKinds: [ 'enum' ],
     inKind: [ 'element', 'type', 'param', 'annotation', 'annotate', 'extend' ],
   },
   elements: {
+    type: elementsDict,
     dictionaryOf: definition,
     defaultKind: 'element',
     validKinds: [ 'element' ],
@@ -280,6 +283,7 @@ const schema = compileSchema( {
     dictionaryOf: actions,
     defaultKind: 'action',
     validKinds: [ 'action', 'function' ],
+    onlyWith: { aspect: 'elements' },
     inKind: [ 'entity', 'aspect', 'annotate', 'extend' ],
   },
   params: {
@@ -656,7 +660,7 @@ const schema = compileSchema( {
       '-expr': { // '-expr' and '-' must not exist top-level
         prop: '@‹anno›',
         type: object,
-        optional: [ '=', '#', 'xpr', 'ref', 'val', 'list', 'literal', 'func', 'args' ],
+        optional: [ '=', '#', 'xpr', 'ref', 'val', 'list', 'literal', 'func', 'args', 'param' ],
         schema: {
           '=': {
             type: renameTo( '$tokenTexts', string ),
@@ -1038,7 +1042,7 @@ function definition( def, spec, xsn, csn, name ) {
       // for an 'annotate', both 'annotate' and the "host" kind must be expected
       (!inExtensions || s.inKind.includes( inExtensions ) ||
        // extending elements in returns can be without 'returns' in CSN
-       // TODO: with warning/info?
+       // see function elementsDict() for detail, TODO: remove finally
        inExtensions === 'action' && p === 'elements');
   }
 }
@@ -1121,6 +1125,27 @@ function returnsDefinition( def, spec, xsn, csn ) {
   return definition( def, spec, xsn, csn, '' );
 }
 
+// Temporary function as long as the message below is not a hard error
+function elementsDict( def, spec, xsn ) {
+  const elements = dictionaryOf( definition )( def, spec );
+  if (inExtensions !== 'action')
+    return elements;
+  warning( 'syntax-expecting-returns', elements[$location],
+           { prop: 'elements', parentprop: 'returns' },
+           // eslint-disable-next-line max-len
+           'Expecting property $(PROP) to be put into an object for property $(PARENTPROP) when annotating action return structures' );
+  xsn.returns = { kind: 'annotate', elements, location: elements[$location] };
+  return undefined;
+}
+
+function enumDict( def, spec, xsn ) {
+  const dict = dictionaryOf( definition )( def, spec );
+  if (!inExtensions)
+    return dict;
+  xsn.elements = dict;          // normalize to `elements` for `annotate`
+  return undefined;
+}
+
 // For v1 CSNs with annotation definitions
 function attachVocabInDefinitions( csn ) {
   if (!csn.vocabularies) {
@@ -1827,6 +1852,11 @@ function calculateKind( def, spec ) {
 function onlyWith( spec, need, csn, prop, xor, expected ) {
   if (!need)
     return spec;
+  if (typeof need === 'object' && !Array.isArray( need )) {
+    need = need[csn.kind];
+    if (!need)
+      return spec;
+  }
   if (typeof need === 'string') {
     if (need in csn)            // TODO: enumerable ?
       return spec;

package/lib/json/to-csn.js

@@ -115,7 +115,6 @@ const transformers = {
   offset: expression,
   on: onCondition,
   // definitions, extensions, members ----------------------------------------
-  returns,                      // storing the return type of actions
   notNull: value,
   default: expression,
   // targetElement: ignore,     // special display of foreign key, renameTo: select
@@ -123,6 +122,7 @@ const transformers = {
   query,
   elements,
   actions,                      // TODO: just normal dictionary
+  returns,                      // storing the return type of actions
   // special: top-level, cardinality -----------------------------------------
   sources,
   definitions: sortedDict,
@@ -465,13 +465,13 @@ function attachAnnotations( annotate, prop, dict, inferred, insideReturns = fals
         attachAnnotations( sub, 'actions', entry.actions, inf );
       else if (entry.params)
         attachAnnotations( sub, 'params', entry.params, inf );
-      const obj = entry.returns || entry; // TODO: create returns !
+      const obj = entry.returns || entry;
       const many = obj.items || obj;
       const elems = (many.targetAspect || many).elements;
       if (elems)
         attachAnnotations( sub, 'elements', elems, inf, entry.returns );
-      if (many.enum)
-        attachAnnotations( sub, 'enum', many.enum, inf );
+      else if (many.enum)       // make 'enum' annotations appear in 'elements' annotate
+        attachAnnotations( sub, 'elements', many.enum, inf, entry.returns );
     }
     if (Object.keys( sub ).length)
       annoDict[name] = sub;

package/lib/language/language.g4

@@ -2010,11 +2010,8 @@ orderByClause[ inQuery ] returns [ query ]
 limitClause[ inQuery ] returns [ query ]
   :
     limkw=LIMIT { $query = this.unaryOpForParens( $inQuery, '$'+'query' ); }
-    ( lim=Number   { $query.limit = { rows: this.numberLiteral( $lim, '' ) }; }
-    | limnull=NULL { $query.limit = { rows: {
-        literal: 'null', val: null, location: this.tokenLocation($limnull) } }; }
-    )
-    ( OFFSET off=Number { $query.limit.offset = this.numberLiteral( $off ); } )? // unsigned integer
+    lim=expression  { $query.limit = { rows: $lim.expr }; }
+    ( OFFSET off=expression { $query.limit.offset = $off.expr; } )? // unsigned integer
   ;
 
 orderBySpec returns[ ob ]

package/lib/main.d.ts

@@ -70,6 +70,18 @@ declare namespace compiler {
      *  - universal : In development (BETA)
      */
     csnFlavor?: string | 'client' | 'gensrc' | 'universal'
+    /**
+     * If set, backends will not create localized convenience views for those views,
+     * that only have an association to a localized entity/view.  Views will only get
+     * a convenience view, if they themselves contain localized elements (i.e. either
+     * have simple projection on localized elements and CDL-casts to a localized element).
+     *
+     * The OData backend will not set `$localized: true` markers for such cases.
+     *
+     * Does not work for backends to.hdi(), to.hdbcds() or to.sql() with `sqlDialect: 'hana'`,
+     * since in all those dialects, associations still exist in generated artifacts.
+     */
+    fewerLocalizedViews?: boolean
   }
 
   /**
@@ -86,6 +98,30 @@ declare namespace compiler {
      * the prefix for SAP CDS packages / CDS files.
      */
     cdsHome?: string
+    /**
+     * "Doc comments" (documentation comments) are those comments starting with `/**` in CDL
+     * or the `doc` property in CSN.  This option is an _output_ option, which can have three
+     * values:
+     *
+     *  - `true`:
+     *     Doc comments will appear in the compiled CSN.  Basic sanity checks are performed:
+     *     In CDL, if a doc comment appears at a not-defined position, where it has no impact,
+     *     an info message is emitted.  For CSN input, it is checked that the `doc` property
+     *     is a string or `null`.
+     *
+     *  - `false`:
+     *    Doc comments will not be parsed for CDL, and will be stripped from input CSN,
+     *    i.e. the compiled CSN (output) does not contain `doc` properties.  No checks
+     *    are performed on doc comments.
+     *
+     *  - `undefined`:
+     *    Doc comments are checked (see value `true`). For CDL, doc comments are not parsed,
+     *    i.e. will not appear in the compiled CSN (output).
+     *    For CSN input, all `doc` properties remain in the CSN.
+     *
+     * The CDL equivalent of the CSN value `doc: null`, is an empty doc comment.
+     */
+    docComment?: boolean
     /**
      * When set to `true`, and the model contains an entity `sap.common.Languages`
      * with an element `code`, all generated texts entities additionally contain
@@ -95,6 +131,17 @@ declare namespace compiler {
      * @since v2.8.0
      */
     addTextsLanguageAssoc?: boolean
+    /**
+     * An array of directory names that are used for CDS module lookups.
+     * Lookup directory `node_modules/` is appended if not set explicitly.
+     *
+     * All directories in this array follow the same lookup-pattern as `node_modules/`.
+     *
+     * See <https://cap.cloud.sap/docs/cds/cdl#model-resolution>
+     *
+     * @since v4.2.0
+     */
+    moduleLookupDirectories?: string[]
     /**
      * Option for {@link compileSources}.  If set, all objects inside the
      * provided sources dictionary are interpreted as XSN structures instead
@@ -468,9 +515,10 @@ declare namespace compiler {
       constructor(messages: CompileMessage[], model?: any, text?: string, ...args: any[]);
       /**
        * String to identify this class. Can be used instead of relying on `instanceof`.
+       * Always `ERR_CDS_COMPILATION_FAILURE`.
        * @since v4.0.0
        */
-      code = 'ERR_CDS_COMPILATION_FAILURE';
+      code: string;
       messages: CompileMessage[];
       toString(): string;
       /**
@@ -803,6 +851,9 @@ declare namespace compiler {
        * identifier in brackets.
        * Otherwise, return the name without brackets.
        *
+       * NOTE: If `name` contains newline characters, the resulting delimited identifier
+       *       will not be parsable by the compiler!
+       *
        * Example:
        *    ```js
        *    to.cdl.smartId('with ![brackets]')
@@ -817,6 +868,9 @@ declare namespace compiler {
        *
        * @param name
        * @param [insideFunction=null]
+       *     Inside special functions such as SAP HANA's `OCCURRENCES_REGEXPR`, there are more
+       *     keywords than in other places.  Set this value to a function name, if you want to
+       *     handle those additional keywords as well.
        */
       function smartId(name: string, insideFunction?: string|null) : string;
       /**
@@ -824,6 +878,9 @@ declare namespace compiler {
        * function identifier in brackets for CDL.
        * Otherwise, return the function name without brackets.
        *
+       * NOTE: If `name` contains newline characters, the resulting delimited identifier
+       *       will not be parsable by the compiler!
+       *
        * Example:
        *    ```js
        *    to.cdl.smartFunctionId('with ![brackets]')
@@ -839,6 +896,9 @@ declare namespace compiler {
        * Escapes the given name according to the CDL language and puts it
        * into `![` and `]`, properly escaping all `]` in the identifier.
        *
+       * NOTE: If `name` contains newline characters, the resulting delimited identifier
+       *       will not be parsable by the compiler!
+       *
        * Example:
        *    ```js
        *    to.cdl.delimitedId('with ![brackets]')

package/lib/model/csnUtils.js

@@ -1081,6 +1081,9 @@ function getLastPartOfRef( ref ) {
  *
  * Overwrite existing ones only if 'overwrite' is true.
  *
+ * IMPORTANT: Consider using copyAnnotationsAndDoc() instead!
+ *            Don't forget about doc comments!
+ *
  * @param {object} fromNode
  * @param {object} toNode
  * @param {boolean} [overwrite]
@@ -1124,6 +1127,32 @@ function copyAnnotationsAndDoc( fromNode, toNode, overwrite = false ) {
   }
 }
 
+/**
+ * Same as `copyAnnotationsAndDoc()` but deletes the annotations on source
+ * side after copying them.  Useful when applying annotations from `cds.extensions`.
+ *
+ * Overwrite existing ones only if 'overwrite' is true.
+ *
+ * @param {object} sourceNode
+ * @param {object} targetNode
+ * @param {boolean} [overwrite]
+ */
+function moveAnnotationsAndDoc( sourceNode, targetNode, overwrite = false ) {
+  // Ignore if no targetNode (in case of errors)
+  if (!targetNode)
+    return;
+
+  const annotations = Object.keys(sourceNode)
+    .filter(key => key.startsWith('@') || key === 'doc');
+
+  for (const anno of annotations) {
+    if (targetNode[anno] === undefined || overwrite) {
+      targetNode[anno] = sourceNode[anno];
+      delete sourceNode[anno];
+    }
+  }
+}
+
 /**
  * Applies annotations from `csn.extensions` to definitions and their elements.
  *
@@ -1151,7 +1180,7 @@ function applyAnnotationsFromExtensions( csn, config ) {
     if (name && filter(name)) {
       const def = csn.definitions[name];
       if (def) {
-        copyAnnotationsAndDoc(ext, def, config.override);
+        moveAnnotationsAndDoc(ext, def, config.override);
         applyAnnotationsToElements(ext, def);
       }
       else if (config.notFound) {
@@ -1173,7 +1202,7 @@ function applyAnnotationsFromExtensions( csn, config ) {
     forEach(ext.elements, (key, sourceElem) => {
       const targetElem = def.elements[key];
       if (targetElem) {
-        copyAnnotationsAndDoc(sourceElem, targetElem, config.override);
+        moveAnnotationsAndDoc(sourceElem, targetElem, config.override);
         applyAnnotationsToElements(sourceElem, targetElem);
       }
     });

package/lib/model/revealInternalProperties.js

@@ -17,7 +17,7 @@ const { CompilerAssertion } = require('../base/error');
 const $inferred = Symbol.for('cds.$inferred');
 const $location = Symbol.for('cds.$location');
 
-class NOT_A_DICTIONARY {}       // used for consol.log display
+class NOT_A_DICTIONARY {}       // used for console.log display
 
 function locationString( loc ) {
   if (Array.isArray(loc))

package/lib/modelCompare/compare.js

@@ -249,7 +249,42 @@ function getElementComparator(otherArtifact, addedElementsDict = null, changedEl
 }
 
 function relevantTypeChange(type, otherType) {
-  return otherType !== type && ![type, otherType].every(t => ['cds.Association', 'cds.Composition'].includes(t));
+  return otherType !== type && !isSuperflousHanaTypeChange(otherType, type) && ![type, otherType].every(t => ['cds.Association', 'cds.Composition'].includes(t));
+}
+
+const superflousTypeChanges = {
+  // turn it into a real dict
+  __proto__: null,
+  // We used to put these types into the CSN, although they are just internal
+  // so we need to be robust against them now.
+  'cds.UTCDateTime': 'cds.DateTime',
+  'cds.UTCTimestamp': 'cds.Timestamp',
+  'cds.LocalDate': 'cds.Date',
+  'cds.LocalTime': 'cds.Time' ,
+};
+
+/**
+ * We removed some old SAP HANA types from the CSN and we now need to not
+ * detect them as changes.
+ *
+ * @param {string} before Type before
+ * @param {string} after Type after
+ * @returns {boolean}
+ */
+function isSuperflousHanaTypeChange( before, after ) {
+  return superflousTypeChanges[before] ? superflousTypeChanges[before] === after : false;
+}
+
+/**
+ * If the element has one of the superflous types, do the change so we don't accidentally
+ * pass such an old type into the SQL renderer.
+ * @param {CSN.Element} element 
+ * @returns {CSN.Element}
+ */
+function remapType( element ) {
+  if(element?.type && superflousTypeChanges[element.type])
+    element.type = superflousTypeChanges[element.type];
+  return element;
 }
 
 /**
@@ -310,7 +345,7 @@ function addedConstraint(entity, constraint, constraintName, constraintType) {
 
 function changedElement(element, otherElement) {
   return {
-    old: otherElement,
+    old: remapType(otherElement),
     new: element
   };
 }

package/lib/modelCompare/utils/filter.js

@@ -159,7 +159,7 @@ function filterCsn( csn ) {
     },
   }, [ (artifact) => {
     forEachKey(artifact, (key) => {
-      if (key.startsWith('@') && !annosToKeep[key])
+      if (key.startsWith('@') && !key.startsWith('@cds.persistence.') && !annosToKeep[key])
         delete artifact[key];
     });
   } ]);

package/lib/optionProcessor.js

@@ -21,7 +21,7 @@ optionProcessor
   .option('    --color <mode>', ['auto', 'always', 'never'])
   .option('-o, --out <dir>')
   .option('    --cds-home <dir>')
-  .option('    --fuzzy-csn-error')
+  .option('    --module-lookup-directories <list>')
   .option('    --trace-fs')
   .option('    --error <id-list>')
   .option('    --warn <id-list>')
@@ -78,7 +78,8 @@ optionProcessor
                               never:
    -o, --out <dir>          Place generated files in directory <dir>, default is "-" for <stdout>
        --cds-home <dir>     When set, modules starting with '@sap/cds/' are searched in <dir>
-       --fuzzy-csn-error    Report free-style CSN properties as errors
+       --module-lookup-directories <list>  Comma separated list of directories to look
+                            for CDS modules. Default is 'node_modules/'.
        --                   Indicate the end of options (helpful if source names start with "-")
 
   Type options
@@ -228,6 +229,7 @@ optionProcessor.command('O, toOdata')
   .option('-f, --odata-format <format>', ['flat', 'structured'])
   .option('-n, --sql-mapping <style>', ['plain', 'quoted', 'hdbcds'], { aliases: [ '--names' ] })
   .option('-s, --service-names <list>')
+  .option('    --fewer-localized-views')
   .help(`
   Usage: cdsc toOdata [options] <files...>
 
@@ -264,6 +266,8 @@ optionProcessor.command('O, toOdata')
                                          source (like "quoted", but using element names with dots)
     -s, --service-names <list>    List of comma-separated service names to be rendered
                                   (default) empty, all services are rendered
+   --fewer-localized-views   If set, the backends will not create localized convenience views for
+                             those views, that only have an association to a localized entity/view.
 `);
 
 optionProcessor.command('C, toCdl')
@@ -296,6 +300,7 @@ optionProcessor.command('Q, toSql')
   .option('    --disable-hana-comments')
   .option('    --generated-by-comment')
   .option('    --better-sqlite-session-variables')
+  .option('    --fewer-localized-views')
   .help(`
   Usage: cdsc toSql [options] <files...>
 
@@ -347,7 +352,10 @@ optionProcessor.command('Q, toSql')
    --pre2134ReferentialConstraintNames   Do not prefix the constraint identifier with "c__"
    --disable-hana-comments    Disable rendering of doc comments as SAP HANA comments.
    --generated-by-comment     Enable rendering of the initial SQL comment for HDI-based artifacts
-   --better-sqlite-session-variables    Enable better-sqlite compatible rendering of $user. Only active if sqlDialect is \`sqlite\`
+   --better-sqlite-session-variables    Enable better-sqlite compatible rendering of $user. Only
+                              active if sqlDialect is \`sqlite\`
+   --fewer-localized-views    If set, the backends will not create localized convenience views for
+                              those views, that only have an association to a localized entity/view.
 
 `);
 
@@ -425,6 +433,7 @@ optionProcessor.command('toCsn')
   .option('    --with-localized')
   .option('    --with-locations')
   .option('    --struct-xpr')
+  .option('    --fewer-localized-views')
   .help(`
   Usage: cdsc toCsn [options] <files...>
 
@@ -441,6 +450,9 @@ optionProcessor.command('toCsn')
                                 universal: in development (BETA)
        --with-locations   Add $location to CSN artifacts. In contrast to \`--enrich-csn\`,
                           $location is an object with 'file', 'line' and 'col' properties.
+       --fewer-localized-views   If --with-locations and this option are set, the backends
+                          will not create localized convenience views for those views,
+                          that only have an association to a localized entity/view.
 
   Internal options (for testing only, may be changed/removed at any time)
        --with-localized   Add localized convenience views to the CSN output.

package/lib/render/toCdl.js

@@ -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
@@ -1236,10 +1249,14 @@ 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)
-      result += renderIncludes(art.includes, env);
 
     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 (type) {
       // For nicer output, no colon if unnamed structure is used.
       result += (!art.type && art.elements) ? ` ${type}` : ` : ${type}`;
@@ -1248,7 +1265,15 @@ function csnToCdl( csn, options ) {
       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;
   }
 
@@ -1259,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 = {} ) {

package/lib/render/toSql.js

@@ -459,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
@@ -1379,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';
   }
 
   /**

package/lib/render/utils/common.js

@@ -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',
 };
 
 /**

package/lib/transform/db/applyTransformations.js

@@ -61,7 +61,7 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
    * The customTransformers are applied here (and only here).
    *
    * @param {object | Array} _parent the thing that has _prop
-   * @param {string|number} _prop the name of the current property
+   * @param {string|number} _prop the name of the current property or index
    * @param {object} node The value of node[_prop]
    */
   function standard( _parent, _prop, node ) {

package/lib/transform/db/cdsPersistence.js

@@ -86,7 +86,7 @@ function getAssocToSkippedIgnorer( csn, options, messageFunctions, csnUtils ) {
        !isPersistedOnDatabase(csn.definitions[member.target])) {
       info(null, path,
            { target: member.target, anno: '@cds.persistence.skip' },
-           'Association has been removed as it\'s target $(TARGET) is annotated with $(ANNO)');
+           'Association has been removed, as its target $(TARGET) is annotated with $(ANNO) and can\'t be rendered in SAP HANA SQL');
       member.$ignore = true;
     }
   }