/* THIS FILE WAS AUTOMATICALLY GENERATED BY inline_grammar.py */
#pragma once

namespace duckdb {

const char INLINED_PEG_GRAMMAR[] = {
	"Statement <-\n"
	"	CreateStatement /\n"
	"	SelectStatement /\n"
	"	SetStatement /\n"
	"	PragmaStatement /\n"
	"	CallStatement /\n"
	"	InsertStatement /\n"
	"	DropStatement /\n"
	"	CopyStatement /\n"
	"	ExplainStatement /\n"
	"	UpdateStatement /\n"
	"	PrepareStatement /\n"
	"	ExecuteStatement /\n"
	"	AlterStatement /\n"
	"	TransactionStatement /\n"
	"	DeleteStatement /\n"
	"	AttachStatement /\n"
	"	UseStatement /\n"
	"	DetachStatement /\n"
	"	CheckpointStatement /\n"
	"	VacuumStatement /\n"
	"	ResetStatement /\n"
	"	ExportStatement /\n"
	"	ImportStatement /\n"
	"	CommentStatement /\n"
	"	DeallocateStatement /\n"
	"	TruncateStatement /\n"
	"	LoadStatement /\n"
	"	InstallStatement /\n"
	"	UpdateExtensionsStatement /\n"
	"	AnalyzeStatement /\n"
	"	MergeIntoStatement\n"
	"CatalogName <- Identifier\n"
	"SchemaName <- Identifier\n"
	"ReservedSchemaName <- Identifier\n"
	"TableName <- Identifier\n"
	"ReservedTableName <- Identifier\n"
	"ReservedIdentifier <- Identifier\n"
	"ColumnName <- Identifier\n"
	"ReservedColumnName <- Identifier\n"
	"IndexName <- Identifier\n"
	"SettingName <- Identifier\n"
	"PragmaName <- Identifier\n"
	"FunctionName <- Identifier\n"
	"ReservedFunctionName <- Identifier\n"
	"TableFunctionName <- Identifier\n"
	"ConstraintName <- ColIdOrString\n"
	"SequenceName <- Identifier\n"
	"CollationName <- Identifier\n"
	"CopyOptionName <- ColLabel\n"
	"SecretName <- ColId\n"
	"NumberLiteral <- < [+-]?[0-9]*([.][0-9]*)? >\n"
	"StringLiteral <- '\\'' [^\\']* '\\''\n"
	"Type <- (TimeType / IntervalType / BitType / RowType / VariantType / MapType / GeometryType / UnionType / NumericType / SetofType / SimpleType) ArrayBounds*\n"
	"SimpleType <- (CharacterType / QualifiedTypeName) TypeModifiers?\n"
	"CharacterType <- ('CHARACTER' 'VARYING'?) /\n"
	"                 ('CHAR' 'VARYING'?) /\n"
	"                 ('NATIONAL' 'CHARACTER' 'VARYING'?) /\n"
	"                 ('NATIONAL' 'CHAR' 'VARYING'?) /\n"
	"                 ('NCHAR' 'VARYING'?) /\n"
	"                 'VARCHAR'\n"
	"IntervalType <- IntervalInterval / IntervalNumber\n"
	"IntervalInterval <- 'INTERVAL' Interval?\n"
	"IntervalNumber <- 'INTERVAL' Parens(NumberLiteral)\n"
	"YearKeyword         <- 'YEAR' / 'YEARS'\n"
	"MonthKeyword        <- 'MONTH' / 'MONTHS'\n"
	"DayKeyword          <- 'DAY' / 'DAYS'\n"
	"HourKeyword         <- 'HOUR' / 'HOURS'\n"
	"MinuteKeyword       <- 'MINUTE' / 'MINUTES'\n"
	"SecondKeyword       <- 'SECOND' / 'SECONDS'\n"
	"MillisecondKeyword  <- 'MILLISECOND' / 'MILLISECONDS'\n"
	"MicrosecondKeyword  <- 'MICROSECOND' / 'MICROSECONDS'\n"
	"WeekKeyword         <- 'WEEK' / 'WEEKS'\n"
	"QuarterKeyword      <- 'QUARTER' / 'QUARTERS'\n"
	"DecadeKeyword       <- 'DECADE' / 'DECADES'\n"
	"CenturyKeyword      <- 'CENTURY' / 'CENTURIES'\n"
	"MillenniumKeyword   <- 'MILLENNIUM' / 'MILLENNIA'\n"
	"Interval <- IntervalToInterval /\n"
	"    YearKeyword /\n"
	"    MonthKeyword /\n"
	"    DayKeyword /\n"
	"    HourKeyword /\n"
	"    MinuteKeyword /\n"
	"    SecondKeyword /\n"
	"    MillisecondKeyword /\n"
	"    MicrosecondKeyword /\n"
	"    WeekKeyword /\n"
	"    QuarterKeyword /\n"
	"    DecadeKeyword /\n"
	"    CenturyKeyword /\n"
	"    MillenniumKeyword\n"
	"IntervalToInterval <- (YearKeyword 'TO' MonthKeyword) /\n"
	"    (DayKeyword 'TO' HourKeyword) /\n"
	"    (DayKeyword 'TO' MinuteKeyword) /\n"
	"    (DayKeyword 'TO' SecondKeyword) /\n"
	"    (HourKeyword 'TO' MinuteKeyword) /\n"
	"    (HourKeyword 'TO' SecondKeyword) /\n"
	"    (MinuteKeyword 'TO' SecondKeyword)\n"
	"BitType <- 'BIT' 'VARYING'? Parens(List(Expression))?\n"
	"GeometryType <- 'GEOMETRY' Parens(Expression)?\n"
	"VariantType <- 'VARIANT'\n"
	"NumericType <- SimpleNumericType / DecimalNumericType\n"
	"SimpleNumericType <- IntType / IntegerType / SmallintType /\n"
	"                BigintType / RealType / BooleanType / DoubleType\n"
	"DecimalNumericType <- FloatType / DecimalType / DecType / NumericModType\n"
	"IntType <- 'INT'\n"
	"IntegerType <- 'INTEGER'\n"
	"SmallintType <- 'SMALLINT'\n"
	"BigintType <- 'BIGINT'\n"
	"RealType <- 'REAL'\n"
	"BooleanType <- 'BOOLEAN'\n"
	"DoubleType <- ('DOUBLE' 'PRECISION')\n"
	"FloatType <- 'FLOAT' Parens(NumberLiteral)?\n"
	"DecimalType <- 'DECIMAL' TypeModifiers?\n"
	"DecType <- 'DEC' TypeModifiers?\n"
	"NumericModType <- 'NUMERIC' TypeModifiers?\n"
	"QualifiedTypeName <- (Identifier '.')* TypeName\n"
	"TypeModifiers <- Parens(List(Expression)?)\n"
	"RowType <- RowOrStruct ColIdTypeList\n"
	"SetofType <- 'SETOF' Type\n"
	"UnionType <- 'UNION' ColIdTypeList\n"
	"ColIdTypeList <- Parens(List(ColIdType))\n"
	"MapType <- 'MAP' Parens(List(Type))\n"
	"ColIdType <- ColId Type\n"
	"ArrayBounds <- SquareBracketsArray / 'ARRAY'\n"
	"ArrayKeyword <- 'ARRAY'\n"
	"SquareBracketsArray <- '[' Expression? ']'\n"
	"TimeType <- TimeOrTimestamp TypeModifiers? TimeZone?\n"
	"TimeOrTimestamp <- TimeTypeId / TimestampTypeId\n"
	"TimeTypeId <- 'TIME'\n"
	"TimestampTypeId <- 'TIMESTAMP'\n"
	"TimeZone <- WithOrWithout 'TIME' 'ZONE'\n"
	"WithOrWithout <- WithRule / WithoutRule\n"
	"WithRule <- 'WITH'\n"
	"WithoutRule <- 'WITHOUT'\n"
	"RowOrStruct <- 'ROW' / 'STRUCT'\n"
	"# internal definitions\n"
	"%whitespace <- [ \\t\\n\\r]*\n"
	"List(D) <- D (',' D)* ','?\n"
	"Parens(D) <- '(' D ')'\n"
	"UnreservedKeyword <- 'ABORT' /\n"
	"'ABSOLUTE' /\n"
	"'ACCESS' /\n"
	"'ACTION' /\n"
	"'ADD' /\n"
	"'ADMIN' /\n"
	"'AFTER' /\n"
	"'AGGREGATE' /\n"
	"'ALSO' /\n"
	"'ALTER' /\n"
	"'ALWAYS' /\n"
	"'ASSERTION' /\n"
	"'ASSIGNMENT' /\n"
	"'ATTACH' /\n"
	"'ATTRIBUTE' /\n"
	"'BACKWARD' /\n"
	"'BEFORE' /\n"
	"'BEGIN' /\n"
	"'CACHE' /\n"
	"'CALL' /\n"
	"'CALLED' /\n"
	"'CASCADE' /\n"
	"'CASCADED' /\n"
	"'CATALOG' /\n"
	"'CENTURY' /\n"
	"'CENTURIES' /\n"
	"'CHAIN' /\n"
	"'CHARACTERISTICS' /\n"
	"'CHECKPOINT' /\n"
	"'CLASS' /\n"
	"'CLOSE' /\n"
	"'CLUSTER' /\n"
	"'COMMENT' /\n"
	"'COMMENTS' /\n"
	"'COMMIT' /\n"
	"'COMMITTED' /\n"
	"'COMPRESSION' /\n"
	"'CONFIGURATION' /\n"
	"'CONFLICT' /\n"
	"'CONNECTION' /\n"
	"'CONSTRAINTS' /\n"
	"'CONTENT' /\n"
	"'CONTINUE' /\n"
	"'CONVERSION' /\n"
	"'COPY' /\n"
	"'COST' /\n"
	"'CSV' /\n"
	"'CUBE' /\n"
	"'CURRENT' /\n"
	"'CURSOR' /\n"
	"'CYCLE' /\n"
	"'DATA' /\n"
	"'DATABASE' /\n"
	"'DAY' /\n"
	"'DAYS' /\n"
	"'DEALLOCATE' /\n"
	"'DECADE' /\n"
	"'DECADES' /\n"
	"'DECLARE' /\n"
	"'DEFAULTS' /\n"
	"'DEFERRED' /\n"
	"'DEFINER' /\n"
	"'DELETE' /\n"
	"'DELIMITER' /\n"
	"'DELIMITERS' /\n"
	"'DEPENDS' /\n"
	"'DETACH' /\n"
	"'DICTIONARY' /\n"
	"'DISABLE' /\n"
	"'DISCARD' /\n"
	"'DOCUMENT' /\n"
	"'DOMAIN' /\n"
	"'DOUBLE' /\n"
	"'DROP' /\n"
	"'EACH' /\n"
	"'ENABLE' /\n"
	"'ENCODING' /\n"
	"'ENCRYPTED' /\n"
	"'ENUM' /\n"
	"'ERROR' /\n"
	"'ESCAPE' /\n"
	"'EVENT' /\n"
	"'EXCLUDE' /\n"
	"'EXCLUDING' /\n"
	"'EXCLUSIVE' /\n"
	"'EXECUTE' /\n"
	"'EXPLAIN' /\n"
	"'EXPORT' /\n"
	"'EXPORT_STATE' /\n"
	"'EXTENSION' /\n"
	"'EXTENSIONS' /\n"
	"'EXTERNAL' /\n"
	"'FAMILY' /\n"
	"'FILTER' /\n"
	"'FIRST' /\n"
	"'FOLLOWING' /\n"
	"'FORCE' /\n"
	"'FORWARD' /\n"
	"'FUNCTION' /\n"
	"'FUNCTIONS' /\n"
	"'GLOBAL' /\n"
	"'GRANT' /\n"
	"'GRANTED' /\n"
	"'GROUPS' /\n"
	"'HANDLER' /\n"
	"'HEADER' /\n"
	"'HOLD' /\n"
	"'HOUR' /\n"
	"'HOURS' /\n"
	"'IDENTITY' /\n"
	"'IF' /\n"
	"'IGNORE' /\n"
	"'IMMEDIATE' /\n"
	"'IMMUTABLE' /\n"
	"'IMPLICIT' /\n"
	"'IMPORT' /\n"
	"'INCLUDE' /\n"
	"'INCLUDING' /\n"
	"'INCREMENT' /\n"
	"'INDEX' /\n"
	"'INDEXES' /\n"
	"'INHERIT' /\n"
	"'INHERITS' /\n"
	"'INLINE' /\n"
	"'INPUT' /\n"
	"'INSENSITIVE' /\n"
	"'INSERT' /\n"
	"'INSTALL' /\n"
	"'INSTEAD' /\n"
	"'INVOKER' /\n"
	"'JSON' /\n"
	"'ISOLATION' /\n"
	"'KEY' /\n"
	"'LABEL' /\n"
	"'LANGUAGE' /\n"
	"'LARGE' /\n"
	"'LAST' /\n"
	"'LEAKPROOF' /\n"
	"'LEVEL' /\n"
	"'LISTEN' /\n"
	"'LOAD' /\n"
	"'LOCAL' /\n"
	"'LOCATION' /\n"
	"'LOCK' /\n"
	"'LOCKED' /\n"
	"'LOGGED' /\n"
	"'MACRO' /\n"
	"'MAPPING' /\n"
	"'MATCH' /\n"
	"'MATCHED' /\n"
	"'MATERIALIZED' /\n"
	"'MAXVALUE' /\n"
	"'MERGE' /\n"
	"'METHOD' /\n"
	"'MICROSECOND' /\n"
	"'MICROSECONDS' /\n"
	"'MILLENNIUM' /\n"
	"'MILLENNIA' /\n"
	"'MILLISECOND' /\n"
	"'MILLISECONDS' /\n"
	"'MINUTE' /\n"
	"'MINUTES' /\n"
	"'MINVALUE' /\n"
	"'MODE' /\n"
	"'MONTH' /\n"
	"'MONTHS' /\n"
	"'MOVE' /\n"
	"'NAME' /\n"
	"'NAMES' /\n"
	"'NEW' /\n"
	"'NEXT' /\n"
	"'NO' /\n"
	"'NOTHING' /\n"
	"'NOTIFY' /\n"
	"'NOWAIT' /\n"
	"'NULLS' /\n"
	"'OBJECT' /\n"
	"'OF' /\n"
	"'OFF' /\n"
	"'OIDS' /\n"
	"'OLD' /\n"
	"'OPERATOR' /\n"
	"'OPTION' /\n"
	"'OPTIONS' /\n"
	"'ORDINALITY' /\n"
	"'OTHERS' /\n"
	"'OVER' /\n"
	"'OVERRIDING' /\n"
	"'OWNED' /\n"
	"'OWNER' /\n"
	"'PARALLEL' /\n"
	"'PARSER' /\n"
	"'PARTIAL' /\n"
	"'PARTITION' /\n"
	"'PARTITIONED' /\n"
	"'PASSING' /\n"
	"'PASSWORD' /\n"
	"'PERCENT' /\n"
	"'PERSISTENT' /\n"
	"'PLANS' /\n"
	"'POLICY' /\n"
	"'PRAGMA' /\n"
	"'PRECEDING' /\n"
	"'PREPARE' /\n"
	"'PREPARED' /\n"
	"'PRESERVE' /\n"
	"'PRIOR' /\n"
	"'PRIVILEGES' /\n"
	"'PROCEDURAL' /\n"
	"'PROCEDURE' /\n"
	"'PROGRAM' /\n"
	"'PUBLICATION' /\n"
	"'QUARTER' /\n"
	"'QUARTERS' /\n"
	"'QUOTE' /\n"
	"'RANGE' /\n"
	"'READ' /\n"
	"'REASSIGN' /\n"
	"'RECHECK' /\n"
	"'RECURSIVE' /\n"
	"'REF' /\n"
	"'REFERENCING' /\n"
	"'REFRESH' /\n"
	"'REINDEX' /\n"
	"'RELATIVE' /\n"
	"'RELEASE' /\n"
	"'RENAME' /\n"
	"'REPEATABLE' /\n"
	"'REPLACE' /\n"
	"'REPLICA' /\n"
	"'RESET' /\n"
	"'RESPECT' /\n"
	"'RESTART' /\n"
	"'RESTRICT' /\n"
	"'RETURNS' /\n"
	"'REVOKE' /\n"
	"'ROLE' /\n"
	"'ROLLBACK' /\n"
	"'ROLLUP' /\n"
	"'ROWS' /\n"
	"'RULE' /\n"
	"'SAMPLE' /\n"
	"'SAVEPOINT' /\n"
	"'SCHEMA' /\n"
	"'SCHEMAS' /\n"
	"'SCOPE' /\n"
	"'SCROLL' /\n"
	"'SEARCH' /\n"
	"'SECRET' /\n"
	"'SECOND' /\n"
	"'SECONDS' /\n"
	"'SECURITY' /\n"
	"'SEQUENCE' /\n"
	"'SEQUENCES' /\n"
	"'SERIALIZABLE' /\n"
	"'SERVER' /\n"
	"'SESSION' /\n"
	"'SET' /\n"
	"'SETS' /\n"
	"'SHARE' /\n"
	"'SIMPLE' /\n"
	"'SKIP' /\n"
	"'SNAPSHOT' /\n"
	"'SORTED' /\n"
	"'SOURCE' /\n"
	"'SQL' /\n"
	"'STABLE' /\n"
	"'STANDALONE' /\n"
	"'START' /\n"
	"'STATEMENT' /\n"
	"'STATISTICS' /\n"
	"'STDIN' /\n"
	"'STDOUT' /\n"
	"'STORAGE' /\n"
	"'STORED' /\n"
	"'STRICT' /\n"
	"'STRIP' /\n"
	"'SUBSCRIPTION' /\n"
	"'SYSID' /\n"
	"'SYSTEM' /\n"
	"'TABLES' /\n"
	"'TABLESPACE' /\n"
	"'TARGET' /\n"
	"'TEMP' /\n"
	"'TEMPLATE' /\n"
	"'TEMPORARY' /\n"
	"'TEXT' /\n"
	"'TIES' /\n"
	"'TRANSACTION' /\n"
	"'TRANSFORM' /\n"
	"'TRIGGER' /\n"
	"'TRUNCATE' /\n"
	"'TRUSTED' /\n"
	"'TYPE' /\n"
	"'TYPES' /\n"
	"'UNBOUNDED' /\n"
	"'UNCOMMITTED' /\n"
	"'UNENCRYPTED' /\n"
	"'UNKNOWN' /\n"
	"'UNLISTEN' /\n"
	"'UNLOGGED' /\n"
	"'UNTIL' /\n"
	"'UPDATE' /\n"
	"'USE' /\n"
	"'USER' /\n"
	"'VACUUM' /\n"
	"'VALID' /\n"
	"'VALIDATE' /\n"
	"'VALIDATOR' /\n"
	"'VALUE' /\n"
	"'VARIABLE' /\n"
	"'VARYING' /\n"
	"'VERSION' /\n"
	"'VIEW' /\n"
	"'VIEWS' /\n"
	"'VIRTUAL' /\n"
	"'VOLATILE' /\n"
	"'WEEK' /\n"
	"'WEEKS' /\n"
	"'WHITESPACE' /\n"
	"'WITHIN' /\n"
	"'WITHOUT' /\n"
	"'WORK' /\n"
	"'WRAPPER' /\n"
	"'WRITE' /\n"
	"'XML' /\n"
	"'YEAR' /\n"
	"'YEARS' /\n"
	"'YES' /\n"
	"'ZONE'\n"
	"ReservedKeyword <- 'ALL' /\n"
	"'ANALYSE' /\n"
	"'ANALYZE' /\n"
	"'AND' /\n"
	"'ANY' /\n"
	"'ARRAY' /\n"
	"'AS' /\n"
	"'ASC' /\n"
	"'ASYMMETRIC' /\n"
	"'BOTH' /\n"
	"'CASE' /\n"
	"'CAST' /\n"
	"'CHECK' /\n"
	"'COLLATE' /\n"
	"'COLUMN' /\n"
	"'CONSTRAINT' /\n"
	"'CREATE' /\n"
	"'DEFAULT' /\n"
	"'DEFERRABLE' /\n"
	"'DESC' /\n"
	"'DESCRIBE' /\n"
	"'DISTINCT' /\n"
	"'DO' /\n"
	"'ELSE' /\n"
	"'END' /\n"
	"'EXCEPT' /\n"
	"'FALSE' /\n"
	"'FETCH' /\n"
	"'FOR' /\n"
	"'FOREIGN' /\n"
	"'FROM' /\n"
	"'GROUP' /\n"
	"'HAVING' /\n"
	"'QUALIFY' /\n"
	"'IN' /\n"
	"'INITIALLY' /\n"
	"'INTERSECT' /\n"
	"'INTO' /\n"
	"'LAMBDA' /\n"
	"'LATERAL' /\n"
	"'LEADING' /\n"
	"'LIMIT' /\n"
	"'NOT' /\n"
	"'NULL' /\n"
	"'OFFSET' /\n"
	"'ON' /\n"
	"'ONLY' /\n"
	"'OR' /\n"
	"'ORDER' /\n"
	"'PIVOT' /\n"
	"'PIVOT_WIDER' /\n"
	"'PIVOT_LONGER' /\n"
	"'PLACING' /\n"
	"'PRIMARY' /\n"
	"'REFERENCES' /\n"
	"'RETURNING' /\n"
	"'SELECT' /\n"
	"'SHOW' /\n"
	"'SOME' /\n"
	"'SUMMARIZE' /\n"
	"'SYMMETRIC' /\n"
	"'TABLE' /\n"
	"'THEN' /\n"
	"'TO' /\n"
	"'TRAILING' /\n"
	"'TRUE' /\n"
	"'UNION' /\n"
	"'UNIQUE' /\n"
	"'UNPIVOT' /\n"
	"'USING' /\n"
	"'VARIADIC' /\n"
	"'WHEN' /\n"
	"'WHERE' /\n"
	"'WINDOW' /\n"
	"'WITH'\n"
	"ColumnNameKeyword <- 'BETWEEN' /\n"
	"'BIGINT' /\n"
	"'BIT' /\n"
	"'BOOLEAN' /\n"
	"'CHAR' /\n"
	"'CHARACTER' /\n"
	"'COALESCE' /\n"
	"'COLUMNS' /\n"
	"'DEC' /\n"
	"'DECIMAL' /\n"
	"'EXISTS' /\n"
	"'EXTRACT' /\n"
	"'FLOAT' /\n"
	"'GENERATED' /\n"
	"'GROUPING' /\n"
	"'GROUPING_ID' /\n"
	"'INOUT' /\n"
	"'INT' /\n"
	"'INTEGER' /\n"
	"'INTERVAL' /\n"
	"'MAP' /\n"
	"'NATIONAL' /\n"
	"'NCHAR' /\n"
	"'NONE' /\n"
	"'NULLIF' /\n"
	"'NUMERIC' /\n"
	"'OUT' /\n"
	"'OVERLAY' /\n"
	"'POSITION' /\n"
	"'PRECISION' /\n"
	"'REAL' /\n"
	"'ROW' /\n"
	"'SETOF' /\n"
	"'SMALLINT' /\n"
	"'SUBSTRING' /\n"
	"'STRUCT' /\n"
	"'TIME' /\n"
	"'TIMESTAMP' /\n"
	"'TREAT' /\n"
	"'TRIM' /\n"
	"'TRY_CAST' /\n"
	"'VALUES' /\n"
	"'VARCHAR' /\n"
	"'XMLATTRIBUTES' /\n"
	"'XMLCONCAT' /\n"
	"'XMLELEMENT' /\n"
	"'XMLEXISTS' /\n"
	"'XMLFOREST' /\n"
	"'XMLNAMESPACES' /\n"
	"'XMLPARSE' /\n"
	"'XMLPI' /\n"
	"'XMLROOT' /\n"
	"'XMLSERIALIZE' /\n"
	"'XMLTABLE'\n"
	"FuncNameKeyword <- 'ASOF' /\n"
	"'AT' /\n"
	"'AUTHORIZATION' /\n"
	"'BINARY' /\n"
	"'COLLATION' /\n"
	"'CONCURRENTLY' /\n"
	"'CROSS' /\n"
	"'FREEZE' /\n"
	"'FULL' /\n"
	"'GENERATED' /\n"
	"'GLOB' /\n"
	"'ILIKE' /\n"
	"'INNER' /\n"
	"'IS' /\n"
	"'ISNULL' /\n"
	"'JOIN' /\n"
	"'LEFT' /\n"
	"'LIKE' /\n"
	"'MAP' /\n"
	"'NATURAL' /\n"
	"'NOTNULL' /\n"
	"'OUTER' /\n"
	"'OVERLAPS' /\n"
	"'POSITIONAL' /\n"
	"'RIGHT' /\n"
	"'SIMILAR' /\n"
	"'STRUCT' /\n"
	"'TABLESAMPLE' /\n"
	"'VERBOSE'\n"
	"TypeNameKeyword <- 'ASOF' /\n"
	"'AT' /\n"
	"'AUTHORIZATION' /\n"
	"'BINARY' /\n"
	"'BY' /\n"
	"'COLLATION' /\n"
	"'COLUMNS' /\n"
	"'CONCURRENTLY' /\n"
	"'CROSS' /\n"
	"'FREEZE' /\n"
	"'FULL' /\n"
	"'GLOB' /\n"
	"'ILIKE' /\n"
	"'INNER' /\n"
	"'IS' /\n"
	"'ISNULL' /\n"
	"'JOIN' /\n"
	"'LEFT' /\n"
	"'LIKE' /\n"
	"'NATURAL' /\n"
	"'NOTNULL' /\n"
	"'OUTER' /\n"
	"'OVERLAPS' /\n"
	"'POSITIONAL' /\n"
	"'RIGHT' /\n"
	"'UNPACK' /\n"
	"'SIMILAR' /\n"
	"'TABLESAMPLE' /\n"
	"'TRY_CAST' /\n"
	"'VERBOSE' /\n"
	"'SEMI' /\n"
	"'ANTI'\n"
	"PivotStatement <- PivotKeyword TableRef PivotOn? PivotUsing? PivotGroupByList?\n"
	"PivotOn <- 'ON' PivotColumnList\n"
	"PivotUsing <- 'USING' TargetList\n"
	"PivotColumnList <- List(PivotColumnEntry)\n"
	"PivotColumnEntry <- PivotColumnSubquery / PivotValueList / PivotColumnEntryInternal\n"
	"PivotColumnEntryInternal <- Expression\n"
	"PivotColumnSubquery <- BaseExpression 'IN' Parens(SelectStatementInternal)\n"
	"PivotKeyword <- 'PIVOT' / 'PIVOT_WIDER'\n"
	"UnpivotKeyword <- 'UNPIVOT' / 'PIVOT_LONGER'\n"
	"UnpivotStatement <- UnpivotKeyword TableRef 'ON' TargetList IntoNameValues?\n"
	"IntoNameValues <- 'INTO' 'NAME' ColIdOrString ValueOrValues List(Identifier)\n"
	"ValueOrValues <- 'VALUE' / 'VALUES'\n"
	"IncludeOrExcludeNulls <- IncludeNulls / ExcludeNulls\n"
	"IncludeNulls <- 'INCLUDE' 'NULLS'\n"
	"ExcludeNulls <- 'EXCLUDE' 'NULLS'\n"
	"UnpivotHeader <- UnpivotHeaderSingle / UnpivotHeaderList\n"
	"UnpivotHeaderSingle <- ColIdOrString\n"
	"UnpivotHeaderList <- Parens(List(ColIdOrString))\n"
	"ColumnReference <- CatalogReservedSchemaTableColumnName / SchemaReservedTableColumnName / TableReservedColumnName / NestedColumnName\n"
	"CatalogReservedSchemaTableColumnName <- CatalogQualification ReservedSchemaQualification ReservedTableQualification ReservedColumnName\n"
	"SchemaReservedTableColumnName <- SchemaQualification ReservedTableQualification ReservedColumnName\n"
	"TableReservedColumnName <- TableQualification ReservedColumnName\n"
	"FunctionExpression <- FunctionIdentifier Parens(DistinctOrAll? List(FunctionArgument)? OrderByClause? IgnoreOrRespectNulls?) WithinGroupClause? FilterClause? ExportClause? OverClause?\n"
	"FunctionIdentifier <- CatalogReservedSchemaFunctionName / SchemaReservedFunctionName / FunctionName\n"
	"CatalogReservedSchemaFunctionName <- CatalogQualification ReservedSchemaQualification? ReservedFunctionName\n"
	"SchemaReservedFunctionName <- SchemaQualification ReservedFunctionName\n"
	"DistinctOrAll <- 'DISTINCT' / 'ALL'\n"
	"ExportClause <- 'EXPORT_STATE'\n"
	"WithinGroupClause <- 'WITHIN' 'GROUP' Parens(OrderByClause)\n"
	"FilterClause <- 'FILTER' Parens('WHERE'? Expression)\n"
	"IgnoreOrRespectNulls <- IgnoreNulls / RespectNulls\n"
	"IgnoreNulls <- 'IGNORE' 'NULLS'\n"
	"RespectNulls <- 'RESPECT' 'NULLS'\n"
	"ParenthesisExpression <- Parens(List(Expression))\n"
	"LiteralExpression <- StringLiteral / NumberLiteral / ConstantLiteral\n"
	"ConstantLiteral <- NullLiteral / TrueLiteral / FalseLiteral\n"
	"NullLiteral <- 'NULL'\n"
	"TrueLiteral <- 'TRUE'\n"
	"FalseLiteral <- 'FALSE'\n"
	"CastExpression <- CastOrTryCast Parens(Expression 'AS' Type)\n"
	"CastOrTryCast <- 'CAST' / 'TRY_CAST'\n"
	"StarExpression <- (ColId '.')* '*' ExcludeList? ReplaceList? RenameList?\n"
	"ExcludeList <- 'EXCLUDE' ExcludeNameList / ExcludeNameSingle\n"
	"ExcludeNameList <- Parens(List(ExcludeName))\n"
	"ExcludeNameSingle <- ExcludeName\n"
	"ExcludeName <- DottedIdentifier / ColIdOrString\n"
	"ReplaceList <- 'REPLACE' ReplaceEntries\n"
	"ReplaceEntries <- ReplaceEntrySingle / ReplaceEntryList\n"
	"ReplaceEntrySingle <- ReplaceEntry\n"
	"ReplaceEntryList <- Parens(List(ReplaceEntry))\n"
	"ReplaceEntry <- Expression 'AS' ColumnReference\n"
	"RenameList <- 'RENAME' (RenameEntryList / SingleRenameEntry)\n"
	"RenameEntryList <- Parens(List(RenameEntry))\n"
	"SingleRenameEntry <- RenameEntry\n"
	"RenameEntry <- ExcludeName 'AS' Identifier\n"
	"SubqueryExpression <- 'NOT'? 'EXISTS'? SubqueryReference\n"
	"CaseExpression <- 'CASE' Expression? CaseWhenThen+ CaseElse? 'END'\n"
	"CaseWhenThen <- 'WHEN' Expression 'THEN' Expression\n"
	"CaseElse <- 'ELSE' Expression\n"
	"TypeLiteral <- ColId StringLiteral\n"
	"IntervalLiteral <- 'INTERVAL' IntervalParameter Interval?\n"
	"IntervalParameter <- StringLiteral / NumberLiteral / ParensExpression\n"
	"FrameClause <- Framing FrameExtent WindowExcludeClause?\n"
	"Framing <- 'ROWS' / 'RANGE' / 'GROUPS'\n"
	"FrameExtent <- BetweenFrameExtent / SingleFrameExtent\n"
	"SingleFrameExtent <- FrameBound\n"
	"BetweenFrameExtent <- 'BETWEEN' FrameBound 'AND' FrameBound\n"
	"FrameBound <- FrameUnbounded / FrameCurrentRow / FrameExpression\n"
	"FrameUnbounded <- 'UNBOUNDED' PrecedingOrFollowing\n"
	"FrameExpression <- Expression PrecedingOrFollowing\n"
	"FrameCurrentRow <- 'CURRENT' 'ROW'\n"
	"PrecedingOrFollowing <- 'PRECEDING' / 'FOLLOWING'\n"
	"WindowExcludeClause <- 'EXCLUDE' WindowExcludeElement\n"
	"WindowExcludeElement <- ExcludeCurrentRow / ExcludeGroup / ExcludeTies / ExcludeNoOthers\n"
	"ExcludeCurrentRow <- 'CURRENT' 'ROW'\n"
	"ExcludeGroup <- 'GROUP'\n"
	"ExcludeTies <- 'TIES'\n"
	"ExcludeNoOthers <- 'NO' 'OTHERS'\n"
	"OverClause <- 'OVER' WindowFrame\n"
	"WindowFrame <- ParensIdentifier / WindowFrameDefinition / Identifier\n"
	"ParensIdentifier <- Parens(Identifier)\n"
	"WindowFrameDefinition <- WindowFrameNameContentsParens / WindowFrameContentsParens\n"
	"WindowFrameNameContentsParens <- Parens(BaseWindowName? WindowFrameContents)\n"
	"WindowFrameContentsParens <- Parens(WindowFrameContents)\n"
	"WindowFrameContents <- WindowPartition? OrderByClause? FrameClause?\n"
	"BaseWindowName <- Identifier\n"
	"WindowPartition <- 'PARTITION' 'BY' List(Expression)\n"
	"ListExpression <- ArrayBoundedListExpression / ArrayParensSelect\n"
	"ArrayBoundedListExpression <- 'ARRAY'? BoundedListExpression\n"
	"ArrayParensSelect <- 'ARRAY' Parens(SelectStatementInternal)\n"
	"BoundedListExpression <- '[' List(Expression)? ']'\n"
	"StructExpression <- '{' List(StructField) '}'\n"
	"StructField <- ColIdOrString ':' Expression\n"
	"MapExpression <- 'MAP' MapStructExpression\n"
	"MapStructExpression <- '{' List(MapStructField)? '}'\n"
	"MapStructField <- Expression ':' Expression\n"
	"GroupingExpression <- GroupingOrGroupingId Parens(List(Expression))\n"
	"GroupingOrGroupingId <- 'GROUPING' / 'GROUPING_ID'\n"
	"Parameter <- QuestionMarkNumberedParameter / AnonymousParameter / NumberedParameter / ColLabelParameter\n"
	"QuestionMarkNumberedParameter <- '?' NumberLiteral\n"
	"AnonymousParameter <- '?'\n"
	"NumberedParameter <- '$' NumberLiteral\n"
	"ColLabelParameter <- '$' ColLabel\n"
	"PositionalExpression <- '#' NumberLiteral\n"
	"DefaultExpression <- 'DEFAULT'\n"
	"ListComprehensionExpression <- '[' Expression 'FOR' List(ColIdOrString) 'IN' Expression ListComprehensionFilter? ']'\n"
	"ListComprehensionFilter <- 'IF' Expression\n"
	"ParensExpression <- Parens(Expression)\n"
	"SingleExpression <-\n"
	"    ParensExpression /\n"
	"	LiteralExpression /\n"
	"	Parameter /\n"
	"    SubqueryExpression /\n"
	"    SpecialFunctionExpression /\n"
	"    ParenthesisExpression /\n"
	"    IntervalLiteral /\n"
	"    TypeLiteral /\n"
	"    CaseExpression /\n"
	"    StarExpression /\n"
	"    CastExpression /\n"
	"    GroupingExpression /\n"
	"    MapExpression /\n"
	"    FunctionExpression /\n"
	"    ColumnReference /\n"
	"    ListComprehensionExpression /\n"
	"    ListExpression /\n"
	"    StructExpression /\n"
	"    PositionalExpression /\n"
	"    DefaultExpression\n"
	"# LEVEL 1 (Lowest)\n"
	"Expression <- LambdaArrowExpression\n"
	"# LEVEL 1.5\n"
	"LambdaArrowExpression <- LogicalOrExpression SingleArrowPair*\n"
	"SingleArrowPair <- '->' LogicalOrExpression\n"
	"LogicalOrExpression <- LogicalAndExpression ('OR' LogicalAndExpression)*\n"
	"# LEVEL 2\n"
	"LogicalAndExpression <- LogicalNotExpression ('AND' LogicalNotExpression)*\n"
	"# LEVEL 3\n"
	"LogicalNotExpression <- 'NOT'* IsExpression\n"
	"# LEVEL 4\n"
	"IsExpression <- IsDistinctFromExpression IsTest*\n"
	"IsTest <- IsLiteral / NotNull / IsNull\n"
	"IsLiteral <- 'IS' 'NOT'? (TrueLiteral / FalseLiteral / NullLiteral / UnknownLiteral)\n"
	"UnknownLiteral <- 'UNKNOWN'\n"
	"NotNull <- ('NOT' 'NULL') / 'NOTNULL'\n"
	"IsNull <- 'ISNULL'\n"
	"# LEVEL 5 (Split because IsDistinctFromExpression allows post expression while IsOperator does not)\n"
	"IsDistinctFromExpression <- ComparisonExpression (IsDistinctFromOp ComparisonExpression)*\n"
	"IsDistinctFromOp <- 'IS' 'NOT'? 'DISTINCT' 'FROM'\n"
	"# LEVEL 6\n"
	"ComparisonExpression <- BetweenInLikeExpression (ComparisonOperator 'NOT'* BetweenInLikeExpression)*\n"
	"ComparisonOperator <-\n"
	"    OperatorEqual /\n"
	"    OperatorNotEqual /\n"
	"    OperatorLessThan /\n"
	"    OperatorGreaterThan /\n"
	"    OperatorLessThanEquals /\n"
	"    OperatorGreaterThanEquals\n"
	"OperatorEqual <- '=' / '=='\n"
	"OperatorNotEqual <- '!=' / '<>'\n"
	"OperatorLessThan <- '<'\n"
	"OperatorGreaterThan <- '>'\n"
	"OperatorLessThanEquals <- '<='\n"
	"OperatorGreaterThanEquals <- '>='\n"
	"# LEVEL 7\n"
	"BetweenInLikeExpression <- OtherOperatorExpression BetweenInLikeOp?\n"
	"BetweenInLikeOp <- 'NOT'? (BetweenClause / InClause / LikeClause)\n"
	"LikeClause <- LikeVariations OtherOperatorExpression EscapeClause?\n"
	"EscapeClause <- 'ESCAPE' Expression\n"
	"LikeVariations <- SimilarToToken / ILikeToken / LikeToken / GlobToken / NotILikeOp / NotLikeOp / NotSimilarToOp\n"
	"LikeToken      <- 'LIKE' / '~~'\n"
	"ILikeToken     <- 'ILIKE' / '~~*'\n"
	"GlobToken      <- 'GLOB' / '~~~'\n"
	"SimilarToToken <- ('SIMILAR' 'TO') / '~'\n"
	"NotILikeOp     <- '!~~*'\n"
	"NotLikeOp      <- '!~~'\n"
	"NotSimilarToOp <- '!~'\n"
	"InClause <- 'IN' InExpression\n"
	"InExpression <- InExpressionList / InSelectStatement / OtherOperatorExpression\n"
	"InExpressionList <- Parens(List(Expression))\n"
	"InSelectStatement <- Parens(SelectStatementInternal)\n"
	"BetweenClause <- 'BETWEEN' OtherOperatorExpression 'AND' OtherOperatorExpression\n"
	"# LEVEL 8\n"
	"OtherOperatorExpression <- BitwiseExpression (OtherOperator BitwiseExpression)*\n"
	"OtherOperator <-\n"
	"    QualifiedOperator / AnyAllOperator / InetOperator / JsonOperator / ListOperator / StringOperator / OperatorLiteral\n"
	"AnyAllOperator <- AnyOp AnyOrAll\n"
	"AnyOrAll <- SubqueryAny / SubqueryAll\n"
	"SubqueryAny <- 'ANY'\n"
	"SubqueryAll <- 'ALL'\n"
	"InetOperator <- '>>=' / '<<='\n"
	"JsonOperator <- '->>'\n"
	"ListOperator <- '&&' / '@>' / '<@'\n"
	"StringOperator <- '^@' / '||'\n"
	"QualifiedOperator <- 'OPERATOR' Parens(AnyOp)\n"
	"AnyOp <- '!~~*' / '>>=' / '<<=' / '->>' / '!~~' / '~~*' / '~~~' / '!~' / '^@' / '||' / '&&' / '@>' / '<@' / '<=' / '>=' / '<>' / '!=' / '==' / '<<' / '>>' / '//' / '**' / '->' / '~~' / '+' / '-' / '*' / '/' / '%' / '^' / '<' / '>' / '=' / '&' / '|' / '~' / '!'\n"
	"# LEVEL 9\n"
	"BitwiseExpression <- AdditiveExpression (BitOperator AdditiveExpression)*\n"
	"BitOperator <- '&' / '|' / '<<' / '>>'\n"
	"# LEVEL 10\n"
	"AdditiveExpression <- MultiplicativeExpression (Term MultiplicativeExpression)*\n"
	"Term <- '+' / '-'\n"
	"# LEVEL 11\n"
	"MultiplicativeExpression <- ExponentiationExpression (Factor ExponentiationExpression)*\n"
	"Factor <- '*' / '/' / '//' / '%'\n"
	"# LEVEL 12\n"
	"ExponentiationExpression <- CollateExpression (ExponentOperator CollateExpression)*\n"
	"ExponentOperator <- '^' / '**'\n"
	"# LEVEL 13\n"
	"CollateExpression <- AtTimeZoneExpression (CollateOperator AtTimeZoneExpression)*\n"
	"CollateOperator <- 'COLLATE'\n"
	"# LEVEL 14\n"
	"AtTimeZoneExpression <- PrefixExpression (AtTimeZoneOperator PrefixExpression)*\n"
	"AtTimeZoneOperator <- 'AT' 'TIME' 'ZONE'\n"
	"# LEVEL 15\n"
	"PrefixExpression <- PrefixOperator* BaseExpression\n"
	"PrefixOperator <- QualifiedOperator / MinusPrefixOperator / PlusPrefixOperator / TildePrefixOperator\n"
	"MinusPrefixOperator <- '-'\n"
	"PlusPrefixOperator <- '+'\n"
	"TildePrefixOperator <- '~'\n"
	"# LEVEL 16 (Highest)\n"
	"BaseExpression <- SingleExpression Indirection*\n"
	"Indirection <- CastOperator / DotOperator / SliceExpression / PostfixOperator\n"
	"CastOperator <- '::' Type\n"
	"DotOperator <- '.' (MethodExpression / ColLabel)\n"
	"MethodExpression <- ColLabel Parens(DistinctOrAll? List(FunctionArgument)? OrderByClause? IgnoreOrRespectNulls?)\n"
	"SliceExpression <- '[' SliceBound ']'\n"
	"SliceBound <- Expression? EndSliceBound? StepSliceBound?\n"
	"EndSliceBound <- ':' (Expression / '-')?\n"
	"StepSliceBound <- ':' Expression?\n"
	"PostfixOperator <- '!'\n"
	"SpecialFunctionExpression <- CoalesceExpression / UnpackExpression / TryExpression / ColumnsExpression / ExtractExpression / LambdaExpression / NullIfExpression / PositionExpression / RowExpression / SubstringExpression / TrimExpression\n"
	"CoalesceExpression <- 'COALESCE' Parens(List(Expression))\n"
	"UnpackExpression <- 'UNPACK' Parens(Expression)\n"
	"TryExpression <- 'TRY' Parens(Expression)\n"
	"ColumnsExpression <- '*'? 'COLUMNS' Parens(Expression)\n"
	"ExtractExpression <- 'EXTRACT' Parens(ExtractArgument 'FROM' Expression)\n"
	"LambdaExpression <- 'LAMBDA' List(ColIdOrString) ':' Expression\n"
	"NullIfExpression <- 'NULLIF' Parens(Expression ',' Expression)\n"
	"PositionExpression <- 'POSITION' Parens(SingleExpression 'IN' SingleExpression)\n"
	"RowExpression <- 'ROW' Parens(List(Expression)?)\n"
	"SubstringExpression <- 'SUBSTRING' Parens(SubstringArguments)\n"
	"SubstringArguments <- SubstringParameters / SubstringExpressionList\n"
	"SubstringExpressionList <- List(Expression)\n"
	"SubstringParameters <- Expression 'FROM' Expression 'FOR' Expression\n"
	"TrimExpression <- 'TRIM' Parens(TrimDirection? TrimSource? List(Expression))\n"
	"TrimDirection <- TrimBoth / TrimLeading / TrimTrailing\n"
	"TrimBoth <- 'BOTH'\n"
	"TrimLeading <- 'LEADING'\n"
	"TrimTrailing <- 'TRAILING'\n"
	"TrimSource <- Expression? 'FROM'\n"
	"ExtractArgument <-\n"
	"    YearKeyword / MonthKeyword / DayKeyword / HourKeyword / MinuteKeyword / SecondKeyword /\n"
	"    MillisecondKeyword / MicrosecondKeyword / WeekKeyword / QuarterKeyword / DecadeKeyword /\n"
	"    CenturyKeyword / MillenniumKeyword / Identifier / StringLiteral\n"
	"ExecuteStatement <- 'EXECUTE' Identifier TableFunctionArguments?\n"
	"CreateSecretStmt <- 'SECRET' IfNotExists? SecretName? SecretStorageSpecifier? GenericCopyOptionList\n"
	"SecretStorageSpecifier <- 'IN' Identifier\n"
	"CreateViewStmt <- 'RECURSIVE'? 'VIEW' IfNotExists? QualifiedName InsertColumnList? 'AS' SelectStatementInternal\n"
	"DescribeStatement <- ShowTables / ShowSelect / ShowAllTables / ShowQualifiedName\n"
	"ShowSelect <- ShowOrDescribeOrSummarize SelectStatementInternal\n"
	"ShowAllTables <- ShowOrDescribe 'ALL' 'TABLES'\n"
	"ShowQualifiedName <- ShowOrDescribeOrSummarize (BaseTableName / StringLiteral)?\n"
	"ShowTables <- ShowOrDescribe 'TABLES' 'FROM' QualifiedName\n"
	"ShowOrDescribeOrSummarize <- ShowOrDescribe / Summarize\n"
	"Summarize <- SummarizeRule\n"
	"SummarizeRule <- 'SUMMARIZE'\n"
	"ShowOrDescribe <- ShowRule / DescribeRule\n"
	"ShowRule <- 'SHOW'\n"
	"DescribeRule <- 'DESCRIBE' / 'DESC'\n"
	"VacuumStatement <- 'VACUUM' VacuumOptions? AnalyzeTarget?\n"
	"VacuumOptions <- VacuumParensOptions / VacuumLegacyOptions\n"
	"VacuumParensOptions <- Parens(List(VacuumOption))\n"
	"VacuumLegacyOptions <- OptFull? OptFreeze? OptVerbose? OptAnalyze?\n"
	"VacuumOption <- OptAnalyze / OptFreeze / OptFull / OptVerbose / Identifier\n"
	"OptAnalyze <- 'ANALYZE'\n"
	"OptFull <- 'FULL'\n"
	"OptFreeze <- 'FREEZE'\n"
	"OptVerbose <- 'VERBOSE'\n"
	"NameList <- Parens(List(ColId))\n"
	"MergeIntoStatement <- WithClause? 'MERGE' 'INTO' TargetOptAlias MergeIntoUsingClause JoinQualifier MergeMatch+ ReturningClause?\n"
	"MergeIntoUsingClause <- 'USING' TableRef\n"
	"MergeMatch <- MatchedClause / NotMatchedClause\n"
	"MatchedClause <- 'WHEN' 'MATCHED' AndExpression? 'THEN' MatchedClauseAction\n"
	"MatchedClauseAction <- UpdateMatchClause / DeleteMatchClause / InsertMatchClause / DoNothingMatchClause / ErrorMatchClause\n"
	"UpdateMatchClause <- 'UPDATE' UpdateMatchInfo?\n"
	"UpdateMatchInfo <- UpdateMatchSetClause / ByNameOrPosition\n"
	"DeleteMatchClause <- 'DELETE'\n"
	"InsertMatchClause <- 'INSERT' InsertMatchInfo?\n"
	"InsertMatchInfo <- InsertValuesList / InsertDefaultValues / InsertByNameOrPosition\n"
	"InsertDefaultValues <- 'DEFAULT' 'VALUES'\n"
	"InsertByNameOrPosition <- ByNameOrPosition? '*'?\n"
	"InsertValuesList <- InsertColumnList? 'VALUES' Parens(List(Expression))\n"
	"DoNothingMatchClause <- 'DO' 'NOTHING'\n"
	"ErrorMatchClause <- 'ERROR' Expression?\n"
	"UpdateMatchSetClause <- 'SET' (UpdateSetClause / '*')\n"
	"AndExpression <- 'AND' Expression\n"
	"NotMatchedClause <- 'WHEN' 'NOT' 'MATCHED' BySourceOrTarget? AndExpression? 'THEN' MatchedClauseAction\n"
	"BySourceOrTarget <- BySource / ByTarget\n"
	"BySource <- 'BY' 'SOURCE'\n"
	"ByTarget <- 'BY' 'TARGET'\n"
	"PragmaStatement <- 'PRAGMA' (PragmaAssign / PragmaFunction)\n"
	"PragmaAssign <- SettingName '=' VariableList\n"
	"PragmaFunction <- PragmaName PragmaParameters?\n"
	"PragmaParameters <- Parens(List(Expression))\n"
	"DeallocateStatement <- 'DEALLOCATE' 'PREPARE'? Identifier\n"
	"PrepareStatement <- 'PREPARE' Identifier TypeList? 'AS' Statement\n"
	"TypeList <- Parens(List(Type))\n"
	"CreateStatement <- 'CREATE' OrReplace? Temporary? CreateStatementVariation\n"
	"CreateStatementVariation <- CreateTableStmt / CreateMacroStmt / CreateSequenceStmt / CreateTypeStmt / CreateSchemaStmt / CreateViewStmt / CreateIndexStmt / CreateSecretStmt\n"
	"OrReplace <- 'OR' 'REPLACE'\n"
	"Temporary <- Persistent / TempPersistent / TemporaryPersistent\n"
	"Persistent <- 'PERSISTENT'\n"
	"TempPersistent <- 'TEMP'\n"
	"TemporaryPersistent <- 'TEMPORARY'\n"
	"CreateTableStmt <- 'TABLE' IfNotExists? QualifiedName (CreateTableAs / CreateColumnList) CommitAction?\n"
	"CreateTableAs <- IdentifierList? PartitionSortedOptions? WithList? 'AS' Statement WithData?\n"
	"PartitionSortedOptions <- PartitionOptSortedOptions / SortedOptPartitionOptions\n"
	"PartitionOptSortedOptions <- PartitionOptions SortedOptions?\n"
	"SortedOptPartitionOptions <- SortedOptions PartitionOptions?\n"
	"PartitionOptions <- 'PARTITIONED' 'BY' Parens(List(Expression))\n"
	"SortedOptions <- 'SORTED' 'BY' Parens(List(Expression))\n"
	"WithData <- 'WITH' 'NO'? 'DATA'\n"
	"IdentifierList <- Parens(List(Identifier))\n"
	"CreateColumnList <- Parens(CreateTableColumnList?) PartitionSortedOptions? WithList?\n"
	"IfNotExists <- 'IF' 'NOT' 'EXISTS'\n"
	"QualifiedName <- CatalogReservedSchemaIdentifier / SchemaReservedIdentifierOrStringLiteral / IdentifierOrStringLiteral\n"
	"SchemaReservedIdentifierOrStringLiteral <- SchemaQualification ReservedIdentifierOrStringLiteral\n"
	"CatalogReservedSchemaIdentifier <- CatalogQualification ReservedSchemaQualification ReservedIdentifierOrStringLiteral\n"
	"IdentifierOrStringLiteral <- Identifier / StringLiteral\n"
	"ReservedIdentifierOrStringLiteral <- ReservedIdentifier / StringLiteral\n"
	"CatalogQualification <- CatalogName '.'\n"
	"SchemaQualification <- SchemaName '.'\n"
	"ReservedSchemaQualification <- ReservedSchemaName '.'\n"
	"TableQualification <- TableName '.'\n"
	"ReservedTableQualification <- ReservedTableName '.'\n"
	"CreateTableColumnList <- List(CreateTableColumnElement)\n"
	"CreateTableColumnElement <- ColumnDefinition / TopLevelConstraint\n"
	"ColumnDefinition <- DottedIdentifier Type? GeneratedColumn? ConstraintNameClause? ColumnConstraint*\n"
	"ColumnConstraint <- NotNullConstraint / UniqueConstraint / PrimaryKeyConstraint / DefaultValue / CheckConstraint / ForeignKeyConstraint / ColumnCollation / ColumnCompression\n"
	"NotNullConstraint <- 'NOT'? 'NULL'\n"
	"UniqueConstraint <- 'UNIQUE'\n"
	"PrimaryKeyConstraint <- 'PRIMARY' 'KEY'\n"
	"DefaultValue <- 'DEFAULT' Expression\n"
	"CheckConstraint <- 'CHECK' Parens(Expression)\n"
	"ForeignKeyConstraint <- 'REFERENCES' BaseTableName Parens(ColumnList)? KeyActions\n"
	"ColumnCollation <- 'COLLATE' DottedIdentifier\n"
	"ColumnCompression <- 'USING' 'COMPRESSION' ColIdOrString\n"
	"KeyActions <- UpdateAction? DeleteAction?\n"
	"UpdateAction <- 'ON' 'UPDATE' KeyAction\n"
	"DeleteAction <- 'ON' 'DELETE' KeyAction\n"
	"KeyAction <- NoKeyAction / RestrictKeyAction / CascadeKeyAction / SetNullKeyAction / SetDefaultKeyAction\n"
	"NoKeyAction <- 'NO' 'ACTION'\n"
	"RestrictKeyAction <- 'RESTRICT'\n"
	"CascadeKeyAction <- 'CASCADE'\n"
	"SetNullKeyAction <- 'SET' 'NULL'\n"
	"SetDefaultKeyAction <- 'SET' 'DEFAULT'\n"
	"TopLevelConstraint <- ConstraintNameClause? TopLevelConstraintList\n"
	"TopLevelConstraintList <- TopPrimaryKeyConstraint / CheckConstraint / TopUniqueConstraint / TopForeignKeyConstraint\n"
	"ConstraintNameClause <- 'CONSTRAINT' Identifier\n"
	"TopPrimaryKeyConstraint <- 'PRIMARY' 'KEY' ColumnIdList\n"
	"TopUniqueConstraint <- 'UNIQUE' ColumnIdList\n"
	"TopForeignKeyConstraint <- 'FOREIGN' 'KEY' ColumnIdList ForeignKeyConstraint\n"
	"ColumnIdList <- Parens(List(ColId))\n"
	"PlainIdentifier <- !ReservedKeyword <[a-z_]i[a-z0-9_]i*>\n"
	"QuotedIdentifier <- '\"' [^\"]* '\"'\n"
	"DottedIdentifier <- Identifier ('.' ColLabel)*\n"
	"Identifier <- QuotedIdentifier / PlainIdentifier\n"
	"ColId <- UnreservedKeyword / ColumnNameKeyword / Identifier\n"
	"ColIdOrString <- ColId / StringLiteral\n"
	"TypeFuncName <- UnreservedKeyword / TypeNameKeyword / FuncNameKeyword / Identifier\n"
	"TypeName <- UnreservedKeyword / TypeNameKeyword / Identifier\n"
	"ColLabel <- ReservedKeyword / UnreservedKeyword / ColumnNameKeyword / FuncNameKeyword / TypeNameKeyword / Identifier\n"
	"ColLabelOrString <- ColLabel / StringLiteral\n"
	"GeneratedColumn <- Generated? 'AS' Parens(Expression) GeneratedColumnType?\n"
	"Generated <- 'GENERATED' AlwaysOrByDefault?\n"
	"AlwaysOrByDefault <- 'ALWAYS' / ('BY' 'DEFAULT')\n"
	"GeneratedColumnType <- 'VIRTUAL' / 'STORED'\n"
	"CommitAction <- 'ON' 'COMMIT' PreserveOrDelete 'ROWS'\n"
	"PreserveOrDelete <- 'PRESERVE' / 'DELETE'\n"
	"CreateIndexStmt <- Unique? 'INDEX' IfNotExists? IndexName? 'ON' BaseTableName InsertColumnList? IndexType? Parens(List(IndexElement))? WithList? WhereClause?\n"
	"WithList <- 'WITH' RelOptionOrOids\n"
	"RelOptionOrOids <- RelOptionList / Oids\n"
	"RelOptionList <- Parens(List(RelOption))\n"
	"Oids <- ('WITH' / 'WITHOUT') 'OIDS'\n"
	"IndexElement <- Expression DescOrAsc? NullsFirstOrLast?\n"
	"Unique <- 'UNIQUE'\n"
	"IndexType <- 'USING' Identifier\n"
	"RelOption <- RelOptionName RelOptionArgumentOpt?\n"
	"RelOptionName <- DottedIdentifier / StringLiteral\n"
	"RelOptionArgumentOpt <- '=' DefArg\n"
	"DefArg <- NullLiteral / ReservedKeyword / StringLiteral / NumberLiteral / NoneLiteral / Expression\n"
	"ReservedKeywordValue <- ReservedKeyword\n"
	"NoneLiteral <- 'NONE'\n"
	"LoadStatement <- 'LOAD' ColIdOrString\n"
	"InstallStatement <- 'FORCE'? 'INSTALL' IdentifierOrStringLiteral FromSource? VersionNumber?\n"
	"UpdateExtensionsStatement <- 'UPDATE' 'EXTENSIONS' Parens(List(Identifier))?\n"
	"FromSource <- 'FROM' (Identifier / StringLiteral)\n"
	"VersionNumber <- 'VERSION' IdentifierOrStringLiteral\n"
	"DropStatement <- 'DROP' DropEntries DropBehavior?\n"
	"DropEntries <-\n"
	"	DropTable /\n"
	"	DropTableFunction /\n"
	"	DropFunction /\n"
	"	DropSchema /\n"
	"	DropIndex /\n"
	"	DropSequence /\n"
	"	DropCollation /\n"
	"	DropType /\n"
	"	DropSecret\n"
	"DropTable <- TableOrView IfExists? List(BaseTableName)\n"
	"DropTableFunction <- CommentMacroTable IfExists? List(TableFunctionName)\n"
	"DropFunction <- FunctionType IfExists? List(FunctionIdentifier)\n"
	"DropSchema <- 'SCHEMA' IfExists? List(QualifiedSchemaName)\n"
	"DropIndex <- 'INDEX' IfExists? List(QualifiedIndexName)\n"
	"QualifiedIndexName <- CatalogQualification? SchemaQualification? IndexName\n"
	"DropSequence <- 'SEQUENCE' IfExists? List(QualifiedSequenceName)\n"
	"DropCollation <- 'COLLATION' IfExists? List(CollationName)\n"
	"DropType <- 'TYPE' IfExists? List(QualifiedTypeName)\n"
	"DropSecret <- Temporary? 'SECRET' IfExists? SecretName DropSecretStorage?\n"
	"TableOrView <- CommentTable / CommentView / MaterializedViewEntry\n"
	"MaterializedViewEntry <- 'MATERIALIZED' 'VIEW'\n"
	"FunctionType <- 'MACRO' / 'FUNCTION'\n"
	"DropBehavior <- 'CASCADE' / 'RESTRICT'\n"
	"IfExists <- 'IF' 'EXISTS'\n"
	"QualifiedSchemaName <- CatalogQualification? SchemaName\n"
	"DropSecretStorage <- 'FROM' Identifier\n"
	"UpdateStatement <- WithClause? 'UPDATE' UpdateTarget UpdateSetClause FromClause? WhereClause? ReturningClause?\n"
	"UpdateTarget <- BaseTableSet / BaseTableAliasSet\n"
	"BaseTableSet <- BaseTableName 'SET'\n"
	"BaseTableAliasSet <- BaseTableName UpdateAlias? 'SET'\n"
	"UpdateAlias <- 'AS'? ColId\n"
	"UpdateSetClause <- UpdateSetElementList / UpdateSetTuple\n"
	"UpdateSetTuple <- Parens(List(ColumnName)) '=' Expression\n"
	"UpdateSetElementList <- List(UpdateSetElement)\n"
	"UpdateSetElement <- UpdateSetColumnTarget '=' Expression\n"
	"UpdateSetColumnTarget <- ColumnName ('.' Identifier)*\n"
	"InsertStatement <- WithClause? 'INSERT' OrAction? 'INTO' InsertTarget ByNameOrPosition? InsertColumnList? InsertValues OnConflictClause? ReturningClause?\n"
	"OrAction <- 'OR' 'REPLACE' / 'IGNORE'\n"
	"ByNameOrPosition <- 'BY' InsertByName / InsertByPosition\n"
	"InsertByName <- 'NAME'\n"
	"InsertByPosition <- 'POSITION'\n"
	"InsertTarget <- BaseTableName InsertAlias?\n"
	"InsertAlias <- 'AS' Identifier\n"
	"ColumnList <- List(ColId)\n"
	"InsertColumnList <- Parens(ColumnList)\n"
	"InsertValues <- SelectStatementInternal / DefaultValues\n"
	"DefaultValues <- 'DEFAULT' 'VALUES'\n"
	"OnConflictClause <- 'ON' 'CONFLICT' OnConflictTarget? OnConflictAction\n"
	"OnConflictTarget <- OnConflictExpressionTarget / OnConflictIndexTarget\n"
	"OnConflictExpressionTarget <- ColumnIdList WhereClause?\n"
	"OnConflictIndexTarget <- 'ON' 'CONSTRAINT' ConstraintName\n"
	"OnConflictAction <- OnConflictUpdate / OnConflictNothing\n"
	"OnConflictUpdate <- 'DO' 'UPDATE' 'SET' UpdateSetClause WhereClause?\n"
	"OnConflictNothing <- 'DO' 'NOTHING'\n"
	"ReturningClause <- 'RETURNING' TargetList\n"
	"CreateSchemaStmt <- 'SCHEMA' IfNotExists? QualifiedName\n"
	"SelectStatement <- SelectStatementInternal\n"
	"SelectStatementInternal <- WithClause? SelectSetOpChain ResultModifiers?\n"
	"SelectSetOpChain <- IntersectChain (SetopClause IntersectChain)*\n"
	"IntersectChain <- SelectAtom (SetIntersectClause SelectAtom)*\n"
	"SetIntersectClause <- 'INTERSECT' DistinctOrAll?\n"
	"SelectAtom <- SelectParens / SelectStatementType\n"
	"SelectParens <- Parens(SelectStatementInternal)\n"
	"SetopClause <- SetopType DistinctOrAll? ByName?\n"
	"SetopType <- SetopUnion / SetopExcept\n"
	"SetopUnion <- 'UNION'\n"
	"SetopExcept <- 'EXCEPT'\n"
	"ByName <- 'BY' 'NAME'\n"
	"SelectStatementType <- OptionalParensSimpleSelect / ValuesClause / DescribeStatement / TableStatement / PivotStatement / UnpivotStatement\n"
	"ResultModifiers <- OrderByClause? LimitOffset?\n"
	"LimitOffset <- LimitOffsetClause / OffsetLimitClause\n"
	"LimitOffsetClause <- LimitClause OffsetClause?\n"
	"OffsetLimitClause <- OffsetClause LimitClause?\n"
	"TableStatement <- 'TABLE' BaseTableName\n"
	"OptionalParensSimpleSelect <- SimpleSelectParens / SimpleSelect\n"
	"SimpleSelectParens <- Parens(SimpleSelect)\n"
	"SimpleSelect <- SelectFrom WhereClause? GroupByClause? HavingClause? WindowClause? QualifyClause? SampleClause?\n"
	"SelectFrom <- SelectFromClause / FromSelectClause\n"
	"SelectFromClause <- SelectClause FromClause?\n"
	"FromSelectClause <- FromClause SelectClause?\n"
	"WithStatement <- ColIdOrString InsertColumnList? UsingKey? 'AS' Materialized? CTEBody\n"
	"CTEBody <- Parens(CTEBodyContent)\n"
	"CTEBodyContent <- SelectStatementInternal / Statement\n"
	"UsingKey <- 'USING' 'KEY' ColumnIdList\n"
	"Materialized <- 'NOT'? 'MATERIALIZED'\n"
	"WithClause <- 'WITH' Recursive? List(WithStatement)\n"
	"Recursive <- 'RECURSIVE'\n"
	"SelectClause <- 'SELECT' DistinctClause? TargetList?\n"
	"TargetList <- List(AliasedExpression)\n"
	"ColumnAliases <- Parens(List(ColIdOrString))\n"
	"DistinctClause <- DistinctOn / DistinctAll\n"
	"DistinctAll <- 'ALL'\n"
	"DistinctOn <- 'DISTINCT' DistinctOnTargets?\n"
	"DistinctOnTargets <- 'ON' Parens(List(Expression))\n"
	"InnerTableRef <- ValuesRef / TableFunction / TableSubquery / BaseTableRef / ParensTableRef\n"
	"TableRef <- InnerTableRef JoinOrPivot*\n"
	"TableSubquery <- Lateral? SubqueryReference TableAlias?\n"
	"BaseTableRef <- TableAliasColon? BaseTableName TableAlias? AtClause? SampleClause?\n"
	"TableAliasColon <- ColIdOrString ':'\n"
	"ValuesRef <- ValuesClause TableAlias?\n"
	"ParensTableRef <- TableAliasColon? Parens(TableRef) TableAlias? SampleClause?\n"
	"JoinOrPivot <- JoinClause / TablePivotClause / TableUnpivotClause\n"
	"TablePivotClause <- 'PIVOT' Parens(TargetList 'FOR' PivotValueList+ PivotGroupByList?) TableAlias?\n"
	"PivotGroupByList <- 'GROUP' 'BY' List(ColIdOrString)\n"
	"TableUnpivotClause <- 'UNPIVOT' IncludeOrExcludeNulls? Parens(UnpivotHeader 'FOR' UnpivotValueList+) TableAlias?\n"
	"PivotHeader <- BaseExpression\n"
	"PivotValueList <- PivotHeader 'IN' (Identifier / PivotTargetList)\n"
	"UnpivotValueList <- UnpivotHeader 'IN' UnpivotTargetList\n"
	"PivotTargetList <- Parens(TargetList)\n"
	"UnpivotTargetList <- Parens(TargetList)\n"
	"Lateral <- 'LATERAL'\n"
	"BaseTableName <- CatalogReservedSchemaTable / SchemaReservedTable / TableName\n"
	"SchemaReservedTable <- SchemaQualification ReservedTableName\n"
	"CatalogReservedSchemaTable <- CatalogQualification ReservedSchemaQualification ReservedTableName\n"
	"TableFunction <- TableFunctionLateralOpt / TableFunctionAliasColon\n"
	"TableFunctionLateralOpt <- Lateral? QualifiedTableFunction TableFunctionArguments WithOrdinality? TableAlias?\n"
	"TableFunctionAliasColon <- TableAliasColon QualifiedTableFunction TableFunctionArguments WithOrdinality? SampleClause?\n"
	"WithOrdinality <- 'WITH' 'ORDINALITY'\n"
	"QualifiedTableFunction <- CatalogQualification? SchemaQualification? TableFunctionName\n"
	"TableFunctionArguments <- Parens(List(FunctionArgument)?)\n"
	"FunctionArgument <- NamedParameter / Expression\n"
	"NamedParameter <- TypeFuncName Type? NamedParameterAssignment Expression\n"
	"NamedParameterAssignment <- ':=' / '=>'\n"
	"TableAlias <- TableAliasAs / TableAliasWithoutAs\n"
	"TableAliasAs <- 'AS' IdentifierOrStringLiteral ColumnAliases?\n"
	"TableAliasWithoutAs <- Identifier ColumnAliases?\n"
	"AtClause <- 'AT' Parens(AtSpecifier)\n"
	"AtSpecifier <- AtUnit '=>' Expression\n"
	"AtUnit <- 'VERSION' / 'TIMESTAMP'\n"
	"JoinClause <- RegularJoinClause / JoinWithoutOnClause\n"
	"RegularJoinClause <- 'ASOF'? JoinType? 'JOIN' TableRef JoinQualifier\n"
	"JoinWithoutOnClause <- JoinPrefix 'JOIN' TableRef\n"
	"JoinQualifier <- OnClause / UsingClause\n"
	"OnClause <- 'ON' Expression\n"
	"UsingClause <- 'USING' Parens(List(ColumnName))\n"
	"JoinType <- FullJoin / LeftJoin / RightJoin / SemiJoin / AntiJoin / InnerJoin\n"
	"JoinPrefix <- CrossJoinPrefix / NaturalJoinPrefix / PositionalJoinPrefix\n"
	"CrossJoinPrefix <- 'CROSS'\n"
	"NaturalJoinPrefix <- 'NATURAL' JoinType?\n"
	"PositionalJoinPrefix <- 'POSITIONAL'\n"
	"FullJoin <- 'FULL' 'OUTER'?\n"
	"LeftJoin <- 'LEFT' 'OUTER'?\n"
	"RightJoin <- 'RIGHT' 'OUTER'?\n"
	"SemiJoin <- 'SEMI'\n"
	"AntiJoin <- 'ANTI'\n"
	"InnerJoin <- 'INNER'\n"
	"FromClause <- 'FROM' List(TableRef)\n"
	"WhereClause <- 'WHERE' Expression\n"
	"GroupByClause <- 'GROUP' 'BY' GroupByExpressions\n"
	"HavingClause <- 'HAVING' Expression\n"
	"QualifyClause <- 'QUALIFY' Expression\n"
	"SampleClause <- (TableSample / UsingSample) SampleEntry\n"
	"UsingSample <- 'USING' 'SAMPLE'\n"
	"TableSample <- 'TABLESAMPLE'\n"
	"WindowClause <- 'WINDOW' List(WindowDefinition)\n"
	"WindowDefinition <- Identifier 'AS' WindowFrameDefinition\n"
	"SampleEntry <- SampleEntryFunction / SampleEntryCount\n"
	"SampleEntryCount <- SampleCount Parens(SampleProperties)?\n"
	"SampleEntryFunction <- SampleFunction? Parens(SampleCount) RepeatableSample?\n"
	"SampleFunction <- ColId\n"
	"SampleProperties <- ColId (',' SampleSeed)?\n"
	"RepeatableSample <- 'REPEATABLE' Parens(SampleSeed)\n"
	"SampleSeed <- NumberLiteral\n"
	"SampleCount <- SampleValue SampleUnit?\n"
	"SampleValue <- NumberLiteral / Parameter\n"
	"SampleUnit <- SamplePercentage / SampleRows\n"
	"SamplePercentage <- '%' / 'PERCENT'\n"
	"SampleRows <- 'ROWS'\n"
	"GroupByExpressions <- GroupByList / GroupByAll\n"
	"GroupByAll <- 'ALL'\n"
	"GroupByList <- List(GroupByExpression)\n"
	"GroupByExpression <- EmptyGroupingItem / CubeOrRollupClause / GroupingSetsClause / Expression\n"
	"EmptyGroupingItem <- '(' ')'\n"
	"CubeOrRollupClause <- CubeOrRollup Parens(List(Expression)?)\n"
	"CubeOrRollup <- 'CUBE' / 'ROLLUP'\n"
	"GroupingSetsClause <- 'GROUPING' 'SETS' Parens(GroupByList)\n"
	"SubqueryReference <- Parens(SelectStatementInternal)\n"
	"OrderByExpression <- Expression DescOrAsc? NullsFirstOrLast?\n"
	"DescOrAsc <- DescendingOrder / AscendingOrder\n"
	"DescendingOrder <- 'DESC' / 'DESCENDING'\n"
	"AscendingOrder <- 'ASC' / 'ASCENDING'\n"
	"NullsFirstOrLast <- NullsFirst / NullsLast\n"
	"NullsFirst <- 'NULLS' 'FIRST'\n"
	"NullsLast <- 'NULLS' 'LAST'\n"
	"OrderByClause <- 'ORDER' 'BY' OrderByExpressions\n"
	"OrderByExpressions <- OrderByAll / OrderByExpressionList\n"
	"OrderByExpressionList <- List(OrderByExpression)\n"
	"OrderByAll <- 'ALL' DescOrAsc? NullsFirstOrLast?\n"
	"LimitClause <- 'LIMIT' LimitValue\n"
	"OffsetClause <- 'OFFSET' OffsetValue\n"
	"OffsetValue <- Expression RowOrRows?\n"
	"RowOrRows <- 'ROW' / 'ROWS'\n"
	"LimitValue <- LimitAll / LimitLiteralPercent / LimitExpression\n"
	"LimitAll <- 'ALL'\n"
	"LimitLiteralPercent <- NumberLiteral 'PERCENT'\n"
	"LimitExpression <- Expression '%'?\n"
	"AliasedExpression <- ColIdExpression / ExpressionAsCollabel / ExpressionOptIdentifier\n"
	"ColIdExpression <- ColId ':' Expression\n"
	"ExpressionAsCollabel <- Expression 'AS' ColLabelOrString\n"
	"ExpressionOptIdentifier <- Expression Identifier?\n"
	"ValuesClause <- 'VALUES' List(ValuesExpressions)\n"
	"ValuesExpressions <- Parens(List(Expression))\n"
	"TransactionStatement <- BeginTransaction / RollbackTransaction / CommitTransaction\n"
	"BeginTransaction <- StartOrBegin Transaction? ReadOrWrite?\n"
	"RollbackTransaction <- AbortOrRollback Transaction?\n"
	"CommitTransaction <- CommitOrEnd Transaction?\n"
	"StartOrBegin <- 'START' / 'BEGIN'\n"
	"Transaction <- 'WORK' / 'TRANSACTION'\n"
	"ReadOrWrite <- 'READ' ReadOnlyOrReadWrite\n"
	"ReadOnlyOrReadWrite <- ReadOnly / ReadWrite\n"
	"ReadOnly <- 'ONLY'\n"
	"ReadWrite <- 'WRITE'\n"
	"AbortOrRollback <- 'ABORT' / 'ROLLBACK'\n"
	"CommitOrEnd <- 'COMMIT' / 'END'\n"
	"DeleteStatement <- WithClause? 'DELETE' 'FROM' TargetOptAlias DeleteUsingClause? WhereClause? ReturningClause?\n"
	"TruncateStatement <- 'TRUNCATE' 'TABLE'? BaseTableName\n"
	"TargetOptAlias <- BaseTableName 'AS'? ColId?\n"
	"DeleteUsingClause <- 'USING' List(TableRef)\n"
	"CreateTypeStmt <- 'TYPE' IfNotExists? QualifiedName 'AS' CreateType\n"
	"CreateType <- EnumSelectType / EnumStringLiteralList / Type\n"
	"EnumSelectType <- 'ENUM' Parens(SelectStatementInternal)\n"
	"EnumStringLiteralList <- 'ENUM' Parens(List(StringLiteral)?)\n"
	"SetStatement <- 'SET' (StandardAssignment / SetTimeZone)\n"
	"StandardAssignment <- (SetVariable / SetSetting) SetAssignment\n"
	"SetTimeZone <- 'TIME' 'ZONE' Expression\n"
	"SetSetting <- SettingScope? SettingName\n"
	"SetVariable <- VariableScope Identifier\n"
	"VariableScope <- 'VARIABLE'\n"
	"SettingScope <- LocalScope / SessionScope / GlobalScope\n"
	"LocalScope <- 'LOCAL'\n"
	"SessionScope <- 'SESSION'\n"
	"GlobalScope <- 'GLOBAL'\n"
	"SetAssignment <- VariableAssign VariableList\n"
	"VariableAssign <- '=' / 'TO'\n"
	"VariableList <- List(Expression)\n"
	"ResetStatement <- 'RESET' (SetVariable / SetSetting)\n"
	"ExportStatement <- 'EXPORT' 'DATABASE' ExportSource? StringLiteral GenericCopyOptionList?\n"
	"ExportSource <- CatalogName 'TO'\n"
	"ImportStatement <- 'IMPORT' 'DATABASE' StringLiteral\n"
	"CheckpointStatement <- 'FORCE'? 'CHECKPOINT' CatalogName?\n"
	"CopyStatement <- 'COPY' (CopyTable / CopySelect / CopyFromDatabase)\n"
	"CopyTable <- BaseTableName InsertColumnList? FromOrTo CopyFileName CopyOptions?\n"
	"FromOrTo <- 'FROM' / 'TO'\n"
	"CopySelect <- Parens(SelectStatementInternal) 'TO' CopyFileName CopyOptions?\n"
	"CopyFileName <- Parameter / ParensExpression / StringLiteral / Identifier / (Identifier '.' ColId)\n"
	"CopyOptions <- 'WITH'? GenericCopyOptionList / SpecializedOptionList\n"
	"SpecializedOptionList <- SpecializedOption*\n"
	"SpecializedOption <- SingleOption / NullAsOption / DelimiterAsOption / EscapeAsOption /\n"
	"	EncodingOption / QuoteAsOption / ForceQuoteOption / PartitionByOption / ForceNullOption\n"
	"SingleOption <- BinaryOption / FreezeOption / OidsOption / CsvOption / HeaderOption\n"
	"BinaryOption <- 'BINARY'\n"
	"FreezeOption <- 'FREEZE'\n"
	"OidsOption <- 'OIDS'\n"
	"CsvOption <- 'CSV'\n"
	"HeaderOption <- 'HEADER'\n"
	"NullAsOption <- 'NULL' 'AS'? StringLiteral\n"
	"DelimiterAsOption <- 'DELIMITER' 'AS'? StringLiteral\n"
	"QuoteAsOption <- 'QUOTE' 'AS'? StringLiteral\n"
	"EscapeAsOption <- 'ESCAPE' 'AS'? StringLiteral\n"
	"EncodingOption <- 'ENCODING' StringLiteral\n"
	"ForceQuoteOption <- 'FORCE'? 'QUOTE' (StarSymbol / ColumnList)\n"
	"PartitionByOption <- 'PARTITION' 'BY' (StarSymbol / ColumnList)\n"
	"ForceNullOption <- 'FORCE' 'NOT'? 'NULL' ColumnList\n"
	"StarSymbol <- '*'\n"
	"GenericCopyOptionList <- Parens(List(GenericCopyOption))\n"
	"GenericCopyOption <- CopyOptionName Expression?\n"
	"CopyFromDatabase <- 'FROM' 'DATABASE' ColId 'TO' ColId CopyDatabaseFlag?\n"
	"CopyDatabaseFlag <- Parens(SchemaOrData)\n"
	"SchemaOrData <- CopySchema / CopyData\n"
	"CopySchema <- 'SCHEMA'\n"
	"CopyData <- 'DATA'\n"
	"AlterStatement <- 'ALTER' AlterOptions\n"
	"AlterOptions <- AlterTableStmt / AlterViewStmt / AlterSequenceStmt / AlterDatabaseStmt / AlterSchemaStmt\n"
	"AlterTableStmt <- 'TABLE' IfExists? BaseTableName List(AlterTableOptions)\n"
	"AlterSchemaStmt <- 'SCHEMA' IfExists? QualifiedName RenameAlter\n"
	"AlterTableOptions <- AddColumn / DropColumn / AlterColumn / AddConstraint / ChangeNullability /\n"
	"        RenameColumn / RenameAlter / SetPartitionedBy / ResetPartitionedBy / SetSortedBy / ResetSortedBy / SetOptions / ResetOptions\n"
	"AddConstraint <- 'ADD' TopLevelConstraint\n"
	"AddColumn <- 'ADD' 'COLUMN'? IfNotExists? AddColumnEntry\n"
	"AddColumnEntry <- DottedIdentifier Type? GeneratedColumn? ColumnConstraint*\n"
	"DropColumn <- 'DROP' 'COLUMN'? IfExists? NestedColumnName DropBehavior?\n"
	"AlterColumn <- 'ALTER' 'COLUMN'? NestedColumnName AlterColumnEntry\n"
	"RenameColumn <- 'RENAME' 'COLUMN'? NestedColumnName 'TO' Identifier\n"
	"NestedColumnName <- (Identifier '.')* ColumnName\n"
	"RenameAlter <- 'RENAME' 'TO' Identifier\n"
	"SetPartitionedBy <- 'SET' 'PARTITIONED' 'BY' Parens(List(Expression))\n"
	"ResetPartitionedBy <- 'RESET' 'PARTITIONED' 'BY'\n"
	"SetSortedBy <- 'SET' 'SORTED' 'BY' Parens(OrderByExpressions)\n"
	"ResetSortedBy <- 'RESET' 'SORTED' 'BY'\n"
	"SetOptions <- 'SET' RelOptionList\n"
	"ResetOptions <- 'RESET' RelOptionList\n"
	"AlterColumnEntry <- AddOrDropDefault / ChangeNullability / AlterType\n"
	"AddOrDropDefault <- AddDefault / DropDefault\n"
	"AddDefault <- 'SET' 'DEFAULT' Expression\n"
	"DropDefault <- 'DROP' 'DEFAULT'\n"
	"ChangeNullability <- DropOrSet 'NOT' 'NULL'\n"
	"DropOrSet <- 'DROP' / 'SET'\n"
	"AlterType <- SetData? 'TYPE' Type? UsingExpression?\n"
	"SetData <- 'SET' 'DATA'?\n"
	"UsingExpression <- 'USING' Expression\n"
	"AlterViewStmt <- 'VIEW' IfExists? BaseTableName RenameAlter\n"
	"AlterSequenceStmt <- 'SEQUENCE' IfExists? QualifiedSequenceName AlterSequenceOptions\n"
	"QualifiedSequenceName <- CatalogQualification? SchemaQualification? SequenceName\n"
	"AlterSequenceOptions <- RenameAlter / SetSequenceOption\n"
	"SetSequenceOption <- SequenceOption+\n"
	"AlterDatabaseStmt <- 'DATABASE' IfExists? Identifier 'SET' 'ALIAS' 'TO' Identifier\n"
	"CreateSequenceStmt <- 'SEQUENCE' IfNotExists? QualifiedName SequenceOption*\n"
	"SequenceOption <-\n"
	"	SeqSetCycle /\n"
	"	SeqSetIncrement /\n"
	"	SeqSetMinMax /\n"
	"	SeqNoMinMax /\n"
	"	SeqStartWith /\n"
	"	SeqOwnedBy\n"
	"SeqSetCycle <- 'NO'? 'CYCLE'\n"
	"SeqSetIncrement <- 'INCREMENT' 'BY'? Expression\n"
	"SeqSetMinMax <- SeqMinOrMax Expression\n"
	"SeqNoMinMax <- 'NO' SeqMinOrMax\n"
	"SeqStartWith <- 'START' 'WITH'? Expression\n"
	"SeqOwnedBy <- 'OWNED' 'BY' QualifiedName\n"
	"SeqMinOrMax <- MinValue / MaxValue\n"
	"MinValue <- 'MINVALUE'\n"
	"MaxValue <- 'MAXVALUE'\n"
	"ExplainStatement <- 'EXPLAIN' 'ANALYZE'? GenericCopyOptionList? ExplainableStatements\n"
	"ExplainableStatements <-\n"
	"    AlterStatement /\n"
	"    AnalyzeStatement /\n"
	"    CallStatement /\n"
	"    CheckpointStatement /\n"
	"    CopyStatement /\n"
	"    CreateStatement /\n"
	"    DeallocateStatement /\n"
	"    DeleteStatement /\n"
	"    DropStatement /\n"
	"    ExecuteStatement /\n"
	"    InsertStatement /\n"
	"    LoadStatement /\n"
	"    MergeIntoStatement /\n"
	"    PragmaStatement /\n"
	"    PrepareStatement /\n"
	"    SelectStatementInternal /\n"
	"    TransactionStatement /\n"
	"    UpdateStatement /\n"
	"    VacuumStatement /\n"
	"    SetStatement /\n"
	"    ResetStatement\n"
	"AnalyzeStatement <- 'ANALYZE' 'VERBOSE'? AnalyzeTarget?\n"
	"AnalyzeTarget <- BaseTableName NameList?\n"
	"CreateMacroStmt <- MacroOrFunction IfNotExists? QualifiedName List(MacroDefinition)\n"
	"MacroOrFunction <- 'MACRO' / 'FUNCTION'\n"
	"MacroDefinition <- Parens(MacroParameters?) 'AS' (TableMacroDefinition / ScalarMacroDefinition)\n"
	"MacroParameters <- List(MacroParameter)\n"
	"MacroParameter <- NamedParameter / SimpleParameter\n"
	"SimpleParameter <- TypeFuncName Type?\n"
	"ScalarMacroDefinition <- Expression\n"
	"TableMacroDefinition <- 'TABLE' SelectStatementInternal\n"
	"CommentStatement <- 'COMMENT' 'ON' CommentOnType DottedIdentifier 'IS' CommentValue\n"
	"CommentOnType <-    CommentTable / CommentSequence / CommentFunction / CommentMacroTable / CommentMacro /\n"
	"                    CommentView / CommentDatabase / CommentIndex / CommentSchema / CommentType / CommentColumn\n"
	"CommentTable <- 'TABLE'\n"
	"CommentSequence <- 'SEQUENCE'\n"
	"CommentFunction <- 'FUNCTION'\n"
	"CommentMacroTable <- 'MACRO' 'TABLE'\n"
	"CommentMacro <- 'MACRO'\n"
	"CommentView <- 'VIEW'\n"
	"CommentDatabase <- 'DATABASE'\n"
	"CommentIndex <- 'INDEX'\n"
	"CommentSchema <- 'SCHEMA'\n"
	"CommentType <- 'TYPE'\n"
	"CommentColumn <- 'COLUMN'\n"
	"CommentValue <- 'NULL' / StringLiteral\n"
	"AttachStatement <- 'ATTACH' OrReplace? IfNotExists? Database? DatabasePath AttachAlias? AttachOptions?\n"
	"Database <- 'DATABASE'\n"
	"DatabasePath <- StringLiteral\n"
	"AttachAlias <- 'AS' ColId\n"
	"AttachOptions <- GenericCopyOptionList\n"
	"DetachStatement <- 'DETACH' Database? IfExists? CatalogName\n"
	"UseStatement <- 'USE' UseTarget\n"
	"UseTarget <- UseTargetCatalogSchema / SchemaName / CatalogName\n"
	"UseTargetCatalogSchema <- CatalogName '.' ReservedSchemaName ('.' Identifier)*\n"
	"CallStatement <- 'CALL' QualifiedTableFunction TableFunctionArguments\n"

};

} // namespace duckdb
