@sap/cds-compiler 5.3.2 → 5.4.2

package/lib/parsers/Lexer.js

@@ -177,9 +177,9 @@ function string( text, lexer, parser, beg ) {
   }
   else {                        // try with previous date/time/timestamp/x
     prefix = parser.tokens[parser.tokens.length - 1];
-    if (prefix.location.endLine !== lexer.location.line ||
+    if (prefix && (prefix.location.endLine !== lexer.location.line ||
         prefix.location.endCol !== lexer.location.col ||
-        !quotedLiterals.includes( prefix.keyword ))
+        !quotedLiterals.includes( prefix.keyword )))
       prefix = null;
     while (re.test( lexer.input ) && lexer.input[re.lastIndex] === "'")
       esc = ++re.lastIndex;
@@ -192,7 +192,7 @@ function string( text, lexer, parser, beg ) {
     const before = (lastIndex) ? 'string' : 'multi';
     // eslint-disable-next-line cds-compiler/message-texts
     parser.error( 'syntax-missing-token-end', lexer.location,
-                  { '#': before, newCode: text }, {
+                  { '#': before, newcode: text }, {
                     string: 'The string literal must end with $(NEWCODE) before the end of line',
                     multi: 'The multi-line string literal must end with $(NEWCODE)',
                   } );

package/lib/parsers/identifiers.js

@@ -0,0 +1,59 @@
+'use strict';
+
+/** RegEx identifying undelimited identifiers in CDL */
+const undelimitedIdentifierRegex = /^[$_\p{ID_Start}][$\p{ID_Continue}\u200C\u200D]*$/u;
+
+/**
+ * Functions without parentheses in CDL (common standard SQL-92 functions)
+ * (do not add more - make it part of the SQL renderer to remove parentheses for
+ * other funny SQL functions like CURRENT_UTCTIMESTAMP).
+ */
+const functionsWithoutParentheses = [
+  'CURRENT_DATE', 'CURRENT_TIME', 'CURRENT_TIMESTAMP',
+  'CURRENT_USER', 'SESSION_USER', 'SYSTEM_USER',
+];
+
+// CDL reserved keywords, used for automatic quoting in 'toCdl' renderer
+// Keep in sync with reserved keywords in language.g4
+const cdlKeywords = [
+  'ALL',
+  'ANY',
+  'AS',
+  'BY',
+  'CASE',
+  'CAST',
+  'DISTINCT',
+  'EXISTS',
+  'EXTRACT',
+  'FALSE', // boolean
+  'FROM',
+  'IN',
+  'KEY',
+  'NEW',
+  'NOT',
+  'NULL',
+  'OF',
+  'ON',
+  'SELECT',
+  'SOME',
+  'TRIM',
+  'TRUE', // boolean
+  'WHEN',
+  'WHERE',
+  'WITH',
+];
+
+function isSimpleCdlIdentifier( id ) {
+  if (undelimitedIdentifierRegex.test(id))
+    return true;
+  const upperId = id.toUpperCase();
+  return !cdlKeywords.includes(upperId) &&
+    !functionsWithoutParentheses.includes(upperId);
+}
+
+module.exports = {
+  undelimitedIdentifierRegex,
+  cdlKeywords,
+  functionsWithoutParentheses,
+  isSimpleCdlIdentifier,
+};

package/lib/render/toCdl.js

@@ -18,8 +18,8 @@ const {
 const { isBuiltinType } = require('../base/builtins');
 const { cloneFullCsn } = require('../model/cloneCsn');
 const { getKeysDict } = require('../model/csnRefs');
+const { undelimitedIdentifierRegex } = require('../parsers/identifiers');
 
-const identifierRegex = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/;
 const specialFunctionKeywords = Object.create(null);
 
 /**
@@ -2104,7 +2104,7 @@ function csnToCdl( csn, options, msg ) {
     return path.split('.').map((step, index) => {
       if (index === 0)
         return quoteNonIdentifierOrKeyword(step, env);
-      else if (!identifierRegex.test(step))
+      else if (!undelimitedIdentifierRegex.test(step))
         return delimitedId(step, env);
       return step;
     }).join('.');
@@ -2142,7 +2142,7 @@ function csnToCdl( csn, options, msg ) {
    * @return {string}
    */
   function quoteNonIdentifier( id, env ) {
-    if (!identifierRegex.test(id))
+    if (!undelimitedIdentifierRegex.test(id))
       return delimitedId(id, env);
     return id;
   }
@@ -2262,7 +2262,7 @@ function removeTrailingNewline( str ) {
  * @return {boolean}
  */
 function requiresQuotingForCdl( id, additionalKeywords ) {
-  return !identifierRegex.test(id) ||
+  return !undelimitedIdentifierRegex.test(id) ||
     keywords.cdl.includes(id.toUpperCase()) ||
     keywords.cdl_functions.includes(id.toUpperCase()) ||
     additionalKeywords.includes(id.toUpperCase());
@@ -2523,7 +2523,7 @@ function apiSmartId( id, insideFunction = null ) {
  */
 function apiSmartFunctionId( funcName ) {
   const funcId = funcName.toUpperCase();
-  const requiresQuoting = !identifierRegex.test(funcName) ||
+  const requiresQuoting = !undelimitedIdentifierRegex.test(funcName) ||
     (keywords.cdl.includes(funcId) && !specialFunctions[funcId]);
   if (requiresQuoting)
     return apiDelimitedId(funcName);

package/lib/render/utils/common.js

@@ -263,6 +263,7 @@ const cdsToSqlTypes = {
     '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
+    'cds.Map': 'NCLOB', // Not supported; see #13149
   },
   hana: {
     'cds.hana.SMALLDECIMAL': 'SMALLDECIMAL',
@@ -270,6 +271,7 @@ const cdsToSqlTypes = {
     'cds.hana.ST_POINT': 'ST_POINT',
     'cds.hana.ST_GEOMETRY': 'ST_GEOMETRY',
     'cds.Vector': 'REAL_VECTOR', // FIXME: test me
+    'cds.Map': 'NCLOB',
   },
   sqlite: {
     'cds.Date': 'DATE_TEXT',
@@ -280,6 +282,7 @@ const cdsToSqlTypes = {
     'cds.hana.BINARY': 'BINARY_BLOB',
     'cds.hana.SMALLDECIMAL': 'SMALLDECIMAL',
     'cds.Vector': 'BINARY_BLOB', // Not supported; see #11725
+    'cds.Map': 'JSON_TEXT', // '_TEXT' suffix required for text affinity
   },
   plain: {
     'cds.Binary': 'VARBINARY',
@@ -292,6 +295,7 @@ const cdsToSqlTypes = {
     'cds.DecimalFloat': 'DECFLOAT', // Decimal and Decimal(p) is mapped to cds.DecimalFloat
     'cds.DateTime': 'TIMESTAMP(0)',
     'cds.Timestamp': 'TIMESTAMP(7)',
+    'cds.Map': 'JSON',
   },
   postgres: {
     // See <https://www.postgresql.org/docs/current/datatype.html>
@@ -302,6 +306,7 @@ const cdsToSqlTypes = {
     'cds.Double': 'FLOAT8',
     'cds.UInt8': 'INTEGER', // Not equivalent
     'cds.Vector': 'VARCHAR', // Not supported; see #11725
+    'cds.Map': 'JSONB',
   },
 };
 

package/lib/render/utils/delta.js

@@ -179,10 +179,8 @@ class DeltaRendererPostgres extends DeltaRenderer {
    */
   alterColumns(artifactName, columnName, delta, definitionsStr, eltName, env) {
     const sqls = [];
-    if (delta.new.notNull === true || delta.new.key === true)
-      definitionsStr = definitionsStr.replace(' NOT NULL', ''); // TODO: Is this robust enough?
-    else if (delta.new.notNull === false || delta.new.$notNull === false)
-      definitionsStr = definitionsStr.replace(' NULL', ''); // TODO: Is this robust enough?
+
+    definitionsStr = this.#removeNullabilityFromElementString(delta, definitionsStr);
 
     if (delta.old.default && !delta.old.value) // Drop old default if any exists
       sqls.push(`ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} ALTER COLUMN ${columnName} DROP DEFAULT;`);
@@ -190,7 +188,7 @@ class DeltaRendererPostgres extends DeltaRenderer {
     if (delta.new.default && !delta.new.value ) { // Alter column with default
       const df = delta.new.default;
       delete delta.new.default;
-      const eltStrNoDefault = this.scopedFunctions.renderElement(eltName, delta.new, null, null, env);
+      const eltStrNoDefault = this.#removeNullabilityFromElementString(delta, this.scopedFunctions.renderElement(eltName, delta.new, null, null, env));
       delta.new.default = df;
       sqls.push(`ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} ALTER ${eltStrNoDefault};`);
       sqls.push(`ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} ALTER COLUMN ${columnName} SET DEFAULT ${this.scopedFunctions.renderExpr(delta.new.default, env.withSubPath('default'))};`);
@@ -206,6 +204,26 @@ class DeltaRendererPostgres extends DeltaRenderer {
 
     return sqls;
   }
+
+  /**
+   * Postgres does not support changing a column AND doing [NOT] NULL things in one statement.
+   * So we filter it from the SQL String and render the appropriate SET/DROP for the NOT NULL separately.
+   *
+   * @param {object} delta
+   * @param {string} string
+   * @returns {string}
+   */
+  #removeNullabilityFromElementString(delta, string) {
+    if (delta.new.notNull === true || delta.new.key === true)
+      string = string.replace(' NOT NULL', ''); // TODO: Is this robust enough?
+    else if (delta.new.notNull === false || delta.new.$notNull === false)
+      string = string.replace(' NULL', ''); // TODO: Is this robust enough?
+    else if (delta.new.notNull === delta.old.notNull)
+      string = string.replace( delta.new.notNull ? ' NOT NULL' : ' NULL', ''); // TODO: Is this robust enough?
+
+
+    return string;
+  }
 }
 
 class DeltaRendererH2 extends DeltaRenderer {

package/lib/transform/db/expansion.js

@@ -596,7 +596,8 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
     while (stack.length > 0) {
       const [ current, currentRef, currentAlias ] = stack.pop();
       if (csnUtils.isStructured(current)) {
-        const elements = Object.entries(current.elements || csnUtils.effectiveType(current).elements).reverse();
+        // `cds.Map` may also be used
+        const elements = Object.entries(current.elements || csnUtils.effectiveType(current).elements || {}).reverse();
         for (const [ name, elem ] of elements)
           stack.push([ elem, currentRef.concat(name), currentAlias.concat(name) ]);
       }

package/lib/transform/db/transformExists.js

@@ -485,7 +485,7 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
           collector.push(translateToSourceSide(column));
         }
         else {
-          collector.push(assignAndDeleteAs({}, part, { ref: [ base, ...part.ref.slice(1) ] }));
+          collector.push(assignAndDeleteAsAndKey({}, part, { ref: [ base, ...part.ref.slice(1) ] }));
         }
       }
       else if (art) { // source side - with local scope
@@ -503,14 +503,15 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
 
 
     /**
-     * Run Object.assign on all of the passed in parameters and delete a .as at the end
+     * Run Object.assign on all of the passed in parameters and delete a .as and .key at the end
      *
      * @param {...any} args
-     * @returns {object} The merged args without an .as property
+     * @returns {object} The merged args without an .as and .key property
      */
-    function assignAndDeleteAs( ...args ) {
+    function assignAndDeleteAsAndKey( ...args ) {
       const obj = Object.assign.apply(null, args);
       delete obj.as;
+      delete obj.key;
       return obj;
     }
     /**
@@ -528,19 +529,19 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
           const column = obj._art._column;
           if (column && column.as)
             return translateToSourceSide(column);
-          return assignAndDeleteAs({}, obj, { ref: [ base, ...obj.ref.slice(1) ] });
+          return assignAndDeleteAsAndKey({}, obj, { ref: [ base, ...obj.ref.slice(1) ] });
         }
         else if (typeof obj.$env === 'string') {
-          return assignAndDeleteAs({}, obj, { ref: [ obj.$env, ...obj.ref ] });
+          return assignAndDeleteAsAndKey({}, obj, { ref: [ obj.$env, ...obj.ref ] });
         }
 
-        return assignAndDeleteAs({}, obj, { ref: [ ...obj.ref ] });
+        return assignAndDeleteAsAndKey({}, obj, { ref: [ ...obj.ref ] });
       }
       else if (obj.xpr) { // we need to drill further down into .xpr
-        return assignAndDeleteAs({}, obj, { xpr: obj.xpr.map(translateToSourceSide) });
+        return assignAndDeleteAsAndKey({}, obj, { xpr: obj.xpr.map(translateToSourceSide) });
       }
       else if (obj.args) {
-        return assignAndDeleteAs({}, obj, { args: obj.args.map(translateToSourceSide) });
+        return assignAndDeleteAsAndKey({}, obj, { args: obj.args.map(translateToSourceSide) });
       }
 
       return obj;

package/lib/transform/effective/annotations.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const { CompilerAssertion } = require('../../base/error');
+const { forEach } = require('../../utils/objectUtils');
 
 const directMappings = {
   '@Common.IsDayOfCalendarMonth': replace('@Semantics.calendar.dayOfMonth'),
@@ -190,6 +191,152 @@ function remapODataAnnotations( csn ) {
   };
 }
 
+/**
+ * Do the .texts anno magic if we can be reasonably sure that we are actually dealing with a .texts entity.
+ *
+ * @param {CSN.Model} csn
+ * @param {string} artifactName
+ * @param {CSN.Artifact} artifact
+ */
+function sealAnnoMagicForTexts(csn, artifactName, artifact) {
+  if (artifactName.endsWith('.texts') && artifact.elements?.locale) {
+    const firstNonKey = getFirstNonKeyElement(artifact);
+    if (firstNonKey && firstNonKey.type === 'cds.String') {
+      artifact['@ObjectModel.supportedCapabilities'] ??= [];
+      if (!artifact['@ObjectModel.supportedCapabilities'].find(part => part['#'] === 'LANGUAGE_DEPENDENT_TEXT'))
+        artifact['@ObjectModel.supportedCapabilities'].push({ '#': 'LANGUAGE_DEPENDENT_TEXT' });
+      if (artifact.elements.locale['@Semantics.language'] === undefined)
+        artifact.elements.locale['@Semantics.language'] = true;
+      if (firstNonKey['@Semantics.text'] === undefined)
+        firstNonKey['@Semantics.text'] = true;
+    }
+  }
+}
+
+/**
+ *
+ * @param {CSN.Artifact} artifact
+ * @returns {CSN.Element|null}
+ */
+function getFirstNonKeyElement(artifact) {
+  for (const elementName in artifact.elements) {
+    if (Object.prototype.hasOwnProperty.call(artifact.elements, elementName)) {
+      if (!artifact.elements[elementName].key)
+        return artifact.elements[elementName];
+    }
+  }
+
+  return null;
+}
+
+/**
+ *
+ * @param {CSN.Model} csn
+ * @returns {object} Transfomer object for applyTransformations
+ */
+function sealAnnoMagic(csn) {
+  return {
+    '@ObjectModel.supportedCapabilities': (parent, prop, anno, path) => {
+      // Filter only for values we care about
+      const filteredAnno = anno.filter(value => value['#'] === 'ANALYTICAL_DIMENSION' || value['#'] === 'LANGUAGE_DEPENDENT_TEXT' || value['#'] === 'ANALYTICAL_PROVIDER');
+      if (filteredAnno.filter(value => value['#'] === 'ANALYTICAL_PROVIDER').length > 0 && parent.kind === 'entity' && isPartOfINAService(csn, path[1]) && parent.elements) {
+        forEach(parent.elements, (elementName, element) => {
+          if (element.target && csn.definitions[element.target]['@ObjectModel.supportedCapabilities']?.filter(value => value['#'] === 'ANALYTICAL_DIMENSION').length > 0) {
+            const tuples = getOnConditionAsComparisonTuples(element.on, elementName);
+            const targetEntity = csn.definitions[element.target];
+            if (element.on.length === 3 && tuples.length > 0 ) {
+              tuples.forEach(({ source }) => {
+                const sourceElement = parent.elements[source.ref[0]];
+                if (!sourceElement.target && sourceElement['@ObjectModel.foreignKey.association'] === undefined)
+                  sourceElement['@ObjectModel.foreignKey.association'] = { '=': elementName };
+              });
+            }
+
+            else if (element.on.length > 3 && tuples.length > 0 && targetEntity['@ObjectModel.representativeKey']) {
+              tuples.forEach(({ source, target }) => {
+                if (target.ref[1] === targetEntity['@ObjectModel.representativeKey']['=']) {
+                  const sourceElement = parent.elements[source.ref[0]];
+                  if (!sourceElement.target && sourceElement['@ObjectModel.foreignKey.association'] === undefined)
+                    sourceElement['@ObjectModel.foreignKey.association'] = { '=': elementName };
+                }
+              });
+            }
+          }
+        });
+      }
+
+      if (filteredAnno.filter(value => value['#'] === 'ANALYTICAL_DIMENSION').length > 0 && parent.kind === 'entity' && parent.elements) {
+        forEach(parent.elements, (_elementName, element) => {
+          if (element['@ObjectModel.text.element'] && parent.elements[element['@ObjectModel.text.element']['=']] && parent.elements[element['@ObjectModel.text.element']['=']]['@Semantics.text'] === undefined)
+            parent.elements[element['@ObjectModel.text.element']['=']]['@Semantics.text'] = true;
+        });
+      }
+
+      if (filteredAnno.length === 1 && parent.kind && parent['@ObjectModel.modelingPattern'] === undefined) {
+        if (filteredAnno[0]['#'] === 'ANALYTICAL_PROVIDER')
+          parent['@ObjectModel.modelingPattern'] = { '#': 'ANALYTICAL_CUBE' };
+        else
+          parent['@ObjectModel.modelingPattern'] = { '#': filteredAnno[0]['#'] };
+      }
+    },
+  };
+}
+
+function isPartOfINAService(csn, artifactName) {
+  const parts = artifactName.split('.');
+  if (parts.length === 1)
+    return false; // No dots
+  for (let i = 0; i < parts.length; i++) {
+    const possibleServiceName = parts.slice(0, i).join('.');
+    const possibleDefinition = csn.definitions[possibleServiceName];
+    if (possibleDefinition?.kind === 'service')
+      return possibleDefinition['@protocol'] === 'ina';
+  }
+
+  return false;
+}
+
+/**
+ * Split the given on-condition into bite-sized tuples IF
+ * - the operator is a =
+ * - one of the arguments is of the form <assoc>.<field>
+ * - one of the arguments is of the form <field>
+ * - there are no braces
+ * - each of the comparison tuples is "joined" via "and"
+ *
+ * Return an empty array if we encounter any tuples/things that do NOT match those criteria
+ * @param {CSN.OnCondition} on
+ * @param {string} assocName
+ * @returns {object[]}
+ */
+function getOnConditionAsComparisonTuples(on, assocName) {
+  const validTuples = [];
+  for (let i = 0; i < on.length - 2; i += 4) {
+    let isValid = false;
+    const arg1 = on[i];
+    const operator = on[i + 1];
+    const arg2 = on[i + 2];
+    const possibleAnd = i + 3 < on.length ? on[i + 3] : 'and';
+    if (possibleAnd === 'and' && operator === '=' && (arg1.ref?.length === 1 && arg2.ref?.length === 2 && arg2.ref[0] === assocName || arg1.ref?.length === 2 && arg1.ref[0] === assocName && arg2.ref?.length === 1 )) { // TODO: Do we care about filters? Filters could cause a crash here?
+      if (arg1.ref.length === 1) { // arg1 needs to point to be <field>, arg2 needs to be <assoc>.<field>
+        validTuples.push({ source: arg1, target: arg2 });
+        isValid = true;
+      }
+      else {  // arg1 needs to point to be <assoc>.<field>, arg2 needs to be <field>
+        validTuples.push({ source: arg2, target: arg1 });
+        isValid = true;
+      }
+    }
+
+    if (!isValid)
+      return [];
+  }
+  return validTuples;
+}
+
+
 module.exports = {
   remapODataAnnotations,
+  sealAnnoMagic,
+  sealAnnoMagicForTexts,
 };

package/lib/transform/effective/main.js

@@ -78,12 +78,26 @@ function effectiveCsn( model, options, messageFunctions ) {
   processCalculatedElementsInEntities(csn, options);
   associations.managedToUnmanaged(csn, options, csnUtils, messageFunctions);
   associations.transformBacklinks(csn, options, csnUtils, messageFunctions);
-  const transformers = mergeTransformers([ options.addCdsPersistenceName ? misc.attachPersistenceName(csn, options, csnUtils) : {}, options.remapOdataAnnotations ? annotations.remapODataAnnotations(csn) : {}, misc.removeDefinitionsAndProperties(csn, options) ], null);
-  applyTransformations(csn, transformers, [], { skipIgnore: false, processAnnotations: true });
+  const transformers = mergeTransformers([
+    options.addCdsPersistenceName ? misc.attachPersistenceName(csn, options, csnUtils) : {},
+    options.remapOdataAnnotations ? annotations.remapODataAnnotations(csn) : {},
+    misc.removeDefinitionsAndProperties(csn, options),
+    options.deriveAnalyticalAnnotations ? annotations.sealAnnoMagic(csn) : {},
+  ], null);
+
+  const artifactTransformers = [];
+  if (options.deriveAnalyticalAnnotations)
+    artifactTransformers.push(annotations.sealAnnoMagicForTexts);
+
+  applyTransformations(csn, transformers, artifactTransformers, { skipIgnore: false, processAnnotations: true });
 
   if (!options.resolveProjections)
     redoProjections.forEach(fn => fn());
 
+
+  // Remove unapplied extensions/annotations
+  delete csn.extensions;
+
   messageFunctions.throwWithError();
 
   return csn;

package/lib/transform/forOdata.js

@@ -10,6 +10,8 @@ const { forEachDefinition,
         isAspect,
         getServiceNames,
         forEachGeneric,
+        cardinality2str,
+        getUtils
       } = require('../model/csnUtils');
 const { checkCSNVersion } = require('../json/csnVersion');
 const validate = require('../checks/validator');
@@ -18,6 +20,7 @@ const expandToFinalBaseType = require('./odata/toFinalBaseType');
 const { timetrace } = require('../utils/timetrace');
 const enrichUniversalCsn = require('./universalCsn/universalCsnEnricher');
 const flattening = require('./odata/flattening');
+const createForeignKeyElements = require('./odata/createForeignKeys');
 const associations = require('./db/associations')
 const expansion = require('./db/expansion');
 const generateDrafts = require('./draft/odata');
@@ -181,24 +184,31 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
   // If errors are detected, throwWithAnyError() will return from further processing
   expandStructsInExpression(csn, { skipArtifact: isExternalServiceMember, drillRef: true });
 
+  // do expansion before Fk creation because of messages reporting
   if (!structuredOData) {
     expansion.expandStructureReferences(csn, options, '_',
       { error, info, throwWithAnyError }, csnUtils,
       { skipArtifact: isExternalServiceMember });
-    const resolved = new WeakMap();
+  }
+
+  createForeignKeyElements(csn, options, messageFunctions, csnUtils, { skipArtifact: isExternalServiceMember });
 
+  if (!structuredOData) {
+    const resolved = new WeakMap();
     const { inspectRef, effectiveType } = csnRefs(csn);
+    const { getFinalTypeInfo } = getUtils(csn);
     const { adaptRefs, transformer: refFlattener } =
       flattening.getStructRefFlatteningTransformer(csn, inspectRef, effectiveType, options, resolved, '_');
 
-    flattening.allInOneFlattening(csn, refFlattener, adaptRefs,
-        inspectRef, isExternalServiceMember, error, csnUtils, options);
+    const allMgdAssocDefs = flattening.allInOneFlattening(csn, refFlattener, adaptRefs,
+      inspectRef, getFinalTypeInfo, isExternalServiceMember, error, csnUtils, options);
     flattening.flattenAllStructStepsInRefs(csn, refFlattener, adaptRefs,
         inspectRef, effectiveType, csnUtils, error, options,
       { //skip: ['action', 'aspect', 'event', 'function', 'type'],
         skipArtifact: isExternalServiceMember,
       });
-
+    flattening.replaceManagedAssocsAsKeys(allMgdAssocDefs, csnUtils);
+      
     // replace structured with flat dictionaries that contain
     // rewritten path expressions
     forEachDefinition(csn, (def) => {
@@ -223,16 +233,14 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
     });
   }
 
-  // TODO: add the generated foreign keys to the columns when we are in a view
-  // see db/views.js::addForeignKeysToColumns
-  flattening.handleManagedAssociationsAndCreateForeignKeys(csn, options, messageFunctions, '_',
-    !structuredOData, csnUtils,{ skipArtifact: isExternalServiceMember });
+  bindCsnReferenceOnly();
 
   // Allow using managed associations as steps in on-conditions to access their fks
   // To be done after handleManagedAssociationsAndCreateForeignKeys,
   // since then the foreign keys of the managed assocs are part of the elements
-  if(!structuredOData)
+  if(!structuredOData) {
     forEachDefinition(csn, associations.getFKAccessFinalizer(csn, csnUtils, '_'));
+  }
 
   // structure flattener reports errors, further processing is not safe -> throw exception in case of errors
   throwWithAnyError();
@@ -277,7 +285,8 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
           !(propertyName === 'enum' || propertyName === 'returns') &&
           (!member.virtual || def.query)) {
         // If we have a 'preserved dotted name' (i.e. we are a result of flattening), use that for the @cds.persistence.name annotation
-        member['@cds.persistence.name'] = getElementDatabaseNameOf(member.$defPath?.slice(1).join('.') || memberName, options.sqlMapping, 'hana'); // hana to allow "hdbcds"
+        member['@cds.persistence.name'] = getElementDatabaseNameOf((!member['@odata.foreignKey4'] && member.$defPath?.slice(1).join('.'))
+                                                                    || memberName, options.sqlMapping, 'hana'); // hana to allow "hdbcds"
       }
 
       // Mark fields with @odata.on.insert/update as @Core.Computed
@@ -286,6 +295,12 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
       // Resolve annotation shorthands for elements, actions, action parameters
       renameShorthandAnnotations(member);
 
+      // If an association was modelled as not null, like so:
+      // <associationName>: Association to <target> not null;
+      // a cardinality property is set to the association member
+      // with the value { "min": 1 };
+      setCardinalityToNotNullAssociations(member);
+
       // - If the association target is annotated with @cds.odata.valuelist, annotate the
       //      association with @Common.ValueList.viaAssociation
       // - Check for @Analytics.Measure and @Aggregation.default
@@ -419,6 +434,27 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
     }
   }
 
+  // If an association was modelled as not null, like so:
+  // <associationName>: Association to <target> not null;
+  // a cardinality property is set to the association member
+  // with the value { "min": 1 };
+  function setCardinalityToNotNullAssociations(member) {
+    if (member.target && member.keys && !member.on) {
+      if (member.notNull) {
+        if (member.cardinality === undefined)
+          member.cardinality = {};
+          // min=0 is falsy => check for undefined
+        if (member.cardinality.min === undefined) {
+          member.cardinality.min = 1;
+        }
+        else if (member.cardinality.min === 0) {
+          warning(null, member.$path, { value: cardinality2str(member, false), code: 'not null' },
+                  'Expected target cardinality $(VALUE) and $(CODE) to match');
+        }
+      }
+    }
+  }
+
   // Apply default type facets to each type definition and every member
   // But do not apply default string length (as in DB)
   function setDefaultTypeFacets(def) {
@@ -466,4 +502,11 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
     }
   }
 
+  function bindCsnReferenceOnly() {
+    // invalidate caches for CSN ref API
+    const csnRefApi = csnRefs(csn);
+    Object.assign(csnUtils, csnRefApi);
+  }
+
+
 } // transform4odataWithCsn

package/lib/transform/forRelationalDB.js

@@ -856,6 +856,13 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
             checkTypeParamValue(node, 'srid', { max: Number.MAX_SAFE_INTEGER }, path);
             break;
           }
+          case 'cds.Map': {
+            if (options.sqlDialect === 'plain')
+              error('ref-unsupported-type', path, { '#': 'dialect', type: node.type, value: 'plain' });
+            else if (options.transformation === 'hdbcds')
+              error('ref-unsupported-type', path, {'#': 'hdbcds', type: node.type, value: options.sqlDialect });
+            break;
+          }
           case 'cds.Vector': {
             if (options.sqlDialect !== 'hana') {
               error('ref-unsupported-type', path, {