@sap/cds-compiler 4.7.4 → 4.8.0

package/CHANGELOG.md

@@ -7,6 +7,49 @@
 Note: `beta` fixes, changes and features are usually not listed in this ChangeLog but [here](doc/CHANGELOG_BETA.md).
 The compiler behavior concerning `beta` features can change at any time without notice.
 
+
+## Version 4.8.0 - 2024-03-21
+
+### Added
+
+- compiler: Type `cds.Vector` was added.  It is mapped to `REAL_VECTOR` on SAP HANA.
+- Support associations to/from entities with parameters for SAP HANA SQL (hdi/direct).
+- to.sql/to.hdi:
+  + SAP HANA keywords `ABSOLUTE`, `REAL_VECTOR`, and `ST_ASESRIJSON` are now included for smart quoting.
+  +PostgreSQL keyword `SYSTEM_USER` is now included for smart quoting.
+- API: Added `to.sql.postgres.keywords` and `to.sql.h2.keywords`.
+  They contain keywords for the respective SQL dialect.
+
+### Changed
+
+- compiler: Overriding an included element must not change the type to an association
+  if it wasn't an association before and vice versa.
+- Update OData vocabularies: 'Authorization', 'Common', 'UI'.
+
+### Fixed
+
+- compiler: `cast()`s to structured types and associations are now rejected. They could lead to crashes before.
+- to.edm(x):
+  + Reject action/function return types that are declared `many of many`.
+  + Render user defined annotation type `cds.Integer` as `Edm.Int`.
+- to.sql|hdi|hdbcds:
+  + Correctly handle `.list` during flattening.
+  + Improve handling of `.items`.
+- to.sql|hdi.migration:
+  + Turn types and aspects into dummies to reduce CSN size.
+  + Correctly detect a removed `.default` and forcefully set the default to `null`.
+
+### Removed
+
+
+## Version 4.7.6 - 2024-02-29
+
+### Fixed
+
+- OData: Restored compatibility with the Java runtime.
+  Drafts generation was applied twice.
+
+
 ## Version 4.7.4 - 2024-02-27
 
 ### Fixed
@@ -18,13 +61,15 @@ The compiler behavior concerning `beta` features can change at any time without
 
 ### Fixed
 
-- Restored compatibility with `@sap/cds-dk` for Java runtime
+- Restored compatibility with `@sap/cds-dk` for Java runtime.
+
+
 
 ## Version 4.7.0 - 2024-02-23
 
 ### Added
 
-- compiler: Virtual elements can now be referenced in expressions in annotation
+- compiler: Virtual elements can now be referenced in expressions in annotation.
 
 ### Changed
 

package/bin/cdsc.js

@@ -217,7 +217,7 @@ function cdsc_main() {
  * @param {object} args
  */
 function validateDirectBackendOption( command, options, args ) {
-  if (![ 'toCdl', 'toOdata', 'toHana', 'toCsn', 'toSql' ].includes(command)) {
+  if (![ 'toCdl', 'toOdata', 'toHana', 'toCsn', 'toSql', 'forJava' ].includes(command)) {
     displayUsage(`Option '--direct-backend' can't be used with command '${command}'`,
                  optionProcessor.helpText, 2);
   }
@@ -272,6 +272,7 @@ function executeCommandLine( command, options, args ) {
     toCsn,
     toHana,
     toOdata,
+    forJava,
     toRename,
     manageConstraints,
     toSql,
@@ -317,6 +318,11 @@ function executeCommandLine( command, options, args ) {
   }
 
   function toEffectiveCsn( model ) {
+    const features = [ 'resolveSimpleTypes', 'resolveProjections' ];
+    for (const feature of features) {
+      if (options[feature]) // map to boolean equivalent
+        options[feature] = options[feature] === 'true';
+    }
     const csn = options.directBackend ? model : compactModel(model, options);
     displayNamedCsn(main.for.effective(csn, options), 'effective');
 
@@ -336,6 +342,14 @@ function executeCommandLine( command, options, args ) {
     return model;
   }
 
+  // Execute the command line command 'forJava' and display the results.
+  // Return the original model
+  function forJava( model ) {
+    const csn = options.directBackend ? model : compactModel(model, options);
+    displayNamedCsn( main.for.java( csn, options ), 'java');
+    return model;
+  }
+
   // Execute the command line option '--to-hana' and display the results.
   // Return the original model (for chaining)
   function toHana( model ) {

package/bin/cdshi.js

@@ -15,16 +15,26 @@ const compiler = require('../lib/compiler');
 const fs = require('fs');
 fs.readFile( '/dev/stdin', 'utf8', highlight );
 
-const categoryChars = {
+const categoryChars = {         // default: first char of category name
+  // first char lowercase = reference other than via extend/annotate:
   artref: 'm',
+  uncheckedRef: 'r',
+  uncheckedAnno: 'a',
   paramname: 'b',
+  typeparamname: 'b',
+  // first char uppercase = definition, extend/annotate ref, or path after `namespace`:
   Entity: 'D',
   Enum: 'H',
   Index: 'J',
   AnnoDef: 'V',
-  Extend: 'Z',
-  Annotate: 'Z',
+  Ext: 'Z',                 // extend/annotate on main def other than service/context
+  ExtService: 'S',          // highlight like service definition
+  ExtContext: 'C',          // highlight like context definition
+  // ExtElement: 'E',       // using the first letter is the default
+  ExtBoundAction: 'B',      // highlight like bound action definition
+  ExtParam: 'P',            // highlight like entity/action parameter definition
   Event: 'Y',
+  // Remark: do not use `x`/`X` (hex literal `x'1e3d'`)
 };
 
 function highlight( err, buf ) {

package/doc/CHANGELOG_BETA.md

@@ -8,7 +8,11 @@ Note: `beta` fixes, changes and features are listed in this ChangeLog just for i
 The compiler behavior concerning `beta` features can change at any time without notice.
 **Don't use `beta` fixes, changes and features in productive mode.**
 
-## Version 4.x.x - 2024-mm-dd
+## Version 4.8.0 - 2024-03-21
+
+### Removed `vectorType`
+
+It is now always enabled.
 
 ### Added `v5preview`
 

package/lib/api/main.js

@@ -9,6 +9,8 @@ const messages = lazyload('../base/messages');
 const compiler = lazyload('../compiler/index');
 const toCsn = lazyload('../json/to-csn');
 const forOdataNew = lazyload('../transform/forOdata.js');
+const generateDrafts = lazyload('../transform/draft/odata');
+const tenant = lazyload('../transform/addTenantFields');
 const toSql = lazyload('../render/toSql');
 const toCdl = require('../render/toCdl');
 const modelCompare = lazyload('../modelCompare/compare');
@@ -155,11 +157,32 @@ function odataInternal( csn, internalOptions, messageFunctions ) {
  * @returns {oDataCSN} Return an oData-pre-processed CSN
  */
 function odata( csn, options, messageFunctions ) {
-  trace.traceApi('for.odata', options);
   const internalOptions = prepareOptions.for.odata(options);
+  messageFunctions.setOptions( internalOptions );
   return odataInternal(csn, internalOptions, messageFunctions);
 }
 
+/**
+ * Return a structured CSN for the Java Runtime: with drafts and tenant support
+ *
+ * @param {CSN.Model} csn Clean input CSN
+ * @param {ODataOptions} options Options
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
+ * @returns {CSN.Model} a CSN for the Java Runtime
+ */
+function java( csn, options, messageFunctions ) {
+  const internalOptions = prepareOptions.for.java(options);
+  internalOptions.transformation = 'odata'; // otherwise generateDrafts adds tenant
+  messageFunctions.setOptions( internalOptions );
+  handleTenantDiscriminator(options, internalOptions, messageFunctions);
+
+  const clone = cloneCsn.cloneFullCsn(csn, internalOptions);
+  const draft = generateDrafts(clone, internalOptions, undefined, messageFunctions);
+  if (internalOptions.tenantDiscriminator)
+    tenant.addTenantFields(draft, internalOptions, messageFunctions );
+  return draft;
+}
+
 /**
  * Process the given csn back to cdl.
  *
@@ -169,8 +192,8 @@ function odata( csn, options, messageFunctions ) {
  * @returns {object} { model: string, namespace: string }
  */
 function cdl( csn, options, messageFunctions ) {
-  trace.traceApi('to.cdl', options);
   const internalOptions = prepareOptions.to.cdl(options);
+  messageFunctions.setOptions( internalOptions );
   return toCdl.csnToCdl(csn, internalOptions, messageFunctions);
 }
 
@@ -204,6 +227,7 @@ function csnForSql( csn, internalOptions, messageFunctions ) {
  */
 function forSql( csn, options, messageFunctions ) {
   const internalOptions = prepareOptions.to.sql(options);
+  messageFunctions.setOptions( internalOptions );
   return csnForSql(csn, internalOptions, messageFunctions); // already sorted for test mode
 }
 
@@ -219,6 +243,7 @@ function forSql( csn, options, messageFunctions ) {
 function forHdi( csn, options, messageFunctions ) {
   const internalOptions = prepareOptions.to.hdi(options);
   internalOptions.transformation = 'sql';
+  messageFunctions.setOptions( internalOptions );
   const transformedCsn = forRelationalDB.transformForRelationalDBWithCsn(
     csn, internalOptions, messageFunctions
   );
@@ -236,6 +261,7 @@ function forHdi( csn, options, messageFunctions ) {
 function forHdbcds( csn, options, messageFunctions ) {
   const internalOptions = prepareOptions.to.hdbcds(options);
   internalOptions.transformation = 'hdbcds';
+  messageFunctions.setOptions( internalOptions );
   const hanaCsn = forRelationalDB.transformForRelationalDBWithCsn(
     csn, internalOptions, messageFunctions
   );
@@ -252,8 +278,9 @@ function forHdbcds( csn, options, messageFunctions ) {
  * @private
  */
 function forEffective( csn, options, messageFunctions ) {
-  const internalOptions = prepareOptions.to.sql(options);
+  const internalOptions = prepareOptions.for.effective(options);
   internalOptions.transformation = 'effective';
+  messageFunctions.setOptions( internalOptions );
   if (options.tenantDiscriminator) {
     messageFunctions.error('api-invalid-option', null, {
       '#': 'forbidden',
@@ -276,9 +303,9 @@ function forEffective( csn, options, messageFunctions ) {
  * @returns {SQL[]} Array of SQL statements, tables first, views second
  */
 function sql( csn, options, messageFunctions ) {
-  trace.traceApi('to.sql', options);
   const internalOptions = prepareOptions.to.sql(options);
   internalOptions.transformation = 'sql';
+  messageFunctions.setOptions( internalOptions );
 
   handleTenantDiscriminator(options, internalOptions, messageFunctions);
 
@@ -303,8 +330,8 @@ function sql( csn, options, messageFunctions ) {
  * @returns {HDIArtifacts} { <filename>:<content>, ...}
  */
 function hdi( csn, options, messageFunctions ) {
-  trace.traceApi('to.hdi', options);
   const internalOptions = prepareOptions.to.hdi(options);
+  messageFunctions.setOptions( internalOptions );
 
   handleTenantDiscriminator(options, internalOptions, messageFunctions);
 
@@ -410,8 +437,8 @@ function remapName( key, csn, filter = () => true ) {
  *                                  - createsAndAlters: An array of SQL statements to ALTER/CREATE tables/views
  */
 function sqlMigration( csn, options, messageFunctions, beforeImage ) {
-  trace.traceApi('to.sql.migration', options);
   const internalOptions = prepareOptions.to.sql(options);
+  messageFunctions.setOptions( internalOptions );
   handleTenantDiscriminator(options, internalOptions, messageFunctions);
   const { error, throwWithError } = messageFunctions;
 
@@ -563,8 +590,8 @@ function sqlMigration( csn, options, messageFunctions, beforeImage ) {
  * @returns {migration} The migration result
  */
 function hdiMigration( csn, options, messageFunctions, beforeImage ) {
-  trace.traceApi('to.hdi.migration', options);
   const internalOptions = prepareOptions.to.hdi(options);
+  messageFunctions.setOptions( internalOptions );
   handleTenantDiscriminator(options, internalOptions, messageFunctions);
 
   // Prepare after-image.
@@ -651,9 +678,9 @@ sql.migration = sqlMigration;
  * @returns {HDBCDS} { <filename>:<content>, ...}
  */
 function hdbcds( csn, options, messageFunctions ) {
-  trace.traceApi('to.hdbcds', options);
   const internalOptions = prepareOptions.to.hdbcds(options);
   internalOptions.transformation = 'hdbcds';
+  messageFunctions.setOptions( internalOptions );
 
   if (options.tenantDiscriminator) {
     messageFunctions.error('api-invalid-option', null, {
@@ -678,12 +705,12 @@ function hdbcds( csn, options, messageFunctions ) {
  * @returns {edm} The JSON representation of the service
  */
 function edm( csn, options, messageFunctions ) {
-  trace.traceApi('to.edm', options);
   // If not provided at all, set service to 'undefined' to trigger validation
   const internalOptions = prepareOptions.to.edm(
     // eslint-disable-next-line comma-dangle
     options.service ? options : Object.assign({ service: undefined }, options)
   );
+  messageFunctions.setOptions( internalOptions );
 
   const { service } = options;
 
@@ -712,8 +739,8 @@ edm.all = edmall;
  * @returns {edms} { <service>:<JSON representation>, ...}
  */
 function edmall( csn, options, messageFunctions ) {
-  trace.traceApi('to.edm.all', options);
   const internalOptions = prepareOptions.to.edm(options);
+  messageFunctions.setOptions( internalOptions );
   const { error } = messageFunctions;
 
   if (internalOptions.odataVersion === 'v2')
@@ -747,12 +774,12 @@ function edmall( csn, options, messageFunctions ) {
  * @returns {edmx} The XML representation of the service
  */
 function edmx( csn, options, messageFunctions ) {
-  trace.traceApi('to.edmx', options);
   // If not provided at all, set service to 'undefined' to trigger validation
   const internalOptions = prepareOptions.to.edmx(
     // eslint-disable-next-line comma-dangle
     options.service ? options : Object.assign({ service: undefined }, options)
   );
+  messageFunctions.setOptions( internalOptions );
 
   const { service } = options;
 
@@ -782,8 +809,8 @@ edmx.all = edmxall;
  * @returns {edmxs} { <service>:<XML representation>, ...}
  */
 function edmxall( csn, options, messageFunctions ) {
-  trace.traceApi('to.edmx.all', options);
   const internalOptions = prepareOptions.to.edmx(options);
+  messageFunctions.setOptions( internalOptions );
 
   const result = {};
   let oDataCsn = csn;
@@ -813,18 +840,18 @@ function edmxall( csn, options, messageFunctions ) {
  * If odataVersion is not 'v4', then no JSON is rendered
  *
  * @param {CSN|oDataCSN} csn Clean input CSN or a pre-transformed CSN
- * @param {ODataOptions} [options={}] Options
+ * @param {ODataOptions} options Options
  * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
  * @returns {object} { <protocol> : { <ServiceName>: { edmx: <XML representation>, edm: <JSON representation> } } }
  */
 // @ts-ignore
-function odata2( csn, options = {}, messageFunctions ) {
-  trace.traceApi('to.odata', options);
+function odata2( csn, options, messageFunctions ) {
   // If not provided at all, set service to undefined to trigger validation
   const internalOptions = prepareOptions.to.odata(
     // eslint-disable-next-line comma-dangle
     options.service ? options : Object.assign({ service: undefined }, options)
   );
+  messageFunctions.setOptions( internalOptions );
 
   const { service } = options;
 
@@ -859,13 +886,13 @@ odata2.all = odataall;
  * If odataVersion is not 'v4', then no JSON is rendered
  *
  * @param {CSN|oDataCSN} csn Clean input CSN or a pre-transformed CSN
- * @param {ODataOptions} [options={}] Options
+ * @param {ODataOptions} options Options
  * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
  * @returns {object} { <protocol>: { <serviceName>: { edmx: <XML representation>, edm: <JSON representation> } } }
  */
-function odataall( csn, options = {}, messageFunctions ) {
-  trace.traceApi('to.odata.all', options);
+function odataall( csn, options, messageFunctions ) {
   const internalOptions = prepareOptions.to.odata(options);
+  messageFunctions.setOptions( internalOptions );
   const { error } = messageFunctions;
 
   if (internalOptions.odataVersion === 'v2')
@@ -999,6 +1026,7 @@ function flattenResultStructure( toProcess ) {
 
 module.exports = {
   odata: publishCsnProcessor(odata, 'for.odata'),
+  java: publishCsnProcessor(java, 'for.java'),
   cdl: publishCsnProcessor(cdl, 'to.cdl'),
   sql: publishCsnProcessor(sql, 'to.sql'),
   hdi: publishCsnProcessor(hdi, 'to.hdi'),
@@ -1048,6 +1076,7 @@ function publishCsnProcessor( processor, _name ) {
    * @returns {any} What ever the processor returns
    */
   function api( csn, options = {}, ...args ) {
+    trace.traceApi(_name, options);
     const originalMessageLength = options.messages?.length;
     try {
       const messageFunctions = messages.makeMessageFunction(csn, options, _name);
@@ -1086,7 +1115,6 @@ function publishCsnProcessor( processor, _name ) {
       if (options.testMode)  // Attach recompilation reason in testMode
         recompileMsg.message += `\n   ↳ cause: ${ err.message }`;
 
-      // next line to be replaced by CSN parser call which reads the CSN object
       const xsn = compiler.recompileX(csn, options);
       const recompiledCsn = toCsn.compactModel(xsn);
       messageFunctions.setModel(recompiledCsn);
@@ -1220,7 +1248,8 @@ function lazyload( moduleName ) {
 }
 
 /**
- * Error when tenantDiscriminator and withHanaAssociations is set by the user.
+ * Error when tenantDiscriminator and withHanaAssociations is set by the user, or
+ * if tenantDiscriminator is used with anything but "plain" mode.
  *
  * Set withHanaAssociations to false when tenantDiscriminator is used.
  *
@@ -1234,12 +1263,21 @@ function handleTenantDiscriminator( options, internalOptions, messageFunctions )
       option: 'tenantDiscriminator',
       prop: 'withHanaAssociations',
     });
+  }
 
-    messageFunctions.throwWithAnyError();
+  if (options.tenantDiscriminator && internalOptions.sqlMapping !== 'plain') {
+    messageFunctions.error('api-invalid-combination', null, {
+      '#': 'tenant-and-naming',
+      option: 'tenantDiscriminator',
+      prop: internalOptions.sqlMapping,
+      value: 'plain',
+    });
   }
-  else if (internalOptions.tenantDiscriminator) {
+
+  messageFunctions.throwWithError();
+
+  if (internalOptions.tenantDiscriminator)
     internalOptions.withHanaAssociations = false;
-  }
 }
 
 

package/lib/api/options.js

@@ -35,6 +35,7 @@ const publicOptionsNewAPI = [
   'withHanaAssociations',
   // ODATA
   'odataOpenapiHints',
+  'edm4OpenAPI',
   'odataVersion',
   'odataFormat',
   'odataContainment',
@@ -48,6 +49,9 @@ const publicOptionsNewAPI = [
   'serviceNames',
   //
   'dictionaryPrototype',
+  // for.effective
+  'resolveSimpleTypes',
+  'resolveProjections',
 ];
 
 // Internal options used for testing/debugging etc.
@@ -119,6 +123,8 @@ function translateOptions( input = {}, defaults = {}, hardRequire = {},
   // Overwrite with the hardRequire options - like src: sql in to.sql()
   Object.assign(options, hardRequire);
 
+  reclassifyErrorsForOpenApi( options );
+
   // Convenience for $user -> $user.id replacement
   if (options.variableReplacements && options.variableReplacements.$user && typeof options.variableReplacements.$user === 'string')
     options.variableReplacements.$user = { id: options.variableReplacements.$user };
@@ -126,6 +132,30 @@ function translateOptions( input = {}, defaults = {}, hardRequire = {},
   return options;
 }
 
+/**
+ * Reclassify certain OData errors to warnings for the OData/EDM/EDMX backends.
+ * Some errors are not necessary for openAPI generation.
+ *
+ * @param {CSN.Options} options OData options
+ */
+function reclassifyErrorsForOpenApi( options ) {
+  if (options.edm4OpenAPI) {
+    // shallow clone, so that we can modify severities without changing the user's.
+    options.severities = Object.assign({}, options.severities ?? {});
+
+    options.severities['odata-spec-violation-array'] = 'Warning';
+    options.severities['odata-spec-violation-assoc'] = 'Warning';
+    options.severities['odata-spec-violation-namespace'] = 'Warning';
+    options.severities['odata-spec-violation-param'] = 'Warning';
+    options.severities['odata-spec-violation-returns'] = 'Warning';
+    options.severities['odata-spec-violation-type-unknown'] = 'Warning';
+    options.severities['odata-spec-violation-no-key'] = 'Warning';
+    options.severities['odata-spec-violation-key-type'] = 'Warning';
+    options.severities['odata-spec-violation-property-name'] = 'Warning';
+  }
+}
+
+
 module.exports = {
   to: {
     cdl: options => translateOptions(options, undefined, undefined, undefined, undefined, 'to.cdl'),
@@ -181,6 +211,16 @@ module.exports = {
       const defaultOptions = { sqlMapping: 'plain', sqlDialect: 'hana' };
       return translateOptions(options, defaultOptions, hardOptions, undefined, undefined, 'for.hana');
     },
+    effective: (options) => {
+      const hardOptions = {};
+      const defaultOptions = {
+        sqlMapping: 'plain', resolveSimpleTypes: true, resolveProjections: true,
+      };
+      const processed = translateOptions(options, defaultOptions, hardOptions, null, [ 'sql-dialect-and-naming' ], 'for.effective');
+
+      return Object.assign({}, processed);
+    },
+    java: options => translateOptions(options, { sqlMapping: 'plain' }, {}, undefined, undefined, 'for.java'),
   },
   overallOptions, // exported for testing
 };

package/lib/base/builtins.js

@@ -0,0 +1,89 @@
+'use strict';
+
+// Model agnostic builtins.
+// It should not contain any specific to XSN, i.e. neither XSN structures
+// nor any other XSN properties.
+
+/**
+ * Checks whether the given absolute path is inside a reserved namespace.
+ *
+ * @param {string} absolute
+ * @returns {boolean}
+ */
+function isInReservedNamespace( absolute ) {
+  return absolute === 'cds' || absolute.startsWith( 'cds.' ) &&
+    !absolute.match( /^cds\.foundation(\.|$)/ ) &&
+    !absolute.match( /^cds\.outbox(\.|$)/ ) && // Requested by Node runtime
+    !absolute.match( /^cds\.xt(\.|$)/ ); // Requested by Mtx
+}
+
+/**
+ * Tell if a type is (directly) a builtin type
+ * Note that in CSN builtins are not in the definition of the model, so we can only
+ * check against their absolute names.  Builtin types are "cds.<something>", i.e. they
+ * are directly in 'cds', but not for example in 'cds.foundation'.
+ *
+ * @param {string|object} type
+ * @returns {boolean}
+ */
+function isBuiltinType( type ) {
+  type = typeof type === 'string' ? type : type?.ref?.[0];
+  return type && isInReservedNamespace( type );
+}
+
+const magicVariables = [
+  '$user',
+  '$at',
+  '$valid',
+  '$now',
+  '$tenant',
+  '$session',
+];
+
+/**
+ * Tell if a name is a magic variable
+ *
+ * @param {string} name
+ * @returns {boolean}
+ */
+function isMagicVariable( name ) {
+  return typeof name === 'string' && magicVariables.includes(name);
+}
+
+/**
+ * Properties that are required next to `=` to make an annotation value an actual expression
+ * and not some foreign structure.
+ *
+ * @type {string[]}
+ */
+const xprInAnnoProperties = [
+  'ref', 'xpr', 'list', 'literal', 'val',
+  '#', 'func', 'args', 'SELECT', 'SET',
+  'cast',
+];
+
+/**
+ * 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 functionsWithoutParens = [
+  'CURRENT_DATE', 'CURRENT_TIME', 'CURRENT_TIMESTAMP',
+  'CURRENT_USER', 'SESSION_USER', 'SYSTEM_USER',
+];
+
+/**
+ * Return whether JSON object `val` is a representation for an annotation expression
+ */
+function isAnnotationExpression( val ) {
+  return val?.['='] !== undefined && xprInAnnoProperties.some( prop => val[prop] !== undefined );
+}
+
+module.exports = {
+  xprInAnnoProperties,
+  functionsWithoutParens,
+  isInReservedNamespace,
+  isBuiltinType,
+  isMagicVariable,
+  isAnnotationExpression,
+}

package/lib/base/keywords.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { functionsWithoutParens } = require('../compiler/builtins');
+const { functionsWithoutParens } = require('./builtins');
 
 module.exports = {
   // CDL reserved keywords, used for automatic quoting in 'toCdl' renderer
@@ -207,6 +207,7 @@ module.exports = {
     'ABAP_TIME',
     'ABAP_XSTRING',
     'ABS',
+    'ABSOLUTE',
     'ACOS',
     'ADD_DAYS',
     'ADD_MONTHS',
@@ -529,6 +530,7 @@ module.exports = {
     'RAW',
     'RDICT',
     'REAL',
+    'REAL_VECTOR',
     'RECORD_COMMIT_TIMESTAMP',
     'RECORD_COUNT',
     'RECORD_ID',
@@ -579,6 +581,7 @@ module.exports = {
     'ST_ALPHASHAPEAGGR',
     'ST_ALPHASHAPEAREAAGGR',
     'ST_ALPHASHAPEEDGEAGGR',
+    'ST_ASESRIJSON',
     'ST_ASGEOJSON',
     'ST_ASMVT',
     'ST_ASSVGAGGR',
@@ -828,6 +831,7 @@ module.exports = {
     'SIMILAR',
     'SOME',
     'SYMMETRIC',
+    'SYSTEM_USER',
     'TABLE',
     'TABLESAMPLE',
     'THEN',