@sap/cds-compiler 3.3.2 → 3.4.0

package/lib/modelCompare/filter.js

@@ -0,0 +1,83 @@
+// 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', 
+    (extend, name, element, error) => {
+      if(isKey(element)) { // Key must not be extended
+        error(null, ['definitions', extend, 'elements', name], {id: name, name: 'sqlite'}, "Added element $(ID) is a primary key change and will not work with $(NAME)")
+      }
+    },
+    (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(null, ['definitions', migrate, 'elements', name], {id: name, name: 'sqlite'}, "Changed element $(ID) is a primary key change and will not work with $(NAME)")
+      } else { // Ignore simple migrations
+        delete change[name];
+      }
+    })
+}
+
+function getFilterObject(dialect, extensionCallback, migrationCallback) {
+  return {
+        // will be called with a simple Array.forEach
+    extension: ({ elements, extend }, error) => {
+      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(null, ['definitions', migrate, 'elements', name], {}, "Dropping elements is not supported")
+      });
+
+      forEach(change, (name, migration) => {
+        if(migration.new.type !== migration.old.type && typeChangeIsNotCompatible(dialect, migration.old.type, migration.new.type)) {
+          error(null, ['definitions', migrate, 'elements', name], { 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(migration.new.length < migration.old.length) {
+          error(null, ['definitions', migrate, 'elements', name], { id: name }, "Changed element $(ID) is a length reduction and is not supported")
+        } else {
+          migrationCallback(migrate, name, migration, change, error);
+        }
+
+        // TODO: precision/scale growth
+      });
+    },
+    deletion: ([artifactName, artifact ], error) => {
+      if(isPersistedAsTable(artifact))
+        error(null, ['definitions', artifactName], "Dropping tables is not supported");
+    }
+  }
+}
+
+const baseMatrix = {
+  // 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': baseMatrix
+};
+
+function typeChangeIsNotCompatible(dialect, before, after) {
+  if(allowedTypeChanges[dialect])
+    return allowedTypeChanges[dialect][before]?.indexOf(after) === -1;
+  return true;
+}

package/lib/optionProcessor.js

@@ -102,6 +102,9 @@ optionProcessor
                               hanaAssocRealCardinality
                               mapAssocToJoinCardinality
                               ignoreAssocPublishingInUnion
+                              enableUniversalCsn
+                              postgres
+                              aspectWithoutElements
                               odataOpenType
                               optionalActionFunctionParameters
        --deprecated <list>  Comma separated list of deprecated options.
@@ -262,7 +265,7 @@ optionProcessor.command('C, toCdl')
 optionProcessor.command('Q, toSql')
   .option('-h, --help')
   .option('-n, --sql-mapping <style>', ['plain', 'quoted', 'hdbcds'], { aliases: [ '--names' ] })
-  .option('-d, --sql-dialect <dialect>',  ['hana', 'sqlite', 'plain', 'postgres'], { aliases: [ '--dialect' ] })
+  .option('-d, --sql-dialect <dialect>',  ['hana', 'sqlite', 'plain', 'postgres', 'h2'], { aliases: [ '--dialect' ] })
   .option('    --render-virtual')
   .option('    --joinfk')
   .option('-u, --user <user>')
@@ -300,6 +303,7 @@ optionProcessor.command('Q, toSql')
                                 hana     : SQL with HANA specific language features
                                 sqlite   : Common SQL for sqlite
                                 postgres : Common SQL for postgres - beta-feature
+                                h2       : Common SQL for h2
    -u, --user <user>          Value for the "$user" variable
    -l, --locale <locale>      Value for the "$user.locale" variable in "sqlite"/"plain" dialect
    -s, --src <style>          Generate SQL source files as <artifact>.<suffix>

package/lib/render/manageConstraints.js

@@ -40,8 +40,10 @@ function alterConstraintsWithCsn(csn, options) {
   const transformedOptions = _transformSqlOptions(csn, options);
   const forSqlCsn = transformForRelationalDBWithCsn(csn, transformedOptions, 'to.sql');
 
-  if (violations && src && src !== 'sql')
-    error(null, null, `Option “--violations“ can't be combined with source style “${src}“`);
+  if (violations && src && src !== 'sql') {
+    error(null, null, { value: '--violations', othervalue: src },
+          'Option $(VALUE) can\'t be combined with source style $(OTHERVALUE)');
+  }
 
   let intermediateResult;
   if (violations)
@@ -67,12 +69,14 @@ function _transformSqlOptions(model, options) {
 
   if (options.sqlDialect !== 'hana') {
     // CDXCORE-465, 'quoted' and 'hdbcds' are to be used in combination with dialect 'hana' only
-    if (options.sqlMapping === 'quoted' || options.sqlMapping === 'hdbcds')
-      error(null, null, `Option "{ sqlDialect: '${options.sqlDialect}' }" can't be combined with "{ sqlMapping: '${options.sqlMapping}' }"`);
+    if (options.sqlMapping === 'quoted' || options.sqlMapping === 'hdbcds') {
+      error(null, null, { value: options.sqlDialect, othervalue: options.sqlMapping },
+            'Option sqlDialect: $(VALUE) can\'t be combined with sqlMapping: $(OTHERVALUE)');
+    }
 
     // No non-HANA SQL for HDI
     if (options.src === 'hdi')
-      error(null, null, `Option "{ sqlDialect: '${options.sqlDialect}' }" can't be used for HDI"`);
+      error(null, null, { value: options.sqlDialect }, 'Option sqlDialect: $(VALUE) can\'t be used for SAP HANA HDI');
   }
 
   return options;

package/lib/render/toCdl.js

@@ -351,13 +351,14 @@ function csnToCdl(csn, options) {
         if (art.query || art.projection)
           return renderView(artifactName, art, env);
         return renderEntity(artifactName, art, env);
+      case 'aspect':
+        return renderAspect(artifactName, art, env);
 
       case 'context':
       case 'service':
         return renderContextOrService(artifactName, art, env);
 
       case 'type':
-      case 'aspect':
       case 'annotation': // annotation in 'csn.definitions' for compiler v1 compatibility
         return renderTypeOrAnnotation(artifactName, art, env);
 
@@ -380,7 +381,6 @@ function csnToCdl(csn, options) {
    */
   function renderEvent(artifactName, art, env) {
     let result = renderAnnotationAssignmentsAndDocComment(art, env);
-    const childEnv = increaseIndent(env);
     const normalizedArtifactName = renderArtifactName(artifactName);
     result += `${env.indent}event ${normalizedArtifactName}`;
     if (art.includes)
@@ -396,11 +396,7 @@ function csnToCdl(csn, options) {
       result += ` : ${renderTypeReferenceAndProps(art, env)};\n`;
     }
     else if (art.elements) {
-      result += ' {\n';
-      for (const name in art.elements)
-        result += renderElement(name, art.elements[name], childEnv);
-
-      result += `${env.indent}}`;
+      result += ` ${renderElements(art, env)};\n`;
     }
     return result;
   }
@@ -432,21 +428,57 @@ function csnToCdl(csn, options) {
 
     if (art.params)
       result += renderParameters(art, env);
+    if (art.includes)
+      result += renderIncludes(art.includes);
+    result += ` ${renderElements(art, env)}`;
+    result += `${renderActionsAndFunctions(art, env)};\n`;
+    return result;
+  }
 
+  /**
+   * Render an aspect. Return the resulting source string.
+   * Behaves very similar to renderEntity, _except_ that aspects are
+   * allowed to _not_ have elements, e.g. `aspect A;`.
+   *
+   * @param {string} artifactName
+   * @param {CSN.Artifact} art
+   * @param {CdlRenderEnvironment} env
+   * @return {string}
+   */
+  function renderAspect(artifactName, art, env) {
+    let result = renderAnnotationAssignmentsAndDocComment(art, env);
+    result += `${env.indent}aspect ${renderArtifactName(artifactName)}`;
     if (art.includes)
       result += renderIncludes(art.includes);
-    result += ' {\n';
-    const childEnv = increaseIndent(env);
-    for (const name in art.elements) {
-      const element = art.elements[name];
-      result += renderElement(name, element, childEnv);
-    }
 
-    result += `${env.indent}}`;
+    if (art.elements)
+      result += ` ${renderElements(art, env)}`;
+    else if (art.actions)
+      // if there are no elements, but actions, CDL syntax requires braces.
+      result += ' { }';
+
     result += `${renderActionsAndFunctions(art, env)};\n`;
     return result;
   }
 
+  /**
+   * Render a list of elements enclosed in braces.  If the list is empty, returns `{ }`.
+   *
+   * @param {object} artifact Artifact with `elements` property.
+   * @param {CdlRenderEnvironment} env
+   * @return {string}
+   */
+  function renderElements(artifact, env) {
+    let elements = '';
+    const childEnv = increaseIndent(env);
+    for (const name in artifact.elements)
+      elements += renderElement(name, artifact.elements[name], childEnv, null);
+
+    if (elements === '')
+      return '{ }';
+    return `{\n${elements}${env.indent}}`;
+  }
+
   /**
    * Render an element (of an entity, type or annotation, not a projection or view).
    * Return the resulting source string.
@@ -651,7 +683,7 @@ function csnToCdl(csn, options) {
 
     // Even the first step might have parameters and/or a filter
     if (path.ref[0].args)
-      result += `(${renderArgs(path.ref[0], ':', env)})`;
+      result += `(${renderArguments(path.ref[0], ':', env)})`;
 
     if (path.ref[0].where) {
       const cardinality = path.ref[0].cardinality ? (`${path.ref[0].cardinality.max}: `) : '';
@@ -841,6 +873,8 @@ function csnToCdl(csn, options) {
       result += renderActionsAndFunctions(art, env);
     result += ';\n';
     result += renderQueryElementAndEnumAnnotations(artifactName, art, env);
+    if (art.includes)
+      result += renderExtension({ extend: artifactName, includes: art.includes }, env);
     return result;
   }
 
@@ -1093,8 +1127,7 @@ function csnToCdl(csn, options) {
       result += ` ${renderTypeReferenceAndProps(art, env)}`;
     else
       result += ` : ${renderTypeReferenceAndProps(art, env)}`;
-    // for aspects, but since types don't have `actions` this does not hurt
-    result += `${renderActionsAndFunctions(art, env)};\n`;
+    result += ';\n';
     return result;
   }
 
@@ -1130,12 +1163,7 @@ function csnToCdl(csn, options) {
     }
 
     if (!artifact.type && artifact.elements) {
-      result += '{\n';
-      const childEnv = envAddPath(increaseIndent(env), 'items');
-      for (const name in artifact.elements)
-        result += renderElement(name, artifact.elements[name], childEnv, null);
-
-      result += `${env.indent}}`;
+      result += renderElements(artifact, env);
       if (!isTypeDef)
         result += renderNullability(artifact);
       // structured default not possible at the moment
@@ -1159,12 +1187,7 @@ function csnToCdl(csn, options) {
       }
       else if (elements) {
         // anonymous aspect, either parseCdl or client CSN.
-        const childEnv = increaseIndent(env);
-        result += '{\n';
-        for (const name in elements)
-          result += renderElement(name, elements[name], childEnv);
-
-        result += `${env.indent}}`;
+        result += renderElements({ elements }, env);
       }
       else {
         throw new ModelError('Association/Composition is missing its target! Throwing exception to trigger recompilation.');
@@ -1350,6 +1373,8 @@ 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) {
@@ -1357,12 +1382,9 @@ function csnToCdl(csn, options) {
     if (typeof s === 'string') {
       // In first path position, do not quote $projection and magic $-variables like CURRENT_DATE, $now etc.
       // FIXME: We should rather explicitly recognize quoting somehow
-
-      if (idx === 0 &&
-              s.startsWith('$'))
+      if (idx === 0 && s.startsWith('$'))
         return s;
-
-      return quoteIdIfRequired(s);
+      return quoteIdIfRequired(s, env.additionalKeywords);
     }
     // ID with filters or parameters
     else if (typeof s === 'object') {
@@ -1372,13 +1394,13 @@ function csnToCdl(csn, options) {
 
       // Not really a path step but an object-like function call
       if (s.func)
-        return `${s.func}(${renderArgs(s, '=>', env)})`;
+        return `${s.func}(${renderArguments(s, '=>', env)})`;
 
       // Path step, possibly with view parameters and/or filters
-      let result = `${quoteIdIfRequired(s.id)}`;
+      let result = `${quoteIdIfRequired(s.id, env.additionalKeywords)}`;
       if (s.args) {
         // View parameters
-        result += `(${renderArgs(s, ':', env)})`;
+        result += `(${renderArguments(s, ':', env)})`;
       }
       if (s.where) {
         // Filter, possibly with cardinality
@@ -1402,24 +1424,48 @@ function csnToCdl(csn, options) {
    * @param {CdlRenderEnvironment} env
    * @returns {string}
    */
-  function renderArgs(node, sep, env) {
-    const args = node.args || [];
-
-    // Positional arguments
-    if (Array.isArray(args)) {
-      const func = node.func?.toUpperCase();
-      if (func)
-        return args.map((arg, i) => renderArgument(arg, env, getKeywordsForSpecialFunctionArgument(func, i))).join(', ');
+  function renderArguments(node, sep, env) {
+    if (!node.args)
+      return '';
+    else if (Array.isArray(node.args))
+      return renderPositionalArguments(node, env);
+    else if (typeof node.args === 'object')
+      return renderNamedArguments(node, sep, env);
+    throw new ModelError(`Unknown args: ${JSON.stringify(node.args)}; expected array/object`);
+  }
 
-      return args.map(arg => renderArgument(arg, env)).join(', ');
-    }
+  /**
+   * Render named function arguments or view parameters,
+   * using 'sep' as separator.
+   *
+   * @param {object} node with `args` to render
+   * @param {string} separator
+   * @param {CdlRenderEnvironment} env
+   * @returns {string}
+   */
+  function renderNamedArguments(node, separator, env) {
+    return Object.keys(node.args).map(function renderNamedArgument(key) {
+      return `${quoteIdIfRequired(key, env.additionalKeywords)} ${separator} ${renderArgument(node.args[key], env)}`;
+    }).join(', ');
+  }
 
-    // Named arguments (object/dict)
-    else if (typeof args === 'object') {
-      return Object.keys(args).map(key => `${quoteIdIfRequired(key)} ${sep} ${renderArgument(args[key], env)}`).join(', ');
+  /**
+   * Render a comma separated list of positional function arguments.
+   *
+   * @param {object} node with `args` to render
+   * @param {CdlRenderEnvironment} env
+   * @returns {string}
+   */
+  function renderPositionalArguments(node, env) {
+    if (!node.args)
+      return '';
+    const func = node.func?.toUpperCase();
+    if (func) {
+      return node.args.map(function renderFunctionArg(arg, i) {
+        return renderArgument(arg, env, getKeywordsForSpecialFunctionArgument(func, i));
+      }).join(', ');
     }
-
-    throw new ModelError(`Unknown args: ${JSON.stringify(args)}`);
+    return node.args.map(arg => renderArgument(arg, env)).join(', ');
   }
 
   /**
@@ -1428,13 +1474,14 @@ function csnToCdl(csn, options) {
    *
    * @param {any} arg
    * @param {CdlRenderEnvironment} env
-   * @param {string[]} additionalAllowedKeywords
+   * @param {string[]} additionalKeywords
    * @return {string}
    */
-  function renderArgument(arg, env, additionalAllowedKeywords = []) {
+  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.
-    return renderExpr(arg, env, true, !isSimpleFunctionExpression(arg && arg.xpr, additionalAllowedKeywords), true);
+    env = { ...env, additionalKeywords };
+    return renderExpr(arg, env, true, !isSimpleFunctionExpression(arg && arg.xpr, additionalKeywords), true);
   }
 
   /**
@@ -1639,7 +1686,7 @@ function csnToCdl(csn, options) {
     if (keywords.cdl_functions.includes(obj.func.toUpperCase()))
       return obj.func;
     const name = identifierRegex.test(obj.func) ? obj.func : quote(obj.func);
-    return `${name}(${renderArgs( obj, '=>', env )})`;
+    return `${name}(${renderArguments( obj, '=>', env )})`;
   }
 
   /**
@@ -1762,27 +1809,33 @@ function increaseIndent(env) {
  * Quote the path steps with `![]` if necessary. For simple ids such as
  * `elem` use `quoteIdIfRequired` instead.
  *
+ * In contrast to quoteIdIfRequired, does not handle additional keywords,
+ * because it was not required, yet.
+ *
  * @param {string} path
  * @returns {string}
  *
  * @todo For paths such as `E.key`, `key` does not have to be in quotes.
  */
 function quotePathIfRequired(path) {
-  return path.split('.').map(quoteIdIfRequired).join('.');
+  return path.split('.').map(step => quoteIdIfRequired(step)).join('.');
 }
 
 /**
  * Quote the id with `![]` if necessary. For paths such as `E.key` use
  * `quotePathIfRequired` instead.
  *
+ * Set additionalKeywords to an array of UPPERCASE keywords
+ * that also need quoting, e.g. in special functions.
+ *
  * @param {string} id
+ * @param {string[]} [additionalKeywords]
  * @return {string}
  */
-function quoteIdIfRequired(id) {
+function quoteIdIfRequired(id, additionalKeywords) {
   // Quote if required for CDL
-  if (requiresQuotingForCdl(id))
+  if (requiresQuotingForCdl(id, additionalKeywords || []))
     return quote(id);
-
   return id;
 }
 
@@ -1818,13 +1871,18 @@ function quote(id) {
  * does not match the first part of the `Identifier` rule of `language.g4`
  * or if 'id' is a reserved keyword.
  *
+ * Set additionalKeywords to an array of UPPERCASE keywords
+ * that also need quoting, e.g. in special functions.
+ *
  * @param {string} id
+ * @param {string[]} [additionalKeywords]
  * @return {boolean}
  */
-function requiresQuotingForCdl(id) {
+function requiresQuotingForCdl(id, additionalKeywords) {
   return !identifierRegex.test(id) ||
     keywords.cdl.includes(id.toUpperCase()) ||
-    keywords.cdl_functions.includes(id.toUpperCase());
+    keywords.cdl_functions.includes(id.toUpperCase()) ||
+    additionalKeywords.includes(id.toUpperCase());
 }
 
 const functionExpressionOperatorsRequireParentheses = [

package/lib/render/toHdbcds.js

@@ -1258,7 +1258,7 @@ function toHdbcdsSource(csn, options) {
     const funcName = regex.test(x.func) ? x.func : quoteId(x.func);
     // we can't quote functions with parens, issue warning if it is a reserved keyword
     if (!funcWithoutParen(x, 'hana') && keywords.hdbcds.includes(uppercaseAndUnderscore(funcName)))
-      warning(null, x.$location, `The identifier “${uppercaseAndUnderscore(funcName)}“ is a SAP HANA keyword`);
+      warning(null, x.$location, { id: uppercaseAndUnderscore(funcName) }, 'The identifier $(ID) is a SAP HANA keyword');
     return renderFunc(funcName, x, 'hana', a => renderArgs(a, '=>', env));
   }
 

package/lib/render/toSql.js

@@ -157,7 +157,7 @@ function toSqlDdl(csn, options) {
       Render column removals as HANA SQL.
      */
     dropColumns(tableName, sqlIds) {
-      return [ `ALTER TABLE ${tableName} DROP (${sqlIds.join(', ')});` ];
+      return [ `ALTER TABLE ${tableName} DROP ${options.sqlDialect === 'hana' ? '(' : ''}${sqlIds.join(', ')}${options.sqlDialect === 'hana' ? ')' : ''};` ];
     },
     /*
       Render association removals as HANA SQL.
@@ -221,7 +221,7 @@ function toSqlDdl(csn, options) {
   };
 
   // FIXME: Currently requires 'options.forHana', because it can only render HANA-ish SQL dialect
-  if (!options.forHana)
+  if (!options.forHana && !isBetaEnabled(options, 'sqlExtensions'))
     throw new Error('toSql can currently only be used with HANA preprocessing');
 
   checkCSNVersion(csn, options);
@@ -1506,6 +1506,8 @@ function toSqlDdl(csn, options) {
           case 'sqlite':
           case 'hana':
             return 'CURRENT_TIMESTAMP';
+          case 'h2':
+            return 'current_timestamp';
           case 'postgres':
             return '(current_timestamp at time zone \'UTC\')';
           default:
@@ -1572,6 +1574,7 @@ function toSqlDdl(csn, options) {
             return 'TO_TIMESTAMP(SESSION_CONTEXT(\'VALID-FROM\'))';
           case 'postgres':
             return '(to_timestamp(current_setting(\'CAP.VALID_FROM\'), \'YYYY-MM-DD HH24:MI:SS.FF6\') at time zone \'UTC\')';
+          case 'h2':
           case 'plain':
             return 'current_timestamp';
           default:
@@ -1590,6 +1593,7 @@ function toSqlDdl(csn, options) {
             return 'TO_TIMESTAMP(SESSION_CONTEXT(\'VALID-TO\'))';
           case 'postgres':
             return '(to_timestamp(current_setting(\'CAP.VALID_TO\'), \'YYYY-MM-DD HH24:MI:SS.FF6\') at time zone \'UTC\')';
+          case 'h2':
           case 'plain':
             return 'current_timestamp';
           default:

package/lib/render/utils/common.js

@@ -283,6 +283,13 @@ const cdsToSqlTypes = {
     'cds.hana.BINARY': 'BINARY',
     'cds.hana.SMALLDECIMAL': 'DECIMAL',
   },
+  h2: {
+    'cds.Binary': 'VARBINARY', // same as for plain
+    'cds.LargeBinary': 'BINARY LARGE OBJECT', // BLOB would require a length!
+    'cds.DecimalFloat': 'DECFLOAT', // Decimal and Decimal(p) is mapped to cds.DecimalFloat
+    'cds.DateTime': 'TIMESTAMP(0)',
+    'cds.Timestamp': 'TIMESTAMP(7)',
+  },
   postgres: {
     // See <https://www.postgresql.org/docs/current/datatype.html>
     'cds.String': 'VARCHAR',

package/lib/sql-identifier.js

@@ -39,6 +39,13 @@ const keywords = require( './base/keywords' );
 
 const sqlDialects = {
   plain: {},
+  h2: {
+    // See http://www.h2database.com/html/grammar.html#name
+    regularRegex: /^[A-Za-z_][A-Za-z_0-9]*$/,
+    reservedWords: keywords.h2,
+    effectiveName: name => name.toUpperCase(),
+    asDelimitedId: name => `"${ name.replace(/"/g, '""')}"`,
+  },
   sqlite: {
     regularRegex: /^[A-Za-z_][A-Za-z_$0-9]*$/,
     reservedWords: keywords.sqlite,