flinksql.pegjs

{
  // List of reserved keywords: https://calcite.apache.org/docs/reference.html#keywords
  const reservedMap = {
    'ABS': true,
    'ALL': true,
    'ALLOCATE': true,
    'ALLOW': true,
    'ALTER': true,
    'AND': true,
    'ANY': true,
    'ARE': true,
    'ARRAY': true,
    'ARRAY_MAX_CARDINALITY': true,
    'AS': true,
    'ASENSITIVE': true,
    'ASYMMETRIC': true,
    'AT': true,
    'ATOMIC': true,
    'AUTHORIZATION': true,
    'AVG': true,

    'BEGIN': true,
    'BEGIN_FRAME': true,
    'BEGIN_PARTITION': true,
    'BETWEEN': true,
    'BIGINT': true,
    'BINARY': true,
    'BIT': true,
    'BLOB': true,
    'BOOLEAN': true,
    'BOTH': true,
    'BY': true,

    'CALL': true,
    'CALLED': true,
    'CARDINALITY': true,
    'CASCADED': true,
    'CASE': true,
    'CAST': true,
    'CEIL': true,
    'CEILING': true,
    'CHAR': true,
    'CHARACTER': true,
    'CHARACTER_LENGTH': true,
    'CHAR_LENGTH': true,
    'CHECK': true,
    'CLASSIFIER': true,
    'CLOB': true,
    'CLOSE': true,
    'COALESCE': true,
    'COLLATE': true,
    'COLLECT': true,
    'COLUMN': true,
    'COMMIT': true,
    'CONDITION': true,
    'CONNECT': true,
    'CONSTRAINT': true,
    'CONTAINS': true,
    'CONVERT': true,
    'CORR': true,
    'CORRESPONDING': true,
    'COUNT': true,
    'COVAR_POP': true,
    'COVAR_SAMP': true,
    'CREATE': true,
    'CROSS': true,
    'CUBE': true,
    'CUME_DIST': true,
    'CURRENT': true,
    'CURRENT_CATALOG': true,
    'CURRENT_DATE': true,
    'CURRENT_DEFAULT_TRANSFORM_GROUP': true,
    'CURRENT_PATH': true,
    'CURRENT_ROLE': true,
    'CURRENT_ROW': true,
    'CURRENT_SCHEMA': true,
    'CURRENT_TIME': true,
    'CURRENT_TIMESTAMP': true,
    'CURRENT_TRANSFORM_GROUP_FOR_TYPE': true,
    'CURRENT_USER': true,
    'CURSOR': true,
    'CYCLE': true,

    'DATE': true,
    'DAY': true,
    'DEALLOCATE': true,
    'DEC': true,
    'DECIMAL': true,
    'DECLARE': true,
    'DEFAULT': true,
    'DEFINE': true,
    'DELETE': true,
    'DENSE_RANK': true,
    'DEREF': true,
    'DESCRIBE': true,
    'DETERMINISTIC': true,
    'DISALLOW': true,
    'DISCONNECT': true,
    'DISTINCT': true,
    'DOUBLE': true,
    'DROP': true,
    'DYNAMIC': true,

    'EACH': true,
    'ELEMENT': true,
    'ELSE': true,
    'EMPTY': true,
    'END': true,
    'END-EXEC': true,
    'END_FRAME': true,
    'END_PARTITION': true,
    'EQUALS': true,
    'ESCAPE': true,
    'EVERY': true,
    'EXCEPT': true,
    'EXEC': true,
    'EXECUTE': true,
    'EXISTS': true,
    'EXP': true,
    'EXPLAIN': true,
    'EXTEND': true,
    'EXTERNAL': true,
    'EXTRACT': true,

    'FALSE': true,
    'FETCH': true,
    'FILTER': true,
    'FIRST_VALUE': true,
    'FLOAT': true,
    'FLOOR': true,
    'FOR': true,
    'FOREIGN': true,
    'FRAME_ROW': true,
    'FREE': true,
    'FROM': true,
    'FULL': true,
    'FUNCTION': true,
    'FUSION': true,

    'GET': true,
    'GLOBAL': true,
    'GRANT': true,
    'GROUP': true,
    'GROUPING': true,
    'GROUPS': true,

    'HAVING': true,
    'HOLD': true,
    'HOUR': true,

    'IDENTITY': true,
    'IMPORT': true,
    'IN': true,
    'INDICATOR': true,
    'INITIAL': true,
    'INNER': true,
    'INOUT': true,
    'INSENSITIVE': true,
    'INSERT': true,
    'INT': true,
    'INTEGER': true,
    'INTERSECT': true,
    'INTERSECTION': true,
    'INTERVAL': true,
    'INTO': true,
    'IS': true,

    'JOIN': true,
    'JSON_ARRAY': true,
    'JSON_ARRAYAGG': true,
    'JSON_EXISTS': true,
    'JSON_OBJECT': true,
    'JSON_OBJECTAGG': true,
    'JSON_QUERY': true,
    'JSON_VALUE': true,

    'LAG': true,
    'LANGUAGE': true,
    'LARGE': true,
    'LAST_VALUE': true,
    'LATERAL': true,
    'LEAD': true,
    'LEADING': true,
    'LEFT': true,
    'LIKE': true,
    'LIKE_REGEX': true,
    'LIMIT': true,
    'LN': true,
    'LOCAL': true,
    'LOCALTIME': true,
    'LOCALTIMESTAMP': true,
    'LOWER': true,

    'MATCH': true,
    'MATCHES': true,
    'MATCH_NUMBER': true,
    'MATCH_RECOGNIZE': true,
    'MAX': true,
    'MEASURES': true,
    'MEMBER': true,
    'MERGE': true,
    'METHOD': true,
    'MIN': true,
    'MINUS': true,
    'MINUTE': true,
    'MOD': true,
    'MODIFIES': true,
    'MODULE': true,
    'MONTH': true,
    'MULTISET': true,

    'NATIONAL': true,
    'NATURAL': true,
    'NCHAR': true,
    'NCLOB': true,
    'NEW': true,
    'NEXT': true,
    'NO': true,
    'NONE': true,
    'NORMALIZE': true,
    'NOT': true,
    'NTH_VALUE': true,
    'NTILE': true,
    'NULL': true,
    'NULLIF': true,
    'NUMERIC': true,

    'OCCURRENCES_REGEX': true,
    'OCTET_LENGTH': true,
    'OF': true,
    'OFFSET': true,
    'OLD': true,
    'OMIT': true,
    'ON': true,
    'ONE': true,
    'ONLY': true,
    'OPEN': true,
    'OR': true,
    'ORDER': true,
    'OUT': true,
    'OUTER': true,
    'OVER': true,
    'OVERLAPS': true,
    'OVERLAY': true,

    'PARAMETER': true,
    'PARTITION': true,
    'PATTERN': true,
    'PER': true,
    'PERCENT': true,
    'PERCENTILE_CONT': true,
    'PERCENTILE_DISC': true,
    'PERCENT_RANK': true,
    'PERIOD': true,
    'PERMUTE': true,
    'PORTION': true,
    'POSITION': true,
    'POSITION_REGEX': true,
    'POWER': true,
    'PRECEDES': true,
    'PRECISION': true,
    'PREPARE': true,
    'PREV': true,
    'PRIMARY': true,
    'PROCEDURE': true,

    'RANGE': true,
    'RANK': true,
    'READS': true,
    'REAL': true,
    'RECURSIVE': true,
    'REF': true,
    'REFERENCES': true,
    'REFERENCING': true,
    'REGR_AVGX': true,
    'REGR_AVGY': true,
    'REGR_COUNT': true,
    'REGR_INTERCEPT': true,
    'REGR_R2': true,
    'REGR_SLOPE': true,
    'REGR_SXX': true,
    'REGR_SXY': true,
    'REGR_SYY': true,
    'RELEASE': true,
    'RESET': true,
    'RESULT': true,
    'RETURN': true,
    'RETURNS': true,
    'REVOKE': true,
    'RIGHT': true,
    'ROLLBACK': true,
    'ROLLUP': true,
    'ROW': true,
    'ROWS': true,
    'ROW_NUMBER': true,
    'RUNNING': true,

    'SAVEPOINT': true,
    'SCOPE': true,
    'SCROLL': true,
    'SEARCH': true,
    'SECOND': true,
    'SEEK': true,
    'SELECT': true,
    'SENSITIVE': true,
    'SESSION_USER': true,
    'SET': true,
    'SHOW': true,
    'SIMILAR': true,
    'SIMILAR': true,
    'SKIP': true,
    'SMALLINT': true,
    'SOME': true,
    'SPECIFIC': true,
    'SPECIFICTYPE': true,
    'SQL': true,
    'SQLEXCEPTION': true,
    'SQLSTATE': true,
    'SQLWARNING': true,
    'SQRT': true,
    'START': true,
    'STATIC': true,
    'STDDEV_POP': true,
    'STDDEV_SAMP': true,
    'STREAM': true,
    'SUBMULTISET': true,
    'SUBSET': true,
    'SUBSTRING': true,
    'SUBSTRING_REGEX': true,
    'SUCCEEDS': true,
    'SUM': true,
    'SYMMETRIC': true,
    'SYSTEM': true,
    'SYSTEM_TIME': true,
    'SYSTEM_USER': true,

    'TABLE': true,
    'TABLESAMPLE': true,
    'THEN': true,
    'TO': true,
    'TIME': true,
    'TIMESTAMP': true,
    'TIMEZONE_HOUR': true,
    'TIMEZONE_MINUTE': true,
    'TINYINT': true,
    'TO': true,
    'TRAILING': true,
    'TRANSLATE': true,
    'TRANSLATE_REGEX': true,
    'TRANSLATION': true,
    'TREAT': true,
    'TRIGGER': true,
    'TRIM': true,
    'TRIM_ARRAY': true,
    'TRUE': true,
    'TRUNCATE': true,

    'UESCAPE': true,
    'UNION': true,
    'UNIQUE': true,
    'UNKNOWN': true,
    'UNNEST': true,
    'UPDATE': true,
    'UPPER': true,
    'UPSERT': true,
    'USER': true,
    'USING': true,

    'VALUE': true,
    'VALUES': true,
    'VALUE_OF': true,
    'VARBINARY': true,
    'VARCHAR': true,
    'VARYING': true,
    'VAR_POP': true,
    'VAR_SAMP': true,
    'VERSIONING': true,

    'WHEN': true,
    'WHENEVER': true,
    'WHERE': true,
    'WIDTH_BUCKET': true,
    'WINDOW': true,
    'WITH': true,
    'WITHIN': true,
    'WITHOUT': true,

    'YEAR': true,
  };

  function getLocationObject() {
    return options.includeLocations ? {loc: location()} : {}
  }

  function createUnaryExpr(op, e) {
    return {
      type: 'unary_expr',
      operator: op,
      expr: e
    };
  }

  function createBinaryExpr(op, left, right) {
    return {
      type: 'binary_expr',
      operator: op,
      left: left,
      right: right
    };
  }

  function isBigInt(numberStr) {
    const previousMaxSafe = BigInt(Number.MAX_SAFE_INTEGER)
    const num = BigInt(numberStr)
    if (num < previousMaxSafe) return false
    return true
  }

  function createList(head, tail, po = 3) {
    const result = [head];
    for (let i = 0; i < tail.length; i++) {
      delete tail[i][po].tableList
      delete tail[i][po].columnList
      result.push(tail[i][po]);
    }
    return result;
  }

  function createBinaryExprChain(head, tail) {
    let result = head;
    for (let i = 0; i < tail.length; i++) {
      result = createBinaryExpr(tail[i][1], result, tail[i][3]);
    }
    return result;
  }

  function queryTableAlias(tableName) {
    const alias = tableAlias[tableName]
    if (alias) return alias
    if (tableName) return tableName
    return null
  }

  function columnListTableAlias(columnList) {
    const newColumnsList = new Set()
    const symbolChar = '::'
    for(let column of columnList.keys()) {
      const columnInfo = column.split(symbolChar)
      if (!columnInfo) {
        newColumnsList.add(column)
        break
      }
      if (columnInfo && columnInfo[1]) columnInfo[1] = queryTableAlias(columnInfo[1])
      newColumnsList.add(columnInfo.join(symbolChar))
    }
    return Array.from(newColumnsList)
  }

  function refreshColumnList(columnList) {
    const columns = columnListTableAlias(columnList)
    columnList.clear()
    columns.forEach(col => columnList.add(col))
  }

  function commonStrToLiteral(strOrLiteral) {
    return typeof strOrLiteral === 'string' ? { type: 'same', value: strOrLiteral } : strOrLiteral
  }

  const cmpPrefixMap = {
    '+': true,
    '-': true,
    '*': true,
    '/': true,
    '>': true,
    '<': true,
    '!': true,
    '=': true,

    //between
    'B': true,
    'b': true,
    //for is or in
    'I': true,
    'i': true,
    //for like
    'L': true,
    'l': true,
    //for not
    'N': true,
    'n': true
  };

  // used for dependency analysis
  let varList = [];

  const tableList = new Set();
  const columnList = new Set();
  const tableAlias = {};
}

start
  = __ n:(multiple_stmt) {
    return n
  }

cmd_stmt
  = drop_stmt
  / create_stmt
  / truncate_stmt
  / rename_stmt
  / call_stmt
  / use_stmt
  / alter_stmt
  / set_stmt
  / lock_stmt

create_stmt
  = create_table_stmt
  / create_constraint_trigger
  / create_extension_stmt
  / create_index_stmt
  / create_db_stmt

alter_stmt
  = alter_table_stmt

crud_stmt
  = union_stmt
  / update_stmt
  / replace_insert_stmt
  / insert_no_columns_stmt
  / delete_stmt
  / cmd_stmt
  / proc_stmts

multiple_stmt
  = head:crud_stmt tail:(__ SEMICOLON __ crud_stmt)* {
      /*
      // is in reality: { tableList: any[]; columnList: any[]; ast: T; }
      export type AstStatement<T> = T;
       => AstStatement<crud_stmt[]> */
      const headAst = head && head.ast || head
      const cur = tail && tail.length && tail[0].length >= 4 ? [headAst] : headAst;
      for (let i = 0; i < tail.length; i++) {
        if(!tail[i][3] || tail[i][3].length === 0) continue;
        cur.push(tail[i][3] && tail[i][3].ast || tail[i][3]);
      }
      return {
        tableList: Array.from(tableList),
        columnList: columnListTableAlias(columnList),
      	ast: cur
      }
    }

set_op
  = u:(KW_UNION / KW_INTERSECT / KW_EXCEPT) __ s:(KW_ALL / KW_DISTINCT)? {
    return s ? `${u.toLowerCase()} ${s.toLowerCase()}` : `${u.toLowerCase()}`
  }

union_stmt
  = head:select_stmt tail:(__ set_op __ select_stmt)* __ ob: order_by_clause? __ l:limit_clause? {
     /* export interface union_stmt_node extends select_stmt_node  {
         _next: union_stmt_node;
         union: 'union' | 'union all' | 'union distinct';
      }
     => AstStatement<union_stmt_node>
     */
      let cur = head
      for (let i = 0; i < tail.length; i++) {
        cur._next = tail[i][3]
        cur.set_op = tail[i][1]
        cur = cur._next
      }
      if(ob) head._orderby = ob
      if(l) head._limit = l
      return {
        tableList: Array.from(tableList),
        columnList: columnListTableAlias(columnList),
        ast: head
      }
    }

if_not_exists_stmt
  = 'IF'i __ KW_NOT __ KW_EXISTS {
    return 'IF NOT EXISTS'
  }

create_extension_stmt
  = a:KW_CREATE __
    e:'EXTENSION'i __
    ife: if_not_exists_stmt? __
    n:(ident_name / literal_string) __
    w:KW_WITH? __
    s:('SCHEMA'i __ ident_name / literal_string)? __
    v:('VERSION'i __ (ident_name / literal_string))? __
    f:(KW_FROM __ (ident_name / literal_string))? {
      /*
       export type nameOrLiteral = literal_string | { type: 'same', value: string; };
      => {
          type: 'create';
          keyword: 'extension';
          if_not_exists?: 'if not exists';
          extension: nameOrLiteral;
          with: 'with';
          schema: nameOrLiteral;
          version: nameOrLiteral;
          from: nameOrLiteral;
        }
      */
      return {
        type: 'create',
        keyword: e.toLowerCase(),
        if_not_exists:ife,
        extension: commonStrToLiteral(n),
        with: w && w[0].toLowerCase(),
        schema: commonStrToLiteral(s && s[2].toLowerCase()), // <== wont that be a bug ?
        version: commonStrToLiteral(v && v[2]),
        from: commonStrToLiteral(f && f[2]),
      }
    }

create_db_definition
  = head:create_option_character_set tail:(__ create_option_character_set)* {
    return createList(head, tail, 1)
  }

create_db_stmt
  = a:KW_CREATE __
    k:(KW_DATABASE / KW_SCHEMA) __
    ife:if_not_exists_stmt? __
    t:proc_func_name __
    c:create_db_definition? {
      const keyword = k.toLowerCase()
      return {
        tableList: Array.from(tableList),
        columnList: columnListTableAlias(columnList),
        ast: {
          type: a[0].toLowerCase(),
          keyword,
          if_not_exists:ife,
          [keyword]: { db: t.schema, schema: t.name },
          create_definitions: c,
        }
      }
    }
with_table_option
  = k:ident_without_kw_type __ KW_ASSIGIN_EQUAL __ v:ident_without_kw_type {
    return {
      keyword: k,
      symbol: '=',
      value: v
    }
  }
with_table_options
  = head:with_table_option tail:(__ COMMA __ with_table_option)* {
      return createList(head, tail);
    }
create_table_stmt
  = a:KW_CREATE __
    tp:KW_TEMPORARY? __
    KW_TABLE __
    ife:if_not_exists_stmt? __
    t:table_ref_list __
    c:create_table_definition __
    to:table_options? __
    wr:(KW_WITH __ LPAREN __ with_table_options __ RPAREN)? __
    ir: (KW_IGNORE / KW_REPLACE)? __
    as: KW_AS? __
    qe: union_stmt? {
      if(t) t.forEach(tt => tableList.add(`create::${[tt.db, tt.schema].filter(Boolean).join('.') || null}::${tt.table}`));
      return {
        tableList: Array.from(tableList),
        columnList: columnListTableAlias(columnList),
        ast: {
          type: a[0].toLowerCase(),
          keyword: 'table',
          temporary: tp && tp[0].toLowerCase(),
          if_not_exists:ife,
          table: t,
          ignore_replace: ir && ir[0].toLowerCase(),
          as: as && as[0].toLowerCase(),
          query_expr: qe && qe.ast,
          create_definitions: c,
          table_options: to,
          with: wr && wr[4],
        }
      }
    }
  / a:KW_CREATE __
    tp:KW_TEMPORARY? __
    KW_TABLE __
    ife:if_not_exists_stmt? __
    t:table_ref_list __
    wr:(KW_WITH __ LPAREN __ with_table_options __ RPAREN)? __
    lt:create_like_table {
      if(t) t.forEach(tt => tableList.add(`create::${[tt.db, tt.schema].filter(Boolean).join('.') || null}::${tt.table}`));
      return {
        tableList: Array.from(tableList),
        columnList: columnListTableAlias(columnList),
        ast: {
          type: a[0].toLowerCase(),
          keyword: 'table',
          temporary: tp && tp[0].toLowerCase(),
          if_not_exists:ife,
          table: t,
          like: lt,
          with: wr && wr[4],
        }
      }
    }

create_index_stmt
  = a:KW_CREATE __
  kw:KW_UNIQUE? __
  t:KW_INDEX __
  co:KW_CONCURRENTLY? __
  n:ident? __
  on:KW_ON __
  ta:table_name __
  um:index_type? __
  LPAREN __ cols:column_order_list __ RPAREN __
  wr:(KW_WITH __ LPAREN __ index_options_list __ RPAREN)? __
  ts:(KW_TABLESPACE __ ident_name)? __
  w:where_clause? __ {
    /*
    export interface create_index_stmt_node {
      type: 'create';
      index_type?: 'unique';
      keyword: 'index';
      concurrently?: 'concurrently';
      index: string;
      on_kw: string;
      table: table_name;
      index_using?: index_type;
      index_columns: column_order[];
      with?: index_option[];
      with_before_where: true;
      tablespace?: {type: 'origin'; value: string; }
      where?: where_clause;
    }
    => AstStatement<create_index_stmt_node>
    */
    return {
        tableList: Array.from(tableList),
        columnList: columnListTableAlias(columnList),
        ast: {
          type: a[0].toLowerCase(),
          index_type: kw && kw.toLowerCase(),
          keyword: t.toLowerCase(),
          concurrently: co && co.toLowerCase(),
          index: n,
          on_kw: on[0].toLowerCase(),
          table: ta,
          index_using: um,
          index_columns: cols,
          with: wr && wr[4],
          with_before_where: true,
          tablespace: ts && { type: 'origin', value: ts[2] },
          where: w,
        }
    }
  }

column_order_list
  = head:column_order tail:(__ COMMA __ column_order)* {
    // => column_order[]
    return createList(head, tail)
  }

column_order
  = c:expr __
  ca:collate_expr? __
  op:ident? __
  o:(KW_ASC / KW_DESC)? __
  nf:('NULLS'i __ ('FIRST'i / 'LAST'i))? {
    /*
    => {
      column: expr;
      collate: collate_expr;
      opclass: ident;
      order: 'asc' | 'desc';
      nulls: 'nulls last' | 'nulls first';
    }
    */
    return {
      ...c,
      collate: ca,
      opclass: op,
      order_by: o && o.toLowerCase(),
      nulls: nf && `${nf[0].toLowerCase()} ${nf[2].toLowerCase()}`,
    }
  }

create_like_table_simple
  = KW_LIKE __ t: table_ref_list {
    // => { type: 'like'; table: table_ref_list; }
    return {
      type: 'like',
      table: t
    }
  }
create_like_table
  = create_like_table_simple
  / LPAREN __ e:create_like_table  __ RPAREN {
     // => create_like_table_simple & { parentheses?: boolean; }
      e.parentheses = true;
      return e;
  }

create_table_definition
  = LPAREN __ head:create_definition tail:(__ COMMA __ create_definition)* __ RPAREN {
      // => create_definition[]
      return createList(head, tail);
    }

create_definition
  = create_column_definition
  / create_index_definition
  / create_fulltext_spatial_index_definition
  / create_constraint_definition

column_definition_opt
  = n:(literal_not_null / literal_null) {
    if (n && !n.value) n.value = 'null'
    return { nullable: n }
  }
  / d:default_expr {
    return { default_val: d }
  }
  / a:('AUTO_INCREMENT'i) {
    return { auto_increment: a.toLowerCase() }
  }
  / 'UNIQUE'i __ k:('KEY'i)? {
    const sql = ['unique']
    if (k) sql.push(k)
    return { unique: sql.join(' ').toLowerCase('') }
  }
  / p:('PRIMARY'i)? __ 'KEY'i {
    const sql = []
    if (p) sql.push('primary')
    sql.push('key')
    return { primary_key: sql.join(' ').toLowerCase('') }
  }
  / co:keyword_comment {
    return { comment: co }
  }
  / ca:collate_expr {
    return { collate: ca }
  }
  / cf:column_format {
    return { column_format: cf }
  }
  / s:storage {
    return { storage: s }
  }
  / re:reference_definition {
    return { reference_definition: re }
  }

column_definition_opt_list
  = head:column_definition_opt __ tail:(__ column_definition_opt)* {
    let opt = head
    for (let i = 0; i < tail.length; i++) {
      opt = { ...opt, ...tail[i][1] }
    }
    return opt
  }

create_column_definition
  = c:column_ref __
    d:data_type __
    cdo:column_definition_opt_list? {
      columnList.add(`create::${c.table}::${c.column}`)
      return {
        column: c,
        definition: d,
        resource: 'column',
        ...(cdo || {})
      }
    }


collate_expr
  = KW_COLLATE __ s:KW_ASSIGIN_EQUAL? __ ca:ident {
    return {
      type: 'collate',
      keyword: 'collate',
      collate: {
        name: ca,
        symbol: s,
      }
    }
  }
column_format
  = k:'COLUMN_FORMAT'i __ f:('FIXED'i / 'DYNAMIC'i / 'DEFAULT'i) {
    // => { type: 'column_format'; value: 'fixed' | 'dynamic' | 'default'; }
    return {
      type: 'column_format',
      value: f.toLowerCase()
    }
  }
storage
  = k:'STORAGE'i __ s:('DISK'i / 'MEMORY'i) {
    // => { type: 'storage'; value: 'disk' | 'memory' }
    return {
      type: 'storage',
      value: s.toLowerCase()
    }
  }
default_expr
  = KW_DEFAULT __ ce:expr {
    // => { type: 'default'; value: literal | expr; }
    return {
      type: 'default',
      value: ce
    }
  }
drop_index_opt
  = head:(ALTER_ALGORITHM / ALTER_LOCK) tail:(__ (ALTER_ALGORITHM / ALTER_LOCK))* {
    return createList(head, tail, 1)
  }
drop_stmt
  = a:KW_DROP __
    r:KW_TABLE __
    t:table_ref_list {
      if(t) t.forEach(tt => tableList.add(`${a}::${[tt.db, tt.schema].filter(Boolean).join('.') || null}::${tt.table}`));
      return {
        tableList: Array.from(tableList),
        columnList: columnListTableAlias(columnList),
        ast: {
          type: a.toLowerCase(),
          keyword: r.toLowerCase(),
          name: t
        }
      };
    }
  / a:KW_DROP __
    r:KW_INDEX __
    i:column_ref __
    KW_ON __
    t:table_name __
    op:drop_index_opt? __ {
      return {
        tableList: Array.from(tableList),
        columnList: columnListTableAlias(columnList),
        ast: {
          type: a.toLowerCase(),
          keyword: r.toLowerCase(),
          name: i,
          table: t,
          options: op
        }
      };
    }
truncate_stmt
  = a:KW_TRUNCATE  __
    kw:KW_TABLE? __
    t:table_ref_list {
      /*
      export interface truncate_stmt_node {
        type: 'trucate';
        keyword: 'table';
        name: table_ref_list;
      }
      => AstStatement<truncate_stmt_node>
      */
      if(t) t.forEach(tt => tableList.add(`${a}::${[tt.db, tt.schema].filter(Boolean).join('.') || null}::${tt.table}`));
      return {
        tableList: Array.from(tableList),
        columnList: columnListTableAlias(columnList),
        ast: {
          type: a.toLowerCase(),
          keyword: kw && kw.toLowerCase() || 'table',
          name: t
        }
      };
    }

use_stmt
  = KW_USE  __
    d:ident {
      /*
      export interface use_stmt_node {
        type: 'use';
        db: ident;
      }
      => AstStatement<use_stmt_node>
      */
      tableList.add(`use::${d}::null`);
      return {
        tableList: Array.from(tableList),
        columnList: columnListTableAlias(columnList),
        ast: {
          type: 'use',
          db: d
        }
      };
    }

alter_table_stmt