@sap/cds-compiler 3.4.2 → 3.4.4

package/lib/model/csnRefs.js

@@ -204,6 +204,7 @@ const artifactProperties = [ 'elements', 'columns', 'keys', 'mixin', 'enum',
 //   * 'target': always follow target, including last ref item
 //   * other (& not provided) = follow target if not last ref item
 const referenceSemantics = {
+  $init: { $initOnly: true },
   type: { lexical: false, dynamic: 'global' }, // TODO: assoc: 'static', see Issue #8458
   includes: { lexical: false, dynamic: 'global', assoc: 'static' }, // no elem ref anyway
   target: { lexical: false, dynamic: 'global', assoc: 'static' },   // no elem ref anyway
@@ -532,6 +533,8 @@ function csnRefs( csn, universalReady ) {
       return resolvePath( path, main.params[head], main, 'param' );
 
     const semantics = referenceSemantics[refCtx] || {};
+    if (semantics.$initOnly)
+      return undefined;
     if (semantics.dynamic === 'global' || ref.global)
       return resolvePath( path, csn.definitions[head], null, 'global', semantics.assoc );
 
@@ -979,6 +982,8 @@ function analyseCsnPath( csnPath, csn, resolve ) {
     else if (artifactProperties.includes( String(prop) )) {
       if (refCtx === 'target' || refCtx === 'targetAspect') { // with 'elements'
         // $self refers to the anonymous aspect
+        if (resolve)
+          resolve( '', '$init', main );
         main = obj;
         art = obj;
         parent = null;

package/lib/modelCompare/compare.js

@@ -49,12 +49,12 @@ function validateCsnVersions(beforeModel, afterModel, options) {
 
   if (!beforeVersionParts || beforeVersionParts.length < 2) {
     const { error, throwWithAnyError } = makeMessageFunction(beforeModel, options, 'modelCompare');
-    error(null, null, { version: beforeVersion }, 'Invalid CSN version: $(VERSION)');
+    error(null, null, { version: beforeVersion || 'undefined' }, 'Invalid CSN version: $(VERSION)');
     throwWithAnyError();
   }
   if (!afterVersionParts || afterVersionParts.length < 2) {
     const { error, throwWithAnyError } = makeMessageFunction(afterModel, options, 'modelCompare');
-    error(null, null, { version: afterVersion }, 'Invalid CSN version: $(VERSION)');
+    error(null, null, { version: afterVersion || 'undefined' }, 'Invalid CSN version: $(VERSION)');
     throwWithAnyError();
   }
   if (beforeVersionParts[0] > afterVersionParts[0] && !(options && options.allowCsnDowngrade)) {

package/lib/modelCompare/utils/.eslintrc.json

@@ -0,0 +1,22 @@
+{
+  "plugins": ["sonarjs"],
+  "extends": ["../../../.eslintrc-ydkjsi.json", "plugin:sonarjs/recommended"],
+  "rules": {
+    "prefer-const": "error",
+    "quotes": ["error", "single", "avoid-escape"],
+    "prefer-template": "error",
+    "no-trailing-spaces": "error",
+    "sonarjs/cognitive-complexity": "off",
+    "sonarjs/no-duplicate-string": ["off"],
+    "sonarjs/no-nested-template-literals": "off",
+    "template-curly-spacing":["error", "never"],
+    "class-methods-use-this": "off",
+    // Who cares - just very whiny and in the way
+    "complexity": "off",
+    "max-len": "off",
+    "no-shadow": "warn"
+  },
+  "env": {
+    "es2020": true
+  }
+}

package/lib/modelCompare/utils/filter.js

@@ -0,0 +1,99 @@
+'use strict';
+
+// Each db has some changes that it can and cannot represent, or that cause problems only on that specific db
+// In this file, we define rules for each db-dialect to detect and act on these cases.
+
+const { forEach } = require('../../utils/objectUtils');
+const { isPersistedAsTable } = require('../../model/csnUtils');
+
+function isKey(element) {
+  return element.key;
+}
+
+module.exports = {
+  sqlite: getFilterObject(
+    'sqlite',
+    function forEachExtension(extend, name, element, error) {
+      if (isKey(element)) { // Key must not be extended
+        error('type-unsupported-key-sqlite', [ 'definitions', extend, 'elements', name ], { id: name, name: 'sqlite' }, 'Added element $(ID) is a primary key change and will not work with dialect $(NAME)');
+      }
+    },
+    function forEachMigration(migrate, name, migration, change, error) {
+      const newIsKey = isKey(migration.new);
+      const oldIsKey = isKey(migration.old);
+      if ((newIsKey || oldIsKey) && oldIsKey !== newIsKey) { // Turned into key or key was removed
+        error('type-unsupported-key-sqlite', [ 'definitions', migrate, 'elements', name ], { id: name, name: 'sqlite' }, 'Changed element $(ID) is a primary key change and will not work with dialect $(NAME)');
+      }
+      else { // Ignore simple migrations
+        delete change[name];
+      }
+    }
+  ),
+  postgres: getFilterObject('postgres'),
+  h2: getFilterObject('h2'),
+};
+
+function getFilterObject(dialect, extensionCallback, migrationCallback) {
+  return {
+    // will be called with a simple Array.forEach
+    extension: ({ elements, extend }, error) => {
+      if (extensionCallback) {
+        forEach(elements, (name, element) => {
+          extensionCallback(extend, name, element, error);
+        });
+      }
+    },
+    // will be called with a Array.map, as we need to filter "change" for SQLite
+    migration: ({ change, migrate, remove }, error) => {
+      forEach(remove, (name) => {
+        error('def-unsupported-element-drop', [ 'definitions', migrate, 'elements', name ], {}, 'Dropping elements is not supported');
+      });
+
+      forEach(change, (name, migration) => {
+        const loc = [ 'definitions', migrate, 'elements', name ];
+        if (migration.new.type === migration.old.type && migration.new.length < migration.old.length)
+          error('type-unsupported-length-change', loc, { id: name }, 'Changed element $(ID) is a length reduction and is not supported');
+        else if (migration.new.type === migration.old.type && migration.new.scale !== migration.old.scale)
+          error('type-unsupported-scale-change', loc, { id: name }, 'Changed element $(ID) is a scale change and is not supported');
+        else if (migration.new.type === migration.old.type && migration.new.precision !== migration.old.scale)
+          error('type-unsupported-precision-change', loc, { id: name }, 'Changed element $(ID) is a precision change and is not supported');
+        else if (migration.new.type !== migration.old.type && typeChangeIsNotCompatible(dialect, migration.old.type, migration.new.type))
+          error('type-unsupported-change', loc, { id: name, name: migration.old.type, type: migration.new.type }, 'Changed element $(ID) is a lossy type change from $(NAME) to $(TYPE) and is not supported');
+        else if (migrationCallback)
+          migrationCallback(migrate, name, migration, change, error);
+
+        // TODO: precision/scale growth
+      });
+    },
+    deletion: ([ artifactName, artifact ], error) => {
+      if (isPersistedAsTable(artifact))
+        error('def-unsupported-table-drop', [ 'definitions', artifactName ], 'Dropping tables is not supported');
+    },
+  };
+}
+
+const defaultAllowedTypeChanges = {
+  // Integer types
+  'cds.hana.tinyint': [ 'cds.UInt8', 'cds.Int16', 'cds.Int32', 'cds.Integer', 'cds.Int64', 'cds.Integer64' ],
+  'cds.UInt8': [ 'cds.hana.tinyint', 'cds.Int16', 'cds.Int32', 'cds.Integer', 'cds.Int64', 'cds.Integer64' ],
+  'cds.Int16': [ 'cds.hana.smallint', 'cds.Int32', 'cds.Integer', 'cds.Int64', 'cds.Integer64' ],
+  'cds.hana.smallint': [ 'cds.Int16', 'cds.Int32', 'cds.Integer', 'cds.Int64', 'cds.Integer64' ],
+  'cds.Int32': [ 'cds.Integer', 'cds.Int64', 'cds.Integer64' ],
+  'cds.Integer': [ 'cds.Int32', 'cds.Int64', 'cds.Integer64' ],
+  'cds.Integer64': [ 'cds.Int64' ],
+  'cds.Int64': [ 'cds.Integer64' ],
+};
+
+const allowedTypeChanges = {
+  sqlite: defaultAllowedTypeChanges,
+  postgres: defaultAllowedTypeChanges,
+  h2: defaultAllowedTypeChanges,
+};
+
+function typeChangeIsNotCompatible(dialect, before, after) {
+  if (allowedTypeChanges[dialect]) {
+    const map = allowedTypeChanges[dialect];
+    return map[before] ? !map[before].includes(after) : true;
+  }
+  return true;
+}

package/lib/render/.eslintrc.json

@@ -10,6 +10,7 @@
     "sonarjs/no-duplicate-string": ["off"],
     "sonarjs/no-nested-template-literals": "off",
     "template-curly-spacing":["error", "never"],
+    "class-methods-use-this": "off",
     // Who cares - just very whiny and in the way
     "complexity": "off",
     "max-len": "off",

package/lib/render/toCdl.js

@@ -2,7 +2,7 @@
 
 const keywords = require('../base/keywords');
 const { isBuiltinType, generatedByCompilerVersion, getNormalizedQuery } = require('../model/csnUtils');
-const { findElement, getExpressionRenderer } = require('./utils/common');
+const { findElement, createExpressionRenderer, withoutCast } = require('./utils/common');
 const { escapeString, hasUnpairedUnicodeSurrogate } = require('./utils/stringEscapes');
 const { checkCSNVersion } = require('../json/csnVersion');
 const { timetrace } = require('../utils/timetrace');
@@ -26,7 +26,7 @@ const identifierRegex = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/;
  */
 function csnToCdl(csn, options) {
   timetrace.start('CDL rendering');
-  let _renderExpr = null;
+  const exprRenderer = createCdlExpressionRenderer();
 
   if (options.csnFlavor === 'universal' && isBetaEnabled(options, 'enableUniversalCsn'))
     enrichUniversalCsn(csn, options);
@@ -635,7 +635,7 @@ function csnToCdl(csn, options) {
         result += renderJoinCardinality(source.cardinality);
         result += `join ${renderViewSource(source.args[i], env)}`;
         if (source.on)
-          result += ` on ${renderExpr(source.on, env, true, true)}`;
+          result += ` on ${exprRenderer.renderExpr(source.on, env)}`;
       }
       result += ')';
       return result;
@@ -687,13 +687,13 @@ function csnToCdl(csn, options) {
 
     if (path.ref[0].where) {
       const cardinality = path.ref[0].cardinality ? (`${path.ref[0].cardinality.max}: `) : '';
-      const expr = renderExpr(path.ref[0].where, env, true, true);
+      const expr = exprRenderer.renderExpr(path.ref[0].where, env);
       result += `[${cardinality}${expr}]`;
     }
 
     // Add any path steps (possibly with parameters and filters) that may follow after that
     if (path.ref.length > 1)
-      result += `:${renderExpr({ ref: path.ref.slice(1) }, env)}`;
+      result += `:${exprRenderer.renderExpr({ ref: path.ref.slice(1) }, env)}`;
 
     return result;
   }
@@ -755,17 +755,19 @@ function csnToCdl(csn, options) {
     result += env.indent;
 
     // only if column is virtual, keyword virtual was present in the source text
-    if (col.virtual)
-      result += 'virtual ';
+    result += col.virtual ? 'virtual ' : '';
+    result += col.key ? 'key ' : '';
 
-    const key = col.key ? 'key ' : '';
     // Use special rendering for .expand/.inline - renderExpr cannot easily handle some cases
-    result += key + ((col.expand || col.inline) ? renderInlineExpand(col, env) : renderExpr(col, env, true));
+    if (col.expand || col.inline)
+      result += renderInlineExpand(col, env);
+    else
+      result += exprRenderer.renderExpr(withoutCast(col), env);
 
     // Alias for inline/expand is already handled by renderInlineExpand
     // A new association (cast with `type` and `target`) uses `as` as its primary name, not alias.
-    const isNewAssociation = col.cast && col.cast.type && col.cast.target;
-    if (col.as && !col.inline && !col.expand && !isNewAssociation)
+    const isNewAssociation = col.cast?.type && col.cast.target;
+    if (!isNewAssociation && col.as && !col.inline && !col.expand)
       result += ` as ${quoteIdIfRequired(col.as)}`;
 
     // Explicit type provided for the view element?
@@ -789,7 +791,7 @@ function csnToCdl(csn, options) {
    */
   function renderInlineExpand(obj, env) {
     // No expression to render for { * } as alias
-    let result = (obj.as && obj.expand && !obj.ref) ? '' : renderExpr(obj, env);
+    let result = (obj.as && obj.expand && !obj.ref) ? '' : exprRenderer.renderExpr(withoutCast(obj), env);
 
     // s as alias { * }
     if (obj.as && (obj.ref || obj.xpr || obj.val !== undefined || obj.func !== undefined))
@@ -937,13 +939,13 @@ function csnToCdl(csn, options) {
       result += renderActionsAndFunctions(query, env);
 
     if (select.where)
-      result += `${continueIndent(result, env)}where ${renderExpr(select.where, env, true, true)}`;
+      result += `${continueIndent(result, env)}where ${exprRenderer.renderExpr(select.where, env)}`;
 
     if (select.groupBy)
-      result += `${continueIndent(result, env)}group by ${select.groupBy.map(expr => renderExpr(expr, env, true, false, true)).join(', ')}`;
+      result += `${continueIndent(result, env)}group by ${select.groupBy.map(expr => exprRenderer.renderExpr(expr, env)).join(', ')}`;
 
     if (select.having)
-      result += `${continueIndent(result, env)}having ${renderExpr(select.having, env, true, true)}`;
+      result += `${continueIndent(result, env)}having ${exprRenderer.renderExpr(select.having, env)}`;
 
     if (select.orderBy)
       result += `${continueIndent(result, env)}order by ${select.orderBy.map(entry => renderOrderByEntry(entry, env)).join(', ')}`;
@@ -979,11 +981,11 @@ function csnToCdl(csn, options) {
     function renderLimit(limit, limitEnv) {
       let limitStr = '';
       if (limit.rows !== undefined)
-        limitStr += `limit ${renderExpr(limit.rows, limitEnv)}`;
+        limitStr += `limit ${exprRenderer.renderExpr(limit.rows, limitEnv)}`;
 
       if (limit.offset !== undefined) {
         const offsetIndent = (limitStr === '') ? '' : `\n${increaseIndent(limitEnv).indent}`;
-        limitStr += `${offsetIndent}offset ${renderExpr(limit.offset, limitEnv)}`;
+        limitStr += `${offsetIndent}offset ${exprRenderer.renderExpr(limit.offset, limitEnv)}`;
       }
       return limitStr;
     }
@@ -1021,7 +1023,7 @@ function csnToCdl(csn, options) {
    * @return {string}
    */
   function renderOrderByEntry(entry, env) {
-    let result = renderAnnotationAssignmentsAndDocComment(entry, env) + renderExpr(entry, env, true, false, true);
+    let result = renderAnnotationAssignmentsAndDocComment(entry, env) + exprRenderer.renderExpr(entry, env);
     if (entry.sort)
       result += ` ${entry.sort}`;
 
@@ -1195,8 +1197,7 @@ function csnToCdl(csn, options) {
 
       // ON-condition (if any)
       if (artifact.on)
-        result += ` on ${renderExpr(artifact.on, env, true, true)}`;
-
+        result += ` on ${exprRenderer.renderExpr(artifact.on, env)}`;
 
       // Foreign keys (if any, unless we also have an ON_condition (which means we have been transformed from managed to unmanaged)
       if (artifact.keys && !artifact.on)
@@ -1237,7 +1238,7 @@ function csnToCdl(csn, options) {
     if (!isTypeDef) // NOT NULL not possible for not-arrayed type definitions
       result += renderNullability(artifact);
     if (artifact.default)
-      result += ` default ${renderExpr(artifact.default, env)}`;
+      result += ` default ${exprRenderer.renderExpr(artifact.default, env)}`;
 
     return result;
   }
@@ -1252,7 +1253,7 @@ function csnToCdl(csn, options) {
   function renderRedirectedTo(art, env) {
     let result = `redirected to ${quotePathIfRequired(art.target)}`;
     if (art.on)
-      result += ` on ${renderExpr(art.on, env, true, true)}`;
+      result += ` on ${exprRenderer.renderExpr(art.on, env)}`;
     else if (art.keys)
       result += ` { ${Object.keys(art.keys).map(name => renderForeignKey(art.keys[name], env)).join(', ')} }`;
     return result;
@@ -1312,7 +1313,7 @@ function csnToCdl(csn, options) {
     result += renderAnnotationAssignmentsAndDocComment(enumValue, env);
     result += env.indent + quoteIdIfRequired(name);
     if (enumValue.val !== undefined)
-      result += ` = ${renderExpr(enumValue, env)}`;
+      result += ` = ${exprRenderer.renderExpr(enumValue, env)}`;
     else if (enumValue['#'] !== undefined)
       result += ` = #${enumValue['#']}`;
     result += ';\n';
@@ -1373,11 +1374,10 @@ function csnToCdl(csn, options) {
    *
    * @param {string|object} s
    * @param {number} idx
-   * @param {boolean} inline
    * @param {object} env
    * @returns {string}
    */
-  function renderPathStep(s, idx, inline, env) {
+  function renderPathStep(s, idx, env) {
     // Simple id or absolute name
     if (typeof s === 'string') {
       // In first path position, do not quote $projection and magic $-variables like CURRENT_DATE, $now etc.
@@ -1405,7 +1405,7 @@ function csnToCdl(csn, options) {
       if (s.where) {
         // Filter, possibly with cardinality
         const cardinality = s.cardinality ? (`${s.cardinality.max}: `) : '';
-        const expr = renderExpr(s.where, env, inline, true);
+        const expr = exprRenderer.renderExpr(s.where, env);
         result += `[${cardinality}${expr}]`;
       }
 
@@ -1479,9 +1479,11 @@ function csnToCdl(csn, options) {
    */
   function renderArgument(arg, env, additionalKeywords = []) {
     // If the argument is a xpr with e.g. `=`, it may require parentheses.
-    // For nested xpr, `renderExpr()` will already add parentheses.
+    // For nested xpr, `exprRenderer.renderExpr()` will already add parentheses.
     env = { ...env, additionalKeywords };
-    return renderExpr(arg, env, true, !isSimpleFunctionExpression(arg && arg.xpr, additionalKeywords), true);
+    if (isSimpleFunctionExpression(arg && arg.xpr, additionalKeywords))
+      return exprRenderer.renderExpr(arg, env);
+    return exprRenderer.renderSubExpr(arg, env);
   }
 
   /**
@@ -1575,7 +1577,7 @@ function csnToCdl(csn, options) {
    */
   function renderForeignKey(fKey, env) {
     const alias = fKey.as ? (` as ${fKey.as}`) : '';
-    return renderExpr(fKey, env) + alias;
+    return exprRenderer.renderExpr(fKey, env) + alias;
   }
 
   /**
@@ -1675,100 +1677,67 @@ function csnToCdl(csn, options) {
     return quotePathIfRequired(artifactName);
   }
 
-  /**
-   * Render a function expression.
-   *
-   * @param {object} obj Object with .func and optionally .args
-   * @param {CdlRenderEnvironment} env
-   * @returns {string}
-   */
-  function renderFuncExpr( obj, env ) {
-    if (keywords.cdl_functions.includes(obj.func.toUpperCase()))
-      return obj.func;
-    const name = identifierRegex.test(obj.func) ? obj.func : quote(obj.func);
-    return `${name}(${renderArguments( obj, '=>', env )})`;
-  }
-
-  /**
-   * Render an expression.
-   *
-   * @param {any} expr
-   * @param {CdlRenderEnvironment} exprEnv
-   * @param {boolean} [isInline]
-   * @param {boolean} [isNestedExpr]
-   * @param {boolean} [alwaysRenderCast]
-   * @returns {string}
-   */
-  function renderExpr(expr, exprEnv, isInline, isNestedExpr, alwaysRenderCast) {
-    if (!_renderExpr) {
-      _renderExpr = getExpressionRenderer({
-        finalize(x) {
-          return x;
-        },
-        explicitTypeCast(x, env) {
-          const typeRef = renderTypeReferenceAndProps(x.cast, env, { typeRefOnly: true, noAnnoCollect: true });
-          const arg = { ...x, cast: null }; // "arg" without cast to avoid recursion.
-          return `cast(${renderArgument(arg, env)} as ${typeRef})`;
-        },
-        val(x, env) {
-          // Literal value, possibly with explicit 'literal' property
-          switch (x.literal || typeof x.val) {
-            case 'number':
-            case 'boolean':
-            case 'null':
-              return x.val;
-            case 'x':
-            case 'date':
-            case 'time':
-            case 'timestamp':
-              return `${x.literal}'${x.val}'`;
-            case 'string':
-              return renderString(x.val, env);
-            case 'object':
-              if (x.val === null)
-                return 'null';
+  function createCdlExpressionRenderer() {
+    return createExpressionRenderer({
+      finalize: x => x,
+      typeCast(x) {
+        const typeRef = renderTypeReferenceAndProps(x.cast, this.env, { typeRefOnly: true, noAnnoCollect: true });
+        const arg = { ...x, cast: null }; // "arg" without cast to avoid recursion.
+        return `cast(${renderArgument(arg, this.env)} as ${typeRef})`;
+      },
+      val(x) {
+        // Literal value, possibly with explicit 'literal' property
+        switch (x.literal || typeof x.val) {
+          case 'number':
+          case 'boolean':
+          case 'null':
+            return x.val;
+          case 'x':
+          case 'date':
+          case 'time':
+          case 'timestamp':
+            return `${x.literal}'${x.val}'`;
+          case 'string':
+            return renderString(x.val, this.env);
+          case 'object':
+            if (x.val === null)
+              return 'null';
             // otherwise fall through to
-            default:
-              throw new ModelError(`Unknown literal or type: ${JSON.stringify(x)}`);
-          }
-        },
-        aliasOnly(x, _env) {
-          return x.as;
-        },
-        enum(x) {
-          return `#${x['#']}`;
-        },
-        ref(x, env) {
-          const { inline } = this;
-          return `${(x.param || x.global) ? ':' : ''}${x.ref.map((step, index) => renderPathStep(step, index, inline, env)).join('.')}`;
-        },
-        windowFunction(x, env) {
-          const funcDef = renderFuncExpr(x, env);
-          const windowFunctionOperator = x.xpr.shift(); // OVER ...
-          return `${funcDef} ${windowFunctionOperator} ( ${renderExpr(x.xpr, env, true)} )`;
-        },
-        func(x, env) {
-          return renderFuncExpr(x, env);
-        },
-        xpr(x, env) {
-          if (this.nestedExpr && !x.cast || x.xpr.some(s => s === 'exists'))
-            return `(${renderExpr(x.xpr, env, this.inline, true)})`;
-          return renderExpr(x.xpr, env, this.inline, true);
-        },
-        // Sub-queries in expressions need to be in parentheses, otherwise
-        // left-associativity of UNIONS may result in different results.
-        // For example: `select from E where id in (select from E union select from E);`:
-        // Without parentheses, it would be different query.
-        SET(x, env) {
-          return `(${renderQuery(x, false, 'view', increaseIndent(env))})`;
-        },
-        SELECT(x, env) {
-          return `(${renderQuery(x, false, 'view', increaseIndent(env))})`;
-        },
-      });
-    }
-
-    return _renderExpr(expr, exprEnv, isInline, isNestedExpr, alwaysRenderCast);
+          default:
+            throw new ModelError(`Unknown literal or type: ${JSON.stringify(x)}`);
+        }
+      },
+      aliasOnly: x => x.as,
+      enum: x => `#${x['#']}`,
+      ref(x) {
+        return `${(x.param || x.global) ? ':' : ''}${x.ref.map((step, index) => renderPathStep(step, index, this.env)).join('.')}`;
+      },
+      windowFunction(x) {
+        const funcDef = this.func(x);
+        return `${funcDef} ${this.renderExpr(x.xpr)}`; // xpr[0] is 'over'
+      },
+      func(x) {
+        if (keywords.cdl_functions.includes(x.func.toUpperCase()))
+          return x.func;
+        const name = identifierRegex.test(x.func) ? x.func : quote(x.func);
+        return `${name}(${renderArguments( x, '=>', this.env )})`;
+      },
+      xpr(x) {
+        if (this.isNestedXpr && !x.cast || x.xpr.some(s => s === 'exists'))
+          return `(${this.renderExpr(x.xpr)})`;
+        return this.renderExpr(x.xpr);
+      },
+      // Sub-queries in expressions need to be in parentheses, otherwise
+      // left-associativity of UNIONS may result in different results.
+      // For example: `select from E where id in (select from E union select from E);`:
+      // Without parentheses, it would be different query.
+      SET(x) {
+        return `(${renderQuery(x, false, 'view', increaseIndent(this.env))})`;
+      },
+      SELECT(x) {
+        return `(${renderQuery(x, false, 'view', increaseIndent(this.env))})`;
+      },
+    });
   }
 }
 
@@ -1887,16 +1856,16 @@ function requiresQuotingForCdl(id, additionalKeywords) {
 
 const functionExpressionOperatorsRequireParentheses = [
   // Antlr rule 'condition', 'conditionAnd'
-  'and', 'or',
+  'AND', 'OR',
 
   // Antlr rule 'conditionTerm'
   '=', '<>', '>', '>=', '<', '<=', '!=',
   // These are not forbidden, since they must be preceded by one of the comparators above.
   // 'any', 'some', 'all',
 
-  'is', 'in', 'not', 'null', 'exists',
+  'IS', 'IN', 'NOT', 'NULL', 'EXISTS',
   // Antlr rule 'predicate'
-  'between', 'like', 'escape',
+  'BETWEEN', 'LIKE', 'ESCAPE',
 ];
 
 /**
@@ -1923,8 +1892,8 @@ const functionExpressionOperatorsRequireParentheses = [
  */
 function isSimpleFunctionExpression(xpr, additionalAllowedKeywords = []) {
   return !xpr || xpr.every(val => typeof val !== 'string' ||
-      (additionalAllowedKeywords.includes(val) ||
-        !functionExpressionOperatorsRequireParentheses.includes(val.toLowerCase())));
+      (additionalAllowedKeywords.includes(val.toUpperCase()) ||
+        !functionExpressionOperatorsRequireParentheses.includes(val.toUpperCase())));
 }
 
 /**