From 0f7f6211dbc1bd6426b41e6ee261f5cd0ff612b0 Mon Sep 17 00:00:00 2001 From: Dmitriy Pleshevskiy Date: Sat, 7 Jan 2023 01:30:38 +0300 Subject: [PATCH] grammar: add base types --- grammar.js | 175 +- src/grammar.json | 830 ++++++++- src/node-types.json | 332 ++++ src/parser.c | 3269 +++++++++++++++++++++++++++------- test/corpus/create/table.txt | 57 + tree-sitter-plpgsql.wasm | Bin 8886 -> 21897 bytes 6 files changed, 3999 insertions(+), 664 deletions(-) diff --git a/grammar.js b/grammar.js index 270f645..b9cebb8 100644 --- a/grammar.js +++ b/grammar.js @@ -3,6 +3,8 @@ module.exports = grammar({ extras: ($) => [/\s\n/, /\s/, $.comment, $.marginalia], + conflicts: ($) => [[$.keyword_char, $.keyword_varchar]], + word: ($) => $._identifier, rules: { @@ -25,12 +27,6 @@ module.exports = grammar({ $.column_definitions ), - table_reference: ($) => - seq( - optional(seq(field("schema", $.identifier), ".")), - field("name", $.identifier) - ), - column_definitions: ($) => seq( "(", @@ -38,11 +34,20 @@ module.exports = grammar({ ")" ), - column_definition: ($) => seq(field("name", $.identifier)), + column_definition: ($) => + seq(field("name", $.identifier), field("datatype", $._type)), //constraint: $ => seq(), + table_reference: ($) => + seq( + optional(seq(field("schema", $.identifier), ".")), + field("name", $.identifier) + ), + // keywords + _if_not_exists: ($) => seq($.keyword_if, $.keyword_not, $.keyword_exists), + keyword_create: (_) => mkKeyword("create"), keyword_table: (_) => mkKeyword("table"), keyword_temporary: (_) => choice(mkKeyword("temporary"), mkKeyword("temp")), @@ -51,13 +56,150 @@ module.exports = grammar({ keyword_not: (_) => mkKeyword("not"), keyword_exists: (_) => mkKeyword("exists"), - _if_not_exists: ($) => seq($.keyword_if, $.keyword_not, $.keyword_exists), + // References: https://www.postgresql.org/docs/15/datatype.html + _type: ($) => + choice( + $._type_numeric, + $._type_character, + $._type_datetime, + $._type_geometric, + $._type_net, + $._type_bit_string, + $._type_text_search, + $.keyword_money, + $.keyword_bytea, + $.keyword_boolean, + $.keyword_uuid, + $.keyword_xml + // TODO: add arrays References: https://www.postgresql.org/docs/15/arrays.html + // TODO: add rangetypes References: https://www.postgresql.org/docs/15/rangetypes.html + // TODO: add OID types References: https://www.postgresql.org/docs/15/datatype-oid.html + ), + + // References: https://www.postgresql.org/docs/15/datatype-numeric.html + _type_numeric: ($) => + choice( + $.keyword_smallint, + $.keyword_integer, + $.keyword_bigint, + $.keyword_real, + $.keyword_smallserial, + $.keyword_serial, + $.keyword_bigserial, + $.double, + $.numeric, + $.decimal + ), + double: ($) => seq(mkKeyword("double"), mkKeyword("precision")), + decimal: ($) => + choice( + parametricType($, $.keyword_decimal, ["precision"]), + parametricType($, $.keyword_decimal, ["precision", "scale"]) + ), + numeric: ($) => + choice( + parametricType($, $.keyword_numeric, ["precision"]), + parametricType($, $.keyword_numeric, ["precision", "scale"]) + ), + + // References: https://www.postgresql.org/docs/15/datatype-character.html + _type_character: ($) => choice($.keyword_text, $.char, $.varchar), + char: ($) => parametricType($, $.keyword_char), + varchar: ($) => parametricType($, $.keyword_varchar), + + // TODO: add interval type + // References: https://www.postgresql.org/docs/15/datatype-datetime.html + _type_datetime: ($) => + choice( + $.keyword_date, + $.keyword_datetime, + $.keyword_time, + $.keyword_timestamp, + $.keyword_timestamptz + ), + + // TODO: add geometric types + // References: https://www.postgresql.org/docs/15/datatype-geometric.html + _type_geometric: ($) => choice(), + + // TODO: add net types + // References: https://www.postgresql.org/docs/15/datatype-net-types.html + _type_net: ($) => choice(), + + // TODO: add bit string types + // References: https://www.postgresql.org/docs/15/datatype-bit.html + _type_bit_string: ($) => choice(), + + // TODO: add text search types + // References: https://www.postgresql.org/docs/15/datatype-textsearch.html + _type_text_search: ($) => choice(), + + // References: https://www.postgresql.org/docs/15/datatype-json.html + _type_json: ($) => choice($.keyword_json, $.keyword_jsonb), + + keyword_boolean: (_) => mkKeyword("boolean"), + + keyword_smallint: (_) => mkKeyword("smallint"), + keyword_integer: (_) => mkKeyword("integer"), + keyword_bigint: (_) => mkKeyword("bigint"), + keyword_decimal: (_) => mkKeyword("decimal"), + keyword_numeric: (_) => mkKeyword("numeric"), + keyword_real: (_) => mkKeyword("real"), + keyword_smallserial: (_) => mkKeyword("smallserial"), + keyword_serial: (_) => mkKeyword("serial"), + keyword_bigserial: (_) => mkKeyword("bigserial"), + + // References: https://www.postgresql.org/docs/15/datatype-money.html + keyword_money: (_) => mkKeyword("money"), + + keyword_text: (_) => mkKeyword("text"), + keyword_char: (_) => choice(mkKeyword("character"), mkKeyword("char")), + keyword_varchar: (_) => + choice( + mkKeyword("varchar"), + seq(mkKeyword("character", mkKeyword("varying"))) + ), + + keyword_bytea: (_) => mkKeyword("bytea"), + + keyword_date: (_) => mkKeyword("date"), + keyword_datetime: (_) => mkKeyword("datetime"), + keyword_time: ($) => + seq( + mkKeyword("time"), + choice(optional($._without_time_zone), $._with_time_zone) + ), + keyword_timestamp: ($) => + seq(mkKeyword("timestamp"), optional($._without_time_zone)), + keyword_timestamptz: ($) => + choice( + mkKeyword("timestamptz"), + seq(mkKeyword("timestamp"), $._with_time_zone) + ), + + _without_time_zone: ($) => seq($._keyword_without, $._keyword_time_zone), + _with_time_zone: ($) => seq($._keyword_with, $._keyword_time_zone), + _keyword_without: (_) => mkKeyword("without"), + _keyword_with: (_) => mkKeyword("with"), + _keyword_time_zone: (_) => seq(mkKeyword("time"), mkKeyword("zone")), + + // References: https://www.postgresql.org/docs/15/datatype-uuid.html + keyword_uuid: (_) => mkKeyword("uuid"), + + // References: https://www.postgresql.org/docs/15/datatype-xml.html + keyword_xml: (_) => mkKeyword("xml"), + + keyword_json: (_) => mkKeyword("json"), + keyword_jsonb: (_) => mkKeyword("jsonb"), + // ------- comment: (_) => seq("--", /.*\n/), // https://stackoverflow.com/questions/13014947/regex-to-match-a-c-style-multiline-comment marginalia: (_) => seq("/*", /[^*]*\*+(?:[^/*][^*]*\*+)*/, "/"), + _number: (_) => /\d+/, + identifier: ($) => choice($._identifier, seq('"', $._identifier, '"')), _identifier: (_) => /([a-zA-Z_][0-9a-zA-Z_]*)/, @@ -71,3 +213,20 @@ function mkKeyword(word) { function commaSepRepeat1(field) { return seq(field, repeat(seq(",", field))); } + +function parametricType($, type, params = ["size"]) { + return prec.right( + choice( + type, + seq( + type, + "(", + // first parameter is guaranteed, shift it out of the array + field(params.shift(), alias($._number, $.literal)), + // then, fill in the ", next" until done + ...params.map((p) => seq(",", field(p, alias($._number, $.literal)))), + ")" + ) + ) + ); +} diff --git a/src/grammar.json b/src/grammar.json index f172826..c2aae80 100644 --- a/src/grammar.json +++ b/src/grammar.json @@ -107,44 +107,6 @@ } ] }, - "table_reference": { - "type": "SEQ", - "members": [ - { - "type": "CHOICE", - "members": [ - { - "type": "SEQ", - "members": [ - { - "type": "FIELD", - "name": "schema", - "content": { - "type": "SYMBOL", - "name": "identifier" - } - }, - { - "type": "STRING", - "value": "." - } - ] - }, - { - "type": "BLANK" - } - ] - }, - { - "type": "FIELD", - "name": "name", - "content": { - "type": "SYMBOL", - "name": "identifier" - } - } - ] - }, "column_definitions": { "type": "SEQ", "members": [ @@ -211,6 +173,69 @@ "type": "SYMBOL", "name": "identifier" } + }, + { + "type": "FIELD", + "name": "datatype", + "content": { + "type": "SYMBOL", + "name": "_type" + } + } + ] + }, + "table_reference": { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "schema", + "content": { + "type": "SYMBOL", + "name": "identifier" + } + }, + { + "type": "STRING", + "value": "." + } + ] + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "FIELD", + "name": "name", + "content": { + "type": "SYMBOL", + "name": "identifier" + } + } + ] + }, + "_if_not_exists": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "keyword_if" + }, + { + "type": "SYMBOL", + "name": "keyword_not" + }, + { + "type": "SYMBOL", + "name": "keyword_exists" } ] }, @@ -251,23 +276,727 @@ "type": "PATTERN", "value": "exists|EXISTS" }, - "_if_not_exists": { + "_type": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "_type_numeric" + }, + { + "type": "SYMBOL", + "name": "_type_character" + }, + { + "type": "SYMBOL", + "name": "_type_datetime" + }, + { + "type": "SYMBOL", + "name": "_type_geometric" + }, + { + "type": "SYMBOL", + "name": "_type_net" + }, + { + "type": "SYMBOL", + "name": "_type_bit_string" + }, + { + "type": "SYMBOL", + "name": "_type_text_search" + }, + { + "type": "SYMBOL", + "name": "keyword_money" + }, + { + "type": "SYMBOL", + "name": "keyword_bytea" + }, + { + "type": "SYMBOL", + "name": "keyword_boolean" + }, + { + "type": "SYMBOL", + "name": "keyword_uuid" + }, + { + "type": "SYMBOL", + "name": "keyword_xml" + } + ] + }, + "_type_numeric": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "keyword_smallint" + }, + { + "type": "SYMBOL", + "name": "keyword_integer" + }, + { + "type": "SYMBOL", + "name": "keyword_bigint" + }, + { + "type": "SYMBOL", + "name": "keyword_real" + }, + { + "type": "SYMBOL", + "name": "keyword_smallserial" + }, + { + "type": "SYMBOL", + "name": "keyword_serial" + }, + { + "type": "SYMBOL", + "name": "keyword_bigserial" + }, + { + "type": "SYMBOL", + "name": "double" + }, + { + "type": "SYMBOL", + "name": "numeric" + }, + { + "type": "SYMBOL", + "name": "decimal" + } + ] + }, + "double": { + "type": "SEQ", + "members": [ + { + "type": "PATTERN", + "value": "double|DOUBLE" + }, + { + "type": "PATTERN", + "value": "precision|PRECISION" + } + ] + }, + "decimal": { + "type": "CHOICE", + "members": [ + { + "type": "PREC_RIGHT", + "value": 0, + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "keyword_decimal" + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "keyword_decimal" + }, + { + "type": "STRING", + "value": "(" + }, + { + "type": "FIELD", + "name": "precision", + "content": { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_number" + }, + "named": true, + "value": "literal" + } + }, + { + "type": "STRING", + "value": ")" + } + ] + } + ] + } + }, + { + "type": "PREC_RIGHT", + "value": 0, + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "keyword_decimal" + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "keyword_decimal" + }, + { + "type": "STRING", + "value": "(" + }, + { + "type": "FIELD", + "name": "precision", + "content": { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_number" + }, + "named": true, + "value": "literal" + } + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "FIELD", + "name": "scale", + "content": { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_number" + }, + "named": true, + "value": "literal" + } + } + ] + }, + { + "type": "STRING", + "value": ")" + } + ] + } + ] + } + } + ] + }, + "numeric": { + "type": "CHOICE", + "members": [ + { + "type": "PREC_RIGHT", + "value": 0, + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "keyword_numeric" + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "keyword_numeric" + }, + { + "type": "STRING", + "value": "(" + }, + { + "type": "FIELD", + "name": "precision", + "content": { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_number" + }, + "named": true, + "value": "literal" + } + }, + { + "type": "STRING", + "value": ")" + } + ] + } + ] + } + }, + { + "type": "PREC_RIGHT", + "value": 0, + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "keyword_numeric" + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "keyword_numeric" + }, + { + "type": "STRING", + "value": "(" + }, + { + "type": "FIELD", + "name": "precision", + "content": { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_number" + }, + "named": true, + "value": "literal" + } + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "FIELD", + "name": "scale", + "content": { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_number" + }, + "named": true, + "value": "literal" + } + } + ] + }, + { + "type": "STRING", + "value": ")" + } + ] + } + ] + } + } + ] + }, + "_type_character": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "keyword_text" + }, + { + "type": "SYMBOL", + "name": "char" + }, + { + "type": "SYMBOL", + "name": "varchar" + } + ] + }, + "char": { + "type": "PREC_RIGHT", + "value": 0, + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "keyword_char" + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "keyword_char" + }, + { + "type": "STRING", + "value": "(" + }, + { + "type": "FIELD", + "name": "size", + "content": { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_number" + }, + "named": true, + "value": "literal" + } + }, + { + "type": "STRING", + "value": ")" + } + ] + } + ] + } + }, + "varchar": { + "type": "PREC_RIGHT", + "value": 0, + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "keyword_varchar" + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "keyword_varchar" + }, + { + "type": "STRING", + "value": "(" + }, + { + "type": "FIELD", + "name": "size", + "content": { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_number" + }, + "named": true, + "value": "literal" + } + }, + { + "type": "STRING", + "value": ")" + } + ] + } + ] + } + }, + "_type_datetime": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "keyword_date" + }, + { + "type": "SYMBOL", + "name": "keyword_datetime" + }, + { + "type": "SYMBOL", + "name": "keyword_time" + }, + { + "type": "SYMBOL", + "name": "keyword_timestamp" + }, + { + "type": "SYMBOL", + "name": "keyword_timestamptz" + } + ] + }, + "_type_geometric": { + "type": "CHOICE", + "members": [] + }, + "_type_net": { + "type": "CHOICE", + "members": [] + }, + "_type_bit_string": { + "type": "CHOICE", + "members": [] + }, + "_type_text_search": { + "type": "CHOICE", + "members": [] + }, + "_type_json": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "keyword_json" + }, + { + "type": "SYMBOL", + "name": "keyword_jsonb" + } + ] + }, + "keyword_boolean": { + "type": "PATTERN", + "value": "boolean|BOOLEAN" + }, + "keyword_smallint": { + "type": "PATTERN", + "value": "smallint|SMALLINT" + }, + "keyword_integer": { + "type": "PATTERN", + "value": "integer|INTEGER" + }, + "keyword_bigint": { + "type": "PATTERN", + "value": "bigint|BIGINT" + }, + "keyword_decimal": { + "type": "PATTERN", + "value": "decimal|DECIMAL" + }, + "keyword_numeric": { + "type": "PATTERN", + "value": "numeric|NUMERIC" + }, + "keyword_real": { + "type": "PATTERN", + "value": "real|REAL" + }, + "keyword_smallserial": { + "type": "PATTERN", + "value": "smallserial|SMALLSERIAL" + }, + "keyword_serial": { + "type": "PATTERN", + "value": "serial|SERIAL" + }, + "keyword_bigserial": { + "type": "PATTERN", + "value": "bigserial|BIGSERIAL" + }, + "keyword_money": { + "type": "PATTERN", + "value": "money|MONEY" + }, + "keyword_text": { + "type": "PATTERN", + "value": "text|TEXT" + }, + "keyword_char": { + "type": "CHOICE", + "members": [ + { + "type": "PATTERN", + "value": "character|CHARACTER" + }, + { + "type": "PATTERN", + "value": "char|CHAR" + } + ] + }, + "keyword_varchar": { + "type": "CHOICE", + "members": [ + { + "type": "PATTERN", + "value": "varchar|VARCHAR" + }, + { + "type": "SEQ", + "members": [ + { + "type": "PATTERN", + "value": "character|CHARACTER" + } + ] + } + ] + }, + "keyword_bytea": { + "type": "PATTERN", + "value": "bytea|BYTEA" + }, + "keyword_date": { + "type": "PATTERN", + "value": "date|DATE" + }, + "keyword_datetime": { + "type": "PATTERN", + "value": "datetime|DATETIME" + }, + "keyword_time": { + "type": "SEQ", + "members": [ + { + "type": "PATTERN", + "value": "time|TIME" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "_without_time_zone" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "SYMBOL", + "name": "_with_time_zone" + } + ] + } + ] + }, + "keyword_timestamp": { + "type": "SEQ", + "members": [ + { + "type": "PATTERN", + "value": "timestamp|TIMESTAMP" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "_without_time_zone" + }, + { + "type": "BLANK" + } + ] + } + ] + }, + "keyword_timestamptz": { + "type": "CHOICE", + "members": [ + { + "type": "PATTERN", + "value": "timestamptz|TIMESTAMPTZ" + }, + { + "type": "SEQ", + "members": [ + { + "type": "PATTERN", + "value": "timestamp|TIMESTAMP" + }, + { + "type": "SYMBOL", + "name": "_with_time_zone" + } + ] + } + ] + }, + "_without_time_zone": { "type": "SEQ", "members": [ { "type": "SYMBOL", - "name": "keyword_if" + "name": "_keyword_without" }, { "type": "SYMBOL", - "name": "keyword_not" - }, - { - "type": "SYMBOL", - "name": "keyword_exists" + "name": "_keyword_time_zone" } ] }, + "_with_time_zone": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "_keyword_with" + }, + { + "type": "SYMBOL", + "name": "_keyword_time_zone" + } + ] + }, + "_keyword_without": { + "type": "PATTERN", + "value": "without|WITHOUT" + }, + "_keyword_with": { + "type": "PATTERN", + "value": "with|WITH" + }, + "_keyword_time_zone": { + "type": "SEQ", + "members": [ + { + "type": "PATTERN", + "value": "time|TIME" + }, + { + "type": "PATTERN", + "value": "zone|ZONE" + } + ] + }, + "keyword_uuid": { + "type": "PATTERN", + "value": "uuid|UUID" + }, + "keyword_xml": { + "type": "PATTERN", + "value": "xml|XML" + }, + "keyword_json": { + "type": "PATTERN", + "value": "json|JSON" + }, + "keyword_jsonb": { + "type": "PATTERN", + "value": "jsonb|JSONB" + }, "comment": { "type": "SEQ", "members": [ @@ -298,6 +1027,10 @@ } ] }, + "_number": { + "type": "PATTERN", + "value": "\\d+" + }, "identifier": { "type": "CHOICE", "members": [ @@ -347,7 +1080,12 @@ "name": "marginalia" } ], - "conflicts": [], + "conflicts": [ + [ + "keyword_char", + "keyword_varchar" + ] + ], "precedences": [], "externals": [], "inline": [], diff --git a/src/node-types.json b/src/node-types.json index d7fb2de..c58c0df 100644 --- a/src/node-types.json +++ b/src/node-types.json @@ -1,8 +1,132 @@ [ + { + "type": "char", + "named": true, + "fields": { + "size": { + "multiple": false, + "required": false, + "types": [ + { + "type": "literal", + "named": true + } + ] + } + }, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "keyword_char", + "named": true + } + ] + } + }, { "type": "column_definition", "named": true, "fields": { + "datatype": { + "multiple": false, + "required": true, + "types": [ + { + "type": "char", + "named": true + }, + { + "type": "decimal", + "named": true + }, + { + "type": "double", + "named": true + }, + { + "type": "keyword_bigint", + "named": true + }, + { + "type": "keyword_bigserial", + "named": true + }, + { + "type": "keyword_boolean", + "named": true + }, + { + "type": "keyword_bytea", + "named": true + }, + { + "type": "keyword_date", + "named": true + }, + { + "type": "keyword_datetime", + "named": true + }, + { + "type": "keyword_integer", + "named": true + }, + { + "type": "keyword_money", + "named": true + }, + { + "type": "keyword_real", + "named": true + }, + { + "type": "keyword_serial", + "named": true + }, + { + "type": "keyword_smallint", + "named": true + }, + { + "type": "keyword_smallserial", + "named": true + }, + { + "type": "keyword_text", + "named": true + }, + { + "type": "keyword_time", + "named": true + }, + { + "type": "keyword_timestamp", + "named": true + }, + { + "type": "keyword_timestamptz", + "named": true + }, + { + "type": "keyword_uuid", + "named": true + }, + { + "type": "keyword_xml", + "named": true + }, + { + "type": "numeric", + "named": true + }, + { + "type": "varchar", + "named": true + } + ] + }, "name": { "multiple": false, "required": true, @@ -82,21 +206,123 @@ ] } }, + { + "type": "decimal", + "named": true, + "fields": { + "precision": { + "multiple": false, + "required": false, + "types": [ + { + "type": "literal", + "named": true + } + ] + }, + "scale": { + "multiple": false, + "required": false, + "types": [ + { + "type": "literal", + "named": true + } + ] + } + }, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "keyword_decimal", + "named": true + } + ] + } + }, + { + "type": "double", + "named": true, + "fields": {} + }, { "type": "identifier", "named": true, "fields": {} }, + { + "type": "keyword_char", + "named": true, + "fields": {} + }, { "type": "keyword_temporary", "named": true, "fields": {} }, + { + "type": "keyword_time", + "named": true, + "fields": {} + }, + { + "type": "keyword_timestamp", + "named": true, + "fields": {} + }, + { + "type": "keyword_timestamptz", + "named": true, + "fields": {} + }, + { + "type": "keyword_varchar", + "named": true, + "fields": {} + }, { "type": "marginalia", "named": true, "fields": {} }, + { + "type": "numeric", + "named": true, + "fields": { + "precision": { + "multiple": false, + "required": false, + "types": [ + { + "type": "literal", + "named": true + } + ] + }, + "scale": { + "multiple": false, + "required": false, + "types": [ + { + "type": "literal", + "named": true + } + ] + } + }, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "keyword_numeric", + "named": true + } + ] + } + }, { "type": "source_file", "named": true, @@ -153,6 +379,32 @@ } } }, + { + "type": "varchar", + "named": true, + "fields": { + "size": { + "multiple": false, + "required": false, + "types": [ + { + "type": "literal", + "named": true + } + ] + } + }, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "keyword_varchar", + "named": true + } + ] + } + }, { "type": "\"", "named": false @@ -189,10 +441,38 @@ "type": ";", "named": false }, + { + "type": "keyword_bigint", + "named": true + }, + { + "type": "keyword_bigserial", + "named": true + }, + { + "type": "keyword_boolean", + "named": true + }, + { + "type": "keyword_bytea", + "named": true + }, { "type": "keyword_create", "named": true }, + { + "type": "keyword_date", + "named": true + }, + { + "type": "keyword_datetime", + "named": true + }, + { + "type": "keyword_decimal", + "named": true + }, { "type": "keyword_exists", "named": true @@ -201,16 +481,68 @@ "type": "keyword_if", "named": true }, + { + "type": "keyword_integer", + "named": true + }, + { + "type": "keyword_json", + "named": true + }, + { + "type": "keyword_jsonb", + "named": true + }, + { + "type": "keyword_money", + "named": true + }, { "type": "keyword_not", "named": true }, + { + "type": "keyword_numeric", + "named": true + }, + { + "type": "keyword_real", + "named": true + }, + { + "type": "keyword_serial", + "named": true + }, + { + "type": "keyword_smallint", + "named": true + }, + { + "type": "keyword_smallserial", + "named": true + }, { "type": "keyword_table", "named": true }, + { + "type": "keyword_text", + "named": true + }, { "type": "keyword_unlogged", "named": true + }, + { + "type": "keyword_uuid", + "named": true + }, + { + "type": "keyword_xml", + "named": true + }, + { + "type": "literal", + "named": true } ] \ No newline at end of file diff --git a/src/parser.c b/src/parser.c index 69a8723..7ee0c79 100644 --- a/src/parser.c +++ b/src/parser.c @@ -6,23 +6,23 @@ #endif #define LANGUAGE_VERSION 14 -#define STATE_COUNT 49 -#define LARGE_STATE_COUNT 2 -#define SYMBOL_COUNT 36 +#define STATE_COUNT 93 +#define LARGE_STATE_COUNT 3 +#define SYMBOL_COUNT 88 #define ALIAS_COUNT 0 -#define TOKEN_COUNT 21 +#define TOKEN_COUNT 52 #define EXTERNAL_TOKEN_COUNT 0 -#define FIELD_COUNT 2 +#define FIELD_COUNT 6 #define MAX_ALIAS_SEQUENCE_LENGTH 6 -#define PRODUCTION_ID_COUNT 3 +#define PRODUCTION_ID_COUNT 7 enum { sym__identifier = 1, anon_sym_SEMI = 2, - anon_sym_DOT = 3, - anon_sym_LPAREN = 4, - anon_sym_COMMA = 5, - anon_sym_RPAREN = 6, + anon_sym_LPAREN = 3, + anon_sym_COMMA = 4, + anon_sym_RPAREN = 5, + anon_sym_DOT = 6, sym_keyword_create = 7, sym_keyword_table = 8, aux_sym_keyword_temporary_token1 = 9, @@ -31,37 +31,89 @@ enum { sym_keyword_if = 12, sym_keyword_not = 13, sym_keyword_exists = 14, - anon_sym_DASH_DASH = 15, - aux_sym_comment_token1 = 16, - anon_sym_SLASH_STAR = 17, - aux_sym_marginalia_token1 = 18, - anon_sym_SLASH = 19, - anon_sym_DQUOTE = 20, - sym_source_file = 21, - sym_statement = 22, - sym__ddl_statement = 23, - sym__create_statement = 24, - sym_create_table = 25, - sym_table_reference = 26, - sym_column_definitions = 27, - sym_column_definition = 28, - sym_keyword_temporary = 29, - sym__if_not_exists = 30, - sym_comment = 31, - sym_marginalia = 32, - sym_identifier = 33, - aux_sym_source_file_repeat1 = 34, - aux_sym_column_definitions_repeat1 = 35, + aux_sym_double_token1 = 15, + aux_sym_double_token2 = 16, + sym_keyword_boolean = 17, + sym_keyword_smallint = 18, + sym_keyword_integer = 19, + sym_keyword_bigint = 20, + sym_keyword_decimal = 21, + sym_keyword_numeric = 22, + sym_keyword_real = 23, + sym_keyword_smallserial = 24, + sym_keyword_serial = 25, + sym_keyword_bigserial = 26, + sym_keyword_money = 27, + sym_keyword_text = 28, + aux_sym_keyword_char_token1 = 29, + aux_sym_keyword_char_token2 = 30, + aux_sym_keyword_varchar_token1 = 31, + sym_keyword_bytea = 32, + sym_keyword_date = 33, + sym_keyword_datetime = 34, + aux_sym_keyword_time_token1 = 35, + aux_sym_keyword_timestamp_token1 = 36, + aux_sym_keyword_timestamptz_token1 = 37, + sym__keyword_without = 38, + sym__keyword_with = 39, + aux_sym__keyword_time_zone_token1 = 40, + sym_keyword_uuid = 41, + sym_keyword_xml = 42, + sym_keyword_json = 43, + sym_keyword_jsonb = 44, + anon_sym_DASH_DASH = 45, + aux_sym_comment_token1 = 46, + anon_sym_SLASH_STAR = 47, + aux_sym_marginalia_token1 = 48, + anon_sym_SLASH = 49, + sym__number = 50, + anon_sym_DQUOTE = 51, + sym_source_file = 52, + sym_statement = 53, + sym__ddl_statement = 54, + sym__create_statement = 55, + sym_create_table = 56, + sym_column_definitions = 57, + sym_column_definition = 58, + sym_table_reference = 59, + sym__if_not_exists = 60, + sym_keyword_temporary = 61, + sym__type = 62, + sym__type_numeric = 63, + sym_double = 64, + sym_decimal = 65, + sym_numeric = 66, + sym__type_character = 67, + sym_char = 68, + sym_varchar = 69, + sym__type_datetime = 70, + sym__type_geometric = 71, + sym__type_net = 72, + sym__type_bit_string = 73, + sym__type_text_search = 74, + sym_keyword_char = 75, + sym_keyword_varchar = 76, + sym_keyword_time = 77, + sym_keyword_timestamp = 78, + sym_keyword_timestamptz = 79, + sym__without_time_zone = 80, + sym__with_time_zone = 81, + sym__keyword_time_zone = 82, + sym_comment = 83, + sym_marginalia = 84, + sym_identifier = 85, + aux_sym_source_file_repeat1 = 86, + aux_sym_column_definitions_repeat1 = 87, }; static const char * const ts_symbol_names[] = { [ts_builtin_sym_end] = "end", [sym__identifier] = "_identifier", [anon_sym_SEMI] = ";", - [anon_sym_DOT] = ".", [anon_sym_LPAREN] = "(", [anon_sym_COMMA] = ",", [anon_sym_RPAREN] = ")", + [anon_sym_DOT] = ".", [sym_keyword_create] = "keyword_create", [sym_keyword_table] = "keyword_table", [aux_sym_keyword_temporary_token1] = "keyword_temporary_token1", @@ -70,22 +122,74 @@ static const char * const ts_symbol_names[] = { [sym_keyword_if] = "keyword_if", [sym_keyword_not] = "keyword_not", [sym_keyword_exists] = "keyword_exists", + [aux_sym_double_token1] = "double_token1", + [aux_sym_double_token2] = "double_token2", + [sym_keyword_boolean] = "keyword_boolean", + [sym_keyword_smallint] = "keyword_smallint", + [sym_keyword_integer] = "keyword_integer", + [sym_keyword_bigint] = "keyword_bigint", + [sym_keyword_decimal] = "keyword_decimal", + [sym_keyword_numeric] = "keyword_numeric", + [sym_keyword_real] = "keyword_real", + [sym_keyword_smallserial] = "keyword_smallserial", + [sym_keyword_serial] = "keyword_serial", + [sym_keyword_bigserial] = "keyword_bigserial", + [sym_keyword_money] = "keyword_money", + [sym_keyword_text] = "keyword_text", + [aux_sym_keyword_char_token1] = "keyword_char_token1", + [aux_sym_keyword_char_token2] = "keyword_char_token2", + [aux_sym_keyword_varchar_token1] = "keyword_varchar_token1", + [sym_keyword_bytea] = "keyword_bytea", + [sym_keyword_date] = "keyword_date", + [sym_keyword_datetime] = "keyword_datetime", + [aux_sym_keyword_time_token1] = "keyword_time_token1", + [aux_sym_keyword_timestamp_token1] = "keyword_timestamp_token1", + [aux_sym_keyword_timestamptz_token1] = "keyword_timestamptz_token1", + [sym__keyword_without] = "_keyword_without", + [sym__keyword_with] = "_keyword_with", + [aux_sym__keyword_time_zone_token1] = "_keyword_time_zone_token1", + [sym_keyword_uuid] = "keyword_uuid", + [sym_keyword_xml] = "keyword_xml", + [sym_keyword_json] = "keyword_json", + [sym_keyword_jsonb] = "keyword_jsonb", [anon_sym_DASH_DASH] = "--", [aux_sym_comment_token1] = "comment_token1", [anon_sym_SLASH_STAR] = "/*", [aux_sym_marginalia_token1] = "marginalia_token1", [anon_sym_SLASH] = "/", + [sym__number] = "literal", [anon_sym_DQUOTE] = "\"", [sym_source_file] = "source_file", [sym_statement] = "statement", [sym__ddl_statement] = "_ddl_statement", [sym__create_statement] = "_create_statement", [sym_create_table] = "create_table", - [sym_table_reference] = "table_reference", [sym_column_definitions] = "column_definitions", [sym_column_definition] = "column_definition", - [sym_keyword_temporary] = "keyword_temporary", + [sym_table_reference] = "table_reference", [sym__if_not_exists] = "_if_not_exists", + [sym_keyword_temporary] = "keyword_temporary", + [sym__type] = "_type", + [sym__type_numeric] = "_type_numeric", + [sym_double] = "double", + [sym_decimal] = "decimal", + [sym_numeric] = "numeric", + [sym__type_character] = "_type_character", + [sym_char] = "char", + [sym_varchar] = "varchar", + [sym__type_datetime] = "_type_datetime", + [sym__type_geometric] = "_type_geometric", + [sym__type_net] = "_type_net", + [sym__type_bit_string] = "_type_bit_string", + [sym__type_text_search] = "_type_text_search", + [sym_keyword_char] = "keyword_char", + [sym_keyword_varchar] = "keyword_varchar", + [sym_keyword_time] = "keyword_time", + [sym_keyword_timestamp] = "keyword_timestamp", + [sym_keyword_timestamptz] = "keyword_timestamptz", + [sym__without_time_zone] = "_without_time_zone", + [sym__with_time_zone] = "_with_time_zone", + [sym__keyword_time_zone] = "_keyword_time_zone", [sym_comment] = "comment", [sym_marginalia] = "marginalia", [sym_identifier] = "identifier", @@ -97,10 +201,10 @@ static const TSSymbol ts_symbol_map[] = { [ts_builtin_sym_end] = ts_builtin_sym_end, [sym__identifier] = sym__identifier, [anon_sym_SEMI] = anon_sym_SEMI, - [anon_sym_DOT] = anon_sym_DOT, [anon_sym_LPAREN] = anon_sym_LPAREN, [anon_sym_COMMA] = anon_sym_COMMA, [anon_sym_RPAREN] = anon_sym_RPAREN, + [anon_sym_DOT] = anon_sym_DOT, [sym_keyword_create] = sym_keyword_create, [sym_keyword_table] = sym_keyword_table, [aux_sym_keyword_temporary_token1] = aux_sym_keyword_temporary_token1, @@ -109,22 +213,74 @@ static const TSSymbol ts_symbol_map[] = { [sym_keyword_if] = sym_keyword_if, [sym_keyword_not] = sym_keyword_not, [sym_keyword_exists] = sym_keyword_exists, + [aux_sym_double_token1] = aux_sym_double_token1, + [aux_sym_double_token2] = aux_sym_double_token2, + [sym_keyword_boolean] = sym_keyword_boolean, + [sym_keyword_smallint] = sym_keyword_smallint, + [sym_keyword_integer] = sym_keyword_integer, + [sym_keyword_bigint] = sym_keyword_bigint, + [sym_keyword_decimal] = sym_keyword_decimal, + [sym_keyword_numeric] = sym_keyword_numeric, + [sym_keyword_real] = sym_keyword_real, + [sym_keyword_smallserial] = sym_keyword_smallserial, + [sym_keyword_serial] = sym_keyword_serial, + [sym_keyword_bigserial] = sym_keyword_bigserial, + [sym_keyword_money] = sym_keyword_money, + [sym_keyword_text] = sym_keyword_text, + [aux_sym_keyword_char_token1] = aux_sym_keyword_char_token1, + [aux_sym_keyword_char_token2] = aux_sym_keyword_char_token2, + [aux_sym_keyword_varchar_token1] = aux_sym_keyword_varchar_token1, + [sym_keyword_bytea] = sym_keyword_bytea, + [sym_keyword_date] = sym_keyword_date, + [sym_keyword_datetime] = sym_keyword_datetime, + [aux_sym_keyword_time_token1] = aux_sym_keyword_time_token1, + [aux_sym_keyword_timestamp_token1] = aux_sym_keyword_timestamp_token1, + [aux_sym_keyword_timestamptz_token1] = aux_sym_keyword_timestamptz_token1, + [sym__keyword_without] = sym__keyword_without, + [sym__keyword_with] = sym__keyword_with, + [aux_sym__keyword_time_zone_token1] = aux_sym__keyword_time_zone_token1, + [sym_keyword_uuid] = sym_keyword_uuid, + [sym_keyword_xml] = sym_keyword_xml, + [sym_keyword_json] = sym_keyword_json, + [sym_keyword_jsonb] = sym_keyword_jsonb, [anon_sym_DASH_DASH] = anon_sym_DASH_DASH, [aux_sym_comment_token1] = aux_sym_comment_token1, [anon_sym_SLASH_STAR] = anon_sym_SLASH_STAR, [aux_sym_marginalia_token1] = aux_sym_marginalia_token1, [anon_sym_SLASH] = anon_sym_SLASH, + [sym__number] = sym__number, [anon_sym_DQUOTE] = anon_sym_DQUOTE, [sym_source_file] = sym_source_file, [sym_statement] = sym_statement, [sym__ddl_statement] = sym__ddl_statement, [sym__create_statement] = sym__create_statement, [sym_create_table] = sym_create_table, - [sym_table_reference] = sym_table_reference, [sym_column_definitions] = sym_column_definitions, [sym_column_definition] = sym_column_definition, - [sym_keyword_temporary] = sym_keyword_temporary, + [sym_table_reference] = sym_table_reference, [sym__if_not_exists] = sym__if_not_exists, + [sym_keyword_temporary] = sym_keyword_temporary, + [sym__type] = sym__type, + [sym__type_numeric] = sym__type_numeric, + [sym_double] = sym_double, + [sym_decimal] = sym_decimal, + [sym_numeric] = sym_numeric, + [sym__type_character] = sym__type_character, + [sym_char] = sym_char, + [sym_varchar] = sym_varchar, + [sym__type_datetime] = sym__type_datetime, + [sym__type_geometric] = sym__type_geometric, + [sym__type_net] = sym__type_net, + [sym__type_bit_string] = sym__type_bit_string, + [sym__type_text_search] = sym__type_text_search, + [sym_keyword_char] = sym_keyword_char, + [sym_keyword_varchar] = sym_keyword_varchar, + [sym_keyword_time] = sym_keyword_time, + [sym_keyword_timestamp] = sym_keyword_timestamp, + [sym_keyword_timestamptz] = sym_keyword_timestamptz, + [sym__without_time_zone] = sym__without_time_zone, + [sym__with_time_zone] = sym__with_time_zone, + [sym__keyword_time_zone] = sym__keyword_time_zone, [sym_comment] = sym_comment, [sym_marginalia] = sym_marginalia, [sym_identifier] = sym_identifier, @@ -145,10 +301,6 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = false, }, - [anon_sym_DOT] = { - .visible = true, - .named = false, - }, [anon_sym_LPAREN] = { .visible = true, .named = false, @@ -161,6 +313,10 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = false, }, + [anon_sym_DOT] = { + .visible = true, + .named = false, + }, [sym_keyword_create] = { .visible = true, .named = true, @@ -193,6 +349,126 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = true, }, + [aux_sym_double_token1] = { + .visible = false, + .named = false, + }, + [aux_sym_double_token2] = { + .visible = false, + .named = false, + }, + [sym_keyword_boolean] = { + .visible = true, + .named = true, + }, + [sym_keyword_smallint] = { + .visible = true, + .named = true, + }, + [sym_keyword_integer] = { + .visible = true, + .named = true, + }, + [sym_keyword_bigint] = { + .visible = true, + .named = true, + }, + [sym_keyword_decimal] = { + .visible = true, + .named = true, + }, + [sym_keyword_numeric] = { + .visible = true, + .named = true, + }, + [sym_keyword_real] = { + .visible = true, + .named = true, + }, + [sym_keyword_smallserial] = { + .visible = true, + .named = true, + }, + [sym_keyword_serial] = { + .visible = true, + .named = true, + }, + [sym_keyword_bigserial] = { + .visible = true, + .named = true, + }, + [sym_keyword_money] = { + .visible = true, + .named = true, + }, + [sym_keyword_text] = { + .visible = true, + .named = true, + }, + [aux_sym_keyword_char_token1] = { + .visible = false, + .named = false, + }, + [aux_sym_keyword_char_token2] = { + .visible = false, + .named = false, + }, + [aux_sym_keyword_varchar_token1] = { + .visible = false, + .named = false, + }, + [sym_keyword_bytea] = { + .visible = true, + .named = true, + }, + [sym_keyword_date] = { + .visible = true, + .named = true, + }, + [sym_keyword_datetime] = { + .visible = true, + .named = true, + }, + [aux_sym_keyword_time_token1] = { + .visible = false, + .named = false, + }, + [aux_sym_keyword_timestamp_token1] = { + .visible = false, + .named = false, + }, + [aux_sym_keyword_timestamptz_token1] = { + .visible = false, + .named = false, + }, + [sym__keyword_without] = { + .visible = false, + .named = true, + }, + [sym__keyword_with] = { + .visible = false, + .named = true, + }, + [aux_sym__keyword_time_zone_token1] = { + .visible = false, + .named = false, + }, + [sym_keyword_uuid] = { + .visible = true, + .named = true, + }, + [sym_keyword_xml] = { + .visible = true, + .named = true, + }, + [sym_keyword_json] = { + .visible = true, + .named = true, + }, + [sym_keyword_jsonb] = { + .visible = true, + .named = true, + }, [anon_sym_DASH_DASH] = { .visible = true, .named = false, @@ -213,6 +489,10 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = false, }, + [sym__number] = { + .visible = true, + .named = true, + }, [anon_sym_DQUOTE] = { .visible = true, .named = false, @@ -237,10 +517,6 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = true, }, - [sym_table_reference] = { - .visible = true, - .named = true, - }, [sym_column_definitions] = { .visible = true, .named = true, @@ -249,7 +525,7 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = true, }, - [sym_keyword_temporary] = { + [sym_table_reference] = { .visible = true, .named = true, }, @@ -257,6 +533,94 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = false, .named = true, }, + [sym_keyword_temporary] = { + .visible = true, + .named = true, + }, + [sym__type] = { + .visible = false, + .named = true, + }, + [sym__type_numeric] = { + .visible = false, + .named = true, + }, + [sym_double] = { + .visible = true, + .named = true, + }, + [sym_decimal] = { + .visible = true, + .named = true, + }, + [sym_numeric] = { + .visible = true, + .named = true, + }, + [sym__type_character] = { + .visible = false, + .named = true, + }, + [sym_char] = { + .visible = true, + .named = true, + }, + [sym_varchar] = { + .visible = true, + .named = true, + }, + [sym__type_datetime] = { + .visible = false, + .named = true, + }, + [sym__type_geometric] = { + .visible = false, + .named = true, + }, + [sym__type_net] = { + .visible = false, + .named = true, + }, + [sym__type_bit_string] = { + .visible = false, + .named = true, + }, + [sym__type_text_search] = { + .visible = false, + .named = true, + }, + [sym_keyword_char] = { + .visible = true, + .named = true, + }, + [sym_keyword_varchar] = { + .visible = true, + .named = true, + }, + [sym_keyword_time] = { + .visible = true, + .named = true, + }, + [sym_keyword_timestamp] = { + .visible = true, + .named = true, + }, + [sym_keyword_timestamptz] = { + .visible = true, + .named = true, + }, + [sym__without_time_zone] = { + .visible = false, + .named = true, + }, + [sym__with_time_zone] = { + .visible = false, + .named = true, + }, + [sym__keyword_time_zone] = { + .visible = false, + .named = true, + }, [sym_comment] = { .visible = true, .named = true, @@ -280,19 +644,31 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { }; enum { - field_name = 1, - field_schema = 2, + field_datatype = 1, + field_name = 2, + field_precision = 3, + field_scale = 4, + field_schema = 5, + field_size = 6, }; static const char * const ts_field_names[] = { [0] = NULL, + [field_datatype] = "datatype", [field_name] = "name", + [field_precision] = "precision", + [field_scale] = "scale", [field_schema] = "schema", + [field_size] = "size", }; static const TSFieldMapSlice ts_field_map_slices[PRODUCTION_ID_COUNT] = { [1] = {.index = 0, .length = 1}, [2] = {.index = 1, .length = 2}, + [3] = {.index = 3, .length = 2}, + [4] = {.index = 5, .length = 1}, + [5] = {.index = 6, .length = 1}, + [6] = {.index = 7, .length = 2}, }; static const TSFieldMapEntry ts_field_map_entries[] = { @@ -301,6 +677,16 @@ static const TSFieldMapEntry ts_field_map_entries[] = { [1] = {field_name, 2}, {field_schema, 0}, + [3] = + {field_datatype, 1}, + {field_name, 0}, + [5] = + {field_precision, 2}, + [6] = + {field_size, 2}, + [7] = + {field_precision, 2}, + {field_scale, 4}, }; static const TSSymbol ts_alias_sequences[PRODUCTION_ID_COUNT][MAX_ALIAS_SEQUENCE_LENGTH] = { @@ -361,6 +747,50 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [46] = 46, [47] = 47, [48] = 48, + [49] = 49, + [50] = 50, + [51] = 51, + [52] = 52, + [53] = 53, + [54] = 54, + [55] = 55, + [56] = 56, + [57] = 57, + [58] = 58, + [59] = 59, + [60] = 60, + [61] = 61, + [62] = 62, + [63] = 63, + [64] = 64, + [65] = 65, + [66] = 66, + [67] = 67, + [68] = 68, + [69] = 69, + [70] = 70, + [71] = 71, + [72] = 72, + [73] = 73, + [74] = 74, + [75] = 75, + [76] = 76, + [77] = 77, + [78] = 78, + [79] = 79, + [80] = 80, + [81] = 81, + [82] = 82, + [83] = 83, + [84] = 84, + [85] = 85, + [86] = 86, + [87] = 87, + [88] = 88, + [89] = 89, + [90] = 90, + [91] = 91, + [92] = 92, }; static bool ts_lex(TSLexer *lexer, TSStateId state) { @@ -369,21 +799,22 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { switch (state) { case 0: if (eof) ADVANCE(12); - if (lookahead == '"') ADVANCE(28); - if (lookahead == '(') ADVANCE(15); - if (lookahead == ')') ADVANCE(17); - if (lookahead == ',') ADVANCE(16); + if (lookahead == '"') ADVANCE(29); + if (lookahead == '(') ADVANCE(14); + if (lookahead == ')') ADVANCE(16); + if (lookahead == ',') ADVANCE(15); if (lookahead == '-') ADVANCE(9); - if (lookahead == '.') ADVANCE(14); + if (lookahead == '.') ADVANCE(17); if (lookahead == '/') ADVANCE(27); if (lookahead == ';') ADVANCE(13); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r' || lookahead == ' ') SKIP(11) + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(28); if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(29); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(30); END_STATE(); case 1: if (lookahead == '\n') ADVANCE(22); @@ -450,17 +881,18 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == '\n' || lookahead == '\r' || lookahead == ' ') SKIP(11) - if (lookahead == '"') ADVANCE(28); - if (lookahead == '(') ADVANCE(15); - if (lookahead == ')') ADVANCE(17); - if (lookahead == ',') ADVANCE(16); + if (lookahead == '"') ADVANCE(29); + if (lookahead == '(') ADVANCE(14); + if (lookahead == ')') ADVANCE(16); + if (lookahead == ',') ADVANCE(15); if (lookahead == '-') ADVANCE(9); - if (lookahead == '.') ADVANCE(14); + if (lookahead == '.') ADVANCE(17); if (lookahead == '/') ADVANCE(27); if (lookahead == ';') ADVANCE(13); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(28); if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(29); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(30); END_STATE(); case 12: ACCEPT_TOKEN(ts_builtin_sym_end); @@ -469,17 +901,17 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { ACCEPT_TOKEN(anon_sym_SEMI); END_STATE(); case 14: - ACCEPT_TOKEN(anon_sym_DOT); - END_STATE(); - case 15: ACCEPT_TOKEN(anon_sym_LPAREN); END_STATE(); - case 16: + case 15: ACCEPT_TOKEN(anon_sym_COMMA); END_STATE(); - case 17: + case 16: ACCEPT_TOKEN(anon_sym_RPAREN); END_STATE(); + case 17: + ACCEPT_TOKEN(anon_sym_DOT); + END_STATE(); case 18: ACCEPT_TOKEN(anon_sym_DASH_DASH); END_STATE(); @@ -531,14 +963,18 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { if (lookahead == '*') ADVANCE(23); END_STATE(); case 28: - ACCEPT_TOKEN(anon_sym_DQUOTE); + ACCEPT_TOKEN(sym__number); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(28); END_STATE(); case 29: + ACCEPT_TOKEN(anon_sym_DQUOTE); + END_STATE(); + case 30: ACCEPT_TOKEN(sym__identifier); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(29); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(30); END_STATE(); default: return false; @@ -550,252 +986,1096 @@ static bool ts_lex_keywords(TSLexer *lexer, TSStateId state) { eof = lexer->eof(lexer); switch (state) { case 0: - if (lookahead == 'C') ADVANCE(1); - if (lookahead == 'E') ADVANCE(2); - if (lookahead == 'I') ADVANCE(3); - if (lookahead == 'N') ADVANCE(4); - if (lookahead == 'T') ADVANCE(5); - if (lookahead == 'U') ADVANCE(6); - if (lookahead == 'c') ADVANCE(7); - if (lookahead == 'e') ADVANCE(8); - if (lookahead == 'i') ADVANCE(9); - if (lookahead == 'n') ADVANCE(10); - if (lookahead == 't') ADVANCE(11); - if (lookahead == 'u') ADVANCE(12); + if (lookahead == 'B') ADVANCE(1); + if (lookahead == 'C') ADVANCE(2); + if (lookahead == 'D') ADVANCE(3); + if (lookahead == 'E') ADVANCE(4); + if (lookahead == 'I') ADVANCE(5); + if (lookahead == 'J') ADVANCE(6); + if (lookahead == 'M') ADVANCE(7); + if (lookahead == 'N') ADVANCE(8); + if (lookahead == 'P') ADVANCE(9); + if (lookahead == 'R') ADVANCE(10); + if (lookahead == 'S') ADVANCE(11); + if (lookahead == 'T') ADVANCE(12); + if (lookahead == 'U') ADVANCE(13); + if (lookahead == 'V') ADVANCE(14); + if (lookahead == 'W') ADVANCE(15); + if (lookahead == 'X') ADVANCE(16); + if (lookahead == 'Z') ADVANCE(17); + if (lookahead == 'b') ADVANCE(18); + if (lookahead == 'c') ADVANCE(19); + if (lookahead == 'd') ADVANCE(20); + if (lookahead == 'e') ADVANCE(21); + if (lookahead == 'i') ADVANCE(22); + if (lookahead == 'j') ADVANCE(23); + if (lookahead == 'm') ADVANCE(24); + if (lookahead == 'n') ADVANCE(25); + if (lookahead == 'p') ADVANCE(26); + if (lookahead == 'r') ADVANCE(27); + if (lookahead == 's') ADVANCE(28); + if (lookahead == 't') ADVANCE(29); + if (lookahead == 'u') ADVANCE(30); + if (lookahead == 'v') ADVANCE(31); + if (lookahead == 'w') ADVANCE(32); + if (lookahead == 'x') ADVANCE(33); + if (lookahead == 'z') ADVANCE(34); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r' || - lookahead == ' ') SKIP(13) + lookahead == ' ') SKIP(35) END_STATE(); case 1: - if (lookahead == 'R') ADVANCE(14); + if (lookahead == 'I') ADVANCE(36); + if (lookahead == 'O') ADVANCE(37); + if (lookahead == 'Y') ADVANCE(38); END_STATE(); case 2: - if (lookahead == 'X') ADVANCE(15); + if (lookahead == 'H') ADVANCE(39); + if (lookahead == 'R') ADVANCE(40); END_STATE(); case 3: - if (lookahead == 'F') ADVANCE(16); + if (lookahead == 'A') ADVANCE(41); + if (lookahead == 'E') ADVANCE(42); + if (lookahead == 'O') ADVANCE(43); END_STATE(); case 4: - if (lookahead == 'O') ADVANCE(17); + if (lookahead == 'X') ADVANCE(44); END_STATE(); case 5: - if (lookahead == 'A') ADVANCE(18); - if (lookahead == 'E') ADVANCE(19); + if (lookahead == 'F') ADVANCE(45); + if (lookahead == 'N') ADVANCE(46); END_STATE(); case 6: - if (lookahead == 'N') ADVANCE(20); + if (lookahead == 'S') ADVANCE(47); END_STATE(); case 7: - if (lookahead == 'r') ADVANCE(21); + if (lookahead == 'O') ADVANCE(48); END_STATE(); case 8: - if (lookahead == 'x') ADVANCE(22); + if (lookahead == 'O') ADVANCE(49); + if (lookahead == 'U') ADVANCE(50); END_STATE(); case 9: - if (lookahead == 'f') ADVANCE(16); + if (lookahead == 'R') ADVANCE(51); END_STATE(); case 10: - if (lookahead == 'o') ADVANCE(23); + if (lookahead == 'E') ADVANCE(52); END_STATE(); case 11: - if (lookahead == 'a') ADVANCE(24); - if (lookahead == 'e') ADVANCE(25); + if (lookahead == 'E') ADVANCE(53); + if (lookahead == 'M') ADVANCE(54); END_STATE(); case 12: - if (lookahead == 'n') ADVANCE(26); + if (lookahead == 'A') ADVANCE(55); + if (lookahead == 'E') ADVANCE(56); + if (lookahead == 'I') ADVANCE(57); END_STATE(); case 13: + if (lookahead == 'N') ADVANCE(58); + if (lookahead == 'U') ADVANCE(59); + END_STATE(); + case 14: + if (lookahead == 'A') ADVANCE(60); + END_STATE(); + case 15: + if (lookahead == 'I') ADVANCE(61); + END_STATE(); + case 16: + if (lookahead == 'M') ADVANCE(62); + END_STATE(); + case 17: + if (lookahead == 'O') ADVANCE(63); + END_STATE(); + case 18: + if (lookahead == 'i') ADVANCE(64); + if (lookahead == 'o') ADVANCE(65); + if (lookahead == 'y') ADVANCE(66); + END_STATE(); + case 19: + if (lookahead == 'h') ADVANCE(67); + if (lookahead == 'r') ADVANCE(68); + END_STATE(); + case 20: + if (lookahead == 'a') ADVANCE(69); + if (lookahead == 'e') ADVANCE(70); + if (lookahead == 'o') ADVANCE(71); + END_STATE(); + case 21: + if (lookahead == 'x') ADVANCE(72); + END_STATE(); + case 22: + if (lookahead == 'f') ADVANCE(45); + if (lookahead == 'n') ADVANCE(73); + END_STATE(); + case 23: + if (lookahead == 's') ADVANCE(74); + END_STATE(); + case 24: + if (lookahead == 'o') ADVANCE(75); + END_STATE(); + case 25: + if (lookahead == 'o') ADVANCE(76); + if (lookahead == 'u') ADVANCE(77); + END_STATE(); + case 26: + if (lookahead == 'r') ADVANCE(78); + END_STATE(); + case 27: + if (lookahead == 'e') ADVANCE(79); + END_STATE(); + case 28: + if (lookahead == 'e') ADVANCE(80); + if (lookahead == 'm') ADVANCE(81); + END_STATE(); + case 29: + if (lookahead == 'a') ADVANCE(82); + if (lookahead == 'e') ADVANCE(83); + if (lookahead == 'i') ADVANCE(84); + END_STATE(); + case 30: + if (lookahead == 'n') ADVANCE(85); + if (lookahead == 'u') ADVANCE(86); + END_STATE(); + case 31: + if (lookahead == 'a') ADVANCE(87); + END_STATE(); + case 32: + if (lookahead == 'i') ADVANCE(88); + END_STATE(); + case 33: + if (lookahead == 'm') ADVANCE(89); + END_STATE(); + case 34: + if (lookahead == 'o') ADVANCE(90); + END_STATE(); + case 35: if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r' || - lookahead == ' ') SKIP(13) - if (lookahead == 'C') ADVANCE(1); - if (lookahead == 'E') ADVANCE(2); - if (lookahead == 'I') ADVANCE(3); - if (lookahead == 'N') ADVANCE(4); - if (lookahead == 'T') ADVANCE(5); - if (lookahead == 'U') ADVANCE(6); - if (lookahead == 'c') ADVANCE(7); - if (lookahead == 'e') ADVANCE(8); - if (lookahead == 'i') ADVANCE(9); - if (lookahead == 'n') ADVANCE(10); - if (lookahead == 't') ADVANCE(11); - if (lookahead == 'u') ADVANCE(12); - END_STATE(); - case 14: - if (lookahead == 'E') ADVANCE(27); - END_STATE(); - case 15: - if (lookahead == 'I') ADVANCE(28); - END_STATE(); - case 16: - ACCEPT_TOKEN(sym_keyword_if); - END_STATE(); - case 17: - if (lookahead == 'T') ADVANCE(29); - END_STATE(); - case 18: - if (lookahead == 'B') ADVANCE(30); - END_STATE(); - case 19: - if (lookahead == 'M') ADVANCE(31); - END_STATE(); - case 20: - if (lookahead == 'L') ADVANCE(32); - END_STATE(); - case 21: - if (lookahead == 'e') ADVANCE(33); - END_STATE(); - case 22: - if (lookahead == 'i') ADVANCE(34); - END_STATE(); - case 23: + lookahead == ' ') SKIP(35) + if (lookahead == 'B') ADVANCE(1); + if (lookahead == 'C') ADVANCE(2); + if (lookahead == 'D') ADVANCE(3); + if (lookahead == 'E') ADVANCE(4); + if (lookahead == 'I') ADVANCE(5); + if (lookahead == 'J') ADVANCE(6); + if (lookahead == 'M') ADVANCE(7); + if (lookahead == 'N') ADVANCE(8); + if (lookahead == 'P') ADVANCE(9); + if (lookahead == 'R') ADVANCE(10); + if (lookahead == 'S') ADVANCE(11); + if (lookahead == 'T') ADVANCE(12); + if (lookahead == 'U') ADVANCE(13); + if (lookahead == 'V') ADVANCE(14); + if (lookahead == 'W') ADVANCE(15); + if (lookahead == 'X') ADVANCE(16); + if (lookahead == 'Z') ADVANCE(17); + if (lookahead == 'b') ADVANCE(18); + if (lookahead == 'c') ADVANCE(19); + if (lookahead == 'd') ADVANCE(20); + if (lookahead == 'e') ADVANCE(21); + if (lookahead == 'i') ADVANCE(22); + if (lookahead == 'j') ADVANCE(23); + if (lookahead == 'm') ADVANCE(24); + if (lookahead == 'n') ADVANCE(25); + if (lookahead == 'p') ADVANCE(26); + if (lookahead == 'r') ADVANCE(27); + if (lookahead == 's') ADVANCE(28); if (lookahead == 't') ADVANCE(29); - END_STATE(); - case 24: - if (lookahead == 'b') ADVANCE(35); - END_STATE(); - case 25: - if (lookahead == 'm') ADVANCE(36); - END_STATE(); - case 26: - if (lookahead == 'l') ADVANCE(37); - END_STATE(); - case 27: - if (lookahead == 'A') ADVANCE(38); - END_STATE(); - case 28: - if (lookahead == 'S') ADVANCE(39); - END_STATE(); - case 29: - ACCEPT_TOKEN(sym_keyword_not); - END_STATE(); - case 30: - if (lookahead == 'L') ADVANCE(40); - END_STATE(); - case 31: - if (lookahead == 'P') ADVANCE(41); - END_STATE(); - case 32: - if (lookahead == 'O') ADVANCE(42); - END_STATE(); - case 33: - if (lookahead == 'a') ADVANCE(43); - END_STATE(); - case 34: - if (lookahead == 's') ADVANCE(44); - END_STATE(); - case 35: - if (lookahead == 'l') ADVANCE(45); + if (lookahead == 'u') ADVANCE(30); + if (lookahead == 'v') ADVANCE(31); + if (lookahead == 'w') ADVANCE(32); + if (lookahead == 'x') ADVANCE(33); + if (lookahead == 'z') ADVANCE(34); END_STATE(); case 36: - if (lookahead == 'p') ADVANCE(46); + if (lookahead == 'G') ADVANCE(91); END_STATE(); case 37: - if (lookahead == 'o') ADVANCE(47); + if (lookahead == 'O') ADVANCE(92); END_STATE(); case 38: - if (lookahead == 'T') ADVANCE(48); + if (lookahead == 'T') ADVANCE(93); END_STATE(); case 39: - if (lookahead == 'T') ADVANCE(49); + if (lookahead == 'A') ADVANCE(94); END_STATE(); case 40: - if (lookahead == 'E') ADVANCE(50); + if (lookahead == 'E') ADVANCE(95); END_STATE(); case 41: - ACCEPT_TOKEN(aux_sym_keyword_temporary_token2); - if (lookahead == 'O') ADVANCE(51); + if (lookahead == 'T') ADVANCE(96); END_STATE(); case 42: - if (lookahead == 'G') ADVANCE(52); + if (lookahead == 'C') ADVANCE(97); END_STATE(); case 43: - if (lookahead == 't') ADVANCE(53); + if (lookahead == 'U') ADVANCE(98); END_STATE(); case 44: - if (lookahead == 't') ADVANCE(54); + if (lookahead == 'I') ADVANCE(99); END_STATE(); case 45: - if (lookahead == 'e') ADVANCE(50); + ACCEPT_TOKEN(sym_keyword_if); END_STATE(); case 46: - ACCEPT_TOKEN(aux_sym_keyword_temporary_token2); - if (lookahead == 'o') ADVANCE(55); + if (lookahead == 'T') ADVANCE(100); END_STATE(); case 47: - if (lookahead == 'g') ADVANCE(56); + if (lookahead == 'O') ADVANCE(101); END_STATE(); case 48: - if (lookahead == 'E') ADVANCE(57); + if (lookahead == 'N') ADVANCE(102); END_STATE(); case 49: - if (lookahead == 'S') ADVANCE(58); + if (lookahead == 'T') ADVANCE(103); END_STATE(); case 50: - ACCEPT_TOKEN(sym_keyword_table); + if (lookahead == 'M') ADVANCE(104); END_STATE(); case 51: - if (lookahead == 'R') ADVANCE(59); + if (lookahead == 'E') ADVANCE(105); END_STATE(); case 52: - if (lookahead == 'G') ADVANCE(60); + if (lookahead == 'A') ADVANCE(106); END_STATE(); case 53: - if (lookahead == 'e') ADVANCE(57); + if (lookahead == 'R') ADVANCE(107); END_STATE(); case 54: - if (lookahead == 's') ADVANCE(58); + if (lookahead == 'A') ADVANCE(108); END_STATE(); case 55: - if (lookahead == 'r') ADVANCE(61); + if (lookahead == 'B') ADVANCE(109); END_STATE(); case 56: - if (lookahead == 'g') ADVANCE(62); + if (lookahead == 'M') ADVANCE(110); + if (lookahead == 'X') ADVANCE(111); END_STATE(); case 57: - ACCEPT_TOKEN(sym_keyword_create); + if (lookahead == 'M') ADVANCE(112); END_STATE(); case 58: - ACCEPT_TOKEN(sym_keyword_exists); + if (lookahead == 'L') ADVANCE(113); END_STATE(); case 59: - if (lookahead == 'A') ADVANCE(63); + if (lookahead == 'I') ADVANCE(114); END_STATE(); case 60: - if (lookahead == 'E') ADVANCE(64); + if (lookahead == 'R') ADVANCE(115); END_STATE(); case 61: - if (lookahead == 'a') ADVANCE(65); + if (lookahead == 'T') ADVANCE(116); END_STATE(); case 62: - if (lookahead == 'e') ADVANCE(66); + if (lookahead == 'L') ADVANCE(117); END_STATE(); case 63: - if (lookahead == 'R') ADVANCE(67); + if (lookahead == 'N') ADVANCE(118); END_STATE(); case 64: - if (lookahead == 'D') ADVANCE(68); + if (lookahead == 'g') ADVANCE(119); END_STATE(); case 65: - if (lookahead == 'r') ADVANCE(69); + if (lookahead == 'o') ADVANCE(120); END_STATE(); case 66: - if (lookahead == 'd') ADVANCE(68); + if (lookahead == 't') ADVANCE(121); END_STATE(); case 67: - if (lookahead == 'Y') ADVANCE(70); + if (lookahead == 'a') ADVANCE(122); END_STATE(); case 68: - ACCEPT_TOKEN(sym_keyword_unlogged); + if (lookahead == 'e') ADVANCE(123); END_STATE(); case 69: - if (lookahead == 'y') ADVANCE(70); + if (lookahead == 't') ADVANCE(124); END_STATE(); case 70: + if (lookahead == 'c') ADVANCE(125); + END_STATE(); + case 71: + if (lookahead == 'u') ADVANCE(126); + END_STATE(); + case 72: + if (lookahead == 'i') ADVANCE(127); + END_STATE(); + case 73: + if (lookahead == 't') ADVANCE(128); + END_STATE(); + case 74: + if (lookahead == 'o') ADVANCE(129); + END_STATE(); + case 75: + if (lookahead == 'n') ADVANCE(130); + END_STATE(); + case 76: + if (lookahead == 't') ADVANCE(103); + END_STATE(); + case 77: + if (lookahead == 'm') ADVANCE(131); + END_STATE(); + case 78: + if (lookahead == 'e') ADVANCE(132); + END_STATE(); + case 79: + if (lookahead == 'a') ADVANCE(133); + END_STATE(); + case 80: + if (lookahead == 'r') ADVANCE(134); + END_STATE(); + case 81: + if (lookahead == 'a') ADVANCE(135); + END_STATE(); + case 82: + if (lookahead == 'b') ADVANCE(136); + END_STATE(); + case 83: + if (lookahead == 'm') ADVANCE(137); + if (lookahead == 'x') ADVANCE(138); + END_STATE(); + case 84: + if (lookahead == 'm') ADVANCE(139); + END_STATE(); + case 85: + if (lookahead == 'l') ADVANCE(140); + END_STATE(); + case 86: + if (lookahead == 'i') ADVANCE(141); + END_STATE(); + case 87: + if (lookahead == 'r') ADVANCE(142); + END_STATE(); + case 88: + if (lookahead == 't') ADVANCE(143); + END_STATE(); + case 89: + if (lookahead == 'l') ADVANCE(117); + END_STATE(); + case 90: + if (lookahead == 'n') ADVANCE(144); + END_STATE(); + case 91: + if (lookahead == 'I') ADVANCE(145); + if (lookahead == 'S') ADVANCE(146); + END_STATE(); + case 92: + if (lookahead == 'L') ADVANCE(147); + END_STATE(); + case 93: + if (lookahead == 'E') ADVANCE(148); + END_STATE(); + case 94: + if (lookahead == 'R') ADVANCE(149); + END_STATE(); + case 95: + if (lookahead == 'A') ADVANCE(150); + END_STATE(); + case 96: + if (lookahead == 'E') ADVANCE(151); + END_STATE(); + case 97: + if (lookahead == 'I') ADVANCE(152); + END_STATE(); + case 98: + if (lookahead == 'B') ADVANCE(153); + END_STATE(); + case 99: + if (lookahead == 'S') ADVANCE(154); + END_STATE(); + case 100: + if (lookahead == 'E') ADVANCE(155); + END_STATE(); + case 101: + if (lookahead == 'N') ADVANCE(156); + END_STATE(); + case 102: + if (lookahead == 'E') ADVANCE(157); + END_STATE(); + case 103: + ACCEPT_TOKEN(sym_keyword_not); + END_STATE(); + case 104: + if (lookahead == 'E') ADVANCE(158); + END_STATE(); + case 105: + if (lookahead == 'C') ADVANCE(159); + END_STATE(); + case 106: + if (lookahead == 'L') ADVANCE(160); + END_STATE(); + case 107: + if (lookahead == 'I') ADVANCE(161); + END_STATE(); + case 108: + if (lookahead == 'L') ADVANCE(162); + END_STATE(); + case 109: + if (lookahead == 'L') ADVANCE(163); + END_STATE(); + case 110: + if (lookahead == 'P') ADVANCE(164); + END_STATE(); + case 111: + if (lookahead == 'T') ADVANCE(165); + END_STATE(); + case 112: + if (lookahead == 'E') ADVANCE(166); + END_STATE(); + case 113: + if (lookahead == 'O') ADVANCE(167); + END_STATE(); + case 114: + if (lookahead == 'D') ADVANCE(168); + END_STATE(); + case 115: + if (lookahead == 'C') ADVANCE(169); + END_STATE(); + case 116: + if (lookahead == 'H') ADVANCE(170); + END_STATE(); + case 117: + ACCEPT_TOKEN(sym_keyword_xml); + END_STATE(); + case 118: + if (lookahead == 'E') ADVANCE(171); + END_STATE(); + case 119: + if (lookahead == 'i') ADVANCE(172); + if (lookahead == 's') ADVANCE(173); + END_STATE(); + case 120: + if (lookahead == 'l') ADVANCE(174); + END_STATE(); + case 121: + if (lookahead == 'e') ADVANCE(175); + END_STATE(); + case 122: + if (lookahead == 'r') ADVANCE(176); + END_STATE(); + case 123: + if (lookahead == 'a') ADVANCE(177); + END_STATE(); + case 124: + if (lookahead == 'e') ADVANCE(178); + END_STATE(); + case 125: + if (lookahead == 'i') ADVANCE(179); + END_STATE(); + case 126: + if (lookahead == 'b') ADVANCE(180); + END_STATE(); + case 127: + if (lookahead == 's') ADVANCE(181); + END_STATE(); + case 128: + if (lookahead == 'e') ADVANCE(182); + END_STATE(); + case 129: + if (lookahead == 'n') ADVANCE(183); + END_STATE(); + case 130: + if (lookahead == 'e') ADVANCE(184); + END_STATE(); + case 131: + if (lookahead == 'e') ADVANCE(185); + END_STATE(); + case 132: + if (lookahead == 'c') ADVANCE(186); + END_STATE(); + case 133: + if (lookahead == 'l') ADVANCE(160); + END_STATE(); + case 134: + if (lookahead == 'i') ADVANCE(187); + END_STATE(); + case 135: + if (lookahead == 'l') ADVANCE(188); + END_STATE(); + case 136: + if (lookahead == 'l') ADVANCE(189); + END_STATE(); + case 137: + if (lookahead == 'p') ADVANCE(190); + END_STATE(); + case 138: + if (lookahead == 't') ADVANCE(165); + END_STATE(); + case 139: + if (lookahead == 'e') ADVANCE(191); + END_STATE(); + case 140: + if (lookahead == 'o') ADVANCE(192); + END_STATE(); + case 141: + if (lookahead == 'd') ADVANCE(168); + END_STATE(); + case 142: + if (lookahead == 'c') ADVANCE(193); + END_STATE(); + case 143: + if (lookahead == 'h') ADVANCE(194); + END_STATE(); + case 144: + if (lookahead == 'e') ADVANCE(171); + END_STATE(); + case 145: + if (lookahead == 'N') ADVANCE(195); + END_STATE(); + case 146: + if (lookahead == 'E') ADVANCE(196); + END_STATE(); + case 147: + if (lookahead == 'E') ADVANCE(197); + END_STATE(); + case 148: + if (lookahead == 'A') ADVANCE(198); + END_STATE(); + case 149: + ACCEPT_TOKEN(aux_sym_keyword_char_token2); + if (lookahead == 'A') ADVANCE(199); + END_STATE(); + case 150: + if (lookahead == 'T') ADVANCE(200); + END_STATE(); + case 151: + ACCEPT_TOKEN(sym_keyword_date); + if (lookahead == 'T') ADVANCE(201); + END_STATE(); + case 152: + if (lookahead == 'M') ADVANCE(202); + END_STATE(); + case 153: + if (lookahead == 'L') ADVANCE(203); + END_STATE(); + case 154: + if (lookahead == 'T') ADVANCE(204); + END_STATE(); + case 155: + if (lookahead == 'G') ADVANCE(205); + END_STATE(); + case 156: + ACCEPT_TOKEN(sym_keyword_json); + if (lookahead == 'B') ADVANCE(206); + END_STATE(); + case 157: + if (lookahead == 'Y') ADVANCE(207); + END_STATE(); + case 158: + if (lookahead == 'R') ADVANCE(208); + END_STATE(); + case 159: + if (lookahead == 'I') ADVANCE(209); + END_STATE(); + case 160: + ACCEPT_TOKEN(sym_keyword_real); + END_STATE(); + case 161: + if (lookahead == 'A') ADVANCE(210); + END_STATE(); + case 162: + if (lookahead == 'L') ADVANCE(211); + END_STATE(); + case 163: + if (lookahead == 'E') ADVANCE(212); + END_STATE(); + case 164: + ACCEPT_TOKEN(aux_sym_keyword_temporary_token2); + if (lookahead == 'O') ADVANCE(213); + END_STATE(); + case 165: + ACCEPT_TOKEN(sym_keyword_text); + END_STATE(); + case 166: + ACCEPT_TOKEN(aux_sym_keyword_time_token1); + if (lookahead == 'S') ADVANCE(214); + END_STATE(); + case 167: + if (lookahead == 'G') ADVANCE(215); + END_STATE(); + case 168: + ACCEPT_TOKEN(sym_keyword_uuid); + END_STATE(); + case 169: + if (lookahead == 'H') ADVANCE(216); + END_STATE(); + case 170: + ACCEPT_TOKEN(sym__keyword_with); + if (lookahead == 'O') ADVANCE(217); + END_STATE(); + case 171: + ACCEPT_TOKEN(aux_sym__keyword_time_zone_token1); + END_STATE(); + case 172: + if (lookahead == 'n') ADVANCE(218); + END_STATE(); + case 173: + if (lookahead == 'e') ADVANCE(219); + END_STATE(); + case 174: + if (lookahead == 'e') ADVANCE(220); + END_STATE(); + case 175: + if (lookahead == 'a') ADVANCE(198); + END_STATE(); + case 176: + ACCEPT_TOKEN(aux_sym_keyword_char_token2); + if (lookahead == 'a') ADVANCE(221); + END_STATE(); + case 177: + if (lookahead == 't') ADVANCE(222); + END_STATE(); + case 178: + ACCEPT_TOKEN(sym_keyword_date); + if (lookahead == 't') ADVANCE(223); + END_STATE(); + case 179: + if (lookahead == 'm') ADVANCE(224); + END_STATE(); + case 180: + if (lookahead == 'l') ADVANCE(225); + END_STATE(); + case 181: + if (lookahead == 't') ADVANCE(226); + END_STATE(); + case 182: + if (lookahead == 'g') ADVANCE(227); + END_STATE(); + case 183: + ACCEPT_TOKEN(sym_keyword_json); + if (lookahead == 'b') ADVANCE(206); + END_STATE(); + case 184: + if (lookahead == 'y') ADVANCE(207); + END_STATE(); + case 185: + if (lookahead == 'r') ADVANCE(228); + END_STATE(); + case 186: + if (lookahead == 'i') ADVANCE(229); + END_STATE(); + case 187: + if (lookahead == 'a') ADVANCE(230); + END_STATE(); + case 188: + if (lookahead == 'l') ADVANCE(231); + END_STATE(); + case 189: + if (lookahead == 'e') ADVANCE(212); + END_STATE(); + case 190: + ACCEPT_TOKEN(aux_sym_keyword_temporary_token2); + if (lookahead == 'o') ADVANCE(232); + END_STATE(); + case 191: + ACCEPT_TOKEN(aux_sym_keyword_time_token1); + if (lookahead == 's') ADVANCE(233); + END_STATE(); + case 192: + if (lookahead == 'g') ADVANCE(234); + END_STATE(); + case 193: + if (lookahead == 'h') ADVANCE(235); + END_STATE(); + case 194: + ACCEPT_TOKEN(sym__keyword_with); + if (lookahead == 'o') ADVANCE(236); + END_STATE(); + case 195: + if (lookahead == 'T') ADVANCE(237); + END_STATE(); + case 196: + if (lookahead == 'R') ADVANCE(238); + END_STATE(); + case 197: + if (lookahead == 'A') ADVANCE(239); + END_STATE(); + case 198: + ACCEPT_TOKEN(sym_keyword_bytea); + END_STATE(); + case 199: + if (lookahead == 'C') ADVANCE(240); + END_STATE(); + case 200: + if (lookahead == 'E') ADVANCE(241); + END_STATE(); + case 201: + if (lookahead == 'I') ADVANCE(242); + END_STATE(); + case 202: + if (lookahead == 'A') ADVANCE(243); + END_STATE(); + case 203: + if (lookahead == 'E') ADVANCE(244); + END_STATE(); + case 204: + if (lookahead == 'S') ADVANCE(245); + END_STATE(); + case 205: + if (lookahead == 'E') ADVANCE(246); + END_STATE(); + case 206: + ACCEPT_TOKEN(sym_keyword_jsonb); + END_STATE(); + case 207: + ACCEPT_TOKEN(sym_keyword_money); + END_STATE(); + case 208: + if (lookahead == 'I') ADVANCE(247); + END_STATE(); + case 209: + if (lookahead == 'S') ADVANCE(248); + END_STATE(); + case 210: + if (lookahead == 'L') ADVANCE(249); + END_STATE(); + case 211: + if (lookahead == 'I') ADVANCE(250); + if (lookahead == 'S') ADVANCE(251); + END_STATE(); + case 212: + ACCEPT_TOKEN(sym_keyword_table); + END_STATE(); + case 213: + if (lookahead == 'R') ADVANCE(252); + END_STATE(); + case 214: + if (lookahead == 'T') ADVANCE(253); + END_STATE(); + case 215: + if (lookahead == 'G') ADVANCE(254); + END_STATE(); + case 216: + if (lookahead == 'A') ADVANCE(255); + END_STATE(); + case 217: + if (lookahead == 'U') ADVANCE(256); + END_STATE(); + case 218: + if (lookahead == 't') ADVANCE(237); + END_STATE(); + case 219: + if (lookahead == 'r') ADVANCE(257); + END_STATE(); + case 220: + if (lookahead == 'a') ADVANCE(258); + END_STATE(); + case 221: + if (lookahead == 'c') ADVANCE(259); + END_STATE(); + case 222: + if (lookahead == 'e') ADVANCE(241); + END_STATE(); + case 223: + if (lookahead == 'i') ADVANCE(260); + END_STATE(); + case 224: + if (lookahead == 'a') ADVANCE(261); + END_STATE(); + case 225: + if (lookahead == 'e') ADVANCE(244); + END_STATE(); + case 226: + if (lookahead == 's') ADVANCE(245); + END_STATE(); + case 227: + if (lookahead == 'e') ADVANCE(262); + END_STATE(); + case 228: + if (lookahead == 'i') ADVANCE(263); + END_STATE(); + case 229: + if (lookahead == 's') ADVANCE(264); + END_STATE(); + case 230: + if (lookahead == 'l') ADVANCE(249); + END_STATE(); + case 231: + if (lookahead == 'i') ADVANCE(265); + if (lookahead == 's') ADVANCE(266); + END_STATE(); + case 232: + if (lookahead == 'r') ADVANCE(267); + END_STATE(); + case 233: + if (lookahead == 't') ADVANCE(268); + END_STATE(); + case 234: + if (lookahead == 'g') ADVANCE(269); + END_STATE(); + case 235: + if (lookahead == 'a') ADVANCE(270); + END_STATE(); + case 236: + if (lookahead == 'u') ADVANCE(271); + END_STATE(); + case 237: + ACCEPT_TOKEN(sym_keyword_bigint); + END_STATE(); + case 238: + if (lookahead == 'I') ADVANCE(272); + END_STATE(); + case 239: + if (lookahead == 'N') ADVANCE(273); + END_STATE(); + case 240: + if (lookahead == 'T') ADVANCE(274); + END_STATE(); + case 241: + ACCEPT_TOKEN(sym_keyword_create); + END_STATE(); + case 242: + if (lookahead == 'M') ADVANCE(275); + END_STATE(); + case 243: + if (lookahead == 'L') ADVANCE(276); + END_STATE(); + case 244: + ACCEPT_TOKEN(aux_sym_double_token1); + END_STATE(); + case 245: + ACCEPT_TOKEN(sym_keyword_exists); + END_STATE(); + case 246: + if (lookahead == 'R') ADVANCE(277); + END_STATE(); + case 247: + if (lookahead == 'C') ADVANCE(278); + END_STATE(); + case 248: + if (lookahead == 'I') ADVANCE(279); + END_STATE(); + case 249: + ACCEPT_TOKEN(sym_keyword_serial); + END_STATE(); + case 250: + if (lookahead == 'N') ADVANCE(280); + END_STATE(); + case 251: + if (lookahead == 'E') ADVANCE(281); + END_STATE(); + case 252: + if (lookahead == 'A') ADVANCE(282); + END_STATE(); + case 253: + if (lookahead == 'A') ADVANCE(283); + END_STATE(); + case 254: + if (lookahead == 'E') ADVANCE(284); + END_STATE(); + case 255: + if (lookahead == 'R') ADVANCE(285); + END_STATE(); + case 256: + if (lookahead == 'T') ADVANCE(286); + END_STATE(); + case 257: + if (lookahead == 'i') ADVANCE(287); + END_STATE(); + case 258: + if (lookahead == 'n') ADVANCE(273); + END_STATE(); + case 259: + if (lookahead == 't') ADVANCE(288); + END_STATE(); + case 260: + if (lookahead == 'm') ADVANCE(289); + END_STATE(); + case 261: + if (lookahead == 'l') ADVANCE(276); + END_STATE(); + case 262: + if (lookahead == 'r') ADVANCE(277); + END_STATE(); + case 263: + if (lookahead == 'c') ADVANCE(278); + END_STATE(); + case 264: + if (lookahead == 'i') ADVANCE(290); + END_STATE(); + case 265: + if (lookahead == 'n') ADVANCE(291); + END_STATE(); + case 266: + if (lookahead == 'e') ADVANCE(292); + END_STATE(); + case 267: + if (lookahead == 'a') ADVANCE(293); + END_STATE(); + case 268: + if (lookahead == 'a') ADVANCE(294); + END_STATE(); + case 269: + if (lookahead == 'e') ADVANCE(295); + END_STATE(); + case 270: + if (lookahead == 'r') ADVANCE(285); + END_STATE(); + case 271: + if (lookahead == 't') ADVANCE(286); + END_STATE(); + case 272: + if (lookahead == 'A') ADVANCE(296); + END_STATE(); + case 273: + ACCEPT_TOKEN(sym_keyword_boolean); + END_STATE(); + case 274: + if (lookahead == 'E') ADVANCE(297); + END_STATE(); + case 275: + if (lookahead == 'E') ADVANCE(298); + END_STATE(); + case 276: + ACCEPT_TOKEN(sym_keyword_decimal); + END_STATE(); + case 277: + ACCEPT_TOKEN(sym_keyword_integer); + END_STATE(); + case 278: + ACCEPT_TOKEN(sym_keyword_numeric); + END_STATE(); + case 279: + if (lookahead == 'O') ADVANCE(299); + END_STATE(); + case 280: + if (lookahead == 'T') ADVANCE(300); + END_STATE(); + case 281: + if (lookahead == 'R') ADVANCE(301); + END_STATE(); + case 282: + if (lookahead == 'R') ADVANCE(302); + END_STATE(); + case 283: + if (lookahead == 'M') ADVANCE(303); + END_STATE(); + case 284: + if (lookahead == 'D') ADVANCE(304); + END_STATE(); + case 285: + ACCEPT_TOKEN(aux_sym_keyword_varchar_token1); + END_STATE(); + case 286: + ACCEPT_TOKEN(sym__keyword_without); + END_STATE(); + case 287: + if (lookahead == 'a') ADVANCE(305); + END_STATE(); + case 288: + if (lookahead == 'e') ADVANCE(306); + END_STATE(); + case 289: + if (lookahead == 'e') ADVANCE(298); + END_STATE(); + case 290: + if (lookahead == 'o') ADVANCE(307); + END_STATE(); + case 291: + if (lookahead == 't') ADVANCE(300); + END_STATE(); + case 292: + if (lookahead == 'r') ADVANCE(308); + END_STATE(); + case 293: + if (lookahead == 'r') ADVANCE(309); + END_STATE(); + case 294: + if (lookahead == 'm') ADVANCE(310); + END_STATE(); + case 295: + if (lookahead == 'd') ADVANCE(304); + END_STATE(); + case 296: + if (lookahead == 'L') ADVANCE(311); + END_STATE(); + case 297: + if (lookahead == 'R') ADVANCE(312); + END_STATE(); + case 298: + ACCEPT_TOKEN(sym_keyword_datetime); + END_STATE(); + case 299: + if (lookahead == 'N') ADVANCE(313); + END_STATE(); + case 300: + ACCEPT_TOKEN(sym_keyword_smallint); + END_STATE(); + case 301: + if (lookahead == 'I') ADVANCE(314); + END_STATE(); + case 302: + if (lookahead == 'Y') ADVANCE(315); + END_STATE(); + case 303: + if (lookahead == 'P') ADVANCE(316); + END_STATE(); + case 304: + ACCEPT_TOKEN(sym_keyword_unlogged); + END_STATE(); + case 305: + if (lookahead == 'l') ADVANCE(311); + END_STATE(); + case 306: + if (lookahead == 'r') ADVANCE(312); + END_STATE(); + case 307: + if (lookahead == 'n') ADVANCE(313); + END_STATE(); + case 308: + if (lookahead == 'i') ADVANCE(317); + END_STATE(); + case 309: + if (lookahead == 'y') ADVANCE(315); + END_STATE(); + case 310: + if (lookahead == 'p') ADVANCE(318); + END_STATE(); + case 311: + ACCEPT_TOKEN(sym_keyword_bigserial); + END_STATE(); + case 312: + ACCEPT_TOKEN(aux_sym_keyword_char_token1); + END_STATE(); + case 313: + ACCEPT_TOKEN(aux_sym_double_token2); + END_STATE(); + case 314: + if (lookahead == 'A') ADVANCE(319); + END_STATE(); + case 315: ACCEPT_TOKEN(aux_sym_keyword_temporary_token1); END_STATE(); + case 316: + ACCEPT_TOKEN(aux_sym_keyword_timestamp_token1); + if (lookahead == 'T') ADVANCE(320); + END_STATE(); + case 317: + if (lookahead == 'a') ADVANCE(321); + END_STATE(); + case 318: + ACCEPT_TOKEN(aux_sym_keyword_timestamp_token1); + if (lookahead == 't') ADVANCE(322); + END_STATE(); + case 319: + if (lookahead == 'L') ADVANCE(323); + END_STATE(); + case 320: + if (lookahead == 'Z') ADVANCE(324); + END_STATE(); + case 321: + if (lookahead == 'l') ADVANCE(323); + END_STATE(); + case 322: + if (lookahead == 'z') ADVANCE(324); + END_STATE(); + case 323: + ACCEPT_TOKEN(sym_keyword_smallserial); + END_STATE(); + case 324: + ACCEPT_TOKEN(aux_sym_keyword_timestamptz_token1); + END_STATE(); default: return false; } @@ -833,10 +2113,10 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [28] = {.lex_state = 0}, [29] = {.lex_state = 0}, [30] = {.lex_state = 0}, - [31] = {.lex_state = 1}, + [31] = {.lex_state = 0}, [32] = {.lex_state = 0}, [33] = {.lex_state = 0}, - [34] = {.lex_state = 5}, + [34] = {.lex_state = 0}, [35] = {.lex_state = 0}, [36] = {.lex_state = 0}, [37] = {.lex_state = 0}, @@ -849,8 +2129,52 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [44] = {.lex_state = 0}, [45] = {.lex_state = 0}, [46] = {.lex_state = 0}, - [47] = {(TSStateId)(-1)}, - [48] = {(TSStateId)(-1)}, + [47] = {.lex_state = 0}, + [48] = {.lex_state = 0}, + [49] = {.lex_state = 0}, + [50] = {.lex_state = 0}, + [51] = {.lex_state = 0}, + [52] = {.lex_state = 0}, + [53] = {.lex_state = 0}, + [54] = {.lex_state = 0}, + [55] = {.lex_state = 0}, + [56] = {.lex_state = 0}, + [57] = {.lex_state = 0}, + [58] = {.lex_state = 0}, + [59] = {.lex_state = 0}, + [60] = {.lex_state = 0}, + [61] = {.lex_state = 0}, + [62] = {.lex_state = 0}, + [63] = {.lex_state = 0}, + [64] = {.lex_state = 5}, + [65] = {.lex_state = 1}, + [66] = {.lex_state = 0}, + [67] = {.lex_state = 0}, + [68] = {.lex_state = 0}, + [69] = {.lex_state = 0}, + [70] = {.lex_state = 0}, + [71] = {.lex_state = 0}, + [72] = {.lex_state = 0}, + [73] = {.lex_state = 0}, + [74] = {.lex_state = 0}, + [75] = {.lex_state = 0}, + [76] = {.lex_state = 0}, + [77] = {.lex_state = 0}, + [78] = {.lex_state = 0}, + [79] = {.lex_state = 0}, + [80] = {.lex_state = 0}, + [81] = {.lex_state = 0}, + [82] = {.lex_state = 0}, + [83] = {.lex_state = 0}, + [84] = {.lex_state = 0}, + [85] = {.lex_state = 0}, + [86] = {.lex_state = 0}, + [87] = {.lex_state = 0}, + [88] = {.lex_state = 0}, + [89] = {.lex_state = 0}, + [90] = {.lex_state = 0}, + [91] = {(TSStateId)(-1)}, + [92] = {(TSStateId)(-1)}, }; static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { @@ -860,10 +2184,10 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [ts_builtin_sym_end] = ACTIONS(1), [sym__identifier] = ACTIONS(1), [anon_sym_SEMI] = ACTIONS(1), - [anon_sym_DOT] = ACTIONS(1), [anon_sym_LPAREN] = ACTIONS(1), [anon_sym_COMMA] = ACTIONS(1), [anon_sym_RPAREN] = ACTIONS(1), + [anon_sym_DOT] = ACTIONS(1), [sym_keyword_create] = ACTIONS(1), [sym_keyword_table] = ACTIONS(1), [aux_sym_keyword_temporary_token1] = ACTIONS(1), @@ -872,53 +2196,181 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_keyword_if] = ACTIONS(1), [sym_keyword_not] = ACTIONS(1), [sym_keyword_exists] = ACTIONS(1), + [aux_sym_double_token1] = ACTIONS(1), + [aux_sym_double_token2] = ACTIONS(1), + [sym_keyword_boolean] = ACTIONS(1), + [sym_keyword_smallint] = ACTIONS(1), + [sym_keyword_integer] = ACTIONS(1), + [sym_keyword_bigint] = ACTIONS(1), + [sym_keyword_decimal] = ACTIONS(1), + [sym_keyword_numeric] = ACTIONS(1), + [sym_keyword_real] = ACTIONS(1), + [sym_keyword_smallserial] = ACTIONS(1), + [sym_keyword_serial] = ACTIONS(1), + [sym_keyword_bigserial] = ACTIONS(1), + [sym_keyword_money] = ACTIONS(1), + [sym_keyword_text] = ACTIONS(1), + [aux_sym_keyword_char_token1] = ACTIONS(1), + [aux_sym_keyword_char_token2] = ACTIONS(1), + [aux_sym_keyword_varchar_token1] = ACTIONS(1), + [sym_keyword_bytea] = ACTIONS(1), + [sym_keyword_date] = ACTIONS(1), + [sym_keyword_datetime] = ACTIONS(1), + [aux_sym_keyword_time_token1] = ACTIONS(1), + [aux_sym_keyword_timestamp_token1] = ACTIONS(1), + [aux_sym_keyword_timestamptz_token1] = ACTIONS(1), + [sym__keyword_without] = ACTIONS(1), + [sym__keyword_with] = ACTIONS(1), + [aux_sym__keyword_time_zone_token1] = ACTIONS(1), + [sym_keyword_uuid] = ACTIONS(1), + [sym_keyword_xml] = ACTIONS(1), + [sym_keyword_json] = ACTIONS(1), + [sym_keyword_jsonb] = ACTIONS(1), [anon_sym_DASH_DASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_SLASH] = ACTIONS(1), + [sym__number] = ACTIONS(1), [anon_sym_DQUOTE] = ACTIONS(1), }, [1] = { - [sym_source_file] = STATE(46), - [sym_statement] = STATE(18), - [sym__ddl_statement] = STATE(44), - [sym__create_statement] = STATE(42), - [sym_create_table] = STATE(41), + [sym_source_file] = STATE(61), + [sym_statement] = STATE(25), + [sym__ddl_statement] = STATE(84), + [sym__create_statement] = STATE(68), + [sym_create_table] = STATE(69), [sym_comment] = STATE(1), [sym_marginalia] = STATE(1), - [aux_sym_source_file_repeat1] = STATE(3), + [aux_sym_source_file_repeat1] = STATE(5), [ts_builtin_sym_end] = ACTIONS(7), [anon_sym_SEMI] = ACTIONS(9), [sym_keyword_create] = ACTIONS(11), [anon_sym_DASH_DASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), }, + [2] = { + [sym__type] = STATE(58), + [sym__type_numeric] = STATE(46), + [sym_double] = STATE(30), + [sym_decimal] = STATE(30), + [sym_numeric] = STATE(30), + [sym__type_character] = STATE(46), + [sym_char] = STATE(50), + [sym_varchar] = STATE(50), + [sym__type_datetime] = STATE(46), + [sym__type_geometric] = STATE(46), + [sym__type_net] = STATE(46), + [sym__type_bit_string] = STATE(46), + [sym__type_text_search] = STATE(46), + [sym_keyword_char] = STATE(27), + [sym_keyword_varchar] = STATE(29), + [sym_keyword_time] = STATE(54), + [sym_keyword_timestamp] = STATE(54), + [sym_keyword_timestamptz] = STATE(54), + [sym_comment] = STATE(2), + [sym_marginalia] = STATE(2), + [aux_sym_double_token1] = ACTIONS(13), + [sym_keyword_boolean] = ACTIONS(15), + [sym_keyword_smallint] = ACTIONS(17), + [sym_keyword_integer] = ACTIONS(17), + [sym_keyword_bigint] = ACTIONS(17), + [sym_keyword_decimal] = ACTIONS(19), + [sym_keyword_numeric] = ACTIONS(21), + [sym_keyword_real] = ACTIONS(17), + [sym_keyword_smallserial] = ACTIONS(17), + [sym_keyword_serial] = ACTIONS(17), + [sym_keyword_bigserial] = ACTIONS(17), + [sym_keyword_money] = ACTIONS(15), + [sym_keyword_text] = ACTIONS(23), + [aux_sym_keyword_char_token1] = ACTIONS(25), + [aux_sym_keyword_char_token2] = ACTIONS(27), + [aux_sym_keyword_varchar_token1] = ACTIONS(29), + [sym_keyword_bytea] = ACTIONS(15), + [sym_keyword_date] = ACTIONS(31), + [sym_keyword_datetime] = ACTIONS(33), + [aux_sym_keyword_time_token1] = ACTIONS(35), + [aux_sym_keyword_timestamp_token1] = ACTIONS(37), + [aux_sym_keyword_timestamptz_token1] = ACTIONS(39), + [sym_keyword_uuid] = ACTIONS(15), + [sym_keyword_xml] = ACTIONS(15), + [anon_sym_DASH_DASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + }, }; static const uint16_t ts_small_parse_table[] = { - [0] = 10, + [0] = 5, ACTIONS(3), 1, anon_sym_DASH_DASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(13), 1, - ts_builtin_sym_end, - ACTIONS(15), 1, - anon_sym_SEMI, - ACTIONS(18), 1, - sym_keyword_create, - STATE(18), 1, - sym_statement, - STATE(41), 1, - sym_create_table, - STATE(42), 1, - sym__create_statement, - STATE(44), 1, - sym__ddl_statement, - STATE(2), 3, + STATE(3), 2, sym_comment, sym_marginalia, - aux_sym_source_file_repeat1, - [33] = 11, + ACTIONS(43), 4, + aux_sym_keyword_char_token2, + sym_keyword_date, + aux_sym_keyword_time_token1, + aux_sym_keyword_timestamp_token1, + ACTIONS(41), 22, + anon_sym_LPAREN, + anon_sym_DOT, + aux_sym_double_token1, + sym_keyword_boolean, + sym_keyword_smallint, + sym_keyword_integer, + sym_keyword_bigint, + sym_keyword_decimal, + sym_keyword_numeric, + sym_keyword_real, + sym_keyword_smallserial, + sym_keyword_serial, + sym_keyword_bigserial, + sym_keyword_money, + sym_keyword_text, + aux_sym_keyword_char_token1, + aux_sym_keyword_varchar_token1, + sym_keyword_bytea, + sym_keyword_datetime, + aux_sym_keyword_timestamptz_token1, + sym_keyword_uuid, + sym_keyword_xml, + [41] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + STATE(4), 2, + sym_comment, + sym_marginalia, + ACTIONS(47), 4, + aux_sym_keyword_char_token2, + sym_keyword_date, + aux_sym_keyword_time_token1, + aux_sym_keyword_timestamp_token1, + ACTIONS(45), 22, + anon_sym_LPAREN, + anon_sym_DOT, + aux_sym_double_token1, + sym_keyword_boolean, + sym_keyword_smallint, + sym_keyword_integer, + sym_keyword_bigint, + sym_keyword_decimal, + sym_keyword_numeric, + sym_keyword_real, + sym_keyword_smallserial, + sym_keyword_serial, + sym_keyword_bigserial, + sym_keyword_money, + sym_keyword_text, + aux_sym_keyword_char_token1, + aux_sym_keyword_varchar_token1, + sym_keyword_bytea, + sym_keyword_datetime, + aux_sym_keyword_timestamptz_token1, + sym_keyword_uuid, + sym_keyword_xml, + [82] = 11, ACTIONS(3), 1, anon_sym_DASH_DASH, ACTIONS(5), 1, @@ -927,213 +2379,206 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_SEMI, ACTIONS(11), 1, sym_keyword_create, - ACTIONS(21), 1, + ACTIONS(49), 1, ts_builtin_sym_end, - STATE(2), 1, + STATE(6), 1, aux_sym_source_file_repeat1, - STATE(18), 1, + STATE(25), 1, sym_statement, - STATE(41), 1, - sym_create_table, - STATE(42), 1, + STATE(68), 1, sym__create_statement, - STATE(44), 1, + STATE(69), 1, + sym_create_table, + STATE(84), 1, sym__ddl_statement, - STATE(3), 2, - sym_comment, - sym_marginalia, - [68] = 9, - ACTIONS(3), 1, - anon_sym_DASH_DASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(23), 1, - sym__identifier, - ACTIONS(25), 1, - sym_keyword_if, - ACTIONS(27), 1, - anon_sym_DQUOTE, - STATE(10), 1, - sym__if_not_exists, - STATE(23), 1, - sym_table_reference, - STATE(25), 1, - sym_identifier, - STATE(4), 2, - sym_comment, - sym_marginalia, - [97] = 9, - ACTIONS(3), 1, - anon_sym_DASH_DASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(23), 1, - sym__identifier, - ACTIONS(25), 1, - sym_keyword_if, - ACTIONS(27), 1, - anon_sym_DQUOTE, - STATE(8), 1, - sym__if_not_exists, - STATE(24), 1, - sym_table_reference, - STATE(25), 1, - sym_identifier, STATE(5), 2, sym_comment, sym_marginalia, - [126] = 8, + [117] = 10, ACTIONS(3), 1, anon_sym_DASH_DASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(29), 1, - sym_keyword_table, - ACTIONS(31), 1, - aux_sym_keyword_temporary_token1, - ACTIONS(33), 1, - aux_sym_keyword_temporary_token2, - ACTIONS(35), 1, - sym_keyword_unlogged, - STATE(35), 1, - sym_keyword_temporary, - STATE(6), 2, + ACTIONS(51), 1, + ts_builtin_sym_end, + ACTIONS(53), 1, + anon_sym_SEMI, + ACTIONS(56), 1, + sym_keyword_create, + STATE(25), 1, + sym_statement, + STATE(68), 1, + sym__create_statement, + STATE(69), 1, + sym_create_table, + STATE(84), 1, + sym__ddl_statement, + STATE(6), 3, sym_comment, sym_marginalia, - [152] = 8, + aux_sym_source_file_repeat1, + [150] = 9, ACTIONS(3), 1, anon_sym_DASH_DASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(27), 1, - anon_sym_DQUOTE, - ACTIONS(37), 1, + ACTIONS(59), 1, sym__identifier, - ACTIONS(39), 1, - anon_sym_RPAREN, - STATE(15), 1, - sym_column_definition, - STATE(21), 1, + ACTIONS(61), 1, + sym_keyword_if, + ACTIONS(63), 1, + anon_sym_DQUOTE, + STATE(14), 1, + sym__if_not_exists, + STATE(38), 1, sym_identifier, + STATE(42), 1, + sym_table_reference, STATE(7), 2, sym_comment, sym_marginalia, - [178] = 7, + [179] = 9, ACTIONS(3), 1, anon_sym_DASH_DASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(27), 1, - anon_sym_DQUOTE, - ACTIONS(37), 1, + ACTIONS(59), 1, sym__identifier, - STATE(23), 1, + ACTIONS(61), 1, + sym_keyword_if, + ACTIONS(63), 1, + anon_sym_DQUOTE, + STATE(15), 1, + sym__if_not_exists, + STATE(32), 1, sym_table_reference, - STATE(25), 1, + STATE(38), 1, sym_identifier, STATE(8), 2, sym_comment, sym_marginalia, - [201] = 4, + [208] = 8, ACTIONS(3), 1, anon_sym_DASH_DASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, + ACTIONS(67), 1, + sym__keyword_without, + ACTIONS(69), 1, + sym__keyword_with, + STATE(49), 1, + sym__with_time_zone, + STATE(51), 1, + sym__without_time_zone, + ACTIONS(65), 2, + anon_sym_COMMA, + anon_sym_RPAREN, STATE(9), 2, sym_comment, sym_marginalia, - ACTIONS(41), 4, - anon_sym_DOT, - anon_sym_LPAREN, - anon_sym_COMMA, - anon_sym_RPAREN, - [218] = 7, + [235] = 7, ACTIONS(3), 1, anon_sym_DASH_DASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(27), 1, - anon_sym_DQUOTE, - ACTIONS(37), 1, - sym__identifier, - STATE(22), 1, - sym_table_reference, - STATE(25), 1, - sym_identifier, + ACTIONS(67), 1, + sym__keyword_without, + ACTIONS(69), 1, + sym__keyword_with, + ACTIONS(71), 2, + anon_sym_COMMA, + anon_sym_RPAREN, STATE(10), 2, sym_comment, sym_marginalia, - [241] = 7, + STATE(52), 2, + sym__without_time_zone, + sym__with_time_zone, + [260] = 8, ACTIONS(3), 1, anon_sym_DASH_DASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(27), 1, + ACTIONS(63), 1, anon_sym_DQUOTE, - ACTIONS(37), 1, + ACTIONS(73), 1, sym__identifier, - STATE(21), 1, + ACTIONS(75), 1, + anon_sym_RPAREN, + STATE(2), 1, sym_identifier, STATE(26), 1, sym_column_definition, STATE(11), 2, sym_comment, sym_marginalia, - [264] = 4, + [286] = 8, ACTIONS(3), 1, anon_sym_DASH_DASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, + ACTIONS(77), 1, + sym_keyword_table, + ACTIONS(79), 1, + aux_sym_keyword_temporary_token1, + ACTIONS(81), 1, + aux_sym_keyword_temporary_token2, + ACTIONS(83), 1, + sym_keyword_unlogged, + STATE(75), 1, + sym_keyword_temporary, STATE(12), 2, sym_comment, sym_marginalia, - ACTIONS(43), 4, - anon_sym_DOT, - anon_sym_LPAREN, - anon_sym_COMMA, - anon_sym_RPAREN, - [281] = 6, + [312] = 7, ACTIONS(3), 1, anon_sym_DASH_DASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(45), 1, - anon_sym_COMMA, - ACTIONS(47), 1, - anon_sym_RPAREN, - STATE(14), 1, - aux_sym_column_definitions_repeat1, + ACTIONS(63), 1, + anon_sym_DQUOTE, + ACTIONS(73), 1, + sym__identifier, + STATE(2), 1, + sym_identifier, + STATE(31), 1, + sym_column_definition, STATE(13), 2, sym_comment, sym_marginalia, - [301] = 5, + [335] = 7, ACTIONS(3), 1, anon_sym_DASH_DASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(49), 1, - anon_sym_COMMA, - ACTIONS(52), 1, - anon_sym_RPAREN, - STATE(14), 3, + ACTIONS(63), 1, + anon_sym_DQUOTE, + ACTIONS(73), 1, + sym__identifier, + STATE(32), 1, + sym_table_reference, + STATE(38), 1, + sym_identifier, + STATE(14), 2, sym_comment, sym_marginalia, - aux_sym_column_definitions_repeat1, - [319] = 6, + [358] = 7, ACTIONS(3), 1, anon_sym_DASH_DASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(45), 1, - anon_sym_COMMA, - ACTIONS(54), 1, - anon_sym_RPAREN, - STATE(13), 1, - aux_sym_column_definitions_repeat1, + ACTIONS(63), 1, + anon_sym_DQUOTE, + ACTIONS(73), 1, + sym__identifier, + STATE(38), 1, + sym_identifier, + STATE(41), 1, + sym_table_reference, STATE(15), 2, sym_comment, sym_marginalia, - [339] = 4, + [381] = 4, ACTIONS(3), 1, anon_sym_DASH_DASH, ACTIONS(5), 1, @@ -1141,37 +2586,37 @@ static const uint16_t ts_small_parse_table[] = { STATE(16), 2, sym_comment, sym_marginalia, - ACTIONS(56), 3, - ts_builtin_sym_end, - anon_sym_SEMI, - sym_keyword_create, - [355] = 6, + ACTIONS(85), 3, + anon_sym_LPAREN, + anon_sym_COMMA, + anon_sym_RPAREN, + [397] = 5, ACTIONS(3), 1, anon_sym_DASH_DASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(27), 1, - anon_sym_DQUOTE, - ACTIONS(37), 1, - sym__identifier, - STATE(40), 1, - sym_identifier, + ACTIONS(88), 1, + anon_sym_LPAREN, + ACTIONS(90), 2, + anon_sym_COMMA, + anon_sym_RPAREN, STATE(17), 2, sym_comment, sym_marginalia, - [375] = 4, + [415] = 5, ACTIONS(3), 1, anon_sym_DASH_DASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, + ACTIONS(92), 1, + anon_sym_LPAREN, + ACTIONS(94), 2, + anon_sym_COMMA, + anon_sym_RPAREN, STATE(18), 2, sym_comment, sym_marginalia, - ACTIONS(58), 3, - ts_builtin_sym_end, - anon_sym_SEMI, - sym_keyword_create, - [391] = 4, + [433] = 4, ACTIONS(3), 1, anon_sym_DASH_DASH, ACTIONS(5), 1, @@ -1179,409 +2624,1013 @@ static const uint16_t ts_small_parse_table[] = { STATE(19), 2, sym_comment, sym_marginalia, - ACTIONS(60), 3, + ACTIONS(96), 3, ts_builtin_sym_end, anon_sym_SEMI, sym_keyword_create, - [407] = 4, + [449] = 5, ACTIONS(3), 1, anon_sym_DASH_DASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(62), 2, - anon_sym_DQUOTE, - sym__identifier, - STATE(20), 2, + ACTIONS(98), 1, + anon_sym_COMMA, + ACTIONS(101), 1, + anon_sym_RPAREN, + STATE(20), 3, sym_comment, sym_marginalia, - [422] = 4, + aux_sym_column_definitions_repeat1, + [467] = 4, ACTIONS(3), 1, anon_sym_DASH_DASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(64), 2, - anon_sym_COMMA, - anon_sym_RPAREN, STATE(21), 2, sym_comment, sym_marginalia, - [437] = 5, + ACTIONS(103), 3, + anon_sym_LPAREN, + anon_sym_COMMA, + anon_sym_RPAREN, + [483] = 6, ACTIONS(3), 1, anon_sym_DASH_DASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(66), 1, - anon_sym_LPAREN, - STATE(45), 1, - sym_column_definitions, + ACTIONS(105), 1, + anon_sym_COMMA, + ACTIONS(107), 1, + anon_sym_RPAREN, + STATE(20), 1, + aux_sym_column_definitions_repeat1, STATE(22), 2, sym_comment, sym_marginalia, - [454] = 5, + [503] = 6, ACTIONS(3), 1, anon_sym_DASH_DASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(66), 1, - anon_sym_LPAREN, - STATE(39), 1, - sym_column_definitions, + ACTIONS(63), 1, + anon_sym_DQUOTE, + ACTIONS(73), 1, + sym__identifier, + STATE(86), 1, + sym_identifier, STATE(23), 2, sym_comment, sym_marginalia, - [471] = 5, + [523] = 4, ACTIONS(3), 1, anon_sym_DASH_DASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(66), 1, - anon_sym_LPAREN, - STATE(30), 1, - sym_column_definitions, STATE(24), 2, sym_comment, sym_marginalia, - [488] = 5, + ACTIONS(109), 3, + anon_sym_LPAREN, + anon_sym_COMMA, + anon_sym_RPAREN, + [539] = 4, ACTIONS(3), 1, anon_sym_DASH_DASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(68), 1, - anon_sym_DOT, - ACTIONS(70), 1, - anon_sym_LPAREN, STATE(25), 2, sym_comment, sym_marginalia, - [505] = 4, + ACTIONS(111), 3, + ts_builtin_sym_end, + anon_sym_SEMI, + sym_keyword_create, + [555] = 6, ACTIONS(3), 1, anon_sym_DASH_DASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(52), 2, + ACTIONS(105), 1, anon_sym_COMMA, + ACTIONS(113), 1, anon_sym_RPAREN, + STATE(22), 1, + aux_sym_column_definitions_repeat1, STATE(26), 2, sym_comment, sym_marginalia, - [520] = 4, + [575] = 5, ACTIONS(3), 1, anon_sym_DASH_DASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(72), 1, - anon_sym_SEMI, + ACTIONS(115), 1, + anon_sym_LPAREN, + ACTIONS(117), 2, + anon_sym_COMMA, + anon_sym_RPAREN, STATE(27), 2, sym_comment, sym_marginalia, - [534] = 4, + [593] = 4, ACTIONS(3), 1, anon_sym_DASH_DASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(74), 1, - anon_sym_SEMI, STATE(28), 2, sym_comment, sym_marginalia, - [548] = 4, + ACTIONS(119), 3, + ts_builtin_sym_end, + anon_sym_SEMI, + sym_keyword_create, + [609] = 5, ACTIONS(3), 1, anon_sym_DASH_DASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(76), 1, - sym_keyword_exists, + ACTIONS(121), 1, + anon_sym_LPAREN, + ACTIONS(123), 2, + anon_sym_COMMA, + anon_sym_RPAREN, STATE(29), 2, sym_comment, sym_marginalia, - [562] = 4, + [627] = 4, ACTIONS(3), 1, anon_sym_DASH_DASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(78), 1, - anon_sym_SEMI, + ACTIONS(125), 2, + anon_sym_COMMA, + anon_sym_RPAREN, STATE(30), 2, sym_comment, sym_marginalia, - [576] = 4, - ACTIONS(80), 1, + [642] = 4, + ACTIONS(3), 1, anon_sym_DASH_DASH, - ACTIONS(82), 1, - aux_sym_comment_token1, - ACTIONS(84), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, + ACTIONS(101), 2, + anon_sym_COMMA, + anon_sym_RPAREN, STATE(31), 2, sym_comment, sym_marginalia, - [590] = 4, + [657] = 5, ACTIONS(3), 1, anon_sym_DASH_DASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(86), 1, - sym__identifier, + ACTIONS(127), 1, + anon_sym_LPAREN, + STATE(87), 1, + sym_column_definitions, STATE(32), 2, sym_comment, sym_marginalia, - [604] = 4, - ACTIONS(3), 1, - anon_sym_DASH_DASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(88), 1, - sym_keyword_not, - STATE(33), 2, - sym_comment, - sym_marginalia, - [618] = 4, - ACTIONS(80), 1, - anon_sym_DASH_DASH, - ACTIONS(84), 1, - anon_sym_SLASH_STAR, - ACTIONS(90), 1, - aux_sym_marginalia_token1, - STATE(34), 2, - sym_comment, - sym_marginalia, - [632] = 4, - ACTIONS(3), 1, - anon_sym_DASH_DASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(92), 1, - sym_keyword_table, - STATE(35), 2, - sym_comment, - sym_marginalia, - [646] = 4, - ACTIONS(3), 1, - anon_sym_DASH_DASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(94), 1, - sym_keyword_table, - STATE(36), 2, - sym_comment, - sym_marginalia, - [660] = 4, - ACTIONS(3), 1, - anon_sym_DASH_DASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(96), 1, - anon_sym_SLASH, - STATE(37), 2, - sym_comment, - sym_marginalia, [674] = 4, ACTIONS(3), 1, anon_sym_DASH_DASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(98), 1, - anon_sym_SEMI, + ACTIONS(129), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + STATE(33), 2, + sym_comment, + sym_marginalia, + [689] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(131), 2, + anon_sym_DQUOTE, + sym__identifier, + STATE(34), 2, + sym_comment, + sym_marginalia, + [704] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(133), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + STATE(35), 2, + sym_comment, + sym_marginalia, + [719] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(135), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + STATE(36), 2, + sym_comment, + sym_marginalia, + [734] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(137), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + STATE(37), 2, + sym_comment, + sym_marginalia, + [749] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(139), 1, + anon_sym_LPAREN, + ACTIONS(141), 1, + anon_sym_DOT, STATE(38), 2, sym_comment, sym_marginalia, - [688] = 4, + [766] = 4, ACTIONS(3), 1, anon_sym_DASH_DASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(100), 1, - anon_sym_SEMI, + ACTIONS(143), 2, + anon_sym_COMMA, + anon_sym_RPAREN, STATE(39), 2, sym_comment, sym_marginalia, - [702] = 4, + [781] = 4, ACTIONS(3), 1, anon_sym_DASH_DASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(102), 1, - anon_sym_LPAREN, + ACTIONS(145), 2, + anon_sym_COMMA, + anon_sym_RPAREN, STATE(40), 2, sym_comment, sym_marginalia, - [716] = 4, + [796] = 5, ACTIONS(3), 1, anon_sym_DASH_DASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(104), 1, - anon_sym_SEMI, + ACTIONS(127), 1, + anon_sym_LPAREN, + STATE(62), 1, + sym_column_definitions, STATE(41), 2, sym_comment, sym_marginalia, - [730] = 4, + [813] = 5, ACTIONS(3), 1, anon_sym_DASH_DASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(106), 1, - anon_sym_SEMI, + ACTIONS(127), 1, + anon_sym_LPAREN, + STATE(79), 1, + sym_column_definitions, STATE(42), 2, sym_comment, sym_marginalia, - [744] = 4, + [830] = 4, ACTIONS(3), 1, anon_sym_DASH_DASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(108), 1, - anon_sym_DQUOTE, + ACTIONS(147), 2, + anon_sym_COMMA, + anon_sym_RPAREN, STATE(43), 2, sym_comment, sym_marginalia, - [758] = 4, + [845] = 4, ACTIONS(3), 1, anon_sym_DASH_DASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(110), 1, - anon_sym_SEMI, + ACTIONS(149), 2, + anon_sym_COMMA, + anon_sym_RPAREN, STATE(44), 2, sym_comment, sym_marginalia, - [772] = 4, + [860] = 4, ACTIONS(3), 1, anon_sym_DASH_DASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(112), 1, - anon_sym_SEMI, + ACTIONS(151), 2, + anon_sym_COMMA, + anon_sym_RPAREN, STATE(45), 2, sym_comment, sym_marginalia, - [786] = 4, + [875] = 4, ACTIONS(3), 1, anon_sym_DASH_DASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(114), 1, - ts_builtin_sym_end, + ACTIONS(153), 2, + anon_sym_COMMA, + anon_sym_RPAREN, STATE(46), 2, sym_comment, sym_marginalia, - [800] = 1, - ACTIONS(116), 1, + [890] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(155), 1, + anon_sym_COMMA, + ACTIONS(157), 1, + anon_sym_RPAREN, + STATE(47), 2, + sym_comment, + sym_marginalia, + [907] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(159), 1, + anon_sym_COMMA, + ACTIONS(161), 1, + anon_sym_RPAREN, + STATE(48), 2, + sym_comment, + sym_marginalia, + [924] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(163), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + STATE(49), 2, + sym_comment, + sym_marginalia, + [939] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(165), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + STATE(50), 2, + sym_comment, + sym_marginalia, + [954] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(167), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + STATE(51), 2, + sym_comment, + sym_marginalia, + [969] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(169), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + STATE(52), 2, + sym_comment, + sym_marginalia, + [984] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(171), 1, + aux_sym_keyword_time_token1, + STATE(44), 1, + sym__keyword_time_zone, + STATE(53), 2, + sym_comment, + sym_marginalia, + [1001] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(173), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + STATE(54), 2, + sym_comment, + sym_marginalia, + [1016] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(171), 1, + aux_sym_keyword_time_token1, + STATE(45), 1, + sym__keyword_time_zone, + STATE(55), 2, + sym_comment, + sym_marginalia, + [1033] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(175), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + STATE(56), 2, + sym_comment, + sym_marginalia, + [1048] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(177), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + STATE(57), 2, + sym_comment, + sym_marginalia, + [1063] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(179), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + STATE(58), 2, + sym_comment, + sym_marginalia, + [1078] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(181), 1, + aux_sym_double_token2, + STATE(59), 2, + sym_comment, + sym_marginalia, + [1092] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(183), 1, + sym__number, + STATE(60), 2, + sym_comment, + sym_marginalia, + [1106] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(185), 1, ts_builtin_sym_end, - [804] = 1, - ACTIONS(118), 1, + STATE(61), 2, + sym_comment, + sym_marginalia, + [1120] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(187), 1, + anon_sym_SEMI, + STATE(62), 2, + sym_comment, + sym_marginalia, + [1134] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(189), 1, + anon_sym_SEMI, + STATE(63), 2, + sym_comment, + sym_marginalia, + [1148] = 4, + ACTIONS(191), 1, + anon_sym_DASH_DASH, + ACTIONS(193), 1, + anon_sym_SLASH_STAR, + ACTIONS(195), 1, + aux_sym_marginalia_token1, + STATE(64), 2, + sym_comment, + sym_marginalia, + [1162] = 4, + ACTIONS(191), 1, + anon_sym_DASH_DASH, + ACTIONS(193), 1, + anon_sym_SLASH_STAR, + ACTIONS(197), 1, + aux_sym_comment_token1, + STATE(65), 2, + sym_comment, + sym_marginalia, + [1176] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(199), 1, + sym__number, + STATE(66), 2, + sym_comment, + sym_marginalia, + [1190] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(201), 1, + sym__number, + STATE(67), 2, + sym_comment, + sym_marginalia, + [1204] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(203), 1, + anon_sym_SEMI, + STATE(68), 2, + sym_comment, + sym_marginalia, + [1218] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(205), 1, + anon_sym_SEMI, + STATE(69), 2, + sym_comment, + sym_marginalia, + [1232] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(207), 1, + anon_sym_DQUOTE, + STATE(70), 2, + sym_comment, + sym_marginalia, + [1246] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(209), 1, + anon_sym_SLASH, + STATE(71), 2, + sym_comment, + sym_marginalia, + [1260] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(211), 1, + sym_keyword_table, + STATE(72), 2, + sym_comment, + sym_marginalia, + [1274] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(213), 1, + sym__number, + STATE(73), 2, + sym_comment, + sym_marginalia, + [1288] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(215), 1, + sym__number, + STATE(74), 2, + sym_comment, + sym_marginalia, + [1302] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(217), 1, + sym_keyword_table, + STATE(75), 2, + sym_comment, + sym_marginalia, + [1316] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(219), 1, + anon_sym_SEMI, + STATE(76), 2, + sym_comment, + sym_marginalia, + [1330] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(221), 1, + aux_sym__keyword_time_zone_token1, + STATE(77), 2, + sym_comment, + sym_marginalia, + [1344] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(223), 1, + sym_keyword_not, + STATE(78), 2, + sym_comment, + sym_marginalia, + [1358] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(225), 1, + anon_sym_SEMI, + STATE(79), 2, + sym_comment, + sym_marginalia, + [1372] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(227), 1, + anon_sym_RPAREN, + STATE(80), 2, + sym_comment, + sym_marginalia, + [1386] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(229), 1, + anon_sym_RPAREN, + STATE(81), 2, + sym_comment, + sym_marginalia, + [1400] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(231), 1, + sym__number, + STATE(82), 2, + sym_comment, + sym_marginalia, + [1414] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(233), 1, + sym__identifier, + STATE(83), 2, + sym_comment, + sym_marginalia, + [1428] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(235), 1, + anon_sym_SEMI, + STATE(84), 2, + sym_comment, + sym_marginalia, + [1442] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(237), 1, + anon_sym_SEMI, + STATE(85), 2, + sym_comment, + sym_marginalia, + [1456] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(239), 1, + anon_sym_LPAREN, + STATE(86), 2, + sym_comment, + sym_marginalia, + [1470] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(241), 1, + anon_sym_SEMI, + STATE(87), 2, + sym_comment, + sym_marginalia, + [1484] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(243), 1, + sym_keyword_exists, + STATE(88), 2, + sym_comment, + sym_marginalia, + [1498] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(245), 1, + anon_sym_RPAREN, + STATE(89), 2, + sym_comment, + sym_marginalia, + [1512] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(247), 1, + anon_sym_RPAREN, + STATE(90), 2, + sym_comment, + sym_marginalia, + [1526] = 1, + ACTIONS(249), 1, + ts_builtin_sym_end, + [1530] = 1, + ACTIONS(251), 1, ts_builtin_sym_end, }; static const uint32_t ts_small_parse_table_map[] = { - [SMALL_STATE(2)] = 0, - [SMALL_STATE(3)] = 33, - [SMALL_STATE(4)] = 68, - [SMALL_STATE(5)] = 97, - [SMALL_STATE(6)] = 126, - [SMALL_STATE(7)] = 152, - [SMALL_STATE(8)] = 178, - [SMALL_STATE(9)] = 201, - [SMALL_STATE(10)] = 218, - [SMALL_STATE(11)] = 241, - [SMALL_STATE(12)] = 264, - [SMALL_STATE(13)] = 281, - [SMALL_STATE(14)] = 301, - [SMALL_STATE(15)] = 319, - [SMALL_STATE(16)] = 339, - [SMALL_STATE(17)] = 355, - [SMALL_STATE(18)] = 375, - [SMALL_STATE(19)] = 391, - [SMALL_STATE(20)] = 407, - [SMALL_STATE(21)] = 422, - [SMALL_STATE(22)] = 437, - [SMALL_STATE(23)] = 454, - [SMALL_STATE(24)] = 471, - [SMALL_STATE(25)] = 488, - [SMALL_STATE(26)] = 505, - [SMALL_STATE(27)] = 520, - [SMALL_STATE(28)] = 534, - [SMALL_STATE(29)] = 548, - [SMALL_STATE(30)] = 562, - [SMALL_STATE(31)] = 576, - [SMALL_STATE(32)] = 590, - [SMALL_STATE(33)] = 604, - [SMALL_STATE(34)] = 618, - [SMALL_STATE(35)] = 632, - [SMALL_STATE(36)] = 646, - [SMALL_STATE(37)] = 660, - [SMALL_STATE(38)] = 674, - [SMALL_STATE(39)] = 688, - [SMALL_STATE(40)] = 702, - [SMALL_STATE(41)] = 716, - [SMALL_STATE(42)] = 730, - [SMALL_STATE(43)] = 744, - [SMALL_STATE(44)] = 758, - [SMALL_STATE(45)] = 772, - [SMALL_STATE(46)] = 786, - [SMALL_STATE(47)] = 800, - [SMALL_STATE(48)] = 804, + [SMALL_STATE(3)] = 0, + [SMALL_STATE(4)] = 41, + [SMALL_STATE(5)] = 82, + [SMALL_STATE(6)] = 117, + [SMALL_STATE(7)] = 150, + [SMALL_STATE(8)] = 179, + [SMALL_STATE(9)] = 208, + [SMALL_STATE(10)] = 235, + [SMALL_STATE(11)] = 260, + [SMALL_STATE(12)] = 286, + [SMALL_STATE(13)] = 312, + [SMALL_STATE(14)] = 335, + [SMALL_STATE(15)] = 358, + [SMALL_STATE(16)] = 381, + [SMALL_STATE(17)] = 397, + [SMALL_STATE(18)] = 415, + [SMALL_STATE(19)] = 433, + [SMALL_STATE(20)] = 449, + [SMALL_STATE(21)] = 467, + [SMALL_STATE(22)] = 483, + [SMALL_STATE(23)] = 503, + [SMALL_STATE(24)] = 523, + [SMALL_STATE(25)] = 539, + [SMALL_STATE(26)] = 555, + [SMALL_STATE(27)] = 575, + [SMALL_STATE(28)] = 593, + [SMALL_STATE(29)] = 609, + [SMALL_STATE(30)] = 627, + [SMALL_STATE(31)] = 642, + [SMALL_STATE(32)] = 657, + [SMALL_STATE(33)] = 674, + [SMALL_STATE(34)] = 689, + [SMALL_STATE(35)] = 704, + [SMALL_STATE(36)] = 719, + [SMALL_STATE(37)] = 734, + [SMALL_STATE(38)] = 749, + [SMALL_STATE(39)] = 766, + [SMALL_STATE(40)] = 781, + [SMALL_STATE(41)] = 796, + [SMALL_STATE(42)] = 813, + [SMALL_STATE(43)] = 830, + [SMALL_STATE(44)] = 845, + [SMALL_STATE(45)] = 860, + [SMALL_STATE(46)] = 875, + [SMALL_STATE(47)] = 890, + [SMALL_STATE(48)] = 907, + [SMALL_STATE(49)] = 924, + [SMALL_STATE(50)] = 939, + [SMALL_STATE(51)] = 954, + [SMALL_STATE(52)] = 969, + [SMALL_STATE(53)] = 984, + [SMALL_STATE(54)] = 1001, + [SMALL_STATE(55)] = 1016, + [SMALL_STATE(56)] = 1033, + [SMALL_STATE(57)] = 1048, + [SMALL_STATE(58)] = 1063, + [SMALL_STATE(59)] = 1078, + [SMALL_STATE(60)] = 1092, + [SMALL_STATE(61)] = 1106, + [SMALL_STATE(62)] = 1120, + [SMALL_STATE(63)] = 1134, + [SMALL_STATE(64)] = 1148, + [SMALL_STATE(65)] = 1162, + [SMALL_STATE(66)] = 1176, + [SMALL_STATE(67)] = 1190, + [SMALL_STATE(68)] = 1204, + [SMALL_STATE(69)] = 1218, + [SMALL_STATE(70)] = 1232, + [SMALL_STATE(71)] = 1246, + [SMALL_STATE(72)] = 1260, + [SMALL_STATE(73)] = 1274, + [SMALL_STATE(74)] = 1288, + [SMALL_STATE(75)] = 1302, + [SMALL_STATE(76)] = 1316, + [SMALL_STATE(77)] = 1330, + [SMALL_STATE(78)] = 1344, + [SMALL_STATE(79)] = 1358, + [SMALL_STATE(80)] = 1372, + [SMALL_STATE(81)] = 1386, + [SMALL_STATE(82)] = 1400, + [SMALL_STATE(83)] = 1414, + [SMALL_STATE(84)] = 1428, + [SMALL_STATE(85)] = 1442, + [SMALL_STATE(86)] = 1456, + [SMALL_STATE(87)] = 1470, + [SMALL_STATE(88)] = 1484, + [SMALL_STATE(89)] = 1498, + [SMALL_STATE(90)] = 1512, + [SMALL_STATE(91)] = 1526, + [SMALL_STATE(92)] = 1530, }; static const TSParseActionEntry ts_parse_actions[] = { [0] = {.entry = {.count = 0, .reusable = false}}, [1] = {.entry = {.count = 1, .reusable = false}}, RECOVER(), - [3] = {.entry = {.count = 1, .reusable = true}}, SHIFT(31), - [5] = {.entry = {.count = 1, .reusable = true}}, SHIFT(34), + [3] = {.entry = {.count = 1, .reusable = true}}, SHIFT(65), + [5] = {.entry = {.count = 1, .reusable = true}}, SHIFT(64), [7] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_source_file, 0), - [9] = {.entry = {.count = 1, .reusable = true}}, SHIFT(19), - [11] = {.entry = {.count = 1, .reusable = true}}, SHIFT(6), - [13] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2), - [15] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2), SHIFT_REPEAT(19), - [18] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2), SHIFT_REPEAT(6), - [21] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_source_file, 1), - [23] = {.entry = {.count = 1, .reusable = false}}, SHIFT(9), - [25] = {.entry = {.count = 1, .reusable = false}}, SHIFT(33), - [27] = {.entry = {.count = 1, .reusable = true}}, SHIFT(32), - [29] = {.entry = {.count = 1, .reusable = true}}, SHIFT(5), - [31] = {.entry = {.count = 1, .reusable = true}}, SHIFT(36), - [33] = {.entry = {.count = 1, .reusable = false}}, SHIFT(36), - [35] = {.entry = {.count = 1, .reusable = true}}, SHIFT(35), - [37] = {.entry = {.count = 1, .reusable = true}}, SHIFT(9), - [39] = {.entry = {.count = 1, .reusable = true}}, SHIFT(27), - [41] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_identifier, 1), - [43] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_identifier, 3), - [45] = {.entry = {.count = 1, .reusable = true}}, SHIFT(11), - [47] = {.entry = {.count = 1, .reusable = true}}, SHIFT(38), - [49] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_column_definitions_repeat1, 2), SHIFT_REPEAT(11), - [52] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_column_definitions_repeat1, 2), - [54] = {.entry = {.count = 1, .reusable = true}}, SHIFT(28), - [56] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_statement, 2), - [58] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 1), - [60] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_statement, 1), - [62] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__if_not_exists, 3), - [64] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_column_definition, 1, .production_id = 1), - [66] = {.entry = {.count = 1, .reusable = true}}, SHIFT(7), - [68] = {.entry = {.count = 1, .reusable = true}}, SHIFT(17), - [70] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_table_reference, 1, .production_id = 1), - [72] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_column_definitions, 2), - [74] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_column_definitions, 3), - [76] = {.entry = {.count = 1, .reusable = true}}, SHIFT(20), - [78] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_create_table, 4), - [80] = {.entry = {.count = 1, .reusable = false}}, SHIFT(31), - [82] = {.entry = {.count = 1, .reusable = true}}, SHIFT(47), - [84] = {.entry = {.count = 1, .reusable = false}}, SHIFT(34), - [86] = {.entry = {.count = 1, .reusable = true}}, SHIFT(43), - [88] = {.entry = {.count = 1, .reusable = true}}, SHIFT(29), - [90] = {.entry = {.count = 1, .reusable = false}}, SHIFT(37), - [92] = {.entry = {.count = 1, .reusable = true}}, SHIFT(4), - [94] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_keyword_temporary, 1), - [96] = {.entry = {.count = 1, .reusable = false}}, SHIFT(48), - [98] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_column_definitions, 4), - [100] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_create_table, 5), - [102] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_table_reference, 3, .production_id = 2), - [104] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__create_statement, 1), - [106] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__ddl_statement, 1), - [108] = {.entry = {.count = 1, .reusable = true}}, SHIFT(12), - [110] = {.entry = {.count = 1, .reusable = true}}, SHIFT(16), - [112] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_create_table, 6), - [114] = {.entry = {.count = 1, .reusable = true}}, ACCEPT_INPUT(), - [116] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_comment, 2), - [118] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_marginalia, 3), + [9] = {.entry = {.count = 1, .reusable = true}}, SHIFT(28), + [11] = {.entry = {.count = 1, .reusable = true}}, SHIFT(12), + [13] = {.entry = {.count = 1, .reusable = true}}, SHIFT(59), + [15] = {.entry = {.count = 1, .reusable = true}}, SHIFT(46), + [17] = {.entry = {.count = 1, .reusable = true}}, SHIFT(30), + [19] = {.entry = {.count = 1, .reusable = true}}, SHIFT(18), + [21] = {.entry = {.count = 1, .reusable = true}}, SHIFT(17), + [23] = {.entry = {.count = 1, .reusable = true}}, SHIFT(50), + [25] = {.entry = {.count = 1, .reusable = true}}, SHIFT(16), + [27] = {.entry = {.count = 1, .reusable = false}}, SHIFT(21), + [29] = {.entry = {.count = 1, .reusable = true}}, SHIFT(24), + [31] = {.entry = {.count = 1, .reusable = false}}, SHIFT(54), + [33] = {.entry = {.count = 1, .reusable = true}}, SHIFT(54), + [35] = {.entry = {.count = 1, .reusable = false}}, SHIFT(10), + [37] = {.entry = {.count = 1, .reusable = false}}, SHIFT(9), + [39] = {.entry = {.count = 1, .reusable = true}}, SHIFT(57), + [41] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_identifier, 3), + [43] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_identifier, 3), + [45] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_identifier, 1), + [47] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_identifier, 1), + [49] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_source_file, 1), + [51] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2), + [53] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2), SHIFT_REPEAT(28), + [56] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2), SHIFT_REPEAT(12), + [59] = {.entry = {.count = 1, .reusable = false}}, SHIFT(4), + [61] = {.entry = {.count = 1, .reusable = false}}, SHIFT(78), + [63] = {.entry = {.count = 1, .reusable = true}}, SHIFT(83), + [65] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_keyword_timestamp, 1), + [67] = {.entry = {.count = 1, .reusable = true}}, SHIFT(55), + [69] = {.entry = {.count = 1, .reusable = false}}, SHIFT(53), + [71] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_keyword_time, 1), + [73] = {.entry = {.count = 1, .reusable = true}}, SHIFT(4), + [75] = {.entry = {.count = 1, .reusable = true}}, SHIFT(76), + [77] = {.entry = {.count = 1, .reusable = true}}, SHIFT(7), + [79] = {.entry = {.count = 1, .reusable = true}}, SHIFT(72), + [81] = {.entry = {.count = 1, .reusable = false}}, SHIFT(72), + [83] = {.entry = {.count = 1, .reusable = true}}, SHIFT(75), + [85] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_keyword_char, 1), REDUCE(sym_keyword_varchar, 1), + [88] = {.entry = {.count = 1, .reusable = true}}, SHIFT(67), + [90] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_numeric, 1), + [92] = {.entry = {.count = 1, .reusable = true}}, SHIFT(66), + [94] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_decimal, 1), + [96] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_statement, 2), + [98] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_column_definitions_repeat1, 2), SHIFT_REPEAT(13), + [101] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_column_definitions_repeat1, 2), + [103] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_keyword_char, 1), + [105] = {.entry = {.count = 1, .reusable = true}}, SHIFT(13), + [107] = {.entry = {.count = 1, .reusable = true}}, SHIFT(63), + [109] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_keyword_varchar, 1), + [111] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 1), + [113] = {.entry = {.count = 1, .reusable = true}}, SHIFT(85), + [115] = {.entry = {.count = 1, .reusable = true}}, SHIFT(73), + [117] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_char, 1), + [119] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_statement, 1), + [121] = {.entry = {.count = 1, .reusable = true}}, SHIFT(74), + [123] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_varchar, 1), + [125] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__type_numeric, 1), + [127] = {.entry = {.count = 1, .reusable = true}}, SHIFT(11), + [129] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_numeric, 6, .production_id = 6), + [131] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__if_not_exists, 3), + [133] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_decimal, 6, .production_id = 6), + [135] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_varchar, 4, .production_id = 5), + [137] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_char, 4, .production_id = 5), + [139] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_table_reference, 1, .production_id = 1), + [141] = {.entry = {.count = 1, .reusable = true}}, SHIFT(23), + [143] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__keyword_time_zone, 2), + [145] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_numeric, 4, .production_id = 4), + [147] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_decimal, 4, .production_id = 4), + [149] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__with_time_zone, 2), + [151] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__without_time_zone, 2), + [153] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__type, 1), + [155] = {.entry = {.count = 1, .reusable = true}}, SHIFT(60), + [157] = {.entry = {.count = 1, .reusable = true}}, SHIFT(40), + [159] = {.entry = {.count = 1, .reusable = true}}, SHIFT(82), + [161] = {.entry = {.count = 1, .reusable = true}}, SHIFT(43), + [163] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_keyword_timestamptz, 2), + [165] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__type_character, 1), + [167] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_keyword_timestamp, 2), + [169] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_keyword_time, 2), + [171] = {.entry = {.count = 1, .reusable = true}}, SHIFT(77), + [173] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__type_datetime, 1), + [175] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_double, 2), + [177] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_keyword_timestamptz, 1), + [179] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_column_definition, 2, .production_id = 3), + [181] = {.entry = {.count = 1, .reusable = true}}, SHIFT(56), + [183] = {.entry = {.count = 1, .reusable = true}}, SHIFT(90), + [185] = {.entry = {.count = 1, .reusable = true}}, ACCEPT_INPUT(), + [187] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_create_table, 6), + [189] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_column_definitions, 4), + [191] = {.entry = {.count = 1, .reusable = false}}, SHIFT(65), + [193] = {.entry = {.count = 1, .reusable = false}}, SHIFT(64), + [195] = {.entry = {.count = 1, .reusable = false}}, SHIFT(71), + [197] = {.entry = {.count = 1, .reusable = true}}, SHIFT(92), + [199] = {.entry = {.count = 1, .reusable = true}}, SHIFT(48), + [201] = {.entry = {.count = 1, .reusable = true}}, SHIFT(47), + [203] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__ddl_statement, 1), + [205] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__create_statement, 1), + [207] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3), + [209] = {.entry = {.count = 1, .reusable = false}}, SHIFT(91), + [211] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_keyword_temporary, 1), + [213] = {.entry = {.count = 1, .reusable = true}}, SHIFT(80), + [215] = {.entry = {.count = 1, .reusable = true}}, SHIFT(81), + [217] = {.entry = {.count = 1, .reusable = true}}, SHIFT(8), + [219] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_column_definitions, 2), + [221] = {.entry = {.count = 1, .reusable = true}}, SHIFT(39), + [223] = {.entry = {.count = 1, .reusable = true}}, SHIFT(88), + [225] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_create_table, 4), + [227] = {.entry = {.count = 1, .reusable = true}}, SHIFT(37), + [229] = {.entry = {.count = 1, .reusable = true}}, SHIFT(36), + [231] = {.entry = {.count = 1, .reusable = true}}, SHIFT(89), + [233] = {.entry = {.count = 1, .reusable = true}}, SHIFT(70), + [235] = {.entry = {.count = 1, .reusable = true}}, SHIFT(19), + [237] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_column_definitions, 3), + [239] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_table_reference, 3, .production_id = 2), + [241] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_create_table, 5), + [243] = {.entry = {.count = 1, .reusable = true}}, SHIFT(34), + [245] = {.entry = {.count = 1, .reusable = true}}, SHIFT(35), + [247] = {.entry = {.count = 1, .reusable = true}}, SHIFT(33), + [249] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_marginalia, 3), + [251] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_comment, 2), }; #ifdef __cplusplus diff --git a/test/corpus/create/table.txt b/test/corpus/create/table.txt index ecba859..fa79501 100644 --- a/test/corpus/create/table.txt +++ b/test/corpus/create/table.txt @@ -110,3 +110,60 @@ create table if not exists foo (); ) ) ) + +================================================================================ +Create a table with different columns +================================================================================ +create table foo ( + c1 text, + c2 boolean, + c3 numeric(1), + c4 timestamp with time zone, + c5 varchar(120), + c6 uuid +); +-------------------------------------------------------------------------------- + +(source_file + (statement + (create_table + (keyword_create) + (keyword_table) + (table_reference + name: (identifier) + ) + (column_definitions + (column_definition + name: (identifier) + datatype: (keyword_text) + ) + (column_definition + name: (identifier) + datatype: (keyword_boolean) + ) + (column_definition + name: (identifier) + datatype: (numeric + (keyword_numeric) + precision: (literal) + ) + ) + (column_definition + name: (identifier) + datatype: (keyword_timestamptz) + ) + (column_definition + name: (identifier) + datatype: (varchar + (keyword_varchar) + size: (literal) + ) + ) + (column_definition + name: (identifier) + datatype: (keyword_uuid) + ) + ) + ) + ) +) diff --git a/tree-sitter-plpgsql.wasm b/tree-sitter-plpgsql.wasm index 7eda81ba98ef503c4a00e9ab7dcf5975350a771c..118f141555c265d2c530b603c8685ac5a59f6a2a 100755 GIT binary patch literal 21897 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