knex 3.2.3 → 3.2.5

package/lib/dialects/sqlite3/schema/internal/parser.js

@@ -1,638 +1,638 @@
-const { tokenize } = require('./tokenizer');
-const { s, a, m, o, l, n, t, e, f } = require('./parser-combinator');
-
-const TOKENS = {
-  keyword:
-    /(?:ABORT|ACTION|ADD|AFTER|ALL|ALTER|ALWAYS|ANALYZE|AND|AS|ASC|ATTACH|AUTOINCREMENT|BEFORE|BEGIN|BETWEEN|BY|CASCADE|CASE|CAST|CHECK|COLLATE|COLUMN|COMMIT|CONFLICT|CONSTRAINT|CREATE|CROSS|CURRENT|CURRENT_DATE|CURRENT_TIME|CURRENT_TIMESTAMP|DATABASE|DEFAULT|DEFERRED|DEFERRABLE|DELETE|DESC|DETACH|DISTINCT|DO|DROP|END|EACH|ELSE|ESCAPE|EXCEPT|EXCLUSIVE|EXCLUDE|EXISTS|EXPLAIN|FAIL|FILTER|FIRST|FOLLOWING|FOR|FOREIGN|FROM|FULL|GENERATED|GLOB|GROUP|GROUPS|HAVING|IF|IGNORE|IMMEDIATE|IN|INDEX|INDEXED|INITIALLY|INNER|INSERT|INSTEAD|INTERSECT|INTO|IS|ISNULL|JOIN|KEY|LAST|LEFT|LIKE|LIMIT|MATCH|MATERIALIZED|NATURAL|NO|NOT|NOTHING|NOTNULL|NULL|NULLS|OF|OFFSET|ON|OR|ORDER|OTHERS|OUTER|OVER|PARTITION|PLAN|PRAGMA|PRECEDING|PRIMARY|QUERY|RAISE|RANGE|RECURSIVE|REFERENCES|REGEXP|REINDEX|RELEASE|RENAME|REPLACE|RESTRICT|RETURNING|RIGHT|ROLLBACK|ROW|ROWS|SAVEPOINT|SELECT|SET|TABLE|TEMP|TEMPORARY|THEN|TIES|TO|TRANSACTION|TRIGGER|UNBOUNDED|UNION|UNIQUE|UPDATE|USING|VACUUM|VALUES|VIEW|VIRTUAL|WHEN|WHERE|WINDOW|WITH|WITHOUT)(?=\s+|-|\(|\)|;|\+|\*|\/|%|==|=|<=|<>|<<|<|>=|>>|>|!=|,|&|~|\|\||\||\.)/,
-  id: /"[^"]*(?:""[^"]*)*"|`[^`]*(?:``[^`]*)*`|\[[^[\]]*\]|[a-z_][a-z0-9_$]*/,
-  string: /'[^']*(?:''[^']*)*'/,
-  blob: /x'(?:[0-9a-f][0-9a-f])+'/,
-  numeric: /(?:\d+(?:\.\d*)?|\.\d+)(?:e(?:\+|-)?\d+)?|0x[0-9a-f]+/,
-  variable: /\?\d*|[@$:][a-z0-9_$]+/,
-  operator: /-|\(|\)|;|\+|\*|\/|%|==|=|<=|<>|<<|<|>=|>>|>|!=|,|&|~|\|\||\||\./,
-  _ws: /\s+/,
-};
-
-function parseCreateTable(sql) {
-  const result = createTable({ input: tokenize(sql, TOKENS) });
-
-  if (!result.success) {
-    throw new Error(
-      `Parsing CREATE TABLE failed at [${result.input
-        .slice(result.index)
-        .map((t) => t.text)
-        .join(' ')}] of "${sql}"`
-    );
-  }
-
-  return result.ast;
-}
-
-function parseCreateIndex(sql) {
-  const result = createIndex({ input: tokenize(sql, TOKENS) });
-
-  if (!result.success) {
-    throw new Error(
-      `Parsing CREATE INDEX failed at [${result.input
-        .slice(result.index)
-        .map((t) => t.text)
-        .join(' ')}] of "${sql}"`
-    );
-  }
-
-  return result.ast;
-}
-
-function createTable(ctx) {
-  return s(
-    [
-      t({ text: 'CREATE' }, (v) => null),
-      temporary,
-      t({ text: 'TABLE' }, (v) => null),
-      exists,
-      schema,
-      table,
-      t({ text: '(' }, (v) => null),
-      columnDefinitionList,
-      tableConstraintList,
-      t({ text: ')' }, (v) => null),
-      rowid,
-      f,
-    ],
-    (v) => Object.assign({}, ...v.filter((x) => x !== null))
-  )(ctx);
-}
-
-function temporary(ctx) {
-  return a([t({ text: 'TEMP' }), t({ text: 'TEMPORARY' }), e], (v) => ({
-    temporary: v !== null,
-  }))(ctx);
-}
-
-function rowid(ctx) {
-  return o(s([t({ text: 'WITHOUT' }), t({ text: 'ROWID' })]), (v) => ({
-    rowid: v !== null,
-  }))(ctx);
-}
-
-function columnDefinitionList(ctx) {
-  return a([
-    s([columnDefinition, t({ text: ',' }), columnDefinitionList], (v) => ({
-      columns: [v[0]].concat(v[2].columns),
-    })),
-    s([columnDefinition], (v) => ({ columns: [v[0]] })),
-  ])(ctx);
-}
-
-function columnDefinition(ctx) {
-  return s(
-    [s([identifier], (v) => ({ name: v[0] })), typeName, columnConstraintList],
-    (v) => Object.assign({}, ...v)
-  )(ctx);
-}
-
-function typeName(ctx) {
-  return o(
-    s(
-      [
-        m(t({ type: 'id' })),
-        a([
-          s(
-            [
-              t({ text: '(' }),
-              signedNumber,
-              t({ text: ',' }),
-              signedNumber,
-              t({ text: ')' }),
-            ],
-            (v) => `(${v[1]}, ${v[3]})`
-          ),
-          s(
-            [t({ text: '(' }), signedNumber, t({ text: ')' })],
-            (v) => `(${v[1]})`
-          ),
-          e,
-        ]),
-      ],
-      (v) => `${v[0].join(' ')}${v[1] || ''}`
-    ),
-    (v) => ({ type: v })
-  )(ctx);
-}
-
-function columnConstraintList(ctx) {
-  return o(m(columnConstraint), (v) => ({
-    constraints: Object.assign(
-      {
-        primary: null,
-        notnull: null,
-        null: null,
-        unique: null,
-        check: null,
-        default: null,
-        collate: null,
-        references: null,
-        as: null,
-      },
-      ...(v || [])
-    ),
-  }))(ctx);
-}
-
-function columnConstraint(ctx) {
-  return a([
-    primaryColumnConstraint,
-    notnullColumnConstraint,
-    nullColumnConstraint,
-    uniqueColumnConstraint,
-    checkColumnConstraint,
-    defaultColumnConstraint,
-    collateColumnConstraint,
-    referencesColumnConstraint,
-    asColumnConstraint,
-  ])(ctx);
-}
-
-function primaryColumnConstraint(ctx) {
-  return s(
-    [
-      constraintName,
-      t({ text: 'PRIMARY' }, (v) => null),
-      t({ text: 'KEY' }, (v) => null),
-      order,
-      conflictClause,
-      autoincrement,
-    ],
-    (v) => ({ primary: Object.assign({}, ...v.filter((x) => x !== null)) })
-  )(ctx);
-}
-
-function autoincrement(ctx) {
-  return o(t({ text: 'AUTOINCREMENT' }), (v) => ({
-    autoincrement: v !== null,
-  }))(ctx);
-}
-
-function notnullColumnConstraint(ctx) {
-  return s(
-    [
-      constraintName,
-      t({ text: 'NOT' }, (v) => null),
-      t({ text: 'NULL' }, (v) => null),
-      conflictClause,
-    ],
-    (v) => ({ notnull: Object.assign({}, ...v.filter((x) => x !== null)) })
-  )(ctx);
-}
-
-function nullColumnConstraint(ctx) {
-  return s(
-    [constraintName, t({ text: 'NULL' }, (v) => null), conflictClause],
-    (v) => ({ null: Object.assign({}, ...v.filter((x) => x !== null)) })
-  )(ctx);
-}
-
-function uniqueColumnConstraint(ctx) {
-  return s(
-    [constraintName, t({ text: 'UNIQUE' }, (v) => null), conflictClause],
-    (v) => ({ unique: Object.assign({}, ...v.filter((x) => x !== null)) })
-  )(ctx);
-}
-
-function checkColumnConstraint(ctx) {
-  return s(
-    [
-      constraintName,
-      t({ text: 'CHECK' }, (v) => null),
-      t({ text: '(' }, (v) => null),
-      s([expression], (v) => ({ expression: v[0] })),
-      t({ text: ')' }, (v) => null),
-    ],
-    (v) => ({ check: Object.assign({}, ...v.filter((x) => x !== null)) })
-  )(ctx);
-}
-
-function defaultColumnConstraint(ctx) {
-  return s(
-    [
-      constraintName,
-      t({ text: 'DEFAULT' }, (v) => null),
-      a([
-        s([t({ text: '(' }), expression, t({ text: ')' })], (v) => ({
-          value: v[1],
-          expression: true,
-        })),
-        s([literalValue], (v) => ({ value: v[0], expression: false })),
-        s([signedNumber], (v) => ({ value: v[0], expression: false })),
-      ]),
-    ],
-    (v) => ({ default: Object.assign({}, ...v.filter((x) => x !== null)) })
-  )(ctx);
-}
-
-function collateColumnConstraint(ctx) {
-  return s(
-    [
-      constraintName,
-      t({ text: 'COLLATE' }, (v) => null),
-      t({ type: 'id' }, (v) => ({ collation: v.text })),
-    ],
-    (v) => ({ collate: Object.assign({}, ...v.filter((x) => x !== null)) })
-  )(ctx);
-}
-
-function referencesColumnConstraint(ctx) {
-  return s(
-    [constraintName, s([foreignKeyClause], (v) => v[0].references)],
-    (v) => ({
-      references: Object.assign({}, ...v.filter((x) => x !== null)),
-    })
-  )(ctx);
-}
-
-function asColumnConstraint(ctx) {
-  return s(
-    [
-      constraintName,
-      o(s([t({ text: 'GENERATED' }), t({ text: 'ALWAYS' })]), (v) => ({
-        generated: v !== null,
-      })),
-      t({ text: 'AS' }, (v) => null),
-      t({ text: '(' }, (v) => null),
-      s([expression], (v) => ({ expression: v[0] })),
-      t({ text: ')' }, (v) => null),
-      a([t({ text: 'STORED' }), t({ text: 'VIRTUAL' }), e], (v) => ({
-        mode: v ? v.toUpperCase() : null,
-      })),
-    ],
-    (v) => ({ as: Object.assign({}, ...v.filter((x) => x !== null)) })
-  )(ctx);
-}
-
-function tableConstraintList(ctx) {
-  return o(m(s([t({ text: ',' }), tableConstraint], (v) => v[1])), (v) => ({
-    constraints: v || [],
-  }))(ctx);
-}
-
-function tableConstraint(ctx) {
-  return a([
-    primaryTableConstraint,
-    uniqueTableConstraint,
-    checkTableConstraint,
-    foreignTableConstraint,
-  ])(ctx);
-}
-
-function primaryTableConstraint(ctx) {
-  return s(
-    [
-      constraintName,
-      t({ text: 'PRIMARY' }, (v) => null),
-      t({ text: 'KEY' }, (v) => null),
-      t({ text: '(' }, (v) => null),
-      indexedColumnList,
-      t({ text: ')' }, (v) => null),
-      conflictClause,
-    ],
-    (v) =>
-      Object.assign({ type: 'PRIMARY KEY' }, ...v.filter((x) => x !== null))
-  )(ctx);
-}
-
-function uniqueTableConstraint(ctx) {
-  return s(
-    [
-      constraintName,
-      t({ text: 'UNIQUE' }, (v) => null),
-      t({ text: '(' }, (v) => null),
-      indexedColumnList,
-      t({ text: ')' }, (v) => null),
-      conflictClause,
-    ],
-    (v) => Object.assign({ type: 'UNIQUE' }, ...v.filter((x) => x !== null))
-  )(ctx);
-}
-
-function conflictClause(ctx) {
-  return o(
-    s(
-      [
-        t({ text: 'ON' }),
-        t({ text: 'CONFLICT' }),
-        a([
-          t({ text: 'ROLLBACK' }),
-          t({ text: 'ABORT' }),
-          t({ text: 'FAIL' }),
-          t({ text: 'IGNORE' }),
-          t({ text: 'REPLACE' }),
-        ]),
-      ],
-      (v) => v[2]
-    ),
-    (v) => ({ conflict: v ? v.toUpperCase() : null })
-  )(ctx);
-}
-
-function checkTableConstraint(ctx) {
-  return s(
-    [
-      constraintName,
-      t({ text: 'CHECK' }, (v) => null),
-      t({ text: '(' }, (v) => null),
-      s([expression], (v) => ({ expression: v[0] })),
-      t({ text: ')' }, (v) => null),
-    ],
-    (v) => Object.assign({ type: 'CHECK' }, ...v.filter((x) => x !== null))
-  )(ctx);
-}
-
-function foreignTableConstraint(ctx) {
-  return s(
-    [
-      constraintName,
-      t({ text: 'FOREIGN' }, (v) => null),
-      t({ text: 'KEY' }, (v) => null),
-      t({ text: '(' }, (v) => null),
-      columnNameList,
-      t({ text: ')' }, (v) => null),
-      foreignKeyClause,
-    ],
-    (v) =>
-      Object.assign({ type: 'FOREIGN KEY' }, ...v.filter((x) => x !== null))
-  )(ctx);
-}
-
-function foreignKeyClause(ctx) {
-  return s(
-    [
-      t({ text: 'REFERENCES' }, (v) => null),
-      table,
-      columnNameListOptional,
-      o(m(a([deleteReference, updateReference, matchReference])), (v) =>
-        Object.assign({ delete: null, update: null, match: null }, ...(v || []))
-      ),
-      deferrable,
-    ],
-    (v) => ({ references: Object.assign({}, ...v.filter((x) => x !== null)) })
-  )(ctx);
-}
-
-function columnNameListOptional(ctx) {
-  return o(
-    s([t({ text: '(' }), columnNameList, t({ text: ')' })], (v) => v[1]),
-    (v) => ({ columns: v ? v.columns : [] })
-  )(ctx);
-}
-
-function columnNameList(ctx) {
-  return s(
-    [
-      o(m(s([identifier, t({ text: ',' })], (v) => v[0])), (v) =>
-        v !== null ? v : []
-      ),
-      identifier,
-    ],
-    (v) => ({ columns: v[0].concat([v[1]]) })
-  )(ctx);
-}
-
-function deleteReference(ctx) {
-  return s([t({ text: 'ON' }), t({ text: 'DELETE' }), onAction], (v) => ({
-    delete: v[2],
-  }))(ctx);
-}
-
-function updateReference(ctx) {
-  return s([t({ text: 'ON' }), t({ text: 'UPDATE' }), onAction], (v) => ({
-    update: v[2],
-  }))(ctx);
-}
-
-function matchReference(ctx) {
-  return s(
-    [t({ text: 'MATCH' }), a([t({ type: 'keyword' }), t({ type: 'id' })])],
-    (v) => ({ match: v[1] })
-  )(ctx);
-}
-
-function deferrable(ctx) {
-  return o(
-    s([
-      o(t({ text: 'NOT' })),
-      t({ text: 'DEFERRABLE' }),
-      o(
-        s(
-          [
-            t({ text: 'INITIALLY' }),
-            a([t({ text: 'DEFERRED' }), t({ text: 'IMMEDIATE' })]),
-          ],
-          (v) => v[1].toUpperCase()
-        )
-      ),
-    ]),
-    (v) => ({ deferrable: v ? { not: v[0] !== null, initially: v[2] } : null })
-  )(ctx);
-}
-
-function constraintName(ctx) {
-  return o(
-    s([t({ text: 'CONSTRAINT' }), identifier], (v) => v[1]),
-    (v) => ({ name: v })
-  )(ctx);
-}
-
-function createIndex(ctx) {
-  return s(
-    [
-      t({ text: 'CREATE' }, (v) => null),
-      unique,
-      t({ text: 'INDEX' }, (v) => null),
-      exists,
-      schema,
-      index,
-      t({ text: 'ON' }, (v) => null),
-      table,
-      t({ text: '(' }, (v) => null),
-      indexedColumnList,
-      t({ text: ')' }, (v) => null),
-      where,
-      f,
-    ],
-    (v) => Object.assign({}, ...v.filter((x) => x !== null))
-  )(ctx);
-}
-
-function unique(ctx) {
-  return o(t({ text: 'UNIQUE' }), (v) => ({ unique: v !== null }))(ctx);
-}
-
-function exists(ctx) {
-  return o(
-    s([t({ text: 'IF' }), t({ text: 'NOT' }), t({ text: 'EXISTS' })]),
-    (v) => ({ exists: v !== null })
-  )(ctx);
-}
-
-function schema(ctx) {
-  return o(
-    s([identifier, t({ text: '.' })], (v) => v[0]),
-    (v) => ({ schema: v })
-  )(ctx);
-}
-
-function index(ctx) {
-  return s([identifier], (v) => ({ index: v[0] }))(ctx);
-}
-
-function table(ctx) {
-  return s([identifier], (v) => ({ table: v[0] }))(ctx);
-}
-
-function where(ctx) {
-  return o(
-    s([t({ text: 'WHERE' }), expression], (v) => v[1]),
-    (v) => ({ where: v })
-  )(ctx);
-}
-
-function indexedColumnList(ctx) {
-  return a([
-    s([indexedColumn, t({ text: ',' }), indexedColumnList], (v) => ({
-      columns: [v[0]].concat(v[2].columns),
-    })),
-    s([indexedColumnExpression, t({ text: ',' }), indexedColumnList], (v) => ({
-      columns: [v[0]].concat(v[2].columns),
-    })),
-    l({ do: indexedColumn, next: t({ text: ')' }) }, (v) => ({
-      columns: [v],
-    })),
-    l({ do: indexedColumnExpression, next: t({ text: ')' }) }, (v) => ({
-      columns: [v],
-    })),
-  ])(ctx);
-}
-
-function indexedColumn(ctx) {
-  return s(
-    [
-      s([identifier], (v) => ({ name: v[0], expression: false })),
-      collation,
-      order,
-    ],
-    (v) => Object.assign({}, ...v.filter((x) => x !== null))
-  )(ctx);
-}
-
-function indexedColumnExpression(ctx) {
-  return s(
-    [
-      s([indexedExpression], (v) => ({ name: v[0], expression: true })),
-      collation,
-      order,
-    ],
-    (v) => Object.assign({}, ...v.filter((x) => x !== null))
-  )(ctx);
-}
-
-function collation(ctx) {
-  return o(
-    s([t({ text: 'COLLATE' }), t({ type: 'id' })], (v) => v[1]),
-    (v) => ({ collation: v })
-  )(ctx);
-}
-
-function order(ctx) {
-  return a([t({ text: 'ASC' }), t({ text: 'DESC' }), e], (v) => ({
-    order: v ? v.toUpperCase() : null,
-  }))(ctx);
-}
-
-function indexedExpression(ctx) {
-  return m(
-    a([
-      n({
-        do: t({ type: 'keyword' }),
-        not: a([
-          t({ text: 'COLLATE' }),
-          t({ text: 'ASC' }),
-          t({ text: 'DESC' }),
-        ]),
-      }),
-      t({ type: 'id' }),
-      t({ type: 'string' }),
-      t({ type: 'blob' }),
-      t({ type: 'numeric' }),
-      t({ type: 'variable' }),
-      n({
-        do: t({ type: 'operator' }),
-        not: a([t({ text: '(' }), t({ text: ')' }), t({ text: ',' })]),
-      }),
-      s([t({ text: '(' }), o(expression), t({ text: ')' })], (v) => v[1] || []),
-    ])
-  )(ctx);
-}
-
-function expression(ctx) {
-  return m(
-    a([
-      t({ type: 'keyword' }),
-      t({ type: 'id' }),
-      t({ type: 'string' }),
-      t({ type: 'blob' }),
-      t({ type: 'numeric' }),
-      t({ type: 'variable' }),
-      n({
-        do: t({ type: 'operator' }),
-        not: a([t({ text: '(' }), t({ text: ')' })]),
-      }),
-      s([t({ text: '(' }), o(expression), t({ text: ')' })], (v) => v[1] || []),
-    ])
-  )(ctx);
-}
-
-function identifier(ctx) {
-  return a([t({ type: 'id' }), t({ type: 'string' })], (v) =>
-    /^["`['][^]*["`\]']$/.test(v) ? v.substring(1, v.length - 1) : v
-  )(ctx);
-}
-
-function onAction(ctx) {
-  return a(
-    [
-      s([t({ text: 'SET' }), t({ text: 'NULL' })], (v) => `${v[0]} ${v[1]}`),
-      s([t({ text: 'SET' }), t({ text: 'DEFAULT' })], (v) => `${v[0]} ${v[1]}`),
-      t({ text: 'CASCADE' }),
-      t({ text: 'RESTRICT' }),
-      s([t({ text: 'NO' }), t({ text: 'ACTION' })], (v) => `${v[0]} ${v[1]}`),
-    ],
-    (v) => v.toUpperCase()
-  )(ctx);
-}
-
-function literalValue(ctx) {
-  return a([
-    t({ type: 'numeric' }),
-    t({ type: 'string' }),
-    t({ type: 'id' }),
-    t({ type: 'blob' }),
-    t({ text: 'NULL' }),
-    t({ text: 'TRUE' }),
-    t({ text: 'FALSE' }),
-    t({ text: 'CURRENT_TIME' }),
-    t({ text: 'CURRENT_DATE' }),
-    t({ text: 'CURRENT_TIMESTAMP' }),
-  ])(ctx);
-}
-
-function signedNumber(ctx) {
-  return s(
-    [a([t({ text: '+' }), t({ text: '-' }), e]), t({ type: 'numeric' })],
-    (v) => `${v[0] || ''}${v[1]}`
-  )(ctx);
-}
-
-module.exports = {
-  parseCreateTable,
-  parseCreateIndex,
-};
+const { tokenize } = require('./tokenizer');
+const { s, a, m, o, l, n, t, e, f } = require('./parser-combinator');
+
+const TOKENS = {
+  keyword:
+    /(?:ABORT|ACTION|ADD|AFTER|ALL|ALTER|ALWAYS|ANALYZE|AND|AS|ASC|ATTACH|AUTOINCREMENT|BEFORE|BEGIN|BETWEEN|BY|CASCADE|CASE|CAST|CHECK|COLLATE|COLUMN|COMMIT|CONFLICT|CONSTRAINT|CREATE|CROSS|CURRENT|CURRENT_DATE|CURRENT_TIME|CURRENT_TIMESTAMP|DATABASE|DEFAULT|DEFERRED|DEFERRABLE|DELETE|DESC|DETACH|DISTINCT|DO|DROP|END|EACH|ELSE|ESCAPE|EXCEPT|EXCLUSIVE|EXCLUDE|EXISTS|EXPLAIN|FAIL|FILTER|FIRST|FOLLOWING|FOR|FOREIGN|FROM|FULL|GENERATED|GLOB|GROUP|GROUPS|HAVING|IF|IGNORE|IMMEDIATE|IN|INDEX|INDEXED|INITIALLY|INNER|INSERT|INSTEAD|INTERSECT|INTO|IS|ISNULL|JOIN|KEY|LAST|LEFT|LIKE|LIMIT|MATCH|MATERIALIZED|NATURAL|NO|NOT|NOTHING|NOTNULL|NULL|NULLS|OF|OFFSET|ON|OR|ORDER|OTHERS|OUTER|OVER|PARTITION|PLAN|PRAGMA|PRECEDING|PRIMARY|QUERY|RAISE|RANGE|RECURSIVE|REFERENCES|REGEXP|REINDEX|RELEASE|RENAME|REPLACE|RESTRICT|RETURNING|RIGHT|ROLLBACK|ROW|ROWS|SAVEPOINT|SELECT|SET|TABLE|TEMP|TEMPORARY|THEN|TIES|TO|TRANSACTION|TRIGGER|UNBOUNDED|UNION|UNIQUE|UPDATE|USING|VACUUM|VALUES|VIEW|VIRTUAL|WHEN|WHERE|WINDOW|WITH|WITHOUT)(?=\s+|-|\(|\)|;|\+|\*|\/|%|==|=|<=|<>|<<|<|>=|>>|>|!=|,|&|~|\|\||\||\.)/,
+  id: /"[^"]*(?:""[^"]*)*"|`[^`]*(?:``[^`]*)*`|\[[^[\]]*\]|[a-z_][a-z0-9_$]*/,
+  string: /'[^']*(?:''[^']*)*'/,
+  blob: /x'(?:[0-9a-f][0-9a-f])+'/,
+  numeric: /(?:\d+(?:\.\d*)?|\.\d+)(?:e(?:\+|-)?\d+)?|0x[0-9a-f]+/,
+  variable: /\?\d*|[@$:][a-z0-9_$]+/,
+  operator: /-|\(|\)|;|\+|\*|\/|%|==|=|<=|<>|<<|<|>=|>>|>|!=|,|&|~|\|\||\||\./,
+  _ws: /\s+/,
+};
+
+function parseCreateTable(sql) {
+  const result = createTable({ input: tokenize(sql, TOKENS) });
+
+  if (!result.success) {
+    throw new Error(
+      `Parsing CREATE TABLE failed at [${result.input
+        .slice(result.index)
+        .map((t) => t.text)
+        .join(' ')}] of "${sql}"`
+    );
+  }
+
+  return result.ast;
+}
+
+function parseCreateIndex(sql) {
+  const result = createIndex({ input: tokenize(sql, TOKENS) });
+
+  if (!result.success) {
+    throw new Error(
+      `Parsing CREATE INDEX failed at [${result.input
+        .slice(result.index)
+        .map((t) => t.text)
+        .join(' ')}] of "${sql}"`
+    );
+  }
+
+  return result.ast;
+}
+
+function createTable(ctx) {
+  return s(
+    [
+      t({ text: 'CREATE' }, (v) => null),
+      temporary,
+      t({ text: 'TABLE' }, (v) => null),
+      exists,
+      schema,
+      table,
+      t({ text: '(' }, (v) => null),
+      columnDefinitionList,
+      tableConstraintList,
+      t({ text: ')' }, (v) => null),
+      rowid,
+      f,
+    ],
+    (v) => Object.assign({}, ...v.filter((x) => x !== null))
+  )(ctx);
+}
+
+function temporary(ctx) {
+  return a([t({ text: 'TEMP' }), t({ text: 'TEMPORARY' }), e], (v) => ({
+    temporary: v !== null,
+  }))(ctx);
+}
+
+function rowid(ctx) {
+  return o(s([t({ text: 'WITHOUT' }), t({ text: 'ROWID' })]), (v) => ({
+    rowid: v !== null,
+  }))(ctx);
+}
+
+function columnDefinitionList(ctx) {
+  return a([
+    s([columnDefinition, t({ text: ',' }), columnDefinitionList], (v) => ({
+      columns: [v[0]].concat(v[2].columns),
+    })),
+    s([columnDefinition], (v) => ({ columns: [v[0]] })),
+  ])(ctx);
+}
+
+function columnDefinition(ctx) {
+  return s(
+    [s([identifier], (v) => ({ name: v[0] })), typeName, columnConstraintList],
+    (v) => Object.assign({}, ...v)
+  )(ctx);
+}
+
+function typeName(ctx) {
+  return o(
+    s(
+      [
+        m(t({ type: 'id' })),
+        a([
+          s(
+            [
+              t({ text: '(' }),
+              signedNumber,
+              t({ text: ',' }),
+              signedNumber,
+              t({ text: ')' }),
+            ],
+            (v) => `(${v[1]}, ${v[3]})`
+          ),
+          s(
+            [t({ text: '(' }), signedNumber, t({ text: ')' })],
+            (v) => `(${v[1]})`
+          ),
+          e,
+        ]),
+      ],
+      (v) => `${v[0].join(' ')}${v[1] || ''}`
+    ),
+    (v) => ({ type: v })
+  )(ctx);
+}
+
+function columnConstraintList(ctx) {
+  return o(m(columnConstraint), (v) => ({
+    constraints: Object.assign(
+      {
+        primary: null,
+        notnull: null,
+        null: null,
+        unique: null,
+        check: null,
+        default: null,
+        collate: null,
+        references: null,
+        as: null,
+      },
+      ...(v || [])
+    ),
+  }))(ctx);
+}
+
+function columnConstraint(ctx) {
+  return a([
+    primaryColumnConstraint,
+    notnullColumnConstraint,
+    nullColumnConstraint,
+    uniqueColumnConstraint,
+    checkColumnConstraint,
+    defaultColumnConstraint,
+    collateColumnConstraint,
+    referencesColumnConstraint,
+    asColumnConstraint,
+  ])(ctx);
+}
+
+function primaryColumnConstraint(ctx) {
+  return s(
+    [
+      constraintName,
+      t({ text: 'PRIMARY' }, (v) => null),
+      t({ text: 'KEY' }, (v) => null),
+      order,
+      conflictClause,
+      autoincrement,
+    ],
+    (v) => ({ primary: Object.assign({}, ...v.filter((x) => x !== null)) })
+  )(ctx);
+}
+
+function autoincrement(ctx) {
+  return o(t({ text: 'AUTOINCREMENT' }), (v) => ({
+    autoincrement: v !== null,
+  }))(ctx);
+}
+
+function notnullColumnConstraint(ctx) {
+  return s(
+    [
+      constraintName,
+      t({ text: 'NOT' }, (v) => null),
+      t({ text: 'NULL' }, (v) => null),
+      conflictClause,
+    ],
+    (v) => ({ notnull: Object.assign({}, ...v.filter((x) => x !== null)) })
+  )(ctx);
+}
+
+function nullColumnConstraint(ctx) {
+  return s(
+    [constraintName, t({ text: 'NULL' }, (v) => null), conflictClause],
+    (v) => ({ null: Object.assign({}, ...v.filter((x) => x !== null)) })
+  )(ctx);
+}
+
+function uniqueColumnConstraint(ctx) {
+  return s(
+    [constraintName, t({ text: 'UNIQUE' }, (v) => null), conflictClause],
+    (v) => ({ unique: Object.assign({}, ...v.filter((x) => x !== null)) })
+  )(ctx);
+}
+
+function checkColumnConstraint(ctx) {
+  return s(
+    [
+      constraintName,
+      t({ text: 'CHECK' }, (v) => null),
+      t({ text: '(' }, (v) => null),
+      s([expression], (v) => ({ expression: v[0] })),
+      t({ text: ')' }, (v) => null),
+    ],
+    (v) => ({ check: Object.assign({}, ...v.filter((x) => x !== null)) })
+  )(ctx);
+}
+
+function defaultColumnConstraint(ctx) {
+  return s(
+    [
+      constraintName,
+      t({ text: 'DEFAULT' }, (v) => null),
+      a([
+        s([t({ text: '(' }), expression, t({ text: ')' })], (v) => ({
+          value: v[1],
+          expression: true,
+        })),
+        s([literalValue], (v) => ({ value: v[0], expression: false })),
+        s([signedNumber], (v) => ({ value: v[0], expression: false })),
+      ]),
+    ],
+    (v) => ({ default: Object.assign({}, ...v.filter((x) => x !== null)) })
+  )(ctx);
+}
+
+function collateColumnConstraint(ctx) {
+  return s(
+    [
+      constraintName,
+      t({ text: 'COLLATE' }, (v) => null),
+      t({ type: 'id' }, (v) => ({ collation: v.text })),
+    ],
+    (v) => ({ collate: Object.assign({}, ...v.filter((x) => x !== null)) })
+  )(ctx);
+}
+
+function referencesColumnConstraint(ctx) {
+  return s(
+    [constraintName, s([foreignKeyClause], (v) => v[0].references)],
+    (v) => ({
+      references: Object.assign({}, ...v.filter((x) => x !== null)),
+    })
+  )(ctx);
+}
+
+function asColumnConstraint(ctx) {
+  return s(
+    [
+      constraintName,
+      o(s([t({ text: 'GENERATED' }), t({ text: 'ALWAYS' })]), (v) => ({
+        generated: v !== null,
+      })),
+      t({ text: 'AS' }, (v) => null),
+      t({ text: '(' }, (v) => null),
+      s([expression], (v) => ({ expression: v[0] })),
+      t({ text: ')' }, (v) => null),
+      a([t({ text: 'STORED' }), t({ text: 'VIRTUAL' }), e], (v) => ({
+        mode: v ? v.toUpperCase() : null,
+      })),
+    ],
+    (v) => ({ as: Object.assign({}, ...v.filter((x) => x !== null)) })
+  )(ctx);
+}
+
+function tableConstraintList(ctx) {
+  return o(m(s([t({ text: ',' }), tableConstraint], (v) => v[1])), (v) => ({
+    constraints: v || [],
+  }))(ctx);
+}
+
+function tableConstraint(ctx) {
+  return a([
+    primaryTableConstraint,
+    uniqueTableConstraint,
+    checkTableConstraint,
+    foreignTableConstraint,
+  ])(ctx);
+}
+
+function primaryTableConstraint(ctx) {
+  return s(
+    [
+      constraintName,
+      t({ text: 'PRIMARY' }, (v) => null),
+      t({ text: 'KEY' }, (v) => null),
+      t({ text: '(' }, (v) => null),
+      indexedColumnList,
+      t({ text: ')' }, (v) => null),
+      conflictClause,
+    ],
+    (v) =>
+      Object.assign({ type: 'PRIMARY KEY' }, ...v.filter((x) => x !== null))
+  )(ctx);
+}
+
+function uniqueTableConstraint(ctx) {
+  return s(
+    [
+      constraintName,
+      t({ text: 'UNIQUE' }, (v) => null),
+      t({ text: '(' }, (v) => null),
+      indexedColumnList,
+      t({ text: ')' }, (v) => null),
+      conflictClause,
+    ],
+    (v) => Object.assign({ type: 'UNIQUE' }, ...v.filter((x) => x !== null))
+  )(ctx);
+}
+
+function conflictClause(ctx) {
+  return o(
+    s(
+      [
+        t({ text: 'ON' }),
+        t({ text: 'CONFLICT' }),
+        a([
+          t({ text: 'ROLLBACK' }),
+          t({ text: 'ABORT' }),
+          t({ text: 'FAIL' }),
+          t({ text: 'IGNORE' }),
+          t({ text: 'REPLACE' }),
+        ]),
+      ],
+      (v) => v[2]
+    ),
+    (v) => ({ conflict: v ? v.toUpperCase() : null })
+  )(ctx);
+}
+
+function checkTableConstraint(ctx) {
+  return s(
+    [
+      constraintName,
+      t({ text: 'CHECK' }, (v) => null),
+      t({ text: '(' }, (v) => null),
+      s([expression], (v) => ({ expression: v[0] })),
+      t({ text: ')' }, (v) => null),
+    ],
+    (v) => Object.assign({ type: 'CHECK' }, ...v.filter((x) => x !== null))
+  )(ctx);
+}
+
+function foreignTableConstraint(ctx) {
+  return s(
+    [
+      constraintName,
+      t({ text: 'FOREIGN' }, (v) => null),
+      t({ text: 'KEY' }, (v) => null),
+      t({ text: '(' }, (v) => null),
+      columnNameList,
+      t({ text: ')' }, (v) => null),
+      foreignKeyClause,
+    ],
+    (v) =>
+      Object.assign({ type: 'FOREIGN KEY' }, ...v.filter((x) => x !== null))
+  )(ctx);
+}
+
+function foreignKeyClause(ctx) {
+  return s(
+    [
+      t({ text: 'REFERENCES' }, (v) => null),
+      table,
+      columnNameListOptional,
+      o(m(a([deleteReference, updateReference, matchReference])), (v) =>
+        Object.assign({ delete: null, update: null, match: null }, ...(v || []))
+      ),
+      deferrable,
+    ],
+    (v) => ({ references: Object.assign({}, ...v.filter((x) => x !== null)) })
+  )(ctx);
+}
+
+function columnNameListOptional(ctx) {
+  return o(
+    s([t({ text: '(' }), columnNameList, t({ text: ')' })], (v) => v[1]),
+    (v) => ({ columns: v ? v.columns : [] })
+  )(ctx);
+}
+
+function columnNameList(ctx) {
+  return s(
+    [
+      o(m(s([identifier, t({ text: ',' })], (v) => v[0])), (v) =>
+        v !== null ? v : []
+      ),
+      identifier,
+    ],
+    (v) => ({ columns: v[0].concat([v[1]]) })
+  )(ctx);
+}
+
+function deleteReference(ctx) {
+  return s([t({ text: 'ON' }), t({ text: 'DELETE' }), onAction], (v) => ({
+    delete: v[2],
+  }))(ctx);
+}
+
+function updateReference(ctx) {
+  return s([t({ text: 'ON' }), t({ text: 'UPDATE' }), onAction], (v) => ({
+    update: v[2],
+  }))(ctx);
+}
+
+function matchReference(ctx) {
+  return s(
+    [t({ text: 'MATCH' }), a([t({ type: 'keyword' }), t({ type: 'id' })])],
+    (v) => ({ match: v[1] })
+  )(ctx);
+}
+
+function deferrable(ctx) {
+  return o(
+    s([
+      o(t({ text: 'NOT' })),
+      t({ text: 'DEFERRABLE' }),
+      o(
+        s(
+          [
+            t({ text: 'INITIALLY' }),
+            a([t({ text: 'DEFERRED' }), t({ text: 'IMMEDIATE' })]),
+          ],
+          (v) => v[1].toUpperCase()
+        )
+      ),
+    ]),
+    (v) => ({ deferrable: v ? { not: v[0] !== null, initially: v[2] } : null })
+  )(ctx);
+}
+
+function constraintName(ctx) {
+  return o(
+    s([t({ text: 'CONSTRAINT' }), identifier], (v) => v[1]),
+    (v) => ({ name: v })
+  )(ctx);
+}
+
+function createIndex(ctx) {
+  return s(
+    [
+      t({ text: 'CREATE' }, (v) => null),
+      unique,
+      t({ text: 'INDEX' }, (v) => null),
+      exists,
+      schema,
+      index,
+      t({ text: 'ON' }, (v) => null),
+      table,
+      t({ text: '(' }, (v) => null),
+      indexedColumnList,
+      t({ text: ')' }, (v) => null),
+      where,
+      f,
+    ],
+    (v) => Object.assign({}, ...v.filter((x) => x !== null))
+  )(ctx);
+}
+
+function unique(ctx) {
+  return o(t({ text: 'UNIQUE' }), (v) => ({ unique: v !== null }))(ctx);
+}
+
+function exists(ctx) {
+  return o(
+    s([t({ text: 'IF' }), t({ text: 'NOT' }), t({ text: 'EXISTS' })]),
+    (v) => ({ exists: v !== null })
+  )(ctx);
+}
+
+function schema(ctx) {
+  return o(
+    s([identifier, t({ text: '.' })], (v) => v[0]),
+    (v) => ({ schema: v })
+  )(ctx);
+}
+
+function index(ctx) {
+  return s([identifier], (v) => ({ index: v[0] }))(ctx);
+}
+
+function table(ctx) {
+  return s([identifier], (v) => ({ table: v[0] }))(ctx);
+}
+
+function where(ctx) {
+  return o(
+    s([t({ text: 'WHERE' }), expression], (v) => v[1]),
+    (v) => ({ where: v })
+  )(ctx);
+}
+
+function indexedColumnList(ctx) {
+  return a([
+    s([indexedColumn, t({ text: ',' }), indexedColumnList], (v) => ({
+      columns: [v[0]].concat(v[2].columns),
+    })),
+    s([indexedColumnExpression, t({ text: ',' }), indexedColumnList], (v) => ({
+      columns: [v[0]].concat(v[2].columns),
+    })),
+    l({ do: indexedColumn, next: t({ text: ')' }) }, (v) => ({
+      columns: [v],
+    })),
+    l({ do: indexedColumnExpression, next: t({ text: ')' }) }, (v) => ({
+      columns: [v],
+    })),
+  ])(ctx);
+}
+
+function indexedColumn(ctx) {
+  return s(
+    [
+      s([identifier], (v) => ({ name: v[0], expression: false })),
+      collation,
+      order,
+    ],
+    (v) => Object.assign({}, ...v.filter((x) => x !== null))
+  )(ctx);
+}
+
+function indexedColumnExpression(ctx) {
+  return s(
+    [
+      s([indexedExpression], (v) => ({ name: v[0], expression: true })),
+      collation,
+      order,
+    ],
+    (v) => Object.assign({}, ...v.filter((x) => x !== null))
+  )(ctx);
+}
+
+function collation(ctx) {
+  return o(
+    s([t({ text: 'COLLATE' }), t({ type: 'id' })], (v) => v[1]),
+    (v) => ({ collation: v })
+  )(ctx);
+}
+
+function order(ctx) {
+  return a([t({ text: 'ASC' }), t({ text: 'DESC' }), e], (v) => ({
+    order: v ? v.toUpperCase() : null,
+  }))(ctx);
+}
+
+function indexedExpression(ctx) {
+  return m(
+    a([
+      n({
+        do: t({ type: 'keyword' }),
+        not: a([
+          t({ text: 'COLLATE' }),
+          t({ text: 'ASC' }),
+          t({ text: 'DESC' }),
+        ]),
+      }),
+      t({ type: 'id' }),
+      t({ type: 'string' }),
+      t({ type: 'blob' }),
+      t({ type: 'numeric' }),
+      t({ type: 'variable' }),
+      n({
+        do: t({ type: 'operator' }),
+        not: a([t({ text: '(' }), t({ text: ')' }), t({ text: ',' })]),
+      }),
+      s([t({ text: '(' }), o(expression), t({ text: ')' })], (v) => v[1] || []),
+    ])
+  )(ctx);
+}
+
+function expression(ctx) {
+  return m(
+    a([
+      t({ type: 'keyword' }),
+      t({ type: 'id' }),
+      t({ type: 'string' }),
+      t({ type: 'blob' }),
+      t({ type: 'numeric' }),
+      t({ type: 'variable' }),
+      n({
+        do: t({ type: 'operator' }),
+        not: a([t({ text: '(' }), t({ text: ')' })]),
+      }),
+      s([t({ text: '(' }), o(expression), t({ text: ')' })], (v) => v[1] || []),
+    ])
+  )(ctx);
+}
+
+function identifier(ctx) {
+  return a([t({ type: 'id' }), t({ type: 'string' })], (v) =>
+    /^["`['][^]*["`\]']$/.test(v) ? v.substring(1, v.length - 1) : v
+  )(ctx);
+}
+
+function onAction(ctx) {
+  return a(
+    [
+      s([t({ text: 'SET' }), t({ text: 'NULL' })], (v) => `${v[0]} ${v[1]}`),
+      s([t({ text: 'SET' }), t({ text: 'DEFAULT' })], (v) => `${v[0]} ${v[1]}`),
+      t({ text: 'CASCADE' }),
+      t({ text: 'RESTRICT' }),
+      s([t({ text: 'NO' }), t({ text: 'ACTION' })], (v) => `${v[0]} ${v[1]}`),
+    ],
+    (v) => v.toUpperCase()
+  )(ctx);
+}
+
+function literalValue(ctx) {
+  return a([
+    t({ type: 'numeric' }),
+    t({ type: 'string' }),
+    t({ type: 'id' }),
+    t({ type: 'blob' }),
+    t({ text: 'NULL' }),
+    t({ text: 'TRUE' }),
+    t({ text: 'FALSE' }),
+    t({ text: 'CURRENT_TIME' }),
+    t({ text: 'CURRENT_DATE' }),
+    t({ text: 'CURRENT_TIMESTAMP' }),
+  ])(ctx);
+}
+
+function signedNumber(ctx) {
+  return s(
+    [a([t({ text: '+' }), t({ text: '-' }), e]), t({ type: 'numeric' })],
+    (v) => `${v[0] || ''}${v[1]}`
+  )(ctx);
+}
+
+module.exports = {
+  parseCreateTable,
+  parseCreateIndex,
+};