@sap/cds-compiler 6.3.6 → 6.4.6

package/lib/transform/forRelationalDB.js

@@ -37,6 +37,7 @@ const { getDefaultTypeLengths } = require('../render/utils/common');
 const { featureFlags } = require('./featureFlags');
 const { cloneCsnNonDict, cloneFullCsn } = require('../model/cloneCsn');
 const { processSqlServices, createServiceDummy } = require('./db/processSqlServices');
+const { expandWildcard } = require('./db/expansion');
 
 // By default: Do not process non-entities/views
 function forEachDefinition(csn, cb) {
@@ -44,68 +45,12 @@ function forEachDefinition(csn, cb) {
 }
 
 /**
- * Return a copy of the compact CSN model with a number of transformations made for rendering
- * in HANA CDS style, used by 'toHana', toSql' and 'toRename'.
- * The behavior is controlled by the following options:
- * options = {
- *    sqlMapping // See the behavior of 'sqlMapping' in toHana, toSql and toRename
- * }
- * The result model will always have 'options.forHana' set, to indicate that these transformations have happened.
- * The following transformations are made:
- * - (000) Some primitive type names are mapped to HANA type names (e.g. DateTime => UTCDateTime,
- *         Date => LocalDate, ...).The primitive type 'UUID' is renamed to 'String' (see also 060 below).
- * - (001) Add a temporal where condition to views where applicable before assoc2join
- * - (010) (not for to.hdbcds with hdbcds names): Transform associations to joins
- * - (015) Draft shadow entities are generated for entities/views annotated with '@odata.draft.enabled'.
- * - (020) Check: in "plain" mode, quoted ids are not allowed.
- *         (a) check in namespace declarations
- *         (b) check in artifact/element definitions.
- * - (040) Abstract entities and entities 'implemented in' something are ignored, as well
- *         as entities annotated with '@cds.persistence.skip' or '@cds.persistence.exists'.
- * - (050) Checks on the hierarchical model (pre-flattening)
- *         array of, @cds.valid.from/to
- * - (045) The query is stripped from entities that are annotated with '@cds.persistence.table',
- *         essentially converting views to entities.
- * - (060) Users of primitive type 'UUID' (which is renamed to 'String' in 000) get length 36'.
- * - (070) Default length N is supplied for strings if not specified.
- * - (080) Annotation definitions are ignored (note that annotation assignments are filtered out by toCdl).
- * - (090) Compositions become associations.
- * - (100) 'masked' is ignored (a), and attribute 'localized' is removed (b)
- * - (110) Actions and functions (bound or unbound) are ignored.
- * - (120) (a) Services become contexts.
- * - (130) (not for to.hdbcds with hdbcds names): Elements having structured types are flattened into
- *         multiple elements (using '_' or '.' as name separator, depending on 'sqlMapping').
- * - (140) (not for to.hdbcds with hdbcds names): Managed associations get explicit ON-conditions, with
- *         generated foreign key elements (also using '_' or '.' as name separator, depending on 'sqlMapping').
- * - (150) (a) Elements from inherited (included) entities are copied into the receiving entity
- *         (b) The 'include' property is removed from entities.
- * - (160) Projections become views, with MIXINs for association elements (adding $projection where
- *         appropriate for ON-conditions).
- * - (170) ON-conditions referring to '$self' are transformed to compare explicit keys instead.
- * - (180) In projections and views, ...
- *         (a) association elements that are mixins must not be explicitly redirected
- *         (b) MIXINs are created for association elements in the select list that are not mixins by themselves.
- * - (190) For all enum types, ...
- *         (a) enum constants in defaults are replaced by their values (assuming a matching enum as element type)
- *         (b) the enum-ness is stripped off (i.e. the enum type is replaced by its final base type).
- * - (200) The 'key' property is removed from all elements of types.
- * - (210) (not for to.hdbcds with hdbcds names): Managed associations in GROUP BY and ORDER BY are
- *         replaced by by their foreign key fields.
- * - (220) Contexts that contain no artifacts or only ignored artifacts are ignored.
- * - (230) (only for to.hdbcds with hdbcds names): The following are rejected in views
- *         (a) Structured elements
- *         (b) Managed association elements
- *         (c) Managed association entries in GROUP BY
- *         (d) Managed association entries in ORDER BY
- * - (240) All artifacts (a), elements, foreign keys, parameters (b) that have a DB representation are annotated
- *         with their database name (as '@cds.persistence.name') according to the naming convention chosen
- *         in 'options.sqlMapping'.
- * - (250) Remove name space definitions again (only in forRelationalDB). Maybe we can omit inserting namespace definitions
- *         completely (TODO)
+ * Transform the given `csn` into a CSN that has SQL/HANA related transformations applied,
+ * such as flattening, wildcard expansion, etc.
  *
- * @param {CSN.Model}   csn
- * @param {CSN.Options} options
- * @param {object}      messageFunctions Message functions such as `error()`, `info()`, …
+ * @param {CSN.Model}      csn
+ * @param {CSN.SqlOptions} options
+ * @param {object}         messageFunctions Message functions such as `error()`, `info()`, …
  */
 function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   // copy the model as we don't want to change the input model
@@ -148,6 +93,12 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
 
   ensureColumnNames(csn, options, csnUtils);
 
+  forEachDefinition(csn, (def) => {
+    // TODO: Combine query traversal with ensureColumnNames()
+    if (def.query || def.projection)
+      traverseQuery(def.query || def, null, null, query => expandWildcard(query, csnUtils, options));
+  });
+
   const dialect = options.sqlDialect;
   const doA2J = !(options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds');
   if (!doA2J)
@@ -185,8 +136,8 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   expandStructsInExpression({ drillRef: true });
 
   forEachDefinition(csn, [
-    // (001) Add a temporal where condition to views where applicable before assoc2join
-    //       assoc2join eventually rewrites the table aliases
+    // Add a temporal where condition to views where applicable before assoc2join
+    // assoc2join eventually rewrites the table aliases
     temporal.getViewDecorator(csn, messageFunctions, csnUtils, options),
     // check unique constraints - further processing is done in rewriteUniqueConstraints
     assertUnique.prepare(csn, options, messageFunctions),
@@ -242,7 +193,6 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   // With flattening errors, it makes little sense to continue.
   throwWithAnyError();
 
-  // (010) If requested, translate associations to joins
   if (doA2J)
     handleAssocToJoins();
 
@@ -287,12 +237,12 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
 
 
   forEachDefinition(csn, [
-    // (040) Ignore entities and views that are abstract or implemented
+    // Ignore entities and views that are abstract or implemented
     // or carry the annotation cds.persistence.skip/exists
     // These entities are not removed from the csn, but flagged as "to be ignored"
     cdsPersistence.getAnnoProcessor(),
-    // (050) Check @cds.valid.from/to only on entity
-    //       Views are checked in (001), unbalanced valid.from/to's or mismatching origins
+    // Check @cds.valid.from/to only on entity
+    // Views are checked in (001), unbalanced valid.from/to's or mismatching origins
     temporal.getAnnotationHandler(csn, options, pathDelimiter, messageFunctions),
   ]);
 
@@ -308,7 +258,7 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   }
 
   {
-    // (045) Strip all query-ish properties from views and projections annotated with '@cds.persistence.table',
+    // Strip all query-ish properties from views and projections annotated with '@cds.persistence.table',
     // and make them entities
     const fns = [ cdsPersistence.getPersistenceTableProcessor(csn, options, messageFunctions) ];
     // Allow using managed associations as steps in on-conditions to access their fks
@@ -338,7 +288,7 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
         rejectManagedAssociationsAndStructuresForHdbcdsNames.call(that, definition, path);
       }
     },
-    // (170) Transform '$self' in backlink associations to appropriate key comparisons
+    // Transform '$self' in backlink associations to appropriate key comparisons
     // Must happen before draft processing because the artificial ON-conditions in generated
     // draft shadow entities have crooked '_artifact' links, confusing the backlink processing.
     // But it must also happen after flattenForeignKeys has been called for all artifacts,
@@ -371,7 +321,7 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   const findAndMarkSqlServiceArtifacts = options.sqlDialect === 'hana' && options.src === 'hdi' && (csn.meta?.[featureFlags]?.$sqlService || csn.meta?.[featureFlags]?.$dummyService || csn.meta?.[featureFlags]?.$dataProductService) ? processSqlServices(csn, options) : () => {};
 
   // Apply view-specific transformations
-  // (160) Projections now finally become views
+  // Projections now finally become views
   // Replace managed association in group/order by with foreign keys
   const transformEntityOrViewPass2 = getViewTransformer(csn, options, messageFunctions);
   forEachDefinition(csn, [ (artifact, artifactName) => {
@@ -382,7 +332,7 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
 
   if (!doA2J) {
     forEachDefinition(csn, [
-      // (200) Strip 'key' property from type elements
+      // Strip 'key' property from type elements
       removeKeyPropInType,
       (artifact, artifactName) => {
         if (artifact.kind === 'type') {
@@ -697,15 +647,6 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     // Length/Precision/Scale is done in addDefaultTypeFacets
   }
 
-  // If 'obj' has final type 'cds.UUID' (renamed to String in 000), set its length to 36.
-  // function setLengthForFormerUuid(obj) {
-  //   if (!obj || !obj.type)
-  //     return;
-  //   if (obj.type === 'cds.UUID' && !obj.length) {
-  //     obj.length = 36;
-  //   }
-  // }
-
   /**
    * Check that required actual parameters on 'node.type' are set, that their values are in the correct range etc.
 

package/lib/transform/localized.js

@@ -58,23 +58,7 @@ const annoPersistenceSkip = '@cds.persistence.skip';
  * @param {CSN.Model} csn
  *     Input CSN model.  Should not have existing convenience views.
  *
- * @param {object} options
- *     CSN options.  Only few options are used, see below for important ones.
- *     Options such as `testMode` or `testSortCsn` can also be set.
- *
- * @param {string} [options.localizedLanguageFallback]
- *     Valid values (if set): 'none', 'coalesce' (default)
- *     Whether to use a `coalesce()` function when selecting from `.texts` entities.
- *     If not set, untranslated strings may not return any value.  If 'coalesce'
- *     is used, it will fall back to the original string.
- *
- * @param {boolean} [options.localizedWithoutCoalesce]
- *     Deprecated version of localizedLanguageFallback. Do not use.
- *
- * @param {boolean} [options.fewerLocalizedViews]
- *     Default: true
- *
- * @param {boolean} [options.testMode]
+ * @param {CSN.Options} options
  *
  * @param {object} config
  *     Configuration for creating convenience views.  Non-user visible options.
@@ -156,14 +140,14 @@ function _addLocalizationViews(csn, options, config) {
 
   /**
    * Add a localized convenience view for the given artifact.
-   * Can either be an entity or view.  `textElements` are the elements which
+   * Can either be an entity or view.  `localizedElements` are the elements which
    * are needed for creating a horizontal convenience view, i.e. only required
    * for entities.
    *
    * @param {string} artName
-   * @param {string[]} [textElements=[]]
+   * @param {string[]} [localizedElements=[]]
    */
-  function addLocalizedView( artName, textElements = [] ) {
+  function addLocalizedView( artName, localizedElements = [] ) {
     const art = csn.definitions[artName];
     const artPath = [ 'definitions', artName ];
     const viewName = `localized.${ artName }`;
@@ -183,32 +167,32 @@ function _addLocalizationViews(csn, options, config) {
     if (art.query || art.projection)
       view = createLocalizedViewForView(art, viewName);
     else
-      view = createLocalizedViewForEntity(art, artName, viewName, textElements);
+      view = createLocalizedViewForEntity(art, artName, viewName, localizedElements);
 
     copyPersistenceAnnotations(view, art);
     csn.definitions[viewName] = view;
   }
 
   /**
-   * Create a localized data view for the given entity `art` with `textElements`.
+   * Create a localized data view for the given entity `art` with `localizedElements`.
    * In JOIN mode the FROM query is rewritten to remove associations and the
    * columns are expanded.
    *
    * @param {CSN.Definition} entity
    * @param {string} entityName
    * @param {string} viewName Name of the localized view.
-   * @param {string[]} [textElements]
+   * @param {string[]} [localizedElements]
    * @returns {CSN.View}
    */
-  function createLocalizedViewForEntity( entity, entityName, viewName, textElements = [] ) {
+  function createLocalizedViewForEntity( entity, entityName, viewName, localizedElements = [] ) {
     // Only use joins if requested and text elements are provided.
-    const shouldUseJoin = useJoins && !!textElements.length;
+    const shouldUseJoin = useJoins && !!localizedElements.length;
     const columns = [ ];
 
     const convenienceView = {
       '@odata.draft.enabled': false,
       kind: 'entity',
-      query: { // TODO: Use projection
+      query: {
         SELECT: {
           from: createFromClauseForEntity(),
           columns,
@@ -222,20 +206,12 @@ function _addLocalizationViews(csn, options, config) {
 
     if (shouldUseJoin)
       // Expand elements; (variant 1)
-      columns.push( ...columnsForEntityWithExcludeList( entity, 'L_0', textElements ) );
+      columns.push( ...columnsForEntityWithExcludeList( entity, 'L_0', localizedElements ) );
     else
       columns.push( '*' ); // (variant 2)
 
-    for (const originalElement of textElements) {
-      const elem = entity.elements[originalElement];
-      // Note: $key is used by forRelationalDB.js to indicate that this element was a key in the original,
-      //      user's entity.  Keys may have been changed by the backends (e.g. by `@cds.valid.key`)
-      if (!elem.key && !elem.$key)
-        columns.push( createColumnLocalizedElement( originalElement, shouldUseJoin ) );
-      else if (shouldUseJoin)
-        // In JOIN mode we also want to add keys.
-        columns.push( createColumnRef( [ 'L_0', originalElement ] ));
-
+    for (const originalElement of localizedElements) {
+      columns.push( createColumnLocalizedElement( originalElement, shouldUseJoin ) );
       addCoreComputedIfNecessary(convenienceView.elements, originalElement);
     }
 
@@ -254,22 +230,52 @@ function _addLocalizationViews(csn, options, config) {
         on: [],
       };
 
-      for (const originalElement of textElements) {
-        const elem = entity.elements[originalElement];
-        if (elem.key || elem.$key) {
-          from.on.push( createColumnRef( [ 'localized_1', originalElement ] ));
-          from.on.push( '=' );
-          from.on.push( createColumnRef( [ 'L_0', originalElement ] ));
-          from.on.push( 'and' );
-        }
-      }
-
-      from.on.push( createColumnRef( [ 'localized_1', 'locale' ] ) );
-      from.on.push( '=' );
-      from.on.push( createColumnRef( [ '$user', 'locale' ] ) );
+      from.on.push(...createJoinConditionFromLocaleElement());
 
       return from;
     }
+
+    function createJoinConditionFromLocaleElement() {
+      const targetAlias = 'localized_1';
+      const sourceAlias = 'L_0';
+      return adaptExpr(entity.elements.localized.on);
+
+      function adaptExpr(expr) {
+        // We only support a few specific ON-conditions, not generic expressions.
+        // In case of unsupported ON-conditions, we emit an error.
+        const res = expr.map((x) => {
+          if (!x || typeof x === 'string')
+            return x;
+          if (x.xpr)
+            return { xpr: adaptExpr(x.xpr) };
+          if (x.ref && !x.ref.some(ref => ref.args || ref.where))
+            return adaptRef(x);
+
+          messageFunctions.error(
+            'def-invalid-localized',
+            [ 'definitions', entityName, 'elements', 'localized', 'on' ],
+            { name: 'localized', alias: entityName },
+            'Element $(NAME) of entity $(ALIAS) does not have a supported ON-condition'
+          );
+          return x;
+        });
+
+        // the `localized` association does not contain the `tenant` element, so we need to add it here
+        const addTenantCol = options.tenantDiscriminator && entity.elements.tenant?.key;
+        if (addTenantCol)
+          return [ { ref: [ targetAlias, 'tenant' ] }, '=', { ref: [ sourceAlias, 'tenant' ] }, 'AND', { xpr: [ ...res ] } ];
+
+        return res;
+      }
+
+      function adaptRef(expr) {
+        if (expr.ref[0].charAt(0) === '$') // variable
+          return { ref: [ ...expr.ref ] };
+        if (expr.ref[0] === 'localized') // target side
+          return { ref: [ targetAlias, ...expr.ref.slice(1) ] };
+        return { ref: [ sourceAlias, ...expr.ref ] }; // source side
+      }
+    }
   }
 
   /**
@@ -316,7 +322,6 @@ function _addLocalizationViews(csn, options, config) {
     if (noCoalesce)
       return createColumnRef( [ ...localizedNames, elementName ], elementName );
 
-
     return {
       func: 'coalesce',
       args: [
@@ -357,8 +362,8 @@ function _addLocalizationViews(csn, options, config) {
 
   /**
    * Returns all text element names for a definition `<artName>` if its texts entity
-   * exists and `<artName>` has localized fields.  Otherwise `null` is returned.
-   * Text elements are localized elements as well as keys.
+   * exists and `<artName>` has localized fields.  Otherwise, `null` is returned.
+   * Text elements are non-key localized elements.
    *
    * @param {string} artName Artifact name
    * @return {string[] | null}
@@ -367,49 +372,31 @@ function _addLocalizationViews(csn, options, config) {
     const art = csn.definitions[artName];
     const artPath = [ 'definitions', artName ];
 
-    let keyCount = 0;
-    let textElements = [];
+    const localizedElements = [];
 
     forEachGeneric(art, 'elements', (elem, elemName, _prop) => {
       if (elem.$ignore) // from SAP HANA backend
         return;
-
-      if (elem.key || elem.$key)
-        keyCount += 1;
-
-      if (elem.key || elem.$key || elem.localized)
-        textElements.push( elemName );
+      if (elem.localized && !elem.key && !elem.$key)
+        localizedElements.push( elemName );
     }, artPath);
 
-    if (textElements.length <= keyCount || keyCount <= 0)
+    if (!localizedElements.length) {
       // Nothing to do: no localized fields or all localized fields are keys
       return null;
-
-    if (!isEntityPreprocessed( art )) {
-      messageFunctions.info(
-        null, artPath, { name: artName },
-        'Skipped creation of convenience view for $(NAME) because the artifact is missing localization elements'
-      );
+    }
+    if (!art.elements.localized) {
+      messageFunctions.info('def-expected-localized', artPath, { '#': 'missing', name: artName, alias: 'localized' });
+      return null;
+    }
+    if (!art.elements.localized.target) {
+      messageFunctions.info('def-expected-localized', artPath, { '#': 'non-assoc', name: artName, alias: 'localized' });
       return null;
     }
 
     const textsName = textsEntityName( artName );
     const textsEntity = csn.definitions[textsName];
 
-    if (!textsEntity) {
-      messageFunctions.info(
-        null, artPath, { name: artName },
-        'Skipped creation of convenience view for $(NAME) because its texts entity could not be found'
-      );
-      return null;
-    }
-    if (!isValidTextsEntity( textsEntity )) {
-      messageFunctions.info(
-        null, [ 'definitions', textsName ], { name: artName },
-        'Skipped creation of convenience view for $(NAME) because its texts entity does not appear to be valid'
-      );
-      return null;
-    }
     if (!art[annoPersistenceSkip] && textsEntity[annoPersistenceSkip]) {
       messageFunctions.message(
         'anno-unexpected-localized-skip', artPath,
@@ -418,22 +405,10 @@ function _addLocalizationViews(csn, options, config) {
       return null;
     }
 
-    // There may be keys in the original artifact that were added by the core compiler,
-    // for example elements that are marked @cds.valid.from.
-    // These keys are not present in the texts entity generated by the compiler.
-    // So if we don't filter them out, we may generate invalid SQL.
-    textElements = textElements.filter((elemName) => {
-      const hasElement = !!textsEntity.elements[elemName];
-      if (!hasElement && (art.elements[elemName].key || art.elements[elemName].$key))
-        keyCount--;
-      return hasElement;
-    });
-
-    if (textElements.length <= keyCount || keyCount <= 0)
-      // Repeat the check already used above as the number of keys may have changed.
-      return null;
-
-    return textElements;
+    // Due to recompilation / flattening, properties may have been propagated from "type-of".
+    // That means we have localized elements with no corresponding element in the texts-entity.
+    // Hence, we simply filter here.
+    return localizedElements.filter(elemName => textsEntity.elements[elemName]);
   }
 
   /**
@@ -646,8 +621,8 @@ function _addLocalizationViews(csn, options, config) {
    * @param {string} artName
    */
   function textsEntityName(artName) {
-    // We can assume that the element exists.  This is checked in isEntityPreprocessed().
-    return csn.definitions[artName].elements.texts.target;
+    // We can assume that the element exists.
+    return csn.definitions[artName].elements.localized.target;
   }
 
   /**
@@ -808,33 +783,6 @@ function checkExistingLocalizationViews(csn, options, messageFunctions) {
   return hasExistingViews || hasNonViews;
 }
 
-/**
- * Returns true if the given entity appears to be a valid texts entity.
- *
- * @param {CSN.Artifact} entity
- */
-function isValidTextsEntity(entity) {
-  if (!entity)
-    return false;
-  const requiredTextsProps = [ 'locale' ];
-  return requiredTextsProps.some( prop => !!entity.elements[prop]);
-}
-
-/**
- * Returns true if the localized entity has elements that are generated by
- * the core-compiler.  If elements are missing but the entity is localized
- * then the pre-processing by the core-compiler was not done.
- *
- * @param {CSN.Artifact} entity
- */
-function isEntityPreprocessed(entity) {
-  if (!entity)
-    return false;
-  if (!entity.elements.localized)
-    return false;
-  return entity.elements.texts && entity.elements.texts.target;
-}
-
 /**
  * @param {string} name
  * @returns {boolean}