@sap/cds-compiler 6.7.3 → 6.9.0

package/lib/parsers/AstBuildingParser.js

@@ -3,11 +3,12 @@
 const BaseParser = require( '../gen/BaseParser' );
 
 const { Location } = require( '../base/location' );
-const { dictAdd, dictAddArray } = require('../base/dictionaries');
+const { dictAdd, dictAddArray } = require('../compiler/dictionaries');
 const { functionsWithoutParentheses } = require('./identifiers');
 
 const { pathName } = require('../compiler/utils');
 const { quotedLiteralPatterns, specialFunctions } = require('../compiler/builtins');
+const { primaryExprProperties } = require('../base/builtins');
 
 const { parseMultiLineStringLiteral } = require('../language/multiLineStringParser');
 const { normalizeNewLine, normalizeNumberString } = require('../language/textUtils');
@@ -39,7 +40,7 @@ const valueTokens = {
   true: true,
 };
 const valueTokensLength = Object.values( valueTokens ).length;
-// likewise, if expectedArray contains all the following tokens, replace them by 'Literal'
+// if expectedArray contains all the following tokens, replace them by 'Literal'
 const literalTokens = {
   Number: true,
   QuotedLiteral: true,
@@ -51,6 +52,29 @@ const literalTokens = {
 };
 const literalTokensLength = Object.values( literalTokens ).length;
 
+// if expectedArray contains all the following tokens, replace them by 'Comparison'
+const comparisonTokens = {
+  '=': true,
+  '<>': true,
+  '>': true,
+  '>=': true,
+  '<': true,
+  '<=': true,
+  '!=': true,
+  '==': true,
+};
+const comparisonTokensLength = Object.values( comparisonTokens ).length;
+
+// if expectedArray contains all the following tokens, replace them by 'Operator'
+const operatorTokens = {
+  '+': true,
+  '-': true,
+  '*': true,
+  '/': true,
+  '||': true,
+};
+const operatorTokensLength = Object.values( operatorTokens ).length;
+
 const extensionDicts = {
   elements: true, enum: true, params: true, returns: true,
 };
@@ -77,11 +101,6 @@ const extensionsCode = {
 const PRECEDENCE_OF_EQUAL = 10;
 
 class AstBuildingParser extends BaseParser {
-  leanConditions = {
-    afterBrace: true,
-    fail: true,
-  };
-
   constructor( lexer, keywords, table, options, messageFunctions ) {
     super( lexer, keywords, table ); // lexer has file
     this.options = options;
@@ -127,6 +146,19 @@ class AstBuildingParser extends BaseParser {
       if (withoutLiteralTokens.length + literalTokensLength === array.length)
         array = [ 'Literal', ...withoutLiteralTokens ];
     }
+
+    const withoutComparisonTokens = raw ? array : array.filter(
+      tok => comparisonTokens[tok] !== true
+    );
+    if (withoutComparisonTokens.length + comparisonTokensLength === array.length)
+      array = [ 'Comparison', ...withoutComparisonTokens ];
+
+    const withoutOperatorTokens = raw ? array : array.filter(
+      tok => operatorTokens[tok] !== true
+    );
+    if (withoutOperatorTokens.length + operatorTokensLength === array.length)
+      array = [ 'Operator', ...withoutOperatorTokens ];
+
     return array.map( tok => this.antlrName( tok ) )
       .sort( (a, b) => (tokenPrecedence(a) < tokenPrecedence(b) ? -1 : 1) );
   }
@@ -165,7 +197,7 @@ class AstBuildingParser extends BaseParser {
   queryOnLeftSloppyAlias( _arg, mode ) {
     if (mode === 'M' || this.isNoKeywordInRuleFollow( _arg, mode ))
       return true;
-    // TODO TOOL: have a base parser method for the test
+    // TODO TOOL: have a base parser method for the test - or extra mode (recovery)
     if (this.conditionTokenIdx === this.tokenIdx &&        // tested on same
         this.conditionStackLength == null)                 // after error recovery
       return false;
@@ -202,7 +234,7 @@ class AstBuildingParser extends BaseParser {
   }
 
   prepareSpecialFunction() {
-    const func = this.tokens[this.tokenIdx - 2].keyword?.toUpperCase();
+    const func = this.lb(2).keyword?.toUpperCase();
     // TODO: use lower-case in specialFunctions
     const spec = specialFunctions[func];
     this.dynamic_.call = { func, argPos: 0 };
@@ -225,7 +257,7 @@ class AstBuildingParser extends BaseParser {
       if (generic !== 'expr')
         return (generic === 'intro') ? 'GenericIntro' : type;
       // if both intro and expr: specialFunctions[fn][argPos][token] = 'expr'
-      const next = this.tokens[this.tokenIdx + 1];
+      const next = this.lb(-1);
       if (next && next.type !== ',' && next.type !== ')' &&
           this.dynamic_.generic[next.keyword?.toUpperCase?.()] !== 'separator')
         return 'GenericIntro';
@@ -273,8 +305,7 @@ class AstBuildingParser extends BaseParser {
       this.dynamic_.inSelectItem ??= [];
       this.dynamic_.inSelectItem = [ ...this.dynamic_.inSelectItem ];
     }
-    this.dynamic_.inSelectItem.push(arg ||
-      (this.tokens[this.tokenIdx - 2].type === '.' ? 'inline' : 'expand'));
+    this.dynamic_.inSelectItem.push(arg || (this.lb(2).type === '.' ? 'inline' : 'expand'));
   }
 
   /**
@@ -285,7 +316,7 @@ class AstBuildingParser extends BaseParser {
   modifierRestriction() {
     const top = this.dynamic_.inSelectItem?.at(-1);
     const insideExpand = this.dynamic_.inSelectItem?.includes('expand');
-    const next = this.tokens[this.tokenIdx]?.keyword;
+    const next = this.la()?.keyword;
     return insideExpand || (next !== 'key' && top === 'inline');
   }
   modifierRestrictionError( args, offending ) {
@@ -304,7 +335,7 @@ class AstBuildingParser extends BaseParser {
       return false;
     // TODO: it would be best to set this.dynamic_.inSelectItem to null in filters
     // (as <prepare>)
-    const next = this.tokens[this.tokenIdx + 1]?.type;
+    const next = this.lb(-1)?.type;
     return next === '*' || next === '{';
   }
 
@@ -321,21 +352,22 @@ class AstBuildingParser extends BaseParser {
   // <prec=10, postfix=once> + test that the next token is not `null`; TODO: code
   // completion for `… default 3 not ~;` → currently just `null` but hey
   isNegatedRelation( prec ) {
-    return this.tokens[this.tokenIdx + 1]?.keyword === 'null' ||
+    return this.lb(-1)?.keyword === 'null' ||
       this.precNone_( prec );
   }
 
   // TODO: as leanCondition ?  `order` should probably appear in the message for
   // test3/Compiler/GrammarRobustness/InvalidSelectInWhere.err.cds
   orderByLimitRestriction( _arg, mode ) {
-    if (mode && (!this.$allowOrderByLimit || this.precPost_( mode, 0 )))
+    if (mode &&
+        (!this.$allowOrderByLimit && mode !== 'M' || this.precPost_( mode, 0 )))
       return true;
     this.$allowOrderByLimit = !mode;
     return false;
   }
 
   isNamedArg() {
-    const type = this.tokens[this.tokenIdx + 1]?.type;
+    const type = this.lb(-1)?.type;
     return type !== ':' && type !== '=>';
   }
 
@@ -485,13 +517,13 @@ class AstBuildingParser extends BaseParser {
   }
 
   noRepeatedCardinality( _arg, mode ) {
-    if (this.tokens[this.tokenIdx - 2]?.type !== ']')
+    if (this.lb(2)?.type !== ']')
       return false;
     if (mode === 'M')
       return true;
     // currently just warning if same cardinality provided twice
     const same = { one: '1', many: '*' }[this.la().keyword];
-    return this.tokens[this.tokenIdx - 3]?.text !== same;
+    return this.lb(3)?.text !== same;
   }
   noRepeatedCardinalityError( args ) {
     let openIdx = this.tokenIdx - 2;
@@ -569,7 +601,7 @@ class AstBuildingParser extends BaseParser {
       const { arrayAnno } = this.dynamic_;
       if (!arrayAnno[0])
         return arrayAnno[0] == null ? 'duplicate' : arg;
-      arrayAnno[0] = this.tokens[this.tokenIdx + 1]?.keyword;
+      arrayAnno[0] = this.lb(-1)?.keyword;
     }
     else if (arg === 'bracket') { // syntax-invalid-ellipsis
       // closing bracket not allowed if last `...` in array is with `up to
@@ -591,7 +623,7 @@ class AstBuildingParser extends BaseParser {
   }
 
   beforeColon() {
-    return this.tokens[this.tokenIdx + 1]?.text !== ':';
+    return this.lb(-1)?.text !== ':';
   }
 
   fail( _arg, mode ) {
@@ -615,13 +647,13 @@ class AstBuildingParser extends BaseParser {
       return;
     // assumes no value < -1:
     const location = (tokenAhead > 0)
-      ? this.combineLocation( this.la(), this.tokens[this.tokenIdx + tokenAhead] )
-      : this.tokens[this.tokenIdx + tokenAhead].location;
+      ? this.combineLocation( this.la(), this.lb(-tokenAhead) )
+      : this.lb(-tokenAhead).location;
     this.error( msgId, location, textArgs );
   }
 
   warnIfColonFollows( name ) {
-    if (this.l() === ':') {
+    if (this.la().type === ':') {
       this.warning( 'syntax-missing-parens', name,
                     { code: '@‹anno›', op: ':', newcode: '@(‹anno›…)' },
                     // eslint-disable-next-line @stylistic/max-len
@@ -643,7 +675,7 @@ class AstBuildingParser extends BaseParser {
 
   reportDubiousAnnoSpacing() {
     const at = this.lb();
-    const before = this.tokens[this.tokenIdx - 2];
+    const before = this.lb(2);
     if (before?.type === 'Id' && before.location.endLine === at.location.line &&
         before.location.endCol === at.location.col) {
       this.warning( 'syntax-expecting-anno-space', at.location, { code: '@' },
@@ -851,7 +883,7 @@ class AstBuildingParser extends BaseParser {
   classifyImplicitName( category, ref ) {
     if (!ref || ref.path) {     // TODO: func
       const tokenIndex = ref?.path.at(-1)?.location.tokenIndex;
-      const token = this.prevTokenWithIndex( tokenIndex ) ?? this.tokens[this.tokenIdx - 1];
+      const token = this.prevTokenWithIndex( tokenIndex ) ?? this.lb();
       const { parsedAs } = token;
       if (parsedAs && parsedAs !== 'token' && parsedAs !== 'keyword')
         token.parsedAs = category;
@@ -1060,7 +1092,7 @@ class AstBuildingParser extends BaseParser {
 
   // TODO: can we remove `;`/EOF from the expected-set for `annotate Foo with ⎀`?
   checkWith( keyword ) {
-    if (this.lb() !== keyword || ![ ';', '}', 'EOF' ].includes( this.l() ))
+    if (this.lb() !== keyword || ![ ';', '}', 'EOF' ].includes( this.la().type ))
       return;
     const tok = this.la();
     const docTokenIndex = this.docCommentIndex &&
@@ -1115,15 +1147,15 @@ class AstBuildingParser extends BaseParser {
   }
 
   // see also <guard=nestedExpand>
-  reportExpandInline( column, isInline ) {
-    // called before matching `{`
+  reportExpandInline( column, sqlStyle, isInline ) {
+    // called before matching `{` (or `*` with inline)
     if (column.value && !column.value.path) {
       // improve error location when using "inline" `.{…}` after ref (arguments and
       // filters not covered, not worth the effort); after an expression where
       // the last token is an identifier, not the `.` is wrong, but the `{`:
-      const token = (isInline && this.tokens[this.tokenIdx - 2].type !== 'Id')
-        ? this.lb()
-        : this.la();
+      const token = (isInline && this.lb(2)?.type !== 'Id')
+        ? this.lb()             // e.g. with `func() .{` → the `.` is wrong
+        : this.la();            // after `current_date` → the `{` is wrong
       this.error( 'syntax-unexpected-nested-proj', token,
                   { code: isInline ? '.{ ‹inline› }' : '{ ‹expand› }' },
                   'Unexpected $(CODE); nested projections can only be used after a reference' );
@@ -1132,6 +1164,15 @@ class AstBuildingParser extends BaseParser {
       // - no errors for refs inside expand/inline, but for refs in sibling expr
       // - think about: reference to these (sub) elements from other view
     }
+    else if (sqlStyle && this.la().text === '{') {
+      this.message( 'syntax-invalid-nested-proj', this.la(),
+                    {
+                      code: isInline ? '.{ ‹inline› }' : '{ ‹expand› }',
+                      keyword: 'select from … { … }',
+                    },
+                    // eslint-disable-next-line @stylistic/max-len
+                    'Unexpected $(CODE); nested projections can only be used within a CDL-style $(KEYWORD)' );
+    }
   }
 
   reportDuplicateClause( prop, erroneous, chosen, code ) {
@@ -1161,6 +1202,15 @@ class AstBuildingParser extends BaseParser {
     }
   }
 
+  checkStructProps( dict ) {
+    const special = primaryExprProperties.find( prop => dict[prop] !== undefined );
+    if (special || dict['=']) {
+      const prop = special || '=';
+      this.message( 'syntax-invalid-anno-struct', dict[prop].name.location,
+                    { '#': (special ? 'std' : 'ref'), prop } );
+    }
+  }
+
   // TODO: remove the check from the parser; move it to shared.js
   checkTypeArgs( art ) {
     const args = art.$typeArgs;
@@ -1175,7 +1225,7 @@ class AstBuildingParser extends BaseParser {
   locationOfPrevTokens( offset ) {
     // TODO: use combined location of lb() and la() and move actions accordingly
     // (for error recovery)
-    const { file, line, col } = this.tokens[this.tokenIdx - offset].location;
+    const { file, line, col } = this.lb( offset ).location;
     const { endLine, endCol } = this.lb().location;
     return {
       file,

package/lib/parsers/index.js

@@ -2,7 +2,7 @@
 
 'use strict';
 
-const lazyload = require('../base/lazyload')( module );
+const lazyload = require('../utils/lazyload')( module );
 const { CompilerAssertion } = require( '../base/error' );
 const { createMessageFunctions } = require( '../base/messages' );
 const { XsnSource } = require('../compiler/xsn-model');

package/lib/render/manageConstraints.js

@@ -11,7 +11,7 @@ const { transformForRelationalDBWithCsn } = require('../transform/forRelationalD
 const {
   renderReferentialConstraint, getIdentifierUtils,
 } = require('./utils/sql');
-const { sortCsn } = require('../model/cloneCsn');
+const { sortCsn } = require('../base/cloneCsn');
 
 /**
  * Used only by `cdsc manageConstraints`.

package/lib/render/toCdl.js

@@ -20,14 +20,14 @@ const { escapeString, hasUnpairedUnicodeSurrogate } = require('./utils/stringEsc
 const { checkCSNVersion } = require('../json/csnVersion');
 const { normalizeTypeRef, forEachDefinition } = require('../model/csnUtils');
 const enrichUniversalCsn = require('../transform/universalCsn/universalCsnEnricher');
-const { isBetaEnabled } = require('../base/model');
+const { isBetaEnabled } = require('../base/specialOptions');
 const { ModelError, CompilerAssertion } = require('../base/error');
 const { typeParameters, specialFunctions } = require('../compiler/builtins');
 const { isAnnotationExpression } = require('../base/builtins');
 const { forEach } = require('../utils/objectUtils');
 const { isBuiltinType } = require('../base/builtins');
-const { cloneFullCsn } = require('../model/cloneCsn');
-const { getKeysDict, implicitAs } = require('../model/csnRefs');
+const { cloneFullCsn } = require('../base/cloneCsn');
+const { getKeysDict, implicitAs } = require('../base/csnRefs');
 const { undelimitedIdentifierRegex } = require('../parsers/identifiers');
 const { getNormalizedQuery } = require('../model/csnUtils');
 const {
@@ -675,41 +675,60 @@ class CsnToCdl {
 
     // If there is nothing to extend, e.g. only annotations, don't render an
     // empty element list.  This would end up in diffs with parseCdl CSN.
-    if (!ext.elements && !ext.columns && !ext.actions && !ext.enum) {
+    if (!ext.elements && !ext.columns && !ext.actions && !ext.enum &&
+        !ext.where && !ext.groupBy && !ext.having && !ext.orderBy && !ext.limit) {
       result += `${ env.indent }extend ${ extName };\n`;
       return result;
     }
 
-    // We have the "old-style" prefix syntax and the "new-style" postfix "with <type>" syntax.
-    // The former one can not only extend (sub-)elements but also actions in the same statement whereas
-    // the latter cannot.
-    // If there are actions, check if there are also elements/columns, and if so, use the prefix notation.
-    const usePrefixNotation = ext.actions && (ext.columns || ext.elements);
-    if (usePrefixNotation)
-      result += `${ env.indent }extend ${ this.getExtendPrefixVariant(ext) } ${ extName } with {\n`;
-    else
-      result += `${ env.indent }extend ${ extName } with ${ this.getExtendPostfixVariant(ext) }{\n`;
+    if (ext.elements || ext.columns || ext.actions || ext.enum) {
+      // We have the "old-style" prefix syntax and the "new-style" postfix "with <type>" syntax.
+      // The former one can not only extend (sub-)elements but also actions in the same statement whereas
+      // the latter cannot.
+      // If there are actions, check if there are also elements/columns, and if so, use the prefix notation.
+      const usePrefixNotation = ext.actions && (ext.columns || ext.elements);
+      if (usePrefixNotation)
+        result += `${ env.indent }extend ${ this.getExtendPrefixVariant(ext) } ${ extName } with {\n`;
+      else
+        result += `${ env.indent }extend ${ extName } with ${ this.getExtendPostfixVariant(ext) }{\n`;
 
-    if (ext.columns)
-      result += this.renderViewColumns(ext, env.withIncreasedIndent());
+      if (ext.columns)
+        result += this.renderViewColumns(ext, env.withIncreasedIndent());
 
-    else if (ext.elements || ext.enum)
-      result += this.renderExtendStatementElements(ext, env);
+      else if (ext.elements || ext.enum)
+        result += this.renderExtendStatementElements(ext, env);
 
-    // Not part of if/else cascade, because it may be in postfix notation.
-    if (ext.actions) {
-      const childEnv = env.withIncreasedIndent();
-      let actions = '';
-      forEach(ext.actions, (actionName, action) => {
-        actions += this.renderActionOrFunction(actionName, action, childEnv.withSubPath([ 'actions', actionName ]), true);
-      });
-      if (!usePrefixNotation)
-        result += actions;
-      else if (actions !== '')
-        result += `${ env.indent }} actions {\n${ actions }`;
+      // Not part of if/else cascade, because it may be in postfix notation.
+      if (ext.actions) {
+        const childEnv = env.withIncreasedIndent();
+        let actions = '';
+        forEach(ext.actions, (actionName, action) => {
+          actions += this.renderActionOrFunction(actionName, action, childEnv.withSubPath([ 'actions', actionName ]), true);
+        });
+        if (!usePrefixNotation)
+          result += actions;
+        else if (actions !== '')
+          result += `${ env.indent }} actions {\n${ actions }`;
+      }
+
+      result += `${ env.indent }}`;
+    }
+    else {
+      result += `${ env.indent }extend ${ extName } with`;
     }
 
-    result += `${ env.indent }};\n`;
+    if (ext.where)
+      result += ` where ${ this.exprRenderer.renderExpr(ext.where, env.withSubPath([ 'where' ])) }`;
+    if (ext.groupBy)
+      result += ` group by ${ ext.groupBy.map((expr, i) => this.exprRenderer.renderExpr(expr, env.withSubPath([ 'groupBy', i ]))).join(', ') }`;
+    if (ext.having)
+      result += ` having ${ this.exprRenderer.renderExpr(ext.having, env.withSubPath([ 'having' ])) }`;
+    if (ext.orderBy)
+      result += ` order by ${ ext.orderBy.map((entry, i) => this.renderOrderByEntry(entry, env.withSubPath([ 'orderBy', i ]))).join(', ') }`;
+    if (ext.limit)
+      result += ` ${ this.renderLimit(ext.limit, env.withSubPath([ 'limit' ])) }`;
+
+    result += ';\n';
     return result;
   }
 
@@ -1997,7 +2016,7 @@ class CsnToCdl {
         return `#${ annoValue['#'] }`;
       }
       // Shorthand for absolute path (as string)
-      else if (annoValue['='] !== undefined) {
+      else if (typeof annoValue['='] === 'string') {
         if (annoValue['='].startsWith('@'))
           return this.quoteAnnotationPathIfRequired(annoValue['='], env);
         return this.quotePathIfRequired(annoValue['='], env);

package/lib/render/toHdbcds.js

@@ -18,13 +18,13 @@ const {
   renderReferentialConstraint,
 } = require('./utils/sql');
 const DuplicateChecker = require('./DuplicateChecker');
-const { isDeprecatedEnabled } = require('../base/model');
+const { isDeprecatedEnabled } = require('../base/specialOptions');
 const { checkCSNVersion } = require('../json/csnVersion');
 const { timetrace } = require('../utils/timetrace');
 
 const { smartId, delimitedId } = require('../sql-identifier');
 const { ModelError, CompilerAssertion } = require('../base/error');
-const { pathId } = require('../model/csnRefs');
+const { pathId } = require('../base/csnRefs');
 
 const $PROJECTION = '$projection';
 const $SELF = '$self';

package/lib/render/toSql.js

@@ -24,15 +24,15 @@ const {
 const DuplicateChecker = require('./DuplicateChecker');
 const { checkCSNVersion } = require('../json/csnVersion');
 const { timetrace } = require('../utils/timetrace');
-const { isBetaEnabled, isDeprecatedEnabled } = require('../base/model');
+const { isBetaEnabled, isDeprecatedEnabled } = require('../base/specialOptions');
 const sqlIdentifiers = require('../sql-identifier');
-const { sortCsn } = require('../model/cloneCsn');
+const { sortCsn } = require('../base/cloneCsn');
 const { manageConstraints, manageConstraint } = require('./manageConstraints');
 const { renderUniqueConstraintString, renderUniqueConstraintDrop, renderUniqueConstraintAdd } = require('./utils/unique');
 const { ModelError, CompilerAssertion } = require('../base/error');
-const { pathId } = require('../model/csnRefs');
+const { pathId } = require('../base/csnRefs');
 const { transformExprOperators } = require('./utils/operators');
-const { exprAsTree, condAsTree } = require('../model/xprAsTree');
+const { exprAsTree, condAsTree } = require('../base/xprAsTree');
 
 class SqlRenderEnvironment {
   indent = '';
@@ -114,7 +114,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
   const {
     error, warning, info, throwWithAnyError,
   } = messageFunctions;
-  const { quoteSqlId, prepareIdentifier, renderArtifactName } = getIdentifierUtils(csn, options);
+  const { quoteSqlId, prepareIdentifier, renderArtifactName } = getIdentifierUtils(csn, options, warning);
   const reportedMissingReplacements = Object.create(null);
 
   const exprRenderer = createExpressionRenderer({
@@ -795,7 +795,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
       return '';
     env = env.withSubPath([ 'elements', elementName ]);
     const isPostgresAlterColumn = env.alterMode && env.changeType === 'migration' && options.sqlDialect === 'postgres';
-    const quotedElementName = quoteSqlId(elementName);
+    const quotedElementName = quoteSqlId(elementName, env.path);
     if (duplicateChecker)
       duplicateChecker.addElement(quotedElementName, elm.$location, elementName);
 
@@ -1422,6 +1422,15 @@ function toSqlDdl( csn, options, messageFunctions ) {
       if (isBuiltinType(elm.type)) {
         // cds.Integer => render as INTEGER (no quotes)
         result += renderBuiltinType(elm.type);
+
+        // On H2 & sqlite the underlying data type for a cds.Vector is a binary, needing a length.
+        // The data is stored as a vector of 4 byte real numbers with dimensions given by length. Additional 4 bytes are used to store the dimensions.
+        if (
+          elm.type === 'cds.Vector' && elm.length &&
+          (options.sqlDialect === 'h2' || options.sqlDialect === 'sqlite')
+        )
+          elm.length = elm.length * 4 + 4;
+
         result += renderTypeParameters(elm);
       }
       else {
@@ -1451,7 +1460,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
    * @returns {string} Rendered type
    */
   function renderBuiltinType( typeName ) {
-    const types = cdsToSqlTypes[options.sqlDialect];
+    const types = cdsToSqlTypes[options.sqliteRealAffinityForDecimal && options.sqlDialect === 'sqlite' ? 'sqlitereal' : options.sqlDialect];
     const result = types?.[typeName] || cdsToSqlTypes.standard[typeName];
     if (!result && options.testMode)
       throw new CompilerAssertion(`Expected to find a type mapping for ${ typeName }`);

package/lib/render/utils/common.js

@@ -21,7 +21,7 @@ const {
   hasValidSkipOrExists, forEachDefinition, getNamespace, getUnderscoredName,
 } = require('../../model/csnUtils');
 
-const { implicitAs } = require('../../model/csnRefs');
+const { implicitAs } = require('../../base/csnRefs');
 
 /**
  * Render the given function
@@ -294,7 +294,7 @@ const cdsToSqlTypes = {
     'cds.Binary': 'BINARY_BLOB',
     'cds.hana.BINARY': 'BINARY_BLOB',
     'cds.hana.SMALLDECIMAL': 'SMALLDECIMAL',
-    'cds.Vector': 'BINARY_BLOB', // Not supported; see #11725
+    'cds.Vector': 'BLOB',
     'cds.Map': 'JSON_TEXT', // '_TEXT' suffix required for text affinity
   },
   plain: {
@@ -309,6 +309,7 @@ const cdsToSqlTypes = {
     'cds.DecimalFloat': 'DECFLOAT',
     'cds.DateTime': 'TIMESTAMP(0)',
     'cds.Timestamp': 'TIMESTAMP(7)',
+    'cds.Vector': 'VARBINARY',
     'cds.Map': 'JSON',
     'cds.UInt8': 'SMALLINT', // See #13870; not equivalent, but smallint can hold >byte
   },
@@ -320,11 +321,18 @@ const cdsToSqlTypes = {
     'cds.Binary': 'BYTEA',
     'cds.Double': 'FLOAT8',
     'cds.UInt8': 'SMALLINT', // See #13870; not equivalent, but smallint can hold >byte
-    'cds.Vector': 'VARCHAR', // Not supported; see #11725
+    'cds.Vector': 'VECTOR', // vector is the datatype for [pgvector](https://github.com/pgvector/pgvector?tab=readme-ov-file)
     'cds.Map': 'JSONB',
   },
 };
 
+cdsToSqlTypes.sqlitereal = {
+  ...cdsToSqlTypes.sqlite,
+  'cds.Decimal': 'REAL_DECIMAL',
+  'cds.DecimalFloat': 'REAL_DECIMAL',
+  'cds.hana.SMALLDECIMAL': 'REAL_SMALLDECIMAL',
+};
+
 // Type mapping from cds type names to HDBCDS type names:
 // Only those types, that need mapping, are listed.
 const cdsToHdbcdsTypes = {

package/lib/render/utils/sql.js

@@ -3,9 +3,9 @@
 'use strict';
 
 const { getResultingName } = require('../../model/csnUtils');
-const { smartId, delimitedId } = require('../../sql-identifier');
+const { smartId, delimitedId, sqlDialects } = require('../../sql-identifier');
 const { ModelError } = require('../../base/error');
-const { setProp } = require('../../base/model');
+const { setProp } = require('../../utils/objectUtils');
 
 /**
  * Render a given referential constraint as part of a SQL CREATE TABLE statement, or as .hdbconstraint artefact.
@@ -66,10 +66,12 @@ function renderReferentialConstraint( constraint, indent, toUpperCase, csn, opti
 /**
  * Get functions which can be used to prepare and quote SQL identifiers based on the options provided.
  *
+ * @param {CSN.Model} csn
  * @param {CSN.Options} options
+ * @param {function} warning
  * @returns quoteSqlId and prepareIdentifier function
  */
-function getIdentifierUtils( csn, options ) {
+function getIdentifierUtils( csn, options, warning ) {
   return { quoteSqlId, prepareIdentifier, renderArtifactName };
   /**
    * Return 'name' with appropriate "-quotes.
@@ -81,10 +83,17 @@ function getIdentifierUtils( csn, options ) {
    * Complain about names that collide with known SQL keywords or functions
    *
    * @param {string} name Identifier to quote
+   * @param {CSN.Path} path Path to the identifier in the CSN model (for warnings)
    * @returns {string} Quoted identifier
    */
-  function quoteSqlId( name ) {
+  function quoteSqlId( name, path ) {
     name = prepareIdentifier(name);
+    const s = sqlDialects[options.sqlDialect];
+    if ( warning && name.length > s.maxIdentifierLength ) {
+      warning( 'query-invalid-identifier',
+               path,
+               { name: options.sqlDialect, number: s.maxIdentifierLength });
+    }
 
     switch (options.sqlMapping) {
       case 'plain':
@@ -139,7 +148,7 @@ function getIdentifierUtils( csn, options ) {
    * @returns {string} Artifact name
    */
   function renderArtifactName( artifactName ) {
-    return quoteSqlId(getResultingName(csn, options.sqlMapping, artifactName));
+    return quoteSqlId(getResultingName(csn, options.sqlMapping, artifactName), [ 'definitions', artifactName ] );
   }
 }