@portll/cobolwork 0.5.0 → 0.7.0

package/lib/db2/stmt/index.mjs

@@ -0,0 +1,141 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Db2 for z/OS CREATE INDEX, after the Db2 13 SQL Reference: the key, the index's clauses (each at
+// most once), its partitions, and the XML index specification.
+
+import { cursor } from '../cursor.mjs';
+import { readName, readInteger, readNumber, readSize, readNameList, only, readDataType } from './table.mjs';
+
+const ORDERS = ['ASC', 'DESC', 'RANDOM'];
+
+// Each key part is a column or a key expression, optionally ordered, or the BUSINESS_TIME period.
+function readKey(c) {
+  return c.items().map((item) => {
+    const s = cursor(item);
+    if (s.isWord('BUSINESS_TIME') && s.isWord(['WITH', 'WITHOUT'], 1)) {
+      s.next();
+      const overlaps = s.next().u === 'WITH';
+      s.expectWord('OVERLAPS');
+      if (!s.done()) s.fail("',' or ')'");
+      return { period: 'BUSINESS_TIME', overlaps };
+    }
+    const last = item[item.length - 1];
+    const ordered = item.length > 1 && last.t === 'word' && ORDERS.includes(last.u);
+    const order = ordered ? last.u : 'ASC';
+    const body = ordered ? item.slice(0, -1) : item;
+    if (!body.length) s.fail('a column or key expression');
+    const b = cursor(body);
+    const column = readName(b);
+    return b.done() ? { column: column.join('.'), order } : { expression: body, order };
+  });
+}
+
+export function readUsing(c) {
+  c.expectWord('USING');
+  if (c.word('VCAT')) return { vcat: readName(c).join('.') };
+  c.expectWord('STOGROUP');
+  const using = { stogroup: readName(c).join('.') };
+  for (;;) {
+    const key = c.isWord('PRIQTY') ? 'priqty' : c.isWord('SECQTY') ? 'secqty' : c.isWord('ERASE') ? 'erase' : null;
+    if (!key) return using;
+    if (key in using) c.fail(`no second ${key.toUpperCase()}`);
+    c.next();
+    using[key] = key === 'erase' ? only(c, ['YES', 'NO']) === 'YES' : Number(readNumber(c));
+  }
+}
+
+// USING, FREEPAGE, PCTFREE and GBPCACHE, shared by the index and each of its partitions.
+function readSpaceClause(c, set) {
+  if (c.isWord('USING')) set('using', readUsing(c));
+  else if (c.word('FREEPAGE')) set('freepage', readInteger(c));
+  else if (c.word('PCTFREE')) set('pctfree', readInteger(c));
+  else if (c.word('GBPCACHE')) set('gbpcache', only(c, ['CHANGED', 'ALL', 'NONE']));
+  else return false;
+  return true;
+}
+
+function setter(c, into) {
+  return (key, value) => {
+    if (key in into) c.fail(`no second ${key}`);
+    into[key] = value;
+  };
+}
+
+function readPartitions(c) {
+  return c.items().map((item) => {
+    const s = cursor(item);
+    const part = { number: (s.expectWord(['PARTITION', 'PART']), readInteger(s)) };
+    const set = setter(s, part);
+    if (s.word('VALUES') || (s.word('ENDING') && (s.word('AT'), true))) {
+      part.limits = s.items().map((v) => {
+        const vs = cursor(v);
+        const limit = vs.word(['MAXVALUE', 'MINVALUE']) ? v[0].u : vs.peek() && vs.peek().t === 'lit' ? vs.next().v : readNumber(vs);
+        if (!vs.done()) vs.fail("',' or ')'");
+        return limit;
+      });
+      if (s.word('INCLUSIVE')) part.inclusive = true;
+    }
+    while (!s.done()) {
+      if (readSpaceClause(s, set)) continue;
+      if (s.word('DSSIZE')) { const n = readInteger(s); s.expectWord('G'); set('dssize', `${n}G`); }
+      else s.fail('a partition clause');
+    }
+    return part;
+  });
+}
+
+function readXmlIndex(c) {
+  c.expectWord('GENERATE');
+  c.expectWord(['KEY', 'KEYS']);
+  c.expectWord('USING');
+  c.expectWord('XMLPATTERN');
+  const pattern = c.next();
+  if (!pattern || pattern.t !== 'lit') { c.pos -= pattern ? 1 : 0; c.fail('an XML pattern string'); }
+  c.expectWord('AS');
+  c.expectWord('SQL');
+  const type = readDataType(c);
+  if (!['VARCHAR', 'DECFLOAT', 'DATE', 'TIMESTAMP'].includes(type.name)) c.fail('VARCHAR, DECFLOAT, DATE or TIMESTAMP');
+  return { pattern: pattern.v, type };
+}
+
+function readOptions(c, node) {
+  const set = setter(c, node.options);
+  while (!c.done()) {
+    if (readSpaceClause(c, set)) continue;
+    if (c.isWord('GENERATE')) set('xml', readXmlIndex(c));
+    else if (c.isWord('INCLUDE') && c.isOp('(', 1)) { c.next(); set('include', readNameList(c)); }
+    else if (c.isWord(['INCLUDE', 'EXCLUDE']) && c.isWord('NULL', 1)) { set('nullKeys', c.next().u); c.next(); c.expectWord('KEYS'); }
+    else if (c.isWord('NOT') && c.isWord(['CLUSTER', 'PADDED'], 1)) { c.next(); set(c.next().u === 'CLUSTER' ? 'cluster' : 'padded', false); }
+    else if (c.word('CLUSTER')) set('cluster', true);
+    else if (c.word('PADDED')) set('padded', true);
+    else if (c.word('PARTITIONED')) set('partitioned', true);
+    else if (c.isWord('PARTITION') && c.isWord('BY', 1)) { c.next(); c.next(); c.expectWord('RANGE'); set('partitions', readPartitions(c)); }
+    else if (c.isOp('(') && c.isWord(['PARTITION', 'PART'], 1)) set('partitions', readPartitions(c));
+    else if (c.word('DEFINE')) set('define', only(c, ['YES', 'NO']) === 'YES');
+    else if (c.word('COMPRESS')) set('compress', only(c, ['YES', 'NO']) === 'YES');
+    else if (c.word('BUFFERPOOL')) set('bufferpool', readName(c).join('.'));
+    else if (c.word('CLOSE')) set('close', only(c, ['YES', 'NO']) === 'YES');
+    else if (c.word('DEFER')) set('defer', only(c, ['YES', 'NO']) === 'YES');
+    else if (c.word('DSSIZE')) { const n = readInteger(c); c.expectWord('G'); set('dssize', `${n}G`); }
+    else if (c.word('PIECESIZE')) set('piecesize', readSize(c));
+    else if (c.word('COPY')) set('copy', only(c, ['YES', 'NO']) === 'YES');
+    else c.fail('an index clause');
+  }
+}
+
+export const parsers = {
+  'CREATE INDEX': (c) => {
+    c.expectWord('CREATE');
+    const node = { kind: 'CREATE INDEX', unique: false, whereNotNull: false, name: null, table: null, key: null, options: {} };
+    if (c.word('UNIQUE')) {
+      node.unique = true;
+      if (c.word('WHERE')) { c.expectWord('NOT'); c.expectWord('NULL'); node.whereNotNull = true; }
+    }
+    c.expectWord('INDEX');
+    node.name = readName(c).join('.');
+    c.expectWord('ON');
+    node.table = readName(c).join('.');
+    if (c.isOp('(')) node.key = readKey(c);
+    readOptions(c, node);
+    return node;
+  },
+};

package/lib/db2/stmt/misc.mjs

@@ -0,0 +1,325 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Parsers for Db2 miscellaneous DDL and session statements: DROP, COMMENT ON, LABEL ON, SET, RENAME,
+// TRUNCATE, CREATE SEQUENCE, ALIAS, SYNONYM, SCHEMA and ROLE.
+
+import { cursor } from '../cursor.mjs';
+
+const DROP_OBJECTS = new Set([
+  'TABLE', 'VIEW', 'INDEX', 'DATABASE', 'TABLESPACE', 'SCHEMA', 'PROCEDURE', 'FUNCTION',
+  'SEQUENCE', 'ALIAS', 'SYNONYM', 'TRIGGER', 'STOGROUP', 'ROLE'
+]);
+
+const COMMENT_OBJECTS = new Set([
+  'TABLE', 'COLUMN', 'INDEX', 'VIEW', 'SEQUENCE', 'PROCEDURE', 'FUNCTION', 'TRIGGER', 'SCHEMA', 'ROLE', 'TABLESPACE'
+]);
+
+const LABEL_OBJECTS = new Set([
+  'TABLE', 'COLUMN', 'INDEX', 'VIEW', 'SEQUENCE', 'PROCEDURE', 'FUNCTION', 'TRIGGER', 'SCHEMA', 'ROLE'
+]);
+
+const SET_CONTEXTS = new Set([
+  'SQLID', 'SCHEMA', 'PATH', 'DEGREE', 'PACKAGESET', 'RULES', 'PRECISION', 'TIMEZONE'
+]);
+
+function readName(c) {
+  const first = c.peek();
+  if (!first) c.fail('a name');
+  if (first.t === 'word' || first.t === 'ident') {
+    c.next();
+    const parts = [first.v];
+    while (c.isOp('.')) {
+      c.next();
+      const next = c.peek();
+      if (!next || (next.t !== 'word' && next.t !== 'ident')) c.fail('a name part');
+      c.next();
+      parts.push(next.v);
+    }
+    return parts;
+  }
+  c.fail('a name');
+}
+
+function readDrop(c, kind) {
+  c.expectWord('DROP');
+  const objTok = c.peek();
+  if (!objTok || objTok.t !== 'word' || !DROP_OBJECTS.has(objTok.u)) {
+    c.fail('a DROP object type');
+  }
+  c.next();
+  if (c.isWord('IF')) {
+    c.fail('IF EXISTS is not supported in Db2 for z/OS');
+  }
+  const name = readName(c);
+  let cascade = false;
+  if (c.isWord('RESTRICT')) {
+    c.next();
+  } else if (c.isWord('CASCADE')) {
+    c.next();
+    cascade = true;
+  }
+  return { kind, name, cascade };
+}
+
+// COMMENT ON and LABEL ON share a shape: an object type and name, then IS and the text; or a table
+// name followed by (column IS 'text', ...), with no object type.
+function readRemark(c, kind, verb, objects, field) {
+  c.expectWord(verb);
+  c.expectWord('ON');
+  if (c.isWord([...objects]) && c.peek(1) && c.peek(1).t !== 'op') {
+    const objectType = c.next().u;
+    const name = readName(c);
+    c.expectWord('IS');
+    const text = c.next();
+    if (!text || text.t !== 'lit') c.fail('a string literal');
+    return { kind, objectType, name, [field]: text.v };
+  }
+  const name = readName(c);
+  const columns = c.items().map((item) => {
+    const s = cursor(item);
+    const column = readName(s);
+    s.expectWord('IS');
+    const text = s.next();
+    if (!text || text.t !== 'lit' || !s.done()) s.fail('a string literal');
+    return { column, [field]: text.v };
+  });
+  return { kind, objectType: 'COLUMNS', name, columns };
+}
+
+const readCommentOn = (c, kind) => readRemark(c, kind, 'COMMENT', COMMENT_OBJECTS, 'comment');
+const readLabelOn = (c, kind) => readRemark(c, kind, 'LABEL', LABEL_OBJECTS, 'label');
+
+// SET [CURRENT] register [=] value[, value]...: CURRENT SQLID, SCHEMA, PATH, DEGREE, PACKAGESET,
+// RULES, PRECISION and TIME ZONE, or the bare SCHEMA and PATH forms.
+function readSet(c, kind) {
+  c.expectWord('SET');
+  const current = !!c.word('CURRENT');
+  const first = c.expectWord().u;
+  const context = first === 'TIME' && c.word('ZONE') ? 'TIMEZONE' : first;
+  if (!SET_CONTEXTS.has(context)) c.fail('a SET context');
+  c.op('=') || c.word('TO');
+  const values = [];
+  do {
+    const v = c.next();
+    if (!v || !['word', 'ident', 'num', 'lit'].includes(v.t)) c.fail('a value');
+    values.push(v.v);
+  } while (c.op(','));
+  return { kind, current, context, value: values.length === 1 ? values[0] : values };
+}
+
+function readRename(c, kind) {
+  c.expectWord('RENAME');
+  let objectType = 'TABLE';
+  if (c.isWord('TABLE')) {
+    c.next();
+  } else if (c.isWord('INDEX')) {
+    c.next();
+    objectType = 'INDEX';
+  }
+  const from = readName(c);
+  c.expectWord('TO');
+  const to = readName(c);
+  return { kind, objectType, from, to };
+}
+
+function readTruncate(c, kind) {
+  c.expectWord('TRUNCATE');
+  let objectType = 'TABLE';
+  if (c.isWord('TABLE')) {
+    c.next();
+  }
+  const name = readName(c);
+  let storage = null;
+  let triggers = null;
+  let immediate = false;
+  while (!c.done()) {
+    if (c.isWord('DROP')) {
+      c.next();
+      storage = 'DROP';
+    } else if (c.isWord('REUSE')) {
+      c.next();
+      c.expectWord('STORAGE');
+      storage = 'REUSE';
+    } else if (c.isWord('IGNORE')) {
+      c.next();
+      c.expectWord('WHEN');
+      c.expectWord('DELETE');
+      c.expectWord('TRIGGERS');
+      triggers = 'IGNORE';
+    } else if (c.isWord('RESTRICT')) {
+      c.next();
+      c.expectWord('WHEN');
+      c.expectWord('DELETE');
+      c.expectWord('TRIGGERS');
+      triggers = 'RESTRICT';
+    } else if (c.isWord('IMMEDIATE')) {
+      c.next();
+      immediate = true;
+    } else {
+      c.fail('a TRUNCATE option');
+    }
+  }
+  return { kind, name, storage, triggers, immediate };
+}
+
+function readCreateSequence(c, kind) {
+  c.expectWord('CREATE');
+  c.expectWord('SEQUENCE');
+  const name = readName(c);
+  let asType = null;
+  let startWith = null;
+  let incrementBy = null;
+  let minValue = null;
+  let noMinValue = false;
+  let maxValue = null;
+  let noMaxValue = false;
+  let cycle = null;
+  let cache = null;
+  let noCache = false;
+  let order = null;
+  while (!c.done()) {
+    if (c.isWord('AS')) {
+      c.next();
+      const typeTok = c.peek();
+      if (!typeTok || (typeTok.t !== 'word' && typeTok.t !== 'ident')) {
+        c.fail('a data type');
+      }
+      c.next();
+      asType = typeTok.v;
+    } else if (c.isWord('START')) {
+      c.next();
+      c.expectWord('WITH');
+      const nTok = c.peek();
+      if (!nTok || nTok.t !== 'num') {
+        c.fail('a number');
+      }
+      c.next();
+      startWith = nTok.v;
+    } else if (c.isWord('INCREMENT')) {
+      c.next();
+      c.expectWord('BY');
+      const nTok = c.peek();
+      if (!nTok || nTok.t !== 'num') {
+        c.fail('a number');
+      }
+      c.next();
+      incrementBy = nTok.v;
+    } else if (c.isWord('MINVALUE')) {
+      c.next();
+      const nTok = c.peek();
+      if (!nTok || nTok.t !== 'num') {
+        c.fail('a number');
+      }
+      c.next();
+      minValue = nTok.v;
+    } else if (c.isWord('NO')) {
+      c.next();
+      if (c.isWord('MINVALUE')) {
+        c.next();
+        noMinValue = true;
+      } else if (c.isWord('MAXVALUE')) {
+        c.next();
+        noMaxValue = true;
+      } else if (c.isWord('CYCLE')) {
+        c.next();
+        cycle = false;
+      } else if (c.isWord('CACHE')) {
+        c.next();
+        noCache = true;
+      } else if (c.isWord('ORDER')) {
+        c.next();
+        order = false;
+      } else {
+        c.fail('MINVALUE, MAXVALUE, CYCLE, CACHE or ORDER');
+      }
+    } else if (c.isWord('MAXVALUE')) {
+      c.next();
+      const nTok = c.peek();
+      if (!nTok || nTok.t !== 'num') {
+        c.fail('a number');
+      }
+      c.next();
+      maxValue = nTok.v;
+    } else if (c.isWord('CYCLE')) {
+      c.next();
+      cycle = true;
+    } else if (c.isWord('CACHE')) {
+      c.next();
+      const nTok = c.peek();
+      if (!nTok || nTok.t !== 'num') {
+        c.fail('a number');
+      }
+      c.next();
+      cache = nTok.v;
+    } else if (c.isWord('ORDER')) {
+      c.next();
+      order = true;
+    } else {
+      c.fail('a SEQUENCE option');
+    }
+  }
+  return { kind, name, asType, startWith, incrementBy, minValue, noMinValue, maxValue, noMaxValue, cycle, cache, noCache, order };
+}
+
+function readCreateAlias(c, kind) {
+  c.expectWord('CREATE');
+  c.expectWord('ALIAS');
+  const name = readName(c);
+  c.expectWord('FOR');
+  const forName = readName(c);
+  return { kind, name, for: forName };
+}
+
+function readCreateSynonym(c, kind) {
+  c.expectWord('CREATE');
+  c.expectWord('SYNONYM');
+  const name = readName(c);
+  c.expectWord('FOR');
+  const forName = readName(c);
+  return { kind, name, for: forName };
+}
+
+function readCreateSchema(c, kind) {
+  c.expectWord('CREATE');
+  c.expectWord('SCHEMA');
+  const name = readName(c);
+  let authorization = null;
+  if (c.isWord('AUTHORIZATION')) {
+    c.next();
+    authorization = readName(c);
+  }
+  return { kind, name, authorization };
+}
+
+function readCreateRole(c, kind) {
+  c.expectWord('CREATE');
+  c.expectWord('ROLE');
+  const name = readName(c);
+  return { kind, name };
+}
+
+export const parsers = {
+  'DROP TABLE': (c) => readDrop(c, 'DROP TABLE'),
+  'DROP VIEW': (c) => readDrop(c, 'DROP VIEW'),
+  'DROP INDEX': (c) => readDrop(c, 'DROP INDEX'),
+  'DROP DATABASE': (c) => readDrop(c, 'DROP DATABASE'),
+  'DROP TABLESPACE': (c) => readDrop(c, 'DROP TABLESPACE'),
+  'DROP SCHEMA': (c) => readDrop(c, 'DROP SCHEMA'),
+  'DROP PROCEDURE': (c) => readDrop(c, 'DROP PROCEDURE'),
+  'DROP FUNCTION': (c) => readDrop(c, 'DROP FUNCTION'),
+  'DROP SEQUENCE': (c) => readDrop(c, 'DROP SEQUENCE'),
+  'DROP ALIAS': (c) => readDrop(c, 'DROP ALIAS'),
+  'DROP SYNONYM': (c) => readDrop(c, 'DROP SYNONYM'),
+  'DROP TRIGGER': (c) => readDrop(c, 'DROP TRIGGER'),
+  'DROP STOGROUP': (c) => readDrop(c, 'DROP STOGROUP'),
+  'DROP ROLE': (c) => readDrop(c, 'DROP ROLE'),
+  'COMMENT ON': (c) => readCommentOn(c, 'COMMENT ON'),
+  'LABEL ON': (c) => readLabelOn(c, 'LABEL ON'),
+  'SET': (c) => readSet(c, 'SET'),
+  'RENAME': (c) => readRename(c, 'RENAME'),
+  'TRUNCATE': (c) => readTruncate(c, 'TRUNCATE'),
+  'CREATE SEQUENCE': (c) => readCreateSequence(c, 'CREATE SEQUENCE'),
+  'CREATE ALIAS': (c) => readCreateAlias(c, 'CREATE ALIAS'),
+  'CREATE SYNONYM': (c) => readCreateSynonym(c, 'CREATE SYNONYM'),
+  'CREATE SCHEMA': (c) => readCreateSchema(c, 'CREATE SCHEMA'),
+  'CREATE ROLE': (c) => readCreateRole(c, 'CREATE ROLE'),
+};