#501$2 Thu 08101604:42:16 jim@keyframe:~
: cd work/xSWO/
#502$3 Thu 08101604:42:24 jim@keyframe:~/work/xSWO
: ls
Doxyfile  bnf2spirit.sh  main.cpp  s2k3.sh     sparql.d  sql2003.i  tests   xSWO.xcodeproj
Makefile  docs           pch.hxx   sparql.cpp  sparql.h  test.git   xSWO.1
#503$4 Thu 08101604:42:24 jim@keyframe:~/work/xSWO
: ./s2k3.sh 
+ IFS='|'
+ sed -re '
/^\w+ *=.+/ {
s,\=,\=\n,g
b
}
:u
s,(\W) ?(ABS|ABSOLUTE|ACTION|ADA|ADD|ADMIN|AFTER|ALL|ALLOCATE|ALTER|ALWAYS|AND|ANY|ARE|ARRAY|AS|ASC|ASENSITIVE|ASSERTION|ASSIGNMENT|ASYMMETRIC|AT|ATOMIC|ATTRIBUTE|ATTRIBUTES|AUTHORIZATION|AVG|BEFORE|BEGIN|BERNOULLI|BETWEEN|BIGINT|BINARY|BLOB|BOOLEAN|BOTH|BREADTH|BY|CALL|CALLED|CARDINALITY|CASCADE|CASCADED|CASE|CAST|CATALOG|CATALOG_NAME|CEIL|CEILING|CHAIN|CHAR|CHARACTER|CHARACTERISTICS|CHARACTERS|CHARACTER_LENGTH|CHARACTER_SET_CATALOG|CHARACTER_SET_NAME|CHARACTER_SET_SCHEMA|CHAR_LENGTH|CHECK|CHECKED|CLASS_ORIGIN|CLOB|CLOSE|COALESCE|COBOL|CODE_UNITS|COLLATE|COLLATION|COLLATION_CATALOG|COLLATION_NAME|COLLATION_SCHEMA|COLLECT|COLUMN|COLUMN_NAME|COMMAND_FUNCTION|COMMAND_FUNCTION_CODE|COMMIT|COMMITTED|CONDITION|CONDITION_NUMBER|CONNECT|CONNECTION_NAME|CONSTRAINT|CONSTRAINTS|CONSTRAINT_CATALOG|CONSTRAINT_NAME|CONSTRAINT_SCHEMA|CONSTRUCTORS|CONTAINS|CONTINUE|CONVERT|CORR|CORRESPONDING|COUNT|COVAR_POP|COVAR_SAMP|CREATE|CROSS|CUBE|CUME_DIST|CURRENT|CURRENT_COLLATION|CURRENT_DATE|CURRENT_DEFAULT_TRANSFORM_GROUP|CURRENT_PATH|CURRENT_ROLE|CURRENT_TIME|CURRENT_TIMESTAMP|CURRENT_TRANSFORM_GROUP_FOR_TYPE|CURRENT_USER|CURSOR|CURSOR_NAME|CYCLE|DATA|DATE|DATETIME_INTERVAL_CODE|DATETIME_INTERVAL_PRECISION|DAY|DEALLOCATE|DEC|DECIMAL|DECLARE|DEFAULT|DEFAULTS|DEFERRABLE|DEFERRED|DEFINED|DEFINER|DEGREE|DELETE|DENSE_RANK|DEPTH|DEREF|DERIVED|DESC|DESCRIBE|DESCRIPTOR|DETERMINISTIC|DIAGNOSTICS|DISCONNECT|DISPATCH|DISTINCT|DOMAIN|DOUBLE|DROP|DYNAMIC|DYNAMIC_FUNCTION|DYNAMIC_FUNCTION_CODE|EACH|ELEMENT|ELSE|END|EQUALS|ESCAPE|EVERY|EXCEPT|EXCEPTION|EXCLUDE|EXCLUDING|EXEC|EXECUTE|EXISTS|EXP|EXTERNAL|EXTRACT|FALSE|FETCH|FILTER|FINAL|FIRST|FLOAT|FLOOR|FOLLOWING|FOR|FOREIGN|FORTRAN|FOUND|FREE|FROM|FULL|FUNCTION|FUSION|GENERAL|GET|GLOBAL|GO|GOTO|GRANT|GRANTED|GROUP|GROUPING|HAVING|HIERARCHY|HOLD|HOUR|IDENTITY|IMMEDIATE|IMPLEMENTATION|IN|INCLUDING|INCREMENT|INDICATOR|INITIALLY|INNER|INOUT|INPUT|INSENSITIVE|INSERT|INSTANCE|INSTANTIABLE|INT|INTEGER|INTERSECT|INTERSECTION|INTERVAL|INTO|INVOKER|IS|ISOLATION|JOIN|KEY|KEY_MEMBER|KEY_TYPE|LANGUAGE|LARGE|LAST|LATERAL|LEADING|LEFT|LENGTH|LEVEL|LIKE|LN|LOCAL|LOCALTIME|LOCALTIMESTAMP|LOCATOR|LOWER|MAP|MATCH|MATCHED|MAX|MAXVALUE|MEMBER|MERGE|MESSAGE_LENGTH|MESSAGE_OCTET_LENGTH|MESSAGE_TEXT|METHOD|MIN|MINUTE|MINVALUE|MOD|MODIFIES|MODULE|MONTH|MORE|MULTISET|MUMPS|NAME|NAMES|NATIONAL|NATURAL|NCHAR|NCLOB|NESTING|NEW|NEXT|NO|NONE|NORMALIZE|NORMALIZED|NOT|NULL|NULLABLE|NULLIF|NULLS|NUMBER|NUMERIC|OBJECT|OCTETS|OCTET_LENGTH|OF|OLD|ON|ONLY|OPEN|OPTION|OPTIONS|OR|ORDER|ORDERING|ORDINALITY|OTHERS|OUT|OUTER|OUTPUT|OVER|OVERLAPS|OVERLAY|OVERRIDING|PAD|PARAMETER|PARAMETER_MODE|PARAMETER_NAME|PARAMETER_ORDINAL_POSITION|PARAMETER_SPECIFIC_CATALOG|PARAMETER_SPECIFIC_NAME|PARAMETER_SPECIFIC_SCHEMA|PARTIAL|PARTITION|PASCAL|PATH|PERCENTILE_CONT|PERCENTILE_DISC|PERCENT_RANK|PLACING|PLI|POSITION|POWER|PRECEDING|PRECISION|PREPARE|PRESERVE|PRIMARY|PRIOR|PRIVILEGES|PROCEDURE|PUBLIC|RANGE|RANK|READ|READS|REAL|RECURSIVE|REF|REFERENCES|REFERENCING|REGR_AVGX|REGR_AVGY|REGR_COUNT|REGR_INTERCEPT|REGR_R2|REGR_SLOPE|REGR_SXX|REGR_SXY|RELATIVE|RELEASE|REPEATABLE|RESTART|RESULT|RETURN|RETURNED_CARDINALITY|RETURNED_LENGTH|RETURNED_OCTET_LENGTH|RETURNED_SQLSTATE|RETURNS|REVOKE|RIGHT|ROLE|ROLLBACK|ROLLUP|ROUTINE|ROUTINE_CATALOG|ROUTINE_NAME|ROUTINE_SCHEMA|ROW|ROWS|ROW_COUNT|ROW_NUMBER|SAVEPOINT|SCALE|SCHEMA|SCHEMA_NAME|SCOPE_CATALOG|SCOPE_NAME|SCOPE_SCHEMA|SCROLL|SEARCH|SECOND|SECTION|SECURITY|SELECT|SELF|SENSITIVE|SEQUENCE|SERIALIZABLE|SERVER_NAME|SESSION|SESSION_USER|SET|SETS|SIMILAR|SIMPLE|SIZE|SMALLINT|SOME|SOURCE|SPACE|SPECIFIC|SPECIFICTYPE|SPECIFIC_NAME|SQL|SQLEXCEPTION|SQLSTATE|SQLWARNING|SQRT|START|STATE|STATEMENT|STATIC|STDDEV_POP|STDDEV_SAMP|STRUCTURE|STYLE|SUBCLASS_ORIGIN|SUBMULTISET|SUBSTRING|SUM|SYMMETRIC|SYSTEM|SYSTEM_USER|TABLE|TABLESAMPLE|TABLE_NAME|TEMPORARY|THEN|TIES|TIME|TIMESTAMP|TIMEZONE_HOUR|TIMEZONE_MINUTE|TO|TOP_LEVEL_COUNT|TRAILING|TRANSACTION|TRANSACTIONS_COMMITTED|TRANSACTIONS_ROLLED_BACK|TRANSACTION_ACTIVE|TRANSFORM|TRANSFORMS|TRANSLATE|TRANSLATION|TREAT|TRIGGER|TRIGGER_CATALOG|TRIGGE+ sed -re '
s/^(ABS|ABSOLUTE|ACTION|ADA|ADD|ADMIN|AFTER|ALL|ALLOCATE|ALTER|ALWAYS|AND|ANY|ARE|ARRAY|AS|ASC|ASENSITIVE|ASSERTION|ASSIGNMENT|ASYMMETRIC|AT|ATOMIC|ATTRIBUTE|ATTRIBUTES|AUTHORIZATION|AVG|BEFORE|BEGIN|BERNOULLI|BETWEEN|BIGINT|BINARY|BLOB|BOOLEAN|BOTH|BREADTH|BY|CALL|CALLED|CARDINALITY|CASCADE|CASCADED|CASE|CAST|CATALOG|CATALOG_NAME|CEIL|CEILING|CHAIN|CHAR|CHARACTER|CHARACTERISTICS|CHARACTERS|CHARACTER_LENGTH|CHARACTER_SET_CATALOG|CHARACTER_SET_NAME|CHARACTER_SET_SCHEMA|CHAR_LENGTH|CHECK|CHECKED|CLASS_ORIGIN|CLOB|CLOSE|COALESCE|COBOL|CODE_UNITS|COLLATE|COLLATION|COLLATION_CATALOG|COLLATION_NAME|COLLATION_SCHEMA|COLLECT|COLUMN|COLUMN_NAME|COMMAND_FUNCTION|COMMAND_FUNCTION_CODE|COMMIT|COMMITTED|CONDITION|CONDITION_NUMBER|CONNECT|CONNECTION_NAME|CONSTRAINT|CONSTRAINTS|CONSTRAINT_CATALOG|CONSTRAINT_NAME|CONSTRAINT_SCHEMA|CONSTRUCTORS|CONTAINS|CONTINUE|CONVERT|CORR|CORRESPONDING|COUNT|COVAR_POP|COVAR_SAMP|CREATE|CROSS|CUBE|CUME_DIST|CURRENT|CURRENT_COLLATION|CURRENT_DATE|CURRENT_DEFAULT_TRANSFORM_GROUP|CURRENT_PATH|CURRENT_ROLE|CURRENT_TIME|CURRENT_TIMESTAMP|CURRENT_TRANSFORM_GROUP_FOR_TYPE|CURRENT_USER|CURSOR|CURSOR_NAME|CYCLE|DATA|DATE|DATETIME_INTERVAL_CODE|DATETIME_INTERVAL_PRECISION|DAY|DEALLOCATE|DEC|DECIMAL|DECLARE|DEFAULT|DEFAULTS|DEFERRABLE|DEFERRED|DEFINED|DEFINER|DEGREE|DELETE|DENSE_RANK|DEPTH|DEREF|DERIVED|DESC|DESCRIBE|DESCRIPTOR|DETERMINISTIC|DIAGNOSTICS|DISCONNECT|DISPATCH|DISTINCT|DOMAIN|DOUBLE|DROP|DYNAMIC|DYNAMIC_FUNCTION|DYNAMIC_FUNCTION_CODE|EACH|ELEMENT|ELSE|END|EQUALS|ESCAPE|EVERY|EXCEPT|EXCEPTION|EXCLUDE|EXCLUDING|EXEC|EXECUTE|EXISTS|EXP|EXTERNAL|EXTRACT|FALSE|FETCH|FILTER|FINAL|FIRST|FLOAT|FLOOR|FOLLOWING|FOR|FOREIGN|FORTRAN|FOUND|FREE|FROM|FULL|FUNCTION|FUSION|GENERAL|GET|GLOBAL|GO|GOTO|GRANT|GRANTED|GROUP|GROUPING|HAVING|HIERARCHY|HOLD|HOUR|IDENTITY|IMMEDIATE|IMPLEMENTATION|IN|INCLUDING|INCREMENT|INDICATOR|INITIALLY|INNER|INOUT|INPUT|INSENSITIVE|INSERT|INSTANCE|INSTANTIABLE|INT|INTEGER|INTERSECT|INTERSECTION|INTERVAL|INTO|INVOKER|IS|ISOLATION|JOIN|KEY|KEY_MEMBER|KEY_TYPE|LANGUAGE|LARGE|LAST|LATERAL|LEADING|LEFT|LENGTH|LEVEL|LIKE|LN|LOCAL|LOCALTIME|LOCALTIMESTAMP|LOCATOR|LOWER|MAP|MATCH|MATCHED|MAX|MAXVALUE|MEMBER|MERGE|MESSAGE_LENGTH|MESSAGE_OCTET_LENGTH|MESSAGE_TEXT|METHOD|MIN|MINUTE|MINVALUE|MOD|MODIFIES|MODULE|MONTH|MORE|MULTISET|MUMPS|NAME|NAMES|NATIONAL|NATURAL|NCHAR|NCLOB|NESTING|NEW|NEXT|NO|NONE|NORMALIZE|NORMALIZED|NOT|NULL|NULLABLE|NULLIF|NULLS|NUMBER|NUMERIC|OBJECT|OCTETS|OCTET_LENGTH|OF|OLD|ON|ONLY|OPEN|OPTION|OPTIONS|OR|ORDER|ORDERING|ORDINALITY|OTHERS|OUT|OUTER|OUTPUT|OVER|OVERLAPS|OVERLAY|OVERRIDING|PAD|PARAMETER|PARAMETER_MODE|PARAMETER_NAME|PARAMETER_ORDINAL_POSITION|PARAMETER_SPECIFIC_CATALOG|PARAMETER_SPECIFIC_NAME|PARAMETER_SPECIFIC_SCHEMA|PARTIAL|PARTITION|PASCAL|PATH|PERCENTILE_CONT|PERCENTILE_DISC|PERCENT_RANK|PLACING|PLI|POSITION|POWER|PRECEDING|PRECISION|PREPARE|PRESERVE|PRIMARY|PRIOR|PRIVILEGES|PROCEDURE|PUBLIC|RANGE|RANK|READ|READS|REAL|RECURSIVE|REF|REFERENCES|REFERENCING|REGR_AVGX|REGR_AVGY|REGR_COUNT|REGR_INTERCEPT|REGR_R2|REGR_SLOPE|REGR_SXX|REGR_SXY|RELATIVE|RELEASE|REPEATABLE|RESTART|RESULT|RETURN|RETURNED_CARDINALITY|RETURNED_LENGTH|RETURNED_OCTET_LENGTH|RETURNED_SQLSTATE|RETURNS|REVOKE|RIGHT|ROLE|ROLLBACK|ROLLUP|ROUTINE|ROUTINE_CATALOG|ROUTINE_NAME|ROUTINE_SCHEMA|ROW|ROWS|ROW_COUNT|ROW_NUMBER|SAVEPOINT|SCALE|SCHEMA|SCHEMA_NAME|SCOPE_CATALOG|SCOPE_NAME|SCOPE_SCHEMA|SCROLL|SEARCH|SECOND|SECTION|SECURITY|SELECT|SELF|SENSITIVE|SEQUENCE|SERIALIZABLE|SERVER_NAME|SESSION|SESSION_USER|SET|SETS|SIMILAR|SIMPLE|SIZE|SMALLINT|SOME|SOURCE|SPACE|SPECIFIC|SPECIFICTYPE|SPECIFIC_NAME|SQL|SQLEXCEPTION|SQLSTATE|SQLWARNING|SQRT|START|STATE|STATEMENT|STATIC|STDDEV_POP|STDDEV_SAMP|STRUCTURE|STYLE|SUBCLASS_ORIGIN|SUBMULTISET|SUBSTRING|SUM|SYMMETRIC|SYSTEM|SYSTEM_USER|TABLE|TABLESAMPLE|TABLE_NAME|TEMPORARY|THEN|TIES|TIME|TIMESTAMP|TIMEZONE_HOUR|TIMEZONE_MINUTE|TO|TOP_LEVEL_COUNT|TRAILING|TRANSACTION|TRANSACTIONS_COMMITTED|TRANSACTIONS_ROLLED_BACK|TRANSACTION_ACTIVE|TRANSFORM|TRANSFORMS|TRANSLATE|TRANSLATION|TREAT|TRIGGER|TRIGGER_CATALOG|TRIGGER_NAME|TRIGGER_SCHEMA|TRIM|TRUE|TYPE|UNBOUNDED|UNCOMMITTED|UNDER|UNION|UNIQUE|UNKNOWN|UNNAMED|UNNEST|UPDATE|UPPER|USAGE|USER|USER_DEFINED_TYPE_CATALOG|USER_DEFINED_TYPE_CODE|USER_DEFINED_TYPE_NAME|USER_DEFINED_TYPE_SCHEMA|USING|VALUE|VALUES|VARCHAR|VARYING|VAR_POP|VAR_SAMP|VIEW|WHEN|WHENEVER|WHERE|WIDTH_BUCKET|WINDOW|WITH|WITHIN|WITHOUT|WORK|WRITE|YEAR|ZONE)$/str_p("&")/
t
'
R_NAME|TRIGGER_SCHEMA|TRIM|TRUE|TYPE|UNBOUNDED|UNCOMMITTED|UNDER|UNION|UNIQUE|UNKNOWN|UNNAMED|UNNEST|UPDATE|UPPER|USAGE|USER|USER_DEFINED_TYPE_CATALOG|USER_DEFINED_TYPE_CODE|USER_DEFINED_TYPE_NAME|USER_DEFINED_TYPE_SCHEMA|USING|VALUE|VALUES|VARCHAR|VARYING|VAR_POP|VAR_SAMP|VIEW|WHEN|WHENEVER|WHERE|WIDTH_BUCKET|WINDOW|WITH|WITHIN|WITHOUT|WORK|WRITE|YEAR|ZONE)(\W|$),\1(\n\2\n)\3,g
t
N
bu
+ sed -re '
/\w+ *=/,/;;;/ {
s,(\||=|^) (.)$,\1ch_p('\''\2'\''),
}
s,'\'''\'''\'','\''\\'\'''\'',
'
+ sed -nre '

/\w+ *=.*/,/;;;/M  {
:z
N
/;;;/! {
bz
}
s,\n,,g
}
s,(\||>>)(\(*)(ch_p|str_p),\1\2,g
p

'
'
BNF >> Grammar >> for >> ISO/IEC >> 9075-2:(2003 >> -Database >> Language >>(
str_p("SQL")
) >>(
str_p("SQL")
)-2003 >>(
str_p("SQL")
))/Foundation=====================================================================================@(#)$Id:sql-2003-2.bnf,v >> 1.11 >> 2005/07/13 >> 18:37:30 >> jleffler >> Exp$;;;
SQLTerminalCharacter = SQLLanguageCharacter;;;
SQLLanguageCharacter = SimpleLatinLetter  | Digit  | SQLSpecialCharacter;;;
SimpleLatinLetter = SimpleLatinUpperCaseLetter  | SimpleLatinLowerCaseLetter;;;
SimpleLatinUpperCaseLetter =ch_p('A')  |('B')  |('C')  |('D')  |('E')  |('F')  |('G')  |('H')  |('I')  |('J')  |('K')  |('L')  |('M')  |('N')  |('O')  |('P')  |('Q')  |('R')  |('S')  |('T')  |('U')  |('V')  |('W')  |('X')  |('Y')  |('Z');;;
SimpleLatinLowerCaseLetter =ch_p('A')  |('B')  |('C')  |('D')  |('E')  |('F')  |('G')  |('H')  |('I')  |('J')  |('K')  |('L')  |('M')  |('N')  |('O')  |('P')  |('Q')  |('R')  |('S')  |('T')  |('U')  |('V')  |('W')  |('X')  |('Y')  |('Z');;;
Digit =ch_p('0')  |('1')  |('2')  |('3')  |('4')  |('5')  |('6')  |('7')  |('8')  |('9');;;
SQLSpecialCharacter = Space  | DoubleQuote  | Percent  | Ampersand  | Quote  | LeftParen  | RightParen  | Asterisk  | PlusSign  | Comma  | MinusSign  | Period  | Solidus  | Colon  | Semicolon  | LessThanOperator  | EqualsOperator  | GreaterThanOperator  | QuestionMark  | LeftBracket  | RightBracket  | Circumflex  | Underscore  | VerticalBar  | LeftBrace  | RightBrace;;;
Space = !!See >> the >> Syntax >> Rules;;;
DoubleQuote =ch_p('"');;;
Percent =ch_p('%');;;
Ampersand =ch_p('&');;;
Quote =ch_p('\'');;;
LeftParen =ch_p('(');;;
RightParen =ch_p(')');;;
Asterisk =ch_p('*');;;
PlusSign =ch_p('+');;;
Comma =ch_p(',');;;
MinusSign =ch_p('-');;;
Period =ch_p('.');;;
Solidus =ch_p('/');;;
Colon =ch_p(':');;;
Semicolon =ch_p(';');;;
LessThanOperator =ch_p('(');;;
EqualsOperator =ch_p('=');;;
GreaterThanOperator =ch_p(')');;;
QuestionMark =ch_p('?');;;
Token = NondelimiterToken  | DelimiterToken;;;
NondelimiterToken = RegularIdentifier  | KeyWord  | UnsignedNumericLiteral  | NationalCharacterStringLiteral  | BitStringLiteral  | HexStringLiteral  | LargeObjectLengthToken  | Multiplier;;;
RegularIdentifier = IdentifierBody;;;
IdentifierBody = (IdentifierStart >> *IdentifierPart);;;
IdentifierPart = IdentifierStart  | IdentifierExtend;;;
IdentifierStart = !!See >> The >> Syntax >> Rules;;;
IdentifierExtend = !!See >> The >> Syntax >> Rules;;;
LargeObjectLengthToken = +Digit >> Multiplier;;;
Multiplier =ch_p('K')  |('M')  |('G');;;
UnicodeDelimitedIdentifier = (U >> Ampersand >> DoubleQuote >> +UnicodeDelimiterBody >> DoubleQuote >> !(str_p("ESCAPE")) >> EscapeCharacter);;;
UnicodeDelimiterBody = +UnicodeIdentifierPart;;;
UnicodeIdentifierPart = DelimitedIdentifierPart  | UnicodeEscapeValue;;;
UnicodeEscapeValue = Unicode4DigitEscapeValue  | Unicode6DigitEscapeValue;;;
Unicode4DigitEscapeValue = EscapeCharacter >> Hexit >> Hexit >> Hexit >> Hexit;;;
Unicode6DigitEscapeValue = EscapeCharacter >> PlusSign >> Hexit >> Hexit >> Hexit >> Hexit >> Hexit >> Hexit;;;
EscapeCharacter = !!See >> The >> Syntax >> Rules;;;
NondoublequoteCharacter = !!See >> The >> Syntax >> Rules;;;
DoublequoteSymbol = DoubleQuote >> DoubleQuote;;;
DelimiterToken = CharacterStringLiteral  | DateString  | TimeString  | TimestampString  | IntervalString  | DelimitedIdentifier  | UnicodeDelimitedIdentifier  | SQLSpecialCharacter  | NotEqualsOperator  | GreaterThanOrEqualsOperator  | LessThanOrEqualsOperator  | ConcatenationOperator  | RightArrow  | LeftBracketTrigraph  | RightBracketTrigraph  | DoubleColon  | DoublePeriod;;;
NotEqualsOperator = LessThanOperator >> GreaterThanOperator;;;
GreaterThanOrEqualsOperator = GreaterThanOperator >> EqualsOperator;;;
LessThanOrEqualsOperator = LessThanOperator >> EqualsOperator;;;
ConcatenationOperator = VerticalBar >> VerticalBar;;;
RightArrow = MinusSign >> GreaterThanOperator;;;
DoubleColon = Colon >> Colon;;;
DoublePeriod = Period >> Period;;;
Separator = +(Comment  | WhiteSpace);;;
Comment = SimpleComment  | BracketedComment;;;
SimpleComment = (SimpleCommentIntroducer >> *CommentCharacter >> Newline);;;
SimpleCommentIntroducer = (MinusSign >> MinusSign >> *MinusSign);;;
BracketedComment = BracketedCommentIntroducer >> BracketedCommentContents >> BracketedCommentTerminator;;;
BracketedCommentIntroducer = Slash >> Asterisk;;;
BracketedCommentTerminator = Asterisk >> Slash;;;
BracketedCommentContents = *((CommentCharacter  | Separator));;;
CommentCharacter = NonquoteCharacter  | Quote;;;
Newline = !!See >> the >> Syntax >> Rules;;;
KeyWord = ReservedWord  | NonReservedWord;;;
NonReservedWord =ch_p('A')  |(("ABS"))  |(("ABSOLUTE"))  |(("ACTION"))  |(("ADA"))  |(("ADMIN"))  |(("AFTER"))  |(("ALWAYS"))  |(("ASC"))  |(("ASSERTION"))  |(("ASSIGNMENT"))  |(("ATTRIBUTE"))  |(("ATTRIBUTES"))  |(("AVG"))  |(("BEFORE"))  |(("BERNOULLI"))  |(("BREADTH"))  |('C')  |(("CARDINALITY"))  |(("CASCADE"))  |(("CATALOG"))  |(("CATALOG_NAME"))  |(("CEIL"))  |(("CEILING"))  |(("CHAIN"))  |(("CHARACTERISTICS"))  |(("CHARACTERS"))  |(("CHARACTER_LENGTH"))  |(("CHARACTER_SET_CATALOG"))  |(("CHARACTER_SET_NAME"))  |(("CHARACTER_SET_SCHEMA"))  |(("CHAR_LENGTH"))  |(("CHECKED"))  |(("CLASS_ORIGIN"))  |(("COALESCE"))  |(("COBOL"))  |(("CODE_UNITS"))  |(("COLLATION"))  |(("COLLATION_CATALOG"))  |(("COLLATION_NAME"))  |(("COLLATION_SCHEMA"))  |(("COLLECT"))  |(("COLUMN_NAME"))  |(("COMMAND_FUNCTION"))  |(("COMMAND_FUNCTION_CODE"))  |(("COMMITTED"))  |(("CONDITION"))  |(("CONDITION_NUMBER"))  |(("CONNECTION_NAME"))  |(("CONSTRAINTS"))  |(("CONSTRAINT_CATALOG"))  |(("CONSTRAINT_NAME"))  |(("CONSTRAINT_SCHEMA"))  |(("CONSTRUCTORS"))  |(("CONTAINS"))  |(("CONVERT"))  |(("CORR"))  |(("COUNT"))  |(("COVAR_POP"))  |(("COVAR_SAMP"))  |(("CUME_DIST"))  |(("CURRENT_COLLATION"))  |(("CURSOR_NAME"))  |(("DATA"))  |(("DATETIME_INTERVAL_CODE"))  |(("DATETIME_INTERVAL_PRECISION"))  |(("DEFAULTS"))  |(("DEFERRABLE"))  |(("DEFERRED"))  |(("DEFINED"))  |(("DEFINER"))  |(("DEGREE"))  |(("DENSE_RANK"))  |(("DEPTH"))  |(("DERIVED"))  |(("DESC"))  |(("DESCRIPTOR"))  |(("DIAGNOSTICS"))  |(("DISPATCH"))  |(("DOMAIN"))  |(("DYNAMIC_FUNCTION"))  |(("DYNAMIC_FUNCTION_CODE"))  |(("EQUALS"))  |(("EVERY"))  |(("EXCEPTION"))  |(("EXCLUDE"))  |(("EXCLUDING"))  |(("EXP"))  |(("EXTRACT"))  |(("FINAL"))  |(("FIRST"))  |(("FLOOR"))  |(("FOLLOWING"))  |(("FORTRAN"))  |(("FOUND"))  |(("FUSION"))  |('G')  |(("GENERAL"))  |(("GO"))  |(("GOTO"))  |(("GRANTED"))  |(("HIERARCHY"))  |(("IMPLEMENTATION"))  |(("INCLUDING"))  |(("INCREMENT"))  |(("INITIALLY"))  |(("INSTANCE"))  |(("INSTANTIABLE"))  |(("INTERSECTION"))  |(("INVOKER"))  |(("ISOLATION"))  |('K')  |(("KEY"))  |(("KEY_MEMBER"))  |(("KEY_TYPE"))  |(("LAST"))  |(("LENGTH"))  |(("LEVEL"))  |(("LN"))  |(("LOCATOR"))  |(("LOWER"))  |('M')  |(("MAP"))  |(("MATCHED"))  |(("MAX"))  |(("MAXVALUE"))  |(("MESSAGE_LENGTH"))  |(("MESSAGE_OCTET_LENGTH"))  |(("MESSAGE_TEXT"))  |(("MIN"))  |(("MINVALUE"))  |(("MOD"))  |(("MORE"))  |(("MUMPS"))  |(("NAME"))  |(("NAMES"))  |(("NESTING"))  |(("NEXT"))  |(("NORMALIZE"))  |(("NORMALIZED"))  |(("NULLABLE"))  |(("NULLIF"))  |(("NULLS"))  |(("NUMBER"))  |(("OBJECT"))  |(("OCTETS"))  |(("OCTET_LENGTH"))  |(("OPTION"))  |(("OPTIONS"))  |(("ORDERING"))  |(("ORDINALITY"))  |(("OTHERS"))  |(("OVERLAY"))  |(("OVERRIDING"))  |(("PAD"))  |(("PARAMETER_MODE"))  |(("PARAMETER_NAME"))  |(("PARAMETER_ORDINAL_POSITION"))  |(("PARAMETER_SPECIFIC_CATALOG"))  |(("PARAMETER_SPECIFIC_NAME"))  |(("PARAMETER_SPECIFIC_SCHEMA"))  |(("PARTIAL"))  |(("PASCAL"))  |(("PATH"))  |(("PERCENTILE_CONT"))  |(("PERCENTILE_DISC"))  |(("PERCENT_RANK"))  |(("PLACING"))  |(("PLI"))  |(("POSITION"))  |(("POWER"))  |(("PRECEDING"))  |(("PRESERVE"))  |(("PRIOR"))  |(("PRIVILEGES"))  |(("PUBLIC"))  |(("RANK"))  |(("READ"))  |(("REGR_AVGX"))  |(("REGR_AVGY"))  |(("REGR_COUNT"))  |(("REGR_INTERCEPT"))  |(("REGR_R2"))  |(("REGR_SLOPE"))  |(("REGR_SXX"))  |(("REGR_SXY"))  |(("REGR_SXY"))  |(("RELATIVE"))  |(("REPEATABLE"))  |(("RESTART"))  |(("RESULT"))  |(("RETURNED_CARDINALITY"))  |(("RETURNED_LENGTH"))  |(("RETURNED_OCTET_LENGTH"))  |(("RETURNED_SQLSTATE"))  |(("ROLE"))  |(("ROUTINE"))  |(("ROUTINE_CATALOG"))  |(("ROUTINE_NAME"))  |(("ROUTINE_SCHEMA"))  |(("ROW_COUNT"))  |(("ROW_NUMBER"))  |(("SCALE"))  |(("SCHEMA"))  |(("SCHEMA_NAME"))  |(("SCOPE_CATALOG"))  |(("SCOPE_NAME"))  |(("SCOPE_SCHEMA"))  |(("SECTION"))  |(("SECURITY"))  |(("SELF"))  |(("SEQUENCE"))  |(("SERIALIZABLE"))  |(("SERVER_NAME"))  |(("SESSION"))  |(("SETS"))  |(("SIMPLE"))  |(("SIZE"))  |(("SOURCE"))  |(("SPACE"))  |(("SPECIFIC_NAME"))  |(("SQRT"))  |(("STATE"))  |(("STATEMENT"))  |(("STDDEV_POP"))  |(("STDDEV_SAMP"))  |(("STRUCTURE"))  |(("STYLE"))  |(("SUBCLASS_ORIGIN"))  |(("SUBSTRING"))  |(("SUM"))  |(("TABLESAMPLE"))  |(("TABLE_NAME"))  |(("TEMPORARY"))  |(("TIES"))  |(("TOP_LEVEL_COUNT"))  |(("TRANSACTION"))  |(("TRANSACTIONS_COMMITTED"))  |(("TRANSACTIONS_ROLLED_BACK"))  |(("TRANSACTION_ACTIVE"))  |(("TRANSFORM"))  |(("TRANSFORMS"))  |(("TRANSLATE"))  |(("TRIGGER_CATALOG"))  |(("TRIGGER_NAME"))  |(("TRIGGER_SCHEMA"))  |(("TRIM"))  |(("TYPE"))  |(("UNBOUNDED"))  |(("UNCOMMITTED"))  |(("UNDER"))  |(("UNNAMED"))  |(("UPPER"))  |(("USAGE"))  |(("USER_DEFINED_TYPE_CATALOG"))  |(("USER_DEFINED_TYPE_CODE"))  |(("USER_DEFINED_TYPE_NAME"))  |(("USER_DEFINED_TYPE_SCHEMA"))  |(("VAR_POP"))  |(("VAR_SAMP"))  |(("VIEW"))  |(("WIDTH_BUCKET"))  |(("WORK"))  |(("WRITE"))  |(("ZONE"));;;
ReservedWord =(str_p("ADD"))  |(("ALL"))  |(("ALLOCATE"))  |(("ALTER"))  |(("AND"))  |(("ANY"))  |(("ARE"))  |(("ARRAY"))  |(("AS"))  |(("ASENSITIVE"))  |(("ASYMMETRIC"))  |(("AT"))  |(("ATOMIC"))  |(("AUTHORIZATION"))  |(("BEGIN"))  |(("BETWEEN"))  |(("BIGINT"))  |(("BINARY"))  |(("BLOB"))  |(("BOOLEAN"))  |(("BOTH"))  |(("BY"))  |(("CALL"))  |(("CALLED"))  |(("CASCADED"))  |(("CASE"))  |(("CAST"))  |(("CHAR"))  |(("CHARACTER"))  |(("CHECK"))  |(("CLOB"))  |(("CLOSE"))  |(("COLLATE"))  |(("COLUMN"))  |(("COMMIT"))  |(("CONNECT"))  |(("CONSTRAINT"))  |(("CONTINUE"))  |(("CORRESPONDING"))  |(("CREATE"))  |(("CROSS"))  |(("CUBE"))  |(("CURRENT"))  |(("CURRENT_DATE"))  |(("CURRENT_DEFAULT_TRANSFORM_GROUP"))  |(("CURRENT_PATH"))  |(("CURRENT_ROLE"))  |(("CURRENT_TIME"))  |(("CURRENT_TIMESTAMP"))  |(("CURRENT_TRANSFORM_GROUP_FOR_TYPE"))  |(("CURRENT_USER"))  |(("CURSOR"))  |(("CYCLE"))  |(("DATE"))  |(("DAY"))  |(("DEALLOCATE"))  |(("DEC"))  |(("DECIMAL"))  |(("DECLARE"))  |(("DEFAULT"))  |(("DELETE"))  |(("DEREF"))  |(("DESCRIBE"))  |(("DETERMINISTIC"))  |(("DISCONNECT"))  |(("DISTINCT"))  |(("DOUBLE"))  |(("DROP"))  |(("DYNAMIC"))  |(("EACH"))  |(("ELEMENT"))  |(("ELSE"))  |(("END"))  | ((str_p("END")) >> -(str_p("EXEC")))  |(("ESCAPE"))  |(("EXCEPT"))  |(("EXEC"))  |(("EXECUTE"))  |(("EXISTS"))  |(("EXTERNAL"))  |(("FALSE"))  |(("FETCH"))  |(("FILTER"))  |(("FLOAT"))  |(("FOR"))  |(("FOREIGN"))  |(("FREE"))  |(("FROM"))  |(("FULL"))  |(("FUNCTION"))  |(("GET"))  |(("GLOBAL"))  |(("GRANT"))  |(("GROUP"))  |(("GROUPING"))  |(("HAVING"))  |(("HOLD"))  |(("HOUR"))  |(("IDENTITY"))  |(("IMMEDIATE"))  |(("IN"))  |(("INDICATOR"))  |(("INNER"))  |(("INOUT"))  |(("INPUT"))  |(("INSENSITIVE"))  |(("INSERT"))  |(("INT"))  |(("INTEGER"))  |(("INTERSECT"))  |(("INTERVAL"))  |(("INTO"))  |(("IS"))  |(("ISOLATION"))  |(("JOIN"))  |(("LANGUAGE"))  |(("LARGE"))  |(("LATERAL"))  |(("LEADING"))  |(("LEFT"))  |(("LIKE"))  |(("LOCAL"))  |(("LOCALTIME"))  |(("LOCALTIMESTAMP"))  |(("MATCH"))  |(("MEMBER"))  |(("MERGE"))  |(("METHOD"))  |(("MINUTE"))  |(("MODIFIES"))  |(("MODULE"))  |(("MONTH"))  |(("MULTISET"))  |(("NATIONAL"))  |(("NATURAL"))  |(("NCHAR"))  |(("NCLOB"))  |(("NEW"))  |(("NO"))  |(("NONE"))  |(("NOT"))  |(("NULL"))  |(("NUMERIC"))  |(("OF"))  |(("OLD"))  |(("ON"))  |(("ONLY"))  |(("OPEN"))  |(("OR"))  |(("ORDER"))  |(("OUT"))  |(("OUTER"))  |(("OUTPUT"))  |(("OVER"))  |(("OVERLAPS"))  |(("PARAMETER"))  |(("PARTITION"))  |(("PRECISION"))  |(("PREPARE"))  |(("PRIMARY"))  |(("PROCEDURE"))  |(("RANGE"))  |(("READS"))  |(("REAL"))  |(("RECURSIVE"))  |(("REF"))  |(("REFERENCES"))  |(("REFERENCING"))  |(("RELEASE"))  |(("RETURN"))  |(("RETURNS"))  |(("REVOKE"))  |(("RIGHT"))  |(("ROLLBACK"))  |(("ROLLUP"))  |(("ROW"))  |(("ROWS"))  |(("SAVEPOINT"))  |(("SCROLL"))  |(("SEARCH"))  |(("SECOND"))  |(("SELECT"))  |(("SENSITIVE"))  |(("SESSION_USER"))  |(("SET"))  |(("SIMILAR"))  |(("SMALLINT"))  |(("SOME"))  |(("SPECIFIC"))  |(("SPECIFICTYPE"))  |(("SQL"))  |(("SQLEXCEPTION"))  |(("SQLSTATE"))  |(("SQLWARNING"))  |(("START"))  |(("STATIC"))  |(("SUBMULTISET"))  |(("SYMMETRIC"))  |(("SYSTEM"))  |(("SYSTEM_USER"))  |(("TABLE"))  |(("THEN"))  |(("TIME"))  |(("TIMESTAMP"))  |(("TIMEZONE_HOUR"))  |(("TIMEZONE_MINUTE"))  |(("TO"))  |(("TRAILING"))  |(("TRANSLATION"))  |(("TREAT"))  |(("TRIGGER"))  |(("TRUE"))  |(("UNION"))  |(("UNIQUE"))  |(("UNKNOWN"))  |(("UNNEST"))  |(("UPDATE"))  |(("USER"))  |(("USING"))  |(("VALUE"))  |(("VALUES"))  |(("VARCHAR"))  |(("VARYING"))  |(("WHEN"))  |(("WHENEVER"))  |(("WHERE"))  |(("WINDOW"))  |(("WITH"))  |(("WITHIN"))  |(("WITHOUT"))  |(("YEAR"));;;
Literal = SignedNumericLiteral  | GeneralLiteral;;;
UnsignedLiteral = UnsignedNumericLiteral  | GeneralLiteral;;;
GeneralLiteral = CharacterStringLiteral  | NationalCharacterStringLiteral  | UnicodeCharacterStringLiteral  | BinaryStringLiteral  | DatetimeLiteral  | IntervalLiteral  | BooleanLiteral;;;
CharacterStringLiteral = !(Introducer >> CharacterSetSpecification >> Quote >> *CharacterRepresentation >> Quote >> *((Separator >> Quote >> *CharacterRepresentation >> Quote)));;;
Introducer = Underscore;;;
CharacterRepresentation = NonquoteCharacter  | QuoteSymbol;;;
NonquoteCharacter = !!See >> The >> Syntax >> Rules;;;
QuoteSymbol = Quote >> Quote;;;
NationalCharacterStringLiteral = (N >> Quote >> *CharacterRepresentation >> Quote >> *((Separator >> Quote >> *CharacterRepresentation >> Quote)));;;
UnicodeCharacterStringLiteral = !(Introducer >> CharacterSetSpecification >> U >> Ampersand >> Quote >> *UnicodeRepresentation >> Quote >> *((Separator >> Quote >> *UnicodeRepresentation >> Quote)) >> !(str_p("ESCAPE")) >> EscapeCharacter);;;
UnicodeRepresentation = CharacterRepresentation  | UnicodeEscapeValue;;;
BinaryStringLiteral = (X >> Quote >> *(Hexit >> Hexit) >> Quote >> *((Separator >> Quote >> *(Hexit >> Hexit) >> Quote)) >> !(str_p("ESCAPE")) >> EscapeCharacter);;;
Hexit = Digit  |('A')  |('B')  |('C')  |('D')  |('E')  |('F')  |('A')  |('B')  |('C')  |('D')  |('E')  |('F');;;
SignedNumericLiteral = !(Sign >> UnsignedNumericLiteral);;;
UnsignedNumericLiteral = ExactNumericLiteral  | ApproximateNumericLiteral;;;
ExactNumericLiteral = (UnsignedInteger >> !(Period >> !UnsignedInteger))  | Period >> UnsignedInteger;;;
Sign = PlusSign  | MinusSign;;;
ApproximateNumericLiteral = Mantissa >> E >> Exponent;;;
Mantissa = ExactNumericLiteral;;;
Exponent = SignedInteger;;;
SignedInteger = !(Sign >> UnsignedInteger);;;
DatetimeLiteral = DateLiteral  | TimeLiteral  | TimestampLiteral;;;
DateLiteral =(str_p("DATE")) >> DateString;;;
TimeLiteral =(str_p("TIME")) >> TimeString;;;
TimestampLiteral =(str_p("TIMESTAMP")) >> TimestampString;;;
DateString = Quote >> UnquotedDateString >> Quote;;;
TimeString = Quote >> UnquotedTimeString >> Quote;;;
TimestampString = Quote >> UnquotedTimestampString >> Quote;;;
TimeZoneInterval = Sign >> HoursValue >> Colon >> MinutesValue;;;
DateValue = YearsValue >> MinusSign >> MonthsValue >> MinusSign >> DaysValue;;;
TimeValue = HoursValue >> Colon >> MinutesValue >> Colon >> SecondsValue;;;
IntervalLiteral = ((str_p("INTERVAL")) >> !Sign >> IntervalString >> IntervalQualifier);;;
IntervalString = Quote >> UnquotedIntervalString >> Quote;;;
UnquotedDateString = DateValue;;;
UnquotedTimeString = (TimeValue >> !TimeZoneInterval);;;
UnquotedTimestampString = UnquotedDateString >> Space >> UnquotedTimeString;;;
UnquotedIntervalString = !(Sign >> YearMonthLiteral  | DayTimeLiteral);;;
YearMonthLiteral = YearsValue  | !(YearsValue >> MinusSign >> MonthsValue);;;
DayTimeLiteral = DayTimeInterval  | TimeInterval;;;
DayTimeInterval = (DaysValue >> !(Space >> HoursValue >> !(Colon >> MinutesValue >> !Colon >> SecondsValue)));;;
TimeInterval = (HoursValue >> !(Colon >> MinutesValue >> !Colon >> SecondsValue))  | (MinutesValue >> !Colon >> SecondsValue)  | SecondsValue;;;
YearsValue = DatetimeValue;;;
MonthsValue = DatetimeValue;;;
DaysValue = DatetimeValue;;;
HoursValue = DatetimeValue;;;
MinutesValue = DatetimeValue;;;
SecondsValue = (SecondsIntegerValue >> !(Period >> !SecondsFraction));;;
SecondsIntegerValue = UnsignedInteger;;;
SecondsFraction = UnsignedInteger;;;
DatetimeValue = UnsignedInteger;;;
BooleanLiteral =(str_p("TRUE"))  |(("FALSE"))  |(("UNKNOWN"));;;
Identifier = ActualIdentifier;;;
ActualIdentifier = RegularIdentifier  | DelimitedIdentifier;;;
SQLLanguageIdentifier = (SQLLanguageIdentifierStart >> *(Underscore  | SQLLanguageIdentifierPart));;;
SQLLanguageIdentifierStart = SimpleLatinLetter;;;
SQLLanguageIdentifierPart = SimpleLatinLetter  | Digit;;;
AuthorizationIdentifier = RoleName  | UserIdentifier;;;
TableName = LocalOrSchemaQualifiedName;;;
DomainName = SchemaQualifiedName;;;
SchemaName = !(CatalogName >> Period >> UnqualifiedSchemaName);;;
CatalogName = Identifier;;;
SchemaQualifiedName = !(SchemaName >> Period >> QualifiedIdentifier);;;
LocalOrSchemaQualifiedName = !(LocalOrSchemaQualifier >> Period >> QualifiedIdentifier);;;
LocalOrSchemaQualifier = SchemaName  |(("MODULE"));;;
QualifiedIdentifier = Identifier;;;
ColumnName = Identifier;;;
CorrelationName = Identifier;;;
QueryName = Identifier;;;
SQLClientModuleName = Identifier;;;
ProcedureName = Identifier;;;
SchemaQualifiedRoutineName = SchemaQualifiedName;;;
MethodName = Identifier;;;
SpecificName = SchemaQualifiedName;;;
CursorName = LocalQualifiedName;;;
LocalQualifiedName = !(LocalQualifier >> Period >> QualifiedIdentifier);;;
LocalQualifier =(str_p("MODULE"));;;
HostParameterName = Colon >> Identifier;;;
SQLParameterName = Identifier;;;
ConstraintName = SchemaQualifiedName;;;
ExternalRoutineName = Identifier  | CharacterStringLiteral;;;
TriggerName = SchemaQualifiedName;;;
CollationName = SchemaQualifiedName;;;
CharacterSetName = !(SchemaName >> Period >> SQLLanguageIdentifier);;;
TransliterationName = SchemaQualifiedName;;;
TranscodingName = SchemaQualifiedName;;;
UserDefinedTypeName = SchemaQualifiedTypeName;;;
SchemaResolvedUserDefinedTypeName = UserDefinedTypeName;;;
SchemaQualifiedTypeName = !(SchemaName >> Period >> QualifiedIdentifier);;;
AttributeName = Identifier;;;
FieldName = Identifier;;;
SavepointName = Identifier;;;
SequenceGeneratorName = SchemaQualifiedName;;;
RoleName = Identifier;;;
UserIdentifier = Identifier;;;
ConnectionName = SimpleValueSpecification;;;
SQLServerName = SimpleValueSpecification;;;
ConnectionUserName = SimpleValueSpecification;;;
SQLStatementName = StatementName  | ExtendedStatementName;;;
StatementName = Identifier;;;
ExtendedStatementName = !(ScopeOption >> SimpleValueSpecification);;;
DynamicCursorName = CursorName  | ExtendedCursorName;;;
ExtendedCursorName = !(ScopeOption >> SimpleValueSpecification);;;
DescriptorName = !(ScopeOption >> SimpleValueSpecification);;;
ScopeOption =(str_p("GLOBAL"))  |(("LOCAL"));;;
WindowName = Identifier;;;
DataType = PredefinedType  | RowType  | PathResolvedUserDefinedTypeName  | ReferenceType  | CollectionType;;;
PredefinedType = (CharacterStringType >> !(str_p("CHARACTER")) >>(("SET")) >> CharacterSetSpecification >> !CollateClause)  | (NationalCharacterStringType >> !CollateClause)  | BinaryLargeObjectStringType  | NumericType  | BooleanType  | DatetimeType  | IntervalType;;;
CharacterStringType = ((str_p("CHARACTER")) >> !LeftParen >> Length >> RightParen)  | ((str_p("CHAR")) >> !LeftParen >> Length >> RightParen)  |(("CHARACTER")) >>(("VARYING")) >> LeftParen >> Length >> RightParen  |(("CHAR")) >>(("VARYING")) >> LeftParen >> Length >> RightParen  |(("VARCHAR")) >> LeftParen >> Length >> RightParen  | ((str_p("CHARACTER")) >>(("LARGE")) >>(("OBJECT")) >> !LeftParen >> LargeObjectLength >> RightParen)  | ((str_p("CHAR")) >>(("LARGE")) >>(("OBJECT")) >> !LeftParen >> LargeObjectLength >> RightParen)  | ((str_p("CLOB")) >> !LeftParen >> LargeObjectLength >> RightParen);;;
NationalCharacterStringType = ((str_p("NATIONAL")) >>(("CHARACTER")) >> !LeftParen >> Length >> RightParen)  | ((str_p("NATIONAL")) >>(("CHAR")) >> !LeftParen >> Length >> RightParen)  | ((str_p("NCHAR")) >> !LeftParen >> Length >> RightParen)  |(("NATIONAL")) >>(("CHARACTER")) >>(("VARYING")) >> LeftParen >> Length >> RightParen  |(("NATIONAL")) >>(("CHAR")) >>(("VARYING")) >> LeftParen >> Length >> RightParen  |(("NCHAR")) >>(("VARYING")) >> LeftParen >> Length >> RightParen  | ((str_p("NATIONAL")) >>(("CHARACTER")) >>(("LARGE")) >>(("OBJECT")) >> !LeftParen >> LargeObjectLength >> RightParen)  | ((str_p("NCHAR")) >>(("LARGE")) >>(("OBJECT")) >> !LeftParen >> LargeObjectLength >> RightParen)  | ((str_p("NCLOB")) >> !LeftParen >> LargeObjectLength >> RightParen);;;
BinaryLargeObjectStringType = ((str_p("BINARY")) >>(("LARGE")) >>(("OBJECT")) >> !LeftParen >> LargeObjectLength >> RightParen)  | ((str_p("BLOB")) >> !LeftParen >> LargeObjectLength >> RightParen);;;
NumericType = ExactNumericType  | ApproximateNumericType;;;
ExactNumericType = ((str_p("NUMERIC")) >> !(LeftParen >> Precision >> !Comma >> Scale >> RightParen))  | ((str_p("DECIMAL")) >> !(LeftParen >> Precision >> !Comma >> Scale >> RightParen))  | ((str_p("DEC")) >> !(LeftParen >> Precision >> !Comma >> Scale >> RightParen))  |(("SMALLINT"))  |(("INTEGER"))  |(("INT"))  |(("BIGINT"));;;
ApproximateNumericType = ((str_p("FLOAT")) >> !LeftParen >> Precision >> RightParen)  |(("REAL"))  |(("DOUBLE")) >>(("PRECISION"));;;
Length = UnsignedInteger;;;
LargeObjectLength = (UnsignedInteger >> !Multiplier >> !CharLengthUnits)  | (LargeObjectLengthToken >> !CharLengthUnits);;;
CharLengthUnits =(str_p("CHARACTERS"))  |(("CODE_UNITS"))  |(("OCTETS"));;;
Precision = UnsignedInteger;;;
Scale = UnsignedInteger;;;
BooleanType =(str_p("BOOLEAN"));;;
DatetimeType =(str_p("DATE"))  | ((str_p("TIME")) >> !LeftParen >> TimePrecision >> RightParen >> !WithOrWithoutTimeZone)  | ((str_p("TIMESTAMP")) >> !LeftParen >> TimestampPrecision >> RightParen >> !WithOrWithoutTimeZone);;;
WithOrWithoutTimeZone =(str_p("WITH")) >>(("TIME")) >>(("ZONE"))  |(("WITHOUT")) >>(("TIME")) >>(("ZONE"));;;
TimePrecision = TimeFractionalSecondsPrecision;;;
TimestampPrecision = TimeFractionalSecondsPrecision;;;
TimeFractionalSecondsPrecision = UnsignedInteger;;;
IntervalType =(str_p("INTERVAL")) >> IntervalQualifier;;;
RowType =(str_p("ROW")) >> RowTypeBody;;;
RowTypeBody = (LeftParen >> (FieldDefinition%Comma) >> RightParen);;;
ReferenceType = ((str_p("REF")) >> LeftParen >> ReferencedType >> RightParen >> !ScopeClause);;;
ScopeClause = SCOPE >> TableName;;;
ReferencedType = PathResolvedUserDefinedTypeName;;;
PathResolvedUserDefinedTypeName = UserDefinedTypeName;;;
PathResolvedUserDefinedTypeName = UserDefinedTypeName;;;
CollectionType = ArrayType  | MultisetType;;;
ArrayType = (DataType >>(("ARRAY")) >> !LeftBracketOrTrigraph >> UnsignedInteger >> RightBracketOrTrigraph);;;
MultisetType = DataType >>(("MULTISET"));;;
FieldDefinition = (FieldName >> DataType >> !ReferenceScopeCheck);;;
ValueExpressionPrimary = ParenthesizedValueExpression  | NonparenthesizedValueExpressionPrimary;;;
ParenthesizedValueExpression = LeftParen >> ValueExpression >> RightParen;;;
NonparenthesizedValueExpressionPrimary = UnsignedValueSpecification  | ColumnReference  | SetFunctionSpecification  | WindowFunction  | ScalarSubquery  | CaseExpression  | CastSpecification  | FieldReference  | SubtypeTreatment  | MethodInvocation  | StaticMethodInvocation  | NewSpecification  | AttributeOrMethodReference  | ReferenceResolution  | CollectionValueConstructor  | ArrayElementReference  | MultisetElementReference  | RoutineInvocation  | NextValueExpression;;;
ValueSpecification = Literal  | GeneralValueSpecification;;;
UnsignedValueSpecification = UnsignedLiteral  | GeneralValueSpecification;;;
GeneralValueSpecification = HostParameterSpecification  | SQLParameterReference  | DynamicParameterSpecification  | EmbeddedVariableSpecification  | CurrentCollationSpecification  |(("CURRENT_DEFAULT_TRANSFORM_GROUP"))  |(("CURRENT_PATH"))  |(("CURRENT_ROLE"))  |(("CURRENT_TRANSFORM_GROUP_FOR_TYPE")) >> PathResolvedUserDefinedTypeName  |(("CURRENT_USER"))  |(("SESSION_USER"))  |(("SYSTEM_USER"))  |(("USER"))  |(("VALUE"));;;
SimpleValueSpecification = Literal  | HostParameterName  | SQLParameterReference  | EmbeddedVariableName;;;
TargetSpecification = HostParameterSpecification  | SQLParameterReference  | ColumnReference  | TargetArrayElementSpecification  | DynamicParameterSpecification  | EmbeddedVariableSpecification;;;
SimpleTargetSpecification = HostParameterSpecification  | SQLParameterReference  | ColumnReference  | EmbeddedVariableName;;;
HostParameterSpecification = (HostParameterName >> !IndicatorParameter);;;
DynamicParameterSpecification = QuestionMark;;;
EmbeddedVariableSpecification = (EmbeddedVariableName >> !IndicatorVariable);;;
IndicatorVariable = !((str_p("INDICATOR")) >> EmbeddedVariableName);;;
IndicatorParameter = !((str_p("INDICATOR")) >> HostParameterName);;;
TargetArrayElementSpecification = TargetArrayReference >> LeftBracketOrTrigraph >> SimpleValueSpecification >> RightBracketOrTrigraph;;;
TargetArrayReference = SQLParameterReference  | ColumnReference;;;
CurrentCollationSpecification =(str_p("CURRENT_COLLATION")) >> LeftParen >> StringValueExpression >> RightParen;;;
ContextuallyTypedValueSpecification = ImplicitlyTypedValueSpecification  | DefaultSpecification;;;
ImplicitlyTypedValueSpecification = NullSpecification  | EmptySpecification;;;
NullSpecification =(str_p("NULL"));;;
EmptySpecification =(str_p("ARRAY")) >> LeftBracketOrTrigraph >> RightBracketOrTrigraph  |(("MULTISET")) >> LeftBracketOrTrigraph >> RightBracketOrTrigraph;;;
DefaultSpecification =(str_p("DEFAULT"));;;
IdentifierChain = ((Identifier%Period));;;
BasicIdentifierChain = IdentifierChain;;;
ColumnReference = BasicIdentifierChain  |(("MODULE")) >> Period >> QualifiedIdentifier >> Period >> ColumnName;;;
SQLParameterReference = BasicIdentifierChain;;;
SetFunctionSpecification = AggregateFunction  | GroupingOperation;;;
GroupingOperation = ((str_p("GROUPING")) >> LeftParen >> (ColumnReference%Comma) >> RightParen);;;
WindowFunction = WindowFunctionType >>(("OVER")) >> WindowNameOrSpecification;;;
WindowFunctionType = RankFunctionType >> LeftParen >> RightParen  |(("ROW_NUMBER")) >> LeftParen >> RightParen  | AggregateFunction;;;
RankFunctionType =(str_p("RANK"))  |(("DENSE_RANK"))  |(("PERCENT_RANK"))  |(("CUME_DIST"));;;
WindowNameOrSpecification = WindowName  | InLineWindowSpecification;;;
InLineWindowSpecification = WindowSpecification;;;
CaseExpression = CaseAbbreviation  | CaseSpecification;;;
CaseAbbreviation =(str_p("NULLIF")) >> LeftParen >> ValueExpression >> Comma >> ValueExpression >> RightParen  | ((str_p("COALESCE")) >> LeftParen >> ValueExpression >> +Comma >> ValueExpression >> RightParen);;;
CaseSpecification = SimpleCase  | SearchedCase;;;
SimpleCase = ((str_p("CASE")) >> CaseOperand >> +SimpleWhenClause >> !ElseClause >>(("END")));;;
SearchedCase = ((str_p("CASE")) >> +SearchedWhenClause >> !ElseClause >>(("END")));;;
SimpleWhenClause =(str_p("WHEN")) >> WhenOperand >>(("THEN")) >> Result;;;
SearchedWhenClause =(str_p("WHEN")) >> SearchCondition >>(("THEN")) >> Result;;;
ElseClause =(str_p("ELSE")) >> Result;;;
CaseOperand = RowValuePredicand  | OverlapsPredicatePart;;;
WhenOperand = RowValuePredicand  | ComparisonPredicatePart2  | BetweenPredicatePart2  | InPredicatePart2  | CharacterLikePredicatePart2  | OctetLikePredicatePart2  | SimilarPredicatePart2  | NullPredicatePart2  | QuantifiedComparisonPredicatePart2  | MatchPredicatePart2  | OverlapsPredicatePart2  | DistinctPredicatePart2  | MemberPredicatePart2  | SubmultisetPredicatePart2  | SetPredicatePart2  | TypePredicatePart2;;;
Result = ResultExpression  |(("NULL"));;;
ResultExpression = ValueExpression;;;
CastSpecification =(str_p("CAST")) >> LeftParen >> CastOperand >>(("AS")) >> CastTarget >> RightParen;;;
CastOperand = ValueExpression  | ImplicitlyTypedValueSpecification;;;
CastTarget = DomainName  | DataType;;;
NextValueExpression =(str_p("NEXT")) >>(("VALUE")) >>(("FOR")) >> SequenceGeneratorName;;;
FieldReference = ValueExpressionPrimary >> Period >> FieldName;;;
SubtypeTreatment =(str_p("TREAT")) >> LeftParen >> SubtypeOperand >>(("AS")) >> TargetSubtype >> RightParen;;;
SubtypeOperand = ValueExpression;;;
TargetSubtype = PathResolvedUserDefinedTypeName  | ReferenceType;;;
MethodInvocation = DirectInvocation  | GeneralizedInvocation;;;
DirectInvocation = (ValueExpressionPrimary >> Period >> MethodName >> !SQLArgumentList);;;
GeneralizedInvocation = (LeftParen >> ValueExpressionPrimary >>(("AS")) >> DataType >> RightParen >> Period >> MethodName >> !SQLArgumentList);;;
MethodSelection = RoutineInvocation;;;
ConstructorMethodSelection = RoutineInvocation;;;
StaticMethodInvocation = (PathResolvedUserDefinedTypeName >> DoubleColon >> MethodName >> !SQLArgumentList);;;
StaticMethodSelection = RoutineInvocation;;;
NewSpecification =(str_p("NEW")) >> RoutineInvocation;;;
NewInvocation = MethodInvocation  | RoutineInvocation;;;
AttributeOrMethodReference = (ValueExpressionPrimary >> DereferenceOperator >> QualifiedIdentifier >> !SQLArgumentList);;;
DereferenceOperator = RightArrow;;;
DereferenceOperation = ReferenceValueExpression >> DereferenceOperator >> AttributeName;;;
MethodReference = ValueExpressionPrimary >> DereferenceOperator >> MethodName >> SQLArgumentList;;;
ReferenceResolution =(str_p("DEREF")) >> LeftParen >> ReferenceValueExpression >> RightParen;;;
ArrayElementReference = ArrayValueExpression >> LeftBracketOrTrigraph >> NumericValueExpression >> RightBracketOrTrigraph;;;
MultisetElementReference =(str_p("ELEMENT")) >> LeftParen >> MultsetValueExpression >> RightParen;;;
ValueExpression = CommonValueExpression  | BooleanValueExpression  | RowValueExpression;;;
CommonValueExpression = NumericValueExpression  | StringValueExpression  | DatetimeValueExpression  | IntervalValueExpression  | UserDefinedTypeValueExpression  | ReferenceValueExpression  | CollectionValueExpression;;;
UserDefinedTypeValueExpression = ValueExpressionPrimary;;;
ReferenceValueExpression = ValueExpressionPrimary;;;
CollectionValueExpression = ArrayValueExpression  | MultisetValueExpression;;;
CollectionValueConstructor = ArrayValueConstructor  | MultisetValueConstructor;;;
NumericValueExpression = Term  | NumericValueExpression >> PlusSign >> Term  | NumericValueExpression >> MinusSign >> Term;;;
Term = Factor  | Term >> Asterisk >> Factor  | Term >> Solidus >> Factor;;;
Factor = !(Sign >> NumericPrimary);;;
NumericPrimary = ValueExpressionPrimary  | NumericValueFunction;;;
NumericValueFunction = PositionExpression  | ExtractExpression  | LengthExpression  | CardinalityExpression  | AbsoluteValueExpression  | ModulusExpression  | NaturalLogarithm  | ExponentialFunction  | PowerFunction  | SquareRoot  | FloorFunction  | CeilingFunction  | WidthBucketFunction;;;
PositionExpression = StringPositionExpression  | BlobPositionExpression;;;
StringPositionExpression = ((str_p("POSITION")) >> LeftParen >> StringValueExpression >>(("IN")) >> StringValueExpression >> !(str_p("USING")) >> CharLengthUnits >> RightParen);;;
BlobPositionExpression =(str_p("POSITION")) >> LeftParen >> BlobValueExpression >>(("IN")) >> BlobValueExpression >> RightParen;;;
LengthExpression = CharLengthExpression  | OctetLengthExpression;;;
CharLengthExpression = ((str_p("CHAR_LENGTH"))  |(("CHARACTER_LENGTH")) >> LeftParen >> StringValueExpression >> !(str_p("USING")) >> CharLengthUnits >> RightParen);;;
OctetLengthExpression =(str_p("OCTET_LENGTH")) >> LeftParen >> StringValueExpression >> RightParen;;;
ExtractExpression =(str_p("EXTRACT")) >> LeftParen >> ExtractField >>(("FROM")) >> ExtractSource >> RightParen;;;
ExtractField = PrimaryDatetimeField  | TimeZoneField;;;
TimeZoneField =(str_p("TIMEZONE_HOUR"))  |(("TIMEZONE_MINUTE"));;;
ExtractSource = DatetimeValueExpression  | IntervalValueExpression;;;
CardinalityExpression =(str_p("CARDINALITY")) >> LeftParen >> CollectionValueExpression >> RightParen;;;
AbsoluteValueExpression =(str_p("ABS")) >> LeftParen >> NumericValueExpression >> RightParen;;;
ModulusExpression =(str_p("MOD")) >> LeftParen >> NumericValueExpressionDividend >> Comma >> NumericValueExpressionDivisor >> RightParen;;;
NaturalLogarithm =(str_p("LN")) >> LeftParen >> NumericValueExpression >> RightParen;;;
ExponentialFunction =(str_p("EXP")) >> LeftParen >> NumericValueExpression >> RightParen;;;
PowerFunction =(str_p("POWER")) >> LeftParen >> NumericValueExpressionBase >> Comma >> NumericValueExpressionExponent >> RightParen;;;
NumericValueExpressionBase = NumericValueExpression;;;
NumericValueExpressionExponent = NumericValueExpression;;;
SquareRoot =(str_p("SQRT")) >> LeftParen >> NumericValueExpression >> RightParen;;;
FloorFunction =(str_p("FLOOR")) >> LeftParen >> NumericValueExpression >> RightParen;;;
CeilingFunction = ((str_p("CEIL"))  |(("CEILING")) >> LeftParen >> NumericValueExpression >> RightParen);;;
WidthBucketFunction =(str_p("WIDTH_BUCKET")) >> LeftParen >> WidthBucketOperand >> Comma >> WidthBucketBound1 >> Comma >> WidthBucketBound2 >> Comma >> WidthBucketCount >> RightParen;;;
WidthBucketOperand = NumericValueExpression;;;
WidthBucketBound1 = NumericValueExpression;;;
WidthBucketBound2 = NumericValueExpression;;;
WidthBucketCount = NumericValueExpression;;;
StringValueExpression = CharacterValueExpression  | BlobValueExpression;;;
CharacterValueExpression = Concatenation  | CharacterFactor;;;
Concatenation = CharacterValueExpression >> ConcatenationOperator >> CharacterFactor;;;
CharacterFactor = (CharacterPrimary >> !CollateClause);;;
CharacterPrimary = ValueExpressionPrimary  | StringValueFunction;;;
BlobValueExpression = BlobConcatenation  | BlobFactor;;;
BlobFactor = BlobPrimary;;;
BlobPrimary = ValueExpressionPrimary  | StringValueFunction;;;
BlobConcatenation = BlobValueExpression >> ConcatenationOperator >> BlobFactor;;;
StringValueFunction = CharacterValueFunction  | BlobValueFunction;;;
CharacterValueFunction = CharacterSubstringFunction  | RegularExpressionSubstringFunction  | Fold  | Transcoding  | CharacterTransliteration  | TrimFunction  | CharacterOverlayFunction  | NormalizeFunction  | SpecificTypeMethod;;;
CharacterSubstringFunction = ((str_p("SUBSTRING")) >> LeftParen >> CharacterValueExpression >>(("FROM")) >> StartPosition >> !(str_p("FOR")) >> StringLength >> !(str_p("USING")) >> CharLengthUnits >> RightParen);;;
RegularExpressionSubstringFunction =(str_p("SUBSTRING")) >> LeftParen >> CharacterValueExpression >>(("SIMILAR")) >> CharacterValueExpression >>(("ESCAPE")) >> EscapeCharacter >> RightParen;;;
Fold = ((str_p("UPPER"))  |(("LOWER")) >> LeftParen >> CharacterValueExpression >> RightParen);;;
Transcoding =(str_p("CONVERT")) >> LeftParen >> CharacterValueExpression >>(("USING")) >> TranscodingName >> RightParen;;;
CharacterTransliteration =(str_p("TRANSLATE")) >> LeftParen >> CharacterValueExpression >>(("USING")) >> TransliterationName >> RightParen;;;
TrimFunction =(str_p("TRIM")) >> LeftParen >> TrimOperands >> RightParen;;;
TrimOperands = !(!(TrimSpecification >> !TrimCharacter >>(("FROM"))) >> TrimSource);;;
TrimSource = CharacterValueExpression;;;
TrimSpecification =(str_p("LEADING"))  |(("TRAILING"))  |(("BOTH"));;;
TrimCharacter = CharacterValueExpression;;;
CharacterOverlayFunction = ((str_p("OVERLAY")) >> LeftParen >> CharacterValueExpression >>(("PLACING")) >> CharacterValueExpression >>(("FROM")) >> StartPosition >> !(str_p("FOR")) >> StringLength >> !(str_p("USING")) >> CharLengthUnits >> RightParen);;;
NormalizeFunction =(str_p("NORMALIZE")) >> LeftParen >> CharacterValueExpression >> RightParen;;;
SpecificTypeMethod = UserDefinedTypeValueExpression >> Period >>(("SPECIFICTYPE"));;;
BlobValueFunction = BlobSubstringFunction  | BlobTrimFunction  | BlobOverlayFunction;;;
BlobSubstringFunction = ((str_p("SUBSTRING")) >> LeftParen >> BlobValueExpression >>(("FROM")) >> StartPosition >> !(str_p("FOR")) >> StringLength >> RightParen);;;
BlobTrimFunction =(str_p("TRIM")) >> LeftParen >> BlobTrimOperands >> RightParen;;;
BlobTrimOperands = !(!(TrimSpecification >> !TrimOctet >>(("FROM"))) >> BlobTrimSource);;;
BlobTrimSource = BlobValueExpression;;;
TrimOctet = BlobValueExpression;;;
BlobOverlayFunction = ((str_p("OVERLAY")) >> LeftParen >> BlobValueExpression >>(("PLACING")) >> BlobValueExpression >>(("FROM")) >> StartPosition >> !(str_p("FOR")) >> StringLength >> RightParen);;;
StartPosition = NumericValueExpression;;;
StringLength = NumericValueExpression;;;
DatetimeValueExpression = DatetimeTerm  | IntervalValueExpression >> PlusSign >> DatetimeTerm  | DatetimeValueExpression >> PlusSign >> IntervalTerm  | DatetimeValueExpression >> MinusSign >> IntervalTerm;;;
DatetimeTerm = DatetimeFactor;;;
DatetimeFactor = (DatetimePrimary >> !TimeZone);;;
DatetimePrimary = ValueExpressionPrimary  | DatetimeValueFunction;;;
TimeZone =(str_p("AT")) >> TimeZoneSpecifier;;;
TimeZoneSpecifier =(str_p("LOCAL"))  |(("TIME")) >>(("ZONE")) >> IntervalPrimary;;;
DatetimeValueFunction = CurrentDateValueFunction  | CurrentTimeValueFunction  | CurrentTimestampValueFunction  | CurrentLocalTimeValueFunction  | CurrentLocalTimestampValueFunction;;;
CurrentDateValueFunction =(str_p("CURRENT_DATE"));;;
CurrentTimeValueFunction = ((str_p("CURRENT_TIME")) >> !LeftParen >> TimePrecision >> RightParen);;;
CurrentLocalTimeValueFunction = ((str_p("LOCALTIME")) >> !LeftParen >> TimePrecision >> RightParen);;;
CurrentTimestampValueFunction = ((str_p("CURRENT_TIMESTAMP")) >> !LeftParen >> TimestampPrecision >> RightParen);;;
CurrentLocalTimestampValueFunction = ((str_p("LOCALTIMESTAMP")) >> !LeftParen >> TimestampPrecision >> RightParen);;;
IntervalValueExpression = IntervalTerm  | IntervalValueExpression1 >> PlusSign >> IntervalTerm1  | IntervalValueExpression1 >> MinusSign >> IntervalTerm1  | LeftParen >> DatetimeValueExpression >> MinusSign >> DatetimeTerm >> RightParen >> IntervalQualifier;;;
IntervalTerm = IntervalFactor  | IntervalTerm2 >> Asterisk >> Factor  | IntervalTerm2 >> Solidus >> Factor  | Term >> Asterisk >> IntervalFactor;;;
IntervalFactor = !(Sign >> IntervalPrimary);;;
IntervalPrimary = (ValueExpressionPrimary >> !IntervalQualifier)  | IntervalValueFunction;;;
IntervalValueExpression1 = IntervalValueExpression;;;
IntervalTerm1 = IntervalTerm;;;
IntervalTerm2 = IntervalTerm;;;
IntervalValueFunction = IntervalAbsoluteValueFunction;;;
IntervalAbsoluteValueFunction =(str_p("ABS")) >> LeftParen >> IntervalValueExpression >> RightParen;;;
BooleanValueExpression = BooleanTerm  | BooleanValueExpression >>(("OR")) >> BooleanTerm;;;
BooleanTerm = BooleanFactor  | BooleanTerm >>(("AND")) >> BooleanFactor;;;
BooleanFactor = !((str_p("NOT")) >> BooleanTest);;;
BooleanTest = (BooleanPrimary >> !((str_p("IS")) >> !(str_p("NOT")) >> TruthValue));;;
TruthValue =(str_p("TRUE"))  |(("FALSE"))  |(("UNKNOWN"));;;
BooleanPrimary = Predicate  | BooleanPredicand;;;
BooleanPredicand = ParenthesizedBooleanValueExpression  | NonparenthesizedValueExpressionPrimary;;;
ParenthesizedBooleanValueExpression = LeftParen >> BooleanValueExpression >> RightParen;;;
ArrayValueExpression = ArrayConcatenation  | ArrayFactor;;;
ArrayConcatenation = ArrayValueExpression1 >> ConcatenationOperator >> ArrayFactor;;;
ArrayValueExpression1 = ArrayValueExpression;;;
ArrayFactor = ValueExpressionPrimary;;;
ArrayValueConstructor = ArrayValueConstructorByEnumeration  | ArrayValueConstructorByQuery;;;
ArrayValueConstructorByEnumeration =(str_p("ARRAY")) >> LeftBracketOrTrigraph >> ArrayElementList >> RightBracketOrTrigraph;;;
ArrayElementList = ((ArrayElement%Comma));;;
ArrayElement = ValueExpression;;;
ArrayValueConstructorByQuery = ((str_p("ARRAY")) >> LeftParen >> QueryExpression >> !OrderByClause >> RightParen);;;
MultisetValueExpression = MultisetTerm  | (MultisetValueExpression >>(("MULTISET")) >>(("UNION")) >> !(str_p("ALL"))  |(("DISTINCT")) >> MultisetTerm)  | (MultisetValueExpression >>(("MULTISET")) >>(("EXCEPT")) >> !(str_p("ALL"))  |(("DISTINCT")) >> MultisetTerm);;;
MultisetTerm = MultisetPrimary  | (MultisetTerm >>(("MULTISET")) >>(("INTERSECT")) >> !(str_p("ALL"))  |(("DISTINCT")) >> MultisetPrimary);;;
MultisetPrimary = MultisetValueFunction  | ValueExpressionPrimary;;;
MultisetValueFunction = MultisetSetFunction;;;
MultisetSetFunction =(str_p("SET")) >> LeftParen >> MultisetValueExpression >> RightParen;;;
MultisetValueConstructor = MultisetValueConstructorByEnumeration  | MultisetValueConstructorByQuery  | TableValueConstructorByQuery;;;
MultisetValueConstructorByEnumeration =(str_p("MULTISET")) >> LeftBracketOrTrigraph >> MultisetElementList >> RightBracketOrTrigraph;;;
MultisetElementList = (MultisetElement >> !(Comma >> MultisetElement));;;
MultisetElement = ValueExpression;;;
MultisetValueConstructorByQuery =(str_p("MULTISET")) >> LeftParen >> QueryExpression >> RightParen;;;
TableValueConstructorByQuery =(str_p("TABLE")) >> LeftParen >> QueryExpression >> RightParen >> Specify >> A >> Value >> Or >> List >> Of >> Values >> To >> Be >> Constructed >> Into >> A >> Row >> Or >> Partial >> Row.;;;
RowValueConstructor = CommonValueExpression  | BooleanValueExpression  | ExplicitRowValueConstructor;;;
ExplicitRowValueConstructor = LeftParen >> RowValueConstructorElement >> Comma >> RowValueConstructorElementList >> RightParen  |(("ROW")) >> LeftParen >> RowValueConstructorElementList >> RightParen  | RowSubquery;;;
RowValueConstructorElementList = ((RowValueConstructorElement%Comma));;;
RowValueConstructorElement = ValueExpression;;;
ContextuallyTypedRowValueConstructor = CommonValueExpression  | BooleanValueExpression  | ContextuallyTypedValueSpecification  | LeftParen >> ContextuallyTypedRowValueConstructorElement >> Comma >> ContextuallyTypedRowValueConstructorElementList >> RightParen  |(("ROW")) >> LeftParen >> ContextuallyTypedRowValueConstructorElementList >> RightParen;;;
ContextuallyTypedRowValueConstructorElementList = ((ContextuallyTypedRowValueConstructorElement%Comma));;;
ContextuallyTypedRowValueConstructorElement = ValueExpression  | ContextuallyTypedValueSpecification;;;
RowValueConstructorPredicand = CommonValueExpression  | BooleanPredicand  | ExplicitRowValueConstructor;;;
RowValueExpression = RowValueSpecialCase  | ExplicitRowValueConstructor;;;
TableRowValueExpression = RowValueSpecialCase  | RowValueConstructor;;;
ContextuallyTypedRowValueExpression = RowValueSpecialCase  | ContextuallyTypedRowValueConstructor;;;
RowValuePredicand = RowValueSpecialCase  | RowValueConstructorPredicand;;;
RowValueSpecialCase = NonparenthesizedValueExpressionPrimary;;;
TableValueConstructor =(str_p("VALUES")) >> RowValueExpressionList;;;
RowValueExpressionList = ((TableRowValueExpression%Comma));;;
ContextuallyTypedTableValueConstructor =(str_p("VALUES")) >> ContextuallyTypedRowValueExpressionList;;;
ContextuallyTypedRowValueExpressionList = ((ContextuallyTypedRowValueExpression%Comma));;;
TableExpression = (FromClause >> !WhereClause >> !GroupByClause >> !HavingClause >> !WindowClause);;;
FromClause =(str_p("FROM")) >> TableReferenceList;;;
TableReferenceList = ((TableReference%Comma));;;
TableReference = (TablePrimaryOrJoinedTable >> !SampleClause);;;
TablePrimaryOrJoinedTable = TablePrimary  | JoinedTable;;;
SampleClause = ((str_p("TABLESAMPLE")) >> SampleMethod >> LeftParen >> SamplePercentage >> RightParen >> !RepeatableClause);;;
SampleMethod =(str_p("BERNOULLI"))  |(("SYSTEM"));;;
RepeatableClause =(str_p("REPEATABLE")) >> LeftParen >> RepeatArgument >> RightParen;;;
SamplePercentage = NumericValueExpression;;;
RepeatArgument = NumericValueExpression;;;
TablePrimary = (TableOrQueryName >> !!((str_p("AS")) >> CorrelationName >> !LeftParen >> DerivedColumnList >> RightParen))  | (DerivedTable >> !(str_p("AS")) >> CorrelationName >> !LeftParen >> DerivedColumnList >> RightParen)  | (LateralDerivedTable >> !(str_p("AS")) >> CorrelationName >> !LeftParen >> DerivedColumnList >> RightParen)  | (CollectionDerivedTable >> !(str_p("AS")) >> CorrelationName >> !LeftParen >> DerivedColumnList >> RightParen)  | (TableFunctionDerivedTable >> !(str_p("AS")) >> CorrelationName >> !LeftParen >> DerivedColumnList >> RightParen)  | (OnlySpec >> !!((str_p("AS")) >> CorrelationName >> !LeftParen >> DerivedColumnList >> RightParen))  | LeftParen >> JoinedTable >> RightParen;;;
OnlySpec =(str_p("ONLY")) >> LeftParen >> TableOrQueryName >> RightParen;;;
LateralDerivedTable =(str_p("LATERAL")) >> TableSubquery;;;
CollectionDerivedTable = ((str_p("UNNEST")) >> LeftParen >> CollectionValueExpression >> RightParen >> !(str_p("WITH")) >>(("ORDINALITY")));;;
TableFunctionDerivedTable =(str_p("TABLE")) >> LeftParen >> CollectionValueExpression >> RightParen;;;
DerivedTable = TableSubquery;;;
TableOrQueryName = TableName  | QueryName;;;
DerivedColumnList = ColumnNameList;;;
ColumnNameList = ((ColumnName%Comma));;;
JoinedTable = CrossJoin  | QualifiedJoin  | NaturalJoin  | UnionJoin;;;
CrossJoin = TableReference >>(("CROSS")) >>(("JOIN")) >> TablePrimary;;;
QualifiedJoin = (TableReference >> !JoinType >>(("JOIN")) >> TableReference >> JoinSpecification);;;
NaturalJoin = (TableReference >>(("NATURAL")) >> !JoinType >>(("JOIN")) >> TablePrimary);;;
UnionJoin = TableReference >>(("UNION")) >>(("JOIN")) >> TablePrimary;;;
JoinSpecification = JoinCondition  | NamedColumnsJoin;;;
JoinCondition =(str_p("ON")) >> SearchCondition;;;
NamedColumnsJoin =(str_p("USING")) >> LeftParen >> JoinColumnList >> RightParen;;;
JoinType =(str_p("INNER"))  | (OuterJoinType >> !(str_p("OUTER")));;;
OuterJoinType =(str_p("LEFT"))  |(("RIGHT"))  |(("FULL"));;;
JoinColumnList = ColumnNameList;;;
WhereClause =(str_p("WHERE")) >> SearchCondition;;;
GroupByClause = ((str_p("GROUP")) >>(("BY")) >> !SetQuantifier >> GroupingElementList);;;
GroupingElementList = ((GroupingElement%Comma));;;
GroupingElement = OrdinaryGroupingSet  | RollupList  | CubeList  | GroupingSetsSpecification  | EmptyGroupingSet;;;
OrdinaryGroupingSet = GroupingColumnReference  | LeftParen >> GroupingColumnReferenceList >> RightParen;;;
GroupingColumnReference = (ColumnReference >> !CollateClause);;;
GroupingColumnReferenceList = ((GroupingColumnReference%Comma));;;
RollupList =(str_p("ROLLUP")) >> LeftParen >> OrdinaryGroupingSetList >> RightParen;;;
OrdinaryGroupingSetList = ((OrdinaryGroupingSet%Comma));;;
CubeList =(str_p("CUBE")) >> LeftParen >> OrdinaryGroupingSetList >> RightParen;;;
GroupingSetsSpecification =(str_p("GROUPING")) >>(("SETS")) >> LeftParen >> GroupingSetList >> RightParen;;;
GroupingSetList = ((GroupingSet%Comma));;;
GroupingSet = OrdinaryGroupingSet  | RollupList  | CubeList  | GroupingSetsSpecification  | EmptyGroupingSet;;;
EmptyGroupingSet = LeftParen >> RightParen;;;
HavingClause =(str_p("HAVING")) >> SearchCondition;;;
WindowClause =(str_p("WINDOW")) >> WindowDefinitionList;;;
WindowDefinitionList = ((WindowDefinition%Comma));;;
WindowDefinition = NewWindowName >>(("AS")) >> WindowSpecification;;;
NewWindowName = WindowName;;;
WindowSpecification = LeftParen >> WindowSpecificationDetails >> RightParen;;;
WindowSpecificationDetails = !(ExistingWindowName >> !WindowPartitionClause >> !WindowOrderClause >> !WindowFrameClause);;;
ExistingWindowName = WindowName;;;
WindowPartitionClause =(str_p("PARTITION")) >>(("BY")) >> WindowPartitionColumnReferenceList;;;
WindowPartitionColumnReferenceList = ((WindowPartitionColumnReference%Comma));;;
WindowPartitionColumnReference = (ColumnReference >> !CollateClause);;;
WindowOrderClause =(str_p("ORDER")) >>(("BY")) >> SortSpecificationList;;;
WindowFrameClause = (WindowFrameUnits >> WindowFrameExtent >> !WindowFrameExclusion);;;
WindowFrameUnits =(str_p("ROWS"))  |(("RANGE"));;;
WindowFrameExtent = WindowFrameStart  | WindowFrameBetween;;;
WindowFrameStart =(str_p("UNBOUNDED")) >>(("PRECEDING"))  | WindowFramePreceding  |(("CURRENT")) >>(("ROW"));;;
WindowFramePreceding = UnsignedValueSpecification >>(("PRECEDING"));;;
WindowFrameBetween =(str_p("BETWEEN")) >> WindowFrameBound1 >>(("AND")) >> WindowFrameBound2;;;
WindowFrameBound1 = WindowFrameBound;;;
WindowFrameBound2 = WindowFrameBound;;;
WindowFrameBound = WindowFrameStart  |(("UNBOUNDED")) >>(("FOLLOWING"))  | WindowFrameFollowing;;;
WindowFrameFollowing = UnsignedValueSpecification >>(("FOLLOWING"));;;
WindowFrameExclusion =(str_p("EXCLUDE")) >>(("CURRENT")) >>(("ROW"))  |(("EXCLUDE")) >>(("GROUP"))  |(("EXCLUDE")) >>(("TIES"))  |(("EXCLUDE")) >>(("NO")) >>(("OTHERS"));;;
QuerySpecification = ((str_p("SELECT")) >> !SetQuantifier >> SelectList >> TableExpression);;;
SelectList = Asterisk  | ((SelectSublist%Comma));;;
SelectSublist = DerivedColumn  | QualifiedAsterisk;;;
QualifiedAsterisk = AsteriskedIdentifierChain >> Period >> Asterisk  | AllFieldsReference;;;
AsteriskedIdentifierChain = ((AsteriskedIdentifier%Period));;;
AsteriskedIdentifier = Identifier;;;
DerivedColumn = (ValueExpression >> !AsClause);;;
AsClause = !((str_p("AS")) >> ColumnName);;;
AllFieldsReference = (ValueExpressionPrimary >> Period >> Asterisk >> !(str_p("AS")) >> LeftParen >> AllFieldsColumnNameList >> RightParen);;;
AllFieldsColumnNameList = ColumnNameList;;;
QueryExpression = !(WithClause >> QueryExpressionBody);;;
WithClause = ((str_p("WITH")) >> !(str_p("RECURSIVE")) >> WithList);;;
WithList = ((WithListElement%Comma));;;
WithListElement = (QueryName >> !LeftParen >> WithColumnList >> RightParen >>(("AS")) >> LeftParen >> QueryExpression >> RightParen >> !SearchOrCycleClause);;;
WithColumnList = ColumnNameList;;;
QueryExpressionBody = NonJoinQueryExpression  | JoinedTable;;;
NonJoinQueryExpression = NonJoinQueryTerm  | (QueryExpressionBody >>(("UNION")) >> !(str_p("ALL"))  |(("DISTINCT")) >> !CorrespondingSpec >> QueryTerm)  | (QueryExpressionBody >>(("EXCEPT")) >> !(str_p("ALL"))  |(("DISTINCT")) >> !CorrespondingSpec >> QueryTerm);;;
QueryTerm = NonJoinQueryTerm  | JoinedTable;;;
NonJoinQueryTerm = NonJoinQueryPrimary  | (QueryTerm >>(("INTERSECT")) >> !(str_p("ALL"))  |(("DISTINCT")) >> !CorrespondingSpec >> QueryPrimary);;;
QueryPrimary = NonJoinQueryPrimary  | JoinedTable;;;
NonJoinQueryPrimary = SimpleTable  | LeftParen >> NonJoinQueryExpression >> RightParen;;;
SimpleTable = QuerySpecification  | TableValueConstructor  | ExplicitTable;;;
ExplicitTable =(str_p("TABLE")) >> TableOrQueryName;;;
CorrespondingSpec = ((str_p("CORRESPONDING")) >> !(str_p("BY")) >> LeftParen >> CorrespondingColumnList >> RightParen);;;
CorrespondingColumnList = ColumnNameList;;;
SearchOrCycleClause = SearchClause  | CycleClause  | SearchClause >> CycleClause;;;
SearchClause =(str_p("SEARCH")) >> RecursiveSearchOrder >>(("SET")) >> SequenceColumn;;;
RecursiveSearchOrder =(str_p("DEPTH")) >>(("FIRST")) >>(("BY")) >> SortSpecificationList  |(("BREADTH")) >>(("FIRST")) >>(("BY")) >> SortSpecificationList;;;
SequenceColumn = ColumnName;;;
CycleClause =(str_p("CYCLE")) >> CycleColumnList >>(("SET")) >> CycleMarkColumn >>(("TO")) >> CycleMarkValue >>(("DEFAULT")) >> NonCycleMarkValue >>(("USING")) >> PathColumn;;;
CycleColumnList = ((CycleColumn%Comma));;;
CycleColumn = ColumnName;;;
CycleMarkColumn = ColumnName;;;
PathColumn = ColumnName;;;
CycleMarkValue = ValueExpression;;;
NonCycleMarkValue = ValueExpression;;;
ScalarSubquery = Subquery;;;
RowSubquery = Subquery;;;
TableSubquery = Subquery;;;
Subquery = LeftParen >> QueryExpression >> RightParen;;;
Predicate = ComparisonPredicate  | BetweenPredicate  | InPredicate  | LikePredicate  | SimilarPredicate  | NullPredicate  | QuantifiedComparisonPredicate  | ExistsPredicate  | UniquePredicate  | NormalizedPredicate  | MatchPredicate  | OverlapsPredicate  | DistinctPredicate  | MemberPredicate  | SubmultisetPredicate  | SetPredicate  | TypePredicate;;;
ComparisonPredicate = RowValuePredicand >> ComparisonPredicatePart2;;;
ComparisonPredicatePart2 = CompOp >> RowValuePredicand;;;
CompOp = EqualsOperator  | NotEqualsOperator  | LessThanOperator  | GreaterThanOperator  | LessThanOrEqualsOperator  | GreaterThanOrEqualsOperator;;;
BetweenPredicate = RowValuePredicand >> BetweenPredicatePart2;;;
BetweenPredicatePart2 = !((str_p("NOT")) >>(("BETWEEN")) >> !(str_p("ASYMMETRIC"))  |(("SYMMETRIC")) >> RowValuePredicand >>(("AND")) >> RowValuePredicand);;;
InPredicate = RowValuePredicand >> InPredicatePart2;;;
InPredicatePart2 = !((str_p("NOT")) >>(("IN")) >> InPredicateValue);;;
InPredicateValue = TableSubquery  | LeftParen >> InValueList >> RightParen;;;
InValueList = ((RowValueExpression%Comma));;;
LikePredicate = CharacterLikePredicate  | OctetLikePredicate;;;
CharacterLikePredicate = RowValuePredicand >> CharacterLikePredicatePart2;;;
CharacterLikePredicatePart2 = !((str_p("NOT")) >>(("LIKE")) >> CharacterPattern >> !(str_p("ESCAPE")) >> EscapeCharacter);;;
CharacterPattern = CharacterValueExpression;;;
EscapeCharacter = CharacterValueExpression;;;
OctetLikePredicate = RowValuePredicand >> OctetLikePredicatePart2;;;
OctetLikePredicatePart2 = !((str_p("NOT")) >>(("LIKE")) >> OctetPattern >> !(str_p("ESCAPE")) >> EscapeOctet);;;
OctetPattern = BlobValueExpression;;;
EscapeOctet = BlobValueExpression;;;
SimilarPredicate = RowValuePredicand >> SimilarPredicatePart2;;;
SimilarPredicatePart2 = !((str_p("NOT")) >>(("SIMILAR")) >>(("TO")) >> SimilarPattern >> !(str_p("ESCAPE")) >> EscapeCharacter);;;
SimilarPattern = CharacterValueExpression;;;
RegularExpression = RegularTerm  | RegularExpression >> VerticalBar >> RegularTerm;;;
RegularTerm = RegularFactor  | RegularTerm >> RegularFactor;;;
RegularFactor = RegularPrimary  | RegularPrimary >> Asterisk  | RegularPrimary >> PlusSign  | RegularPrimary >> QuestionMark  | RegularPrimary >> RepeatFactor;;;
RepeatFactor = (LeftBrace >> LowValue >> !UpperLimit >> RightBrace);;;
UpperLimit = (Comma >> !HighValue);;;
LowValue = UnsignedInteger;;;
HighValue = UnsignedInteger;;;
RegularPrimary = CharacterSpecifier  | Percent  | RegularCharacterSet  | LeftParen >> RegularExpression >> RightParen;;;
CharacterSpecifier = NonEscapedCharacter  | EscapedCharacter;;;
NonEscapedCharacter = !!See >> The >> Syntax >> Rules;;;
EscapedCharacter = !!See >> The >> Syntax >> Rules;;;
RegularCharacterSet = Underscore  | (LeftBracket >> +CharacterEnumeration >> RightBracket)  | (LeftBracket >> Circumflex >> +CharacterEnumeration >> RightBracket)  | (LeftBracket >> +CharacterEnumerationInclude >> Circumflex >> +CharacterEnumerationExclude >> RightBracket);;;
CharacterEnumerationInclude = CharacterEnumeration;;;
CharacterEnumerationExclude = CharacterEnumeration;;;
CharacterEnumeration = CharacterSpecifier  | CharacterSpecifier >> MinusSign >> CharacterSpecifier  | LeftBracket >> Colon >> RegularCharacterSetIdentifier >> Colon >> RightBracket;;;
RegularCharacterSetIdentifier = Identifier;;;
NullPredicate = RowValuePredicand >> NullPredicatePart2;;;
NullPredicatePart2 = ((str_p("IS")) >> !(str_p("NOT")) >>(("NULL")));;;
QuantifiedComparisonPredicate = RowValuePredicand >> QuantifiedComparisonPredicatePart2;;;
QuantifiedComparisonPredicatePart2 = CompOp >> Quantifier >> TableSubquery;;;
Quantifier = All  | Some;;;
All =(str_p("ALL"));;;
Some =(str_p("SOME"))  |(("ANY"));;;
ExistsPredicate =(str_p("EXISTS")) >> TableSubquery;;;
UniquePredicate =(str_p("UNIQUE")) >> TableSubquery;;;
NormalizedPredicate = (StringValueExpression >>(("IS")) >> !(str_p("NOT")) >>(("NORMALIZED")));;;
MatchPredicate = RowValuePredicand >> MatchPredicatePart2;;;
MatchPredicatePart2 = ((str_p("MATCH")) >> !(str_p("UNIQUE")) >> !(str_p("SIMPLE"))  |(("PARTIAL"))  |(("FULL")) >> TableSubquery);;;
OverlapsPredicate = OverlapsPredicatePart1 >> OverlapsPredicatePart2;;;
OverlapsPredicatePart1 = RowValuePredicand1;;;
OverlapsPredicatePart2 =(str_p("OVERLAPS")) >> RowValuePredicand2;;;
RowValuePredicand1 = RowValuePredicand;;;
RowValuePredicand2 = RowValuePredicand;;;
DistinctPredicate = RowValuePredicand3 >> DistinctPredicatePart2;;;
DistinctPredicatePart2 =(str_p("IS")) >>(("DISTINCT")) >>(("FROM")) >> RowValuePredicand4;;;
RowValuePredicand3 = RowValuePredicand;;;
RowValuePredicand4 = RowValuePredicand;;;
MemberPredicate = RowValuePredicand >> MemberPredicatePart2;;;
MemberPredicatePart2 = !((str_p("NOT")) >>(("MEMBER")) >> !(str_p("OF")) >> MultisetValueExpression);;;
SubmultisetPredicate = RowValuePredicand >> SubmultisetPredicatePart2;;;
SubmultisetPredicatePart2 = !((str_p("NOT")) >>(("SUBMULTISET")) >> !(str_p("OF")) >> MultisetValueExpression);;;
SetPredicate = RowValuePredicand >> SetPredicatePart2;;;
SetPredicatePart2 = ((str_p("IS")) >> !(str_p("NOT")) >> A >>(("SET")));;;
TypePredicate = RowValuePredicand >> TypePredicatePart2;;;
TypePredicatePart2 = ((str_p("IS")) >> !(str_p("NOT")) >>(("OF")) >> LeftParen >> TypeList >> RightParen);;;
TypeList = ((UserDefinedTypeSpecification%Comma));;;
UserDefinedTypeSpecification = InclusiveUserDefinedTypeSpecification  | ExclusiveUserDefinedTypeSpecification;;;
InclusiveUserDefinedTypeSpecification = PathResolvedUserDefinedTypeName;;;
ExclusiveUserDefinedTypeSpecification =(str_p("ONLY")) >> PathResolvedUserDefinedTypeName;;;
SearchCondition = BooleanValueExpression;;;
IntervalQualifier = StartField >>(("TO")) >> EndField  | SingleDatetimeField;;;
StartField = (NonSecondPrimaryDatetimeField >> !LeftParen >> IntervalLeadingFieldPrecision >> RightParen);;;
EndField = NonSecondPrimaryDatetimeField  | ((str_p("SECOND")) >> !LeftParen >> IntervalFractionalSecondsPrecision >> RightParen);;;
SingleDatetimeField = (NonSecondPrimaryDatetimeField >> !LeftParen >> IntervalLeadingFieldPrecision >> RightParen)  | ((str_p("SECOND")) >> !(LeftParen >> IntervalLeadingFieldPrecision >> !Comma >> IntervalFractionalSecondsPrecision >> RightParen));;;
PrimaryDatetimeField = NonSecondPrimaryDatetimeField  |(("SECOND"));;;
NonSecondPrimaryDatetimeField =(str_p("YEAR"))  |(("MONTH"))  |(("DAY"))  |(("HOUR"))  |(("MINUTE"));;;
IntervalFractionalSecondsPrecision = UnsignedInteger;;;
IntervalLeadingFieldPrecision = UnsignedInteger;;;
LanguageClause =(str_p("LANGUAGE")) >> LanguageName;;;
LanguageName =(str_p("ADA"))  |('C')  |(("COBOL"))  |(("FORTRAN"))  |(("MUMPS"))  |(("PASCAL"))  |(("PLI"))  |(("SQL"));;;
PathSpecification =(str_p("PATH")) >> SchemaNameList;;;
SchemaNameList = ((SchemaName%Comma));;;
RoutineInvocation = RoutineName >> SQLArgumentList;;;
RoutineName = !(SchemaName >> Period >> QualifiedIdentifier);;;
SQLArgumentList = (LeftParen >> !((SQLArgument%Comma)) >> RightParen);;;
SQLArgument = ValueExpression  | GeneralizedExpression  | TargetSpecification;;;
GeneralizedExpression = ValueExpression >>(("AS")) >> PathResolvedUserDefinedTypeName;;;
CharacterSetSpecification = StandardCharacterSetName  | ImplementationDefinedCharacterSetName  | UserDefinedCharacterSetName;;;
StandardCharacterSetName = CharacterSetName;;;
ImplementationDefinedCharacterSetName = CharacterSetName;;;
UserDefinedCharacterSetName = CharacterSetName;;;
SpecificRoutineDesignator =(str_p("SPECIFIC")) >> RoutineType >> SpecificName  | (RoutineType >> MemberName >> !(str_p("FOR")) >> SchemaResolvedUserDefinedTypeName);;;
RoutineType =(str_p("ROUTINE"))  |(("FUNCTION"))  |(("PROCEDURE"))  | !((str_p("INSTANCE"))  |(("STATIC"))  | CONSTRUCTOR >>(("METHOD")));;;
MemberName = (MemberNameAlternatives >> !DataTypeList);;;
MemberNameAlternatives = SchemaQualifiedRoutineName  | MethodName;;;
DataTypeList = (LeftParen >> !((DataType%Comma)) >> RightParen);;;
CollateClause =(str_p("COLLATE")) >> CollationName;;;
ConstraintNameDefinition =(str_p("CONSTRAINT")) >> ConstraintName;;;
ConstraintCharacteristics = (ConstraintCheckTime >> !!((str_p("NOT")) >>(("DEFERRABLE"))))  | !((str_p("NOT")) >>(("DEFERRABLE")) >> !ConstraintCheckTime);;;
ConstraintCheckTime =(str_p("INITIALLY")) >>(("DEFERRED"))  |(("INITIALLY")) >>(("IMMEDIATE"));;;
AggregateFunction = ((str_p("COUNT")) >> LeftParen >> Asterisk >> RightParen >> !FilterClause)  | (GeneralSetFunction >> !FilterClause)  | (BinarySetFunction >> !FilterClause)  | (OrderedSetFunction >> !FilterClause);;;
GeneralSetFunction = (SetFunctionType >> LeftParen >> !SetQuantifier >> ValueExpression >> RightParen);;;
SetFunctionType = ComputationalOperation;;;
ComputationalOperation =(str_p("AVG"))  |(("MAX"))  |(("MIN"))  |(("SUM"))  |(("EVERY"))  |(("ANY"))  |(("SOME"))  |(("COUNT"))  |(("STDDEV_POP"))  |(("STDDEV_SAMP"))  |(("VAR_SAMP"))  |(("VAR_POP"))  |(("COLLECT"))  |(("FUSION"))  |(("INTERSECTION"));;;
SetQuantifier =(str_p("DISTINCT"))  |(("ALL"));;;
FilterClause =(str_p("FILTER")) >> LeftParen >>(("WHERE")) >> SearchCondition >> RightParen;;;
BinarySetFunction = BinarySetFunctionType >> LeftParen >> DependentVariableExpression >> Comma >> IndependentVariableExpression >> RightParen;;;
BinarySetFunctionType =(str_p("COVAR_POP"))  |(("COVAR_SAMP"))  |(("CORR"))  |(("REGR_SLOPE"))  |(("REGR_INTERCEPT"))  |(("REGR_COUNT"))  |(("REGR_R2"))  |(("REGR_AVGX"))  |(("REGR_AVGY"))  |(("REGR_SXX"))  | REGR_SYY  |(("REGR_SXY"));;;
DependentVariableExpression = NumericValueExpression;;;
IndependentVariableExpression = NumericValueExpression;;;
OrderedSetFunction = HypotheticalSetFunction  | InverseDistributionFunction;;;
HypotheticalSetFunction = RankFunctionType >> LeftParen >> HypotheticalSetFunctionValueExpressionList >> RightParen >> WithinGroupSpecification;;;
WithinGroupSpecification =(str_p("WITHIN")) >>(("GROUP")) >> LeftParen >>(("ORDER")) >>(("BY")) >> SortSpecificationList >> RightParen;;;
HypotheticalSetFunctionValueExpressionList = ((ValueExpression%Comma));;;
InverseDistributionFunction = InverseDistributionFunctionType >> LeftParen >> InverseDistributionFunctionArgument >> RightParen >> WithinGroupSpecification;;;
InverseDistributionFunctionArgument = NumericValueExpression;;;
InverseDistributionFunctionType =(str_p("PERCENTILE_CONT"))  |(("PERCENTILE_DISC"));;;
SortSpecificationList = ((SortSpecification%Comma));;;
SortSpecification = (SortKey >> !OrderingSpecification >> !NullOrdering);;;
SortKey = ValueExpression;;;
OrderingSpecification =(str_p("ASC"))  |(("DESC"));;;
NullOrdering =(str_p("NULLS")) >>(("FIRST"))  |(("NULLS")) >>(("LAST"));;;
SchemaDefinition = ((str_p("CREATE")) >>(("SCHEMA")) >> SchemaNameClause >> !SchemaCharacterSetOrPath >> *SchemaElement);;;
SchemaCharacterSetOrPath = SchemaCharacterSetSpecification  | SchemaPathSpecification  | SchemaCharacterSetSpecification >> SchemaPathSpecification  | SchemaPathSpecification >> SchemaCharacterSetSpecification;;;
SchemaNameClause = SchemaName  |(("AUTHORIZATION")) >> SchemaAuthorizationIdentifier  | SchemaName >>(("AUTHORIZATION")) >> SchemaAuthorizationIdentifier;;;
SchemaAuthorizationIdentifier = AuthorizationIdentifier;;;
SchemaCharacterSetSpecification =(str_p("DEFAULT")) >>(("CHARACTER")) >>(("SET")) >> CharacterSetSpecification;;;
SchemaPathSpecification = PathSpecification;;;
SchemaElement = TableDefinition  | ViewDefinition  | DomainDefinition  | CharacterSetDefinition  | CollationDefinition  | TransliterationDefinition  | AssertionDefinition  | TriggerDefinition  | UserDefinedTypeDefinition  | UserDefinedCastDefinition  | UserDefinedOrderingDefinition  | TransformDefinition  | SchemaRoutine  | SequenceGeneratorDefinition  | GrantStatement  | RoleDefinition;;;
DropSchemaStatement =(str_p("DROP")) >>(("SCHEMA")) >> SchemaName >> DropBehavior;;;
DropBehavior =(str_p("CASCADE"))  | RESTRICT;;;
TableDefinition = ((str_p("CREATE")) >> !TableScope >>(("TABLE")) >> TableName >> TableContentsSource >> !(str_p("ON")) >>(("COMMIT")) >> TableCommitAction >>(("ROWS")));;;
TableContentsSource = TableElementList  | ((str_p("OF")) >> PathResolvedUserDefinedTypeName >> !SubtableClause >> !TableElementList)  | AsSubqueryClause;;;
TableScope = GlobalOrLocal >>(("TEMPORARY"));;;
GlobalOrLocal =(str_p("GLOBAL"))  |(("LOCAL"));;;
TableCommitAction =(str_p("PRESERVE"))  |(("DELETE"));;;
TableElementList = (LeftParen >> (TableElement%Comma) >> RightParen);;;
TableElement = ColumnDefinition  | TableConstraintDefinition  | LikeClause  | SelfReferencingColumnSpecification  | ColumnOptions;;;
SelfReferencingColumnSpecification =(str_p("REF")) >>(("IS")) >> SelfReferencingColumnName >> ReferenceGeneration;;;
ReferenceGeneration =(str_p("SYSTEM")) >> GENERATED  |(("USER")) >> GENERATED  |(("DERIVED"));;;
SelfReferencingColumnName = ColumnName;;;
ColumnOptions = ColumnName >>(("WITH")) >>(("OPTIONS")) >> ColumnOptionList;;;
ColumnOptionList = !(ScopeClause >> !DefaultClause >> *ColumnConstraintDefinition);;;
SubtableClause =(str_p("UNDER")) >> SupertableClause;;;
SupertableClause = SupertableName;;;
SupertableName = TableName;;;
LikeClause = ((str_p("LIKE")) >> TableName >> !LikeOptions);;;
LikeOptions = IdentityOption  | ColumnDefaultOption;;;
IdentityOption =(str_p("INCLUDING")) >>(("IDENTITY"))  |(("EXCLUDING")) >>(("IDENTITY"));;;
ColumnDefaultOption =(str_p("INCLUDING")) >>(("DEFAULTS"))  |(("EXCLUDING")) >>(("DEFAULTS"));;;
AsSubqueryClause = !(LeftParen >> ColumnNameList >> RightParen >>(("AS")) >> Subquery >> WithOrWithoutData);;;
WithOrWithoutData =(str_p("WITH")) >>(("NO")) >>(("DATA"))  |(("WITH")) >>(("DATA"));;;
ColumnDefinition = (ColumnName >> !DataType  | DomainName >> !ReferenceScopeCheck >> !DefaultClause  | IdentityColumnSpecification  | GenerationClause >> *ColumnConstraintDefinition >> !CollateClause);;;
ColumnConstraintDefinition = !(ConstraintNameDefinition >> ColumnConstraint >> !ConstraintCharacteristics);;;
ColumnConstraint =(str_p("NOT")) >>(("NULL"))  | UniqueSpecification  | ReferencesSpecification  | CheckConstraintDefinition;;;
ReferenceScopeCheck = ((str_p("REFERENCES")) >>(("ARE")) >> !(str_p("NOT")) >>(("CHECKED")) >> !(str_p("ON")) >>(("DELETE")) >> ReferenceScopeCheckAction);;;
ReferenceScopeCheckAction = ReferentialAction;;;
IdentityColumnSpecification = (GENERATED >>(("ALWAYS"))  |(("BY")) >>(("DEFAULT")) >>(("AS")) >>(("IDENTITY")) >> !LeftParen >> CommonSequenceGeneratorOptions >> RightParen);;;
GenerationClause = GenerationRule >>(("AS")) >> GenerationExpression;;;
GenerationRule = GENERATED >>(("ALWAYS"));;;
GenerationExpression = LeftParen >> ValueExpression >> RightParen;;;
DefaultClause =(str_p("DEFAULT")) >> DefaultOption;;;
DefaultOption = Literal  | DatetimeValueFunction  |(("USER"))  |(("CURRENT_USER"))  |(("CURRENT_ROLE"))  |(("SESSION_USER"))  |(("SYSTEM_USER"))  |(("CURRENT_PATH"))  | ImplicitlyTypedValueSpecification;;;
TableConstraintDefinition = !(ConstraintNameDefinition >> TableConstraint >> !ConstraintCharacteristics);;;
TableConstraint = UniqueConstraintDefinition  | ReferentialConstraintDefinition  | CheckConstraintDefinition;;;
UniqueConstraintDefinition = UniqueSpecification >> LeftParen >> UniqueColumnList >> RightParen  | ((str_p("UNIQUE")) >>(("VALUE")));;;
UniqueSpecification =(str_p("UNIQUE"))  |(("PRIMARY")) >>(("KEY"));;;
UniqueColumnList = ColumnNameList;;;
ReferentialConstraintDefinition =(str_p("FOREIGN")) >>(("KEY")) >> LeftParen >> ReferencingColumns >> RightParen >> ReferencesSpecification;;;
ReferencesSpecification = ((str_p("REFERENCES")) >> ReferencedTableAndColumns >> !(str_p("MATCH")) >> MatchType >> !ReferentialTriggeredAction);;;
MatchType =(str_p("FULL"))  |(("PARTIAL"))  |(("SIMPLE"));;;
ReferencingColumns = ReferenceColumnList;;;
ReferencedTableAndColumns = (TableName >> !LeftParen >> ReferenceColumnList >> RightParen);;;
ReferenceColumnList = ColumnNameList;;;
ReferentialTriggeredAction = (UpdateRule >> !DeleteRule)  | (DeleteRule >> !UpdateRule);;;
UpdateRule =(str_p("ON")) >>(("UPDATE")) >> ReferentialAction;;;
DeleteRule =(str_p("ON")) >>(("DELETE")) >> ReferentialAction;;;
ReferentialAction =(str_p("CASCADE"))  |(("SET")) >>(("NULL"))  |(("SET")) >>(("DEFAULT"))  | RESTRICT  |(("NO")) >>(("ACTION"));;;
CheckConstraintDefinition =(str_p("CHECK")) >> LeftParen >> SearchCondition >> RightParen;;;
AlterTableStatement =(str_p("ALTER")) >>(("TABLE")) >> TableName >> AlterTableAction;;;
AlterTableAction = AddColumnDefinition  | AlterColumnDefinition  | DropColumnDefinition  | AddTableConstraintDefinition  | DropTableConstraintDefinition;;;
AddColumnDefinition = ((str_p("ADD")) >> !(str_p("COLUMN")) >> ColumnDefinition);;;
AlterColumnDefinition = ((str_p("ALTER")) >> !(str_p("COLUMN")) >> ColumnName >> AlterColumnAction);;;
AlterColumnAction = SetColumnDefaultClause  | DropColumnDefaultClause  | AddColumnScopeClause  | DropColumnScopeClause  | AlterIdentityColumnSpecification;;;
SetColumnDefaultClause =(str_p("SET")) >> DefaultClause;;;
DropColumnDefaultClause =(str_p("DROP")) >>(("DEFAULT"));;;
AddColumnScopeClause =(str_p("ADD")) >> ScopeClause;;;
DropColumnScopeClause =(str_p("DROP")) >> SCOPE >> DropBehavior;;;
AlterIdentityColumnSpecification = +AlterIdentityColumnOption;;;
AlterIdentityColumnOption = AlterSequenceGeneratorRestartOption  |(("SET")) >> BasicSequenceGeneratorOption;;;
DropColumnDefinition = ((str_p("DROP")) >> !(str_p("COLUMN")) >> ColumnName >> DropBehavior);;;
AddTableConstraintDefinition =(str_p("ADD")) >> TableConstraintDefinition;;;
DropTableConstraintDefinition =(str_p("DROP")) >>(("CONSTRAINT")) >> ConstraintName >> DropBehavior;;;
DropTableStatement =(str_p("DROP")) >>(("TABLE")) >> TableName >> DropBehavior;;;
ViewDefinition = ((str_p("CREATE")) >> !(str_p("RECURSIVE")) >>(("VIEW")) >> TableName >> ViewSpecification >>(("AS")) >> QueryExpression >> !((str_p("WITH")) >> !LevelsClause >>(("CHECK")) >>(("OPTION"))));;;
ViewSpecification = RegularViewSpecification  | ReferenceableViewSpecification;;;
RegularViewSpecification = !(LeftParen >> ViewColumnList >> RightParen);;;
ReferenceableViewSpecification = ((str_p("OF")) >> PathResolvedUserDefinedTypeName >> !SubviewClause >> !ViewElementList);;;
SubviewClause =(str_p("UNDER")) >> TableName;;;
ViewElementList = (LeftParen >> (ViewElement%Comma) >> RightParen);;;
ViewElement = SelfReferencingColumnSpecification  | ViewColumnOption;;;
ViewColumnOption = ColumnName >>(("WITH")) >>(("OPTIONS")) >> ScopeClause;;;
LevelsClause =(str_p("CASCADED"))  |(("LOCAL"));;;
ViewColumnList = ColumnNameList;;;
DropViewStatement =(str_p("DROP")) >>(("VIEW")) >> TableName >> DropBehavior;;;
DomainDefinition = ((str_p("CREATE")) >>(("DOMAIN")) >> DomainName >> !(str_p("AS")) >> DataType >> !DefaultClause >> *DomainConstraint >> !CollateClause);;;
DomainConstraint = !(ConstraintNameDefinition >> CheckConstraintDefinition >> !ConstraintCharacteristics);;;
AlterDomainStatement =(str_p("ALTER")) >>(("DOMAIN")) >> DomainName >> AlterDomainAction;;;
AlterDomainAction = SetDomainDefaultClause  | DropDomainDefaultClause  | AddDomainConstraintDefinition  | DropDomainConstraintDefinition;;;
SetDomainDefaultClause =(str_p("SET")) >> DefaultClause;;;
DropDomainDefaultClause =(str_p("DROP")) >>(("DEFAULT"));;;
AddDomainConstraintDefinition =(str_p("ADD")) >> DomainConstraint;;;
DropDomainConstraintDefinition =(str_p("DROP")) >>(("CONSTRAINT")) >> ConstraintName;;;
DropDomainStatement =(str_p("DROP")) >>(("DOMAIN")) >> DomainName >> DropBehavior;;;
CharacterSetDefinition = ((str_p("CREATE")) >>(("CHARACTER")) >>(("SET")) >> CharacterSetName >> !(str_p("AS")) >> CharacterSetSource >> !CollateClause);;;
CharacterSetSource =(str_p("GET")) >> CharacterSetSpecification;;;
DropCharacterSetStatement =(str_p("DROP")) >>(("CHARACTER")) >>(("SET")) >> CharacterSetName;;;
CollationDefinition = ((str_p("CREATE")) >>(("COLLATION")) >> CollationName >>(("FOR")) >> CharacterSetSpecification >>(("FROM")) >> ExistingCollationName >> !PadCharacteristic);;;
ExistingCollationName = CollationName;;;
PadCharacteristic =(str_p("NO")) >>(("PAD"))  |(("PAD")) >>(("SPACE"));;;
DropCollationStatement =(str_p("DROP")) >>(("COLLATION")) >> CollationName >> DropBehavior;;;
TransliterationDefinition =(str_p("CREATE")) >>(("TRANSLATION")) >> TransliterationName >>(("FOR")) >> SourceCharacterSetSpecification >>(("TO")) >> TargetCharacterSetSpecification >>(("FROM")) >> TransliterationSource;;;
SourceCharacterSetSpecification = CharacterSetSpecification;;;
TargetCharacterSetSpecification = CharacterSetSpecification;;;
TransliterationSource = ExistingTransliterationName  | TransliterationRoutine;;;
ExistingTransliterationName = TransliterationName;;;
TransliterationRoutine = SpecificRoutineDesignator;;;
DropTransliterationStatement =(str_p("DROP")) >>(("TRANSLATION")) >> TransliterationName;;;
AssertionDefinition = ((str_p("CREATE")) >>(("ASSERTION")) >> ConstraintName >>(("CHECK")) >> LeftParen >> SearchCondition >> RightParen >> !ConstraintCharacteristics);;;
DropAssertionStatement =(str_p("DROP")) >>(("ASSERTION")) >> ConstraintName;;;
TriggerDefinition = ((str_p("CREATE")) >>(("TRIGGER")) >> TriggerName >> TriggerActionTime >> TriggerEvent >>(("ON")) >> TableName >> !(str_p("REFERENCING")) >> OldOrNewValuesAliasList >> TriggeredAction);;;
TriggerActionTime =(str_p("BEFORE"))  |(("AFTER"));;;
TriggerEvent =(str_p("INSERT"))  |(("DELETE"))  | ((str_p("UPDATE")) >> !(str_p("OF")) >> TriggerColumnList);;;
TriggerColumnList = ColumnNameList;;;
TriggeredAction = !(((str_p("FOR")) >>(("EACH")) >>(("ROW"))  |(("STATEMENT"))) >> !(str_p("WHEN")) >> LeftParen >> SearchCondition >> RightParen >> TriggeredSQLStatement);;;
TriggeredSQLStatement = SQLProcedureStatement  | ((str_p("BEGIN")) >>(("ATOMIC")) >> +SQLProcedureStatement >> Semicolon >>(("END")));;;
OldOrNewValuesAliasList = +OldOrNewValuesAlias;;;
OldOrNewValuesAlias = ((str_p("OLD")) >> !(str_p("ROW")) >> !(str_p("AS")) >> OldValuesCorrelationName)  | ((str_p("NEW")) >> !(str_p("ROW")) >> !(str_p("AS")) >> NewValuesCorrelationName)  | ((str_p("OLD")) >>(("TABLE")) >> !(str_p("AS")) >> OldValuesTableAlias)  | ((str_p("NEW")) >>(("TABLE")) >> !(str_p("AS")) >> NewValuesTableAlias);;;
OldValuesTableAlias = Identifier;;;
NewValuesTableAlias = Identifier;;;
OldValuesCorrelationName = CorrelationName;;;
NewValuesCorrelationName = CorrelationName;;;
DropTriggerStatement =(str_p("DROP")) >>(("TRIGGER")) >> TriggerName;;;
UserDefinedTypeDefinition =(str_p("CREATE")) >>(("TYPE")) >> UserDefinedTypeBody;;;
UserDefinedTypeBody = (SchemaResolvedUserDefinedTypeName >> !SubtypeClause >> !(str_p("AS")) >> Representation >> !UserDefinedTypeOptionList >> !MethodSpecificationList);;;
UserDefinedTypeOptionList = (UserDefinedTypeOption >> *UserDefinedTypeOption);;;
UserDefinedTypeOption = InstantiableClause  | Finality  | ReferenceTypeSpecification  | RefCastOption  | CastOption;;;
SubtypeClause =(str_p("UNDER")) >> SupertypeName;;;
SupertypeName = PathResolvedUserDefinedTypeName;;;
Representation = PredefinedType  | MemberList;;;
MemberList = (LeftParen >> (Member%Comma) >> RightParen);;;
Member = AttributeDefinition;;;
InstantiableClause =(str_p("INSTANTIABLE"))  |(("NOT")) >>(("INSTANTIABLE"));;;
Finality =(str_p("FINAL"))  |(("NOT")) >>(("FINAL"));;;
ReferenceTypeSpecification = UserDefinedRepresentation  | DerivedRepresentation  | SystemGeneratedRepresentation;;;
UserDefinedRepresentation =(str_p("REF")) >>(("USING")) >> PredefinedType;;;
DerivedRepresentation =(str_p("REF")) >>(("FROM")) >> ListOfAttributes;;;
SystemGeneratedRepresentation =(str_p("REF")) >>(("IS")) >>(("SYSTEM")) >> GENERATED;;;
RefCastOption = !(CastToRef >> !CastToType);;;
CastToRef =(str_p("CAST")) >> LeftParen >>(("SOURCE")) >>(("AS")) >>(("REF")) >> RightParen >>(("WITH")) >> CastToRefIdentifier;;;
CastToRefIdentifier = Identifier;;;
CastToType =(str_p("CAST")) >> LeftParen >>(("REF")) >>(("AS")) >>(("SOURCE")) >> RightParen >>(("WITH")) >> CastToTypeIdentifier;;;
CastToTypeIdentifier = Identifier;;;
ListOfAttributes = (LeftParen >> (AttributeName%Comma) >> RightParen);;;
CastOption = !(CastToDistinct >> !CastToSource);;;
CastToDistinct =(str_p("CAST")) >> LeftParen >>(("SOURCE")) >>(("AS")) >>(("DISTINCT")) >> RightParen >>(("WITH")) >> CastToDistinctIdentifier;;;
CastToDistinctIdentifier = Identifier;;;
CastToSource =(str_p("CAST")) >> LeftParen >>(("DISTINCT")) >>(("AS")) >>(("SOURCE")) >> RightParen >>(("WITH")) >> CastToSourceIdentifier;;;
CastToSourceIdentifier = Identifier;;;
MethodSpecificationList = ((MethodSpecification%Comma));;;
MethodSpecification = OriginalMethodSpecification  | OverridingMethodSpecification;;;
OriginalMethodSpecification = (PartialMethodSpecification >> !(str_p("SELF")) >>(("AS")) >>(("RESULT")) >> !(str_p("SELF")) >>(("AS")) >>(("LOCATOR")) >> !MethodCharacteristics);;;
OverridingMethodSpecification =(str_p("OVERRIDING")) >> PartialMethodSpecification;;;
PartialMethodSpecification = !((str_p("INSTANCE"))  |(("STATIC"))  | CONSTRUCTOR >>(("METHOD")) >> MethodName >> SQLParameterDeclarationList >> ReturnsClause >> !(str_p("SPECIFIC")) >> SpecificMethodName);;;
SpecificMethodName = !(SchemaName >> Period >> QualifiedIdentifier);;;
MethodCharacteristics = +MethodCharacteristic;;;
MethodCharacteristic = LanguageClause  | ParameterStyleClause  | DeterministicCharacteristic  | SQLDataAccessIndication  | NullCallClause;;;
AttributeDefinition = (AttributeName >> DataType >> !ReferenceScopeCheck >> !AttributeDefault >> !CollateClause);;;
AttributeDefault = DefaultClause;;;
AlterTypeStatement =(str_p("ALTER")) >>(("TYPE")) >> SchemaResolvedUserDefinedTypeName >> AlterTypeAction;;;
AlterTypeAction = AddAttributeDefinition  | DropAttributeDefinition  | AddOriginalMethodSpecification  | AddOverridingMethodSpecification  | DropMethodSpecification;;;
AddAttributeDefinition =(str_p("ADD")) >>(("ATTRIBUTE")) >> AttributeDefinition;;;
DropAttributeDefinition =(str_p("DROP")) >>(("ATTRIBUTE")) >> AttributeName >> RESTRICT;;;
AddOriginalMethodSpecification =(str_p("ADD")) >> OriginalMethodSpecification;;;
AddOverridingMethodSpecification =(str_p("ADD")) >> OverridingMethodSpecification;;;
DropMethodSpecification =(str_p("DROP")) >> SpecificMethodSpecificationDesignator >> RESTRICT;;;
SpecificMethodSpecificationDesignator = !((str_p("INSTANCE"))  |(("STATIC"))  | CONSTRUCTOR >>(("METHOD")) >> MethodName >> DataTypeList);;;
DropDataTypeStatement =(str_p("DROP")) >>(("TYPE")) >> SchemaResolvedUserDefinedTypeName >> DropBehavior;;;
SQLInvokedRoutine = SchemaRoutine;;;
SchemaRoutine = SchemaProcedure  | SchemaFunction;;;
SchemaProcedure =(str_p("CREATE")) >> SQLInvokedProcedure;;;
SchemaFunction =(str_p("CREATE")) >> SQLInvokedFunction;;;
SQLInvokedProcedure =(str_p("PROCEDURE")) >> SchemaQualifiedRoutineName >> SQLParameterDeclarationList >> RoutineCharacteristics >> RoutineBody;;;
SQLInvokedFunction = (FunctionSpecification  | MethodSpecificationDesignator >> RoutineBody);;;
SQLParameterDeclarationList = (LeftParen >> !((SQLParameterDeclaration%Comma)) >> RightParen);;;
SQLParameterDeclaration = !(ParameterMode >> !SQLParameterName >> ParameterType >> !(str_p("RESULT")));;;
ParameterMode =(str_p("IN"))  |(("OUT"))  |(("INOUT"));;;
ParameterType = (DataType >> !LocatorIndication);;;
LocatorIndication =(str_p("AS")) >>(("LOCATOR"));;;
FunctionSpecification = ((str_p("FUNCTION")) >> SchemaQualifiedRoutineName >> SQLParameterDeclarationList >> ReturnsClause >> RoutineCharacteristics >> !DispatchClause);;;
MethodSpecificationDesignator =(str_p("SPECIFIC")) >>(("METHOD")) >> SpecificMethodName  | !((str_p("INSTANCE"))  |(("STATIC"))  | CONSTRUCTOR >>(("METHOD")) >> MethodName >> SQLParameterDeclarationList >> !ReturnsClause >>(("FOR")) >> SchemaResolvedUserDefinedTypeName);;;
RoutineCharacteristics = *(RoutineCharacteristic);;;
RoutineCharacteristic = LanguageClause  | ParameterStyleClause  |(("SPECIFIC")) >> SpecificName  | DeterministicCharacteristic  | SQLDataAccessIndication  | NullCallClause  | DynamicResultSetsCharacteristic  | SavepointLevelIndication;;;
SavepointLevelIndication =(str_p("NEW")) >>(("SAVEPOINT")) >>(("LEVEL"))  |(("OLD")) >>(("SAVEPOINT")) >>(("LEVEL"));;;
DynamicResultSetsCharacteristic =(str_p("DYNAMIC")) >>(("RESULT")) >>(("SETS")) >> MaximumDynamicResultSets;;;
ParameterStyleClause =(str_p("PARAMETER")) >>(("STYLE")) >> ParameterStyle;;;
DispatchClause =(str_p("STATIC")) >>(("DISPATCH"));;;
ReturnsClause =(str_p("RETURNS")) >> ReturnsType;;;
ReturnsType = (ReturnsDataType >> !ResultCast)  | ReturnsTableType;;;
ReturnsTableType =(str_p("TABLE")) >> TableFunctionColumnList;;;
TableFunctionColumnList = (LeftParen >> (TableFunctionColumnListElement%Comma) >> RightParen);;;
TableFunctionColumnListElement = ColumnName >> DataType;;;
ResultCast =(str_p("CAST")) >>(("FROM")) >> ResultCastFromType;;;
ResultCastFromType = (DataType >> !LocatorIndication);;;
ReturnsDataType = (DataType >> !LocatorIndication);;;
RoutineBody = SQLRoutineSpec  | ExternalBodyReference;;;
SQLRoutineSpec = !(RightsClause >> SQLRoutineBody);;;
RightsClause =(str_p("SQL")) >>(("SECURITY")) >>(("INVOKER"))  |(("SQL")) >>(("SECURITY")) >>(("DEFINER"));;;
SQLRoutineBody = SQLProcedureStatement;;;
ExternalBodyReference = ((str_p("EXTERNAL")) >> !(str_p("NAME")) >> ExternalRoutineName >> !ParameterStyleClause >> !TransformGroupSpecification >> !ExternalSecurityClause);;;
ExternalSecurityClause =(str_p("EXTERNAL")) >>(("SECURITY")) >>(("DEFINER"))  |(("EXTERNAL")) >>(("SECURITY")) >>(("INVOKER"))  |(("EXTERNAL")) >>(("SECURITY")) >>(("IMPLEMENTATION")) >>(("DEFINED"));;;
ParameterStyle =(str_p("SQL"))  |(("GENERAL"));;;
DeterministicCharacteristic =(str_p("DETERMINISTIC"))  |(("NOT")) >>(("DETERMINISTIC"));;;
SQLDataAccessIndication =(str_p("NO")) >>(("SQL"))  |(("CONTAINS")) >>(("SQL"))  |(("READS")) >>(("SQL")) >>(("DATA"))  |(("MODIFIES")) >>(("SQL")) >>(("DATA"));;;
NullCallClause =(str_p("RETURNS")) >>(("NULL")) >>(("ON")) >>(("NULL")) >>(("INPUT"))  |(("CALLED")) >>(("ON")) >>(("NULL")) >>(("INPUT"));;;
MaximumDynamicResultSets = UnsignedInteger;;;
TransformGroupSpecification = ((str_p("TRANSFORM")) >>(("GROUP")) >> SingleGroupSpecification  | MultipleGroupSpecification);;;
SingleGroupSpecification = GroupName;;;
MultipleGroupSpecification = ((GroupSpecification%Comma));;;
GroupSpecification = GroupName >>(("FOR")) >>(("TYPE")) >> PathResolvedUserDefinedTypeName;;;
AlterRoutineStatement =(str_p("ALTER")) >> SpecificRoutineDesignator >> AlterRoutineCharacteristics >> AlterRoutineBehavior;;;
AlterRoutineCharacteristics = +AlterRoutineCharacteristic;;;
AlterRoutineCharacteristic = LanguageClause  | ParameterStyleClause  | SQLDataAccessIndication  | NullCallClause  | DynamicResultSetsCharacteristic  |(("NAME")) >> ExternalRoutineName;;;
AlterRoutineBehavior = RESTRICT;;;
DropRoutineStatement =(str_p("DROP")) >> SpecificRoutineDesignator >> DropBehavior;;;
UserDefinedCastDefinition = ((str_p("CREATE")) >>(("CAST")) >> LeftParen >> SourceDataType >>(("AS")) >> TargetDataType >> RightParen >>(("WITH")) >> CastFunction >> !(str_p("AS")) >>(("ASSIGNMENT")));;;
CastFunction = SpecificRoutineDesignator;;;
SourceDataType = DataType;;;
TargetDataType = DataType;;;
DropUserDefinedCastStatement =(str_p("DROP")) >>(("CAST")) >> LeftParen >> SourceDataType >>(("AS")) >> TargetDataType >> RightParen >> DropBehavior;;;
UserDefinedOrderingDefinition =(str_p("CREATE")) >>(("ORDERING")) >>(("FOR")) >> SchemaResolvedUserDefinedTypeName >> OrderingForm;;;
OrderingForm = EqualsOrderingForm  | FullOrderingForm;;;
EqualsOrderingForm =(str_p("EQUALS")) >>(("ONLY")) >>(("BY")) >> OrderingCategory;;;
FullOrderingForm =(str_p("ORDER")) >>(("FULL")) >>(("BY")) >> OrderingCategory;;;
OrderingCategory = RelativeCategory  | MapCategory  | StateCategory;;;
RelativeCategory =(str_p("RELATIVE")) >>(("WITH")) >> RelativeFunctionSpecification;;;
MapCategory =(str_p("MAP")) >>(("WITH")) >> MapFunctionSpecification;;;
StateCategory = ((str_p("STATE")) >> !SpecificName);;;
RelativeFunctionSpecification = SpecificRoutineDesignator;;;
MapFunctionSpecification = SpecificRoutineDesignator;;;
DropUserDefinedOrderingStatement =(str_p("DROP")) >>(("ORDERING")) >>(("FOR")) >> SchemaResolvedUserDefinedTypeName >> DropBehavior;;;
TransformDefinition = ((str_p("CREATE")) >>(("TRANSFORM"))  |(("TRANSFORMS")) >>(("FOR")) >> SchemaResolvedUserDefinedTypeName >> +TransformGroup);;;
TransformGroup = GroupName >> LeftParen >> TransformElementList >> RightParen;;;
GroupName = Identifier;;;
TransformElementList = (TransformElement >> !Comma >> TransformElement);;;
TransformElement = ToSql  | FromSql;;;
ToSql =(str_p("TO")) >>(("SQL")) >>(("WITH")) >> ToSqlFunction;;;
FromSql =(str_p("FROM")) >>(("SQL")) >>(("WITH")) >> FromSqlFunction;;;
ToSqlFunction = SpecificRoutineDesignator;;;
FromSqlFunction = SpecificRoutineDesignator;;;
AlterTransformStatement = ((str_p("ALTER")) >>(("TRANSFORM"))  |(("TRANSFORMS")) >>(("FOR")) >> SchemaResolvedUserDefinedTypeName >> +AlterGroup);;;
AlterGroup = GroupName >> LeftParen >> AlterTransformActionList >> RightParen;;;
AlterTransformActionList = ((AlterTransformAction%Comma));;;
AlterTransformAction = AddTransformElementList  | DropTransformElementList;;;
AddTransformElementList =(str_p("ADD")) >> LeftParen >> TransformElementList >> RightParen;;;
DropTransformElementList = ((str_p("DROP")) >> LeftParen >> TransformKind >> !Comma >> TransformKind >> DropBehavior >> RightParen);;;
TransformKind =(str_p("TO")) >>(("SQL"))  |(("FROM")) >>(("SQL"));;;
DropTransformStatement = ((str_p("DROP")) >>(("TRANSFORM"))  |(("TRANSFORMS")) >> TransformsToBeDropped >>(("FOR")) >> SchemaResolvedUserDefinedTypeName >> DropBehavior);;;
TransformsToBeDropped =(str_p("ALL"))  | TransformGroupElement;;;
TransformGroupElement = GroupName;;;
SequenceGeneratorDefinition = ((str_p("CREATE")) >>(("SEQUENCE")) >> SequenceGeneratorName >> !SequenceGeneratorOptions);;;
SequenceGeneratorOptions = +SequenceGeneratorOption;;;
SequenceGeneratorOption = SequenceGeneratorDataTypeOption  | CommonSequenceGeneratorOptions;;;
CommonSequenceGeneratorOptions = +CommonSequenceGeneratorOption;;;
CommonSequenceGeneratorOption = SequenceGeneratorStartWithOption  | BasicSequenceGeneratorOption;;;
BasicSequenceGeneratorOption = SequenceGeneratorIncrementByOption  | SequenceGeneratorMaxvalueOption  | SequenceGeneratorMinvalueOption  | SequenceGeneratorCycleOption;;;
SequenceGeneratorDataTypeOption =(str_p("AS")) >> DataType;;;
SequenceGeneratorStartWithOption =(str_p("START")) >>(("WITH")) >> SequenceGeneratorStartValue;;;
SequenceGeneratorStartValue = SignedNumericLiteral;;;
SequenceGeneratorIncrementByOption =(str_p("INCREMENT")) >>(("BY")) >> SequenceGeneratorIncrement;;;
SequenceGeneratorIncrement = SignedNumericLiteral;;;
SequenceGeneratorMaxvalueOption =(str_p("MAXVALUE")) >> SequenceGeneratorMaxValue  |(("NO")) >>(("MAXVALUE"));;;
SequenceGeneratorMaxValue = SignedNumericLiteral;;;
SequenceGeneratorMinvalueOption =(str_p("MINVALUE")) >> SequenceGeneratorMinValue  |(("NO")) >>(("MINVALUE"));;;
SequenceGeneratorMinValue = SignedNumericLiteral;;;
SequenceGeneratorCycleOption =(str_p("CYCLE"))  |(("NO")) >>(("CYCLE"));;;
AlterSequenceGeneratorStatement =(str_p("ALTER")) >>(("SEQUENCE")) >> SequenceGeneratorName >> AlterSequenceGeneratorOptions;;;
AlterSequenceGeneratorOptions = +AlterSequenceGeneratorOption;;;
AlterSequenceGeneratorOption = AlterSequenceGeneratorRestartOption  | BasicSequenceGeneratorOption;;;
AlterSequenceGeneratorRestartOption =(str_p("RESTART")) >>(("WITH")) >> SequenceGeneratorRestartValue;;;
SequenceGeneratorRestartValue = SignedNumericLiteral;;;
DropSequenceGeneratorStatement =(str_p("DROP")) >>(("SEQUENCE")) >> SequenceGeneratorName >> DropBehavior;;;
GrantStatement = GrantPrivilegeStatement  | GrantRoleStatement;;;
GrantPrivilegeStatement = ((str_p("GRANT")) >> Privileges >>(("TO")) >> (Grantee%Comma) >> !(str_p("WITH")) >>(("HIERARCHY")) >>(("OPTION")) >> !(str_p("WITH")) >>(("GRANT")) >>(("OPTION")) >> !(str_p("GRANTED")) >>(("BY")) >> Grantor);;;
Privileges = ObjectPrivileges >>(("ON")) >> ObjectName;;;
ObjectName = !((str_p("TABLE")) >> TableName)  |(("DOMAIN")) >> DomainName  |(("COLLATION")) >> CollationName  |(("CHARACTER")) >>(("SET")) >> CharacterSetName  |(("TRANSLATION")) >> TransliterationName  |(("TYPE")) >> SchemaResolvedUserDefinedTypeName  |(("SEQUENCE")) >> SequenceGeneratorName  | SpecificRoutineDesignator;;;
ObjectPrivileges =(str_p("ALL")) >>(("PRIVILEGES"))  | ((Action%Comma));;;
Action =(str_p("SELECT"))  |(("SELECT")) >> LeftParen >> PrivilegeColumnList >> RightParen  |(("SELECT")) >> LeftParen >> PrivilegeMethodList >> RightParen  |(("DELETE"))  | ((str_p("INSERT")) >> !LeftParen >> PrivilegeColumnList >> RightParen)  | ((str_p("UPDATE")) >> !LeftParen >> PrivilegeColumnList >> RightParen)  | ((str_p("REFERENCES")) >> !LeftParen >> PrivilegeColumnList >> RightParen)  |(("USAGE"))  |(("TRIGGER"))  |(("UNDER"))  |(("EXECUTE"));;;
PrivilegeMethodList = ((SpecificRoutineDesignator%Comma));;;
PrivilegeColumnList = ColumnNameList;;;
Grantee =(str_p("PUBLIC"))  | AuthorizationIdentifier;;;
Grantor =(str_p("CURRENT_USER"))  |(("CURRENT_ROLE"));;;
RoleDefinition = ((str_p("CREATE")) >>(("ROLE")) >> RoleName >> !(str_p("WITH")) >>(("ADMIN")) >> Grantor);;;
GrantRoleStatement = ((str_p("GRANT")) >> (RoleGranted%Comma) >>(("TO")) >> (Grantee%Comma) >> !(str_p("WITH")) >>(("ADMIN")) >>(("OPTION")) >> !(str_p("GRANTED")) >>(("BY")) >> Grantor);;;
RoleGranted = RoleName;;;
DropRoleStatement =(str_p("DROP")) >>(("ROLE")) >> RoleName;;;
RevokeStatement = RevokePrivilegeStatement  | RevokeRoleStatement;;;
RevokePrivilegeStatement = ((str_p("REVOKE")) >> !RevokeOptionExtension >> Privileges >>(("FROM")) >> (Grantee%Comma) >> !(str_p("GRANTED")) >>(("BY")) >> Grantor >> DropBehavior);;;
RevokeOptionExtension =(str_p("GRANT")) >>(("OPTION")) >>(("FOR"))  |(("HIERARCHY")) >>(("OPTION")) >>(("FOR"));;;
RevokeRoleStatement = ((str_p("REVOKE")) >> !(str_p("ADMIN")) >>(("OPTION")) >>(("FOR")) >> (RoleRevoked%Comma) >>(("FROM")) >> (Grantee%Comma) >> !(str_p("GRANTED")) >>(("BY")) >> Grantor >> DropBehavior);;;
RoleRevoked = RoleName;;;
SQLClientModuleDefinition = (ModuleNameClause >> LanguageClause >> ModuleAuthorizationClause >> !ModulePathSpecification >> !ModuleTransformGroupSpecification >> !ModuleCollation >> *TemporaryTableDeclaration >> +ModuleContents);;;
ModuleAuthorizationClause =(str_p("SCHEMA")) >> SchemaName  | ((str_p("AUTHORIZATION")) >> ModuleAuthorizationIdentifier >> !((str_p("FOR")) >>(("STATIC")) >>(("ONLY"))  |(("AND")) >>(("DYNAMIC"))))  | ((str_p("SCHEMA")) >> SchemaName >>(("AUTHORIZATION")) >> ModuleAuthorizationIdentifier >> !((str_p("FOR")) >>(("STATIC")) >>(("ONLY"))  |(("AND")) >>(("DYNAMIC"))));;;
ModuleAuthorizationIdentifier = AuthorizationIdentifier;;;
ModulePathSpecification = PathSpecification;;;
ModuleTransformGroupSpecification = TransformGroupSpecification;;;
ModuleCollations = +ModuleCollationSpecification;;;
ModuleCollationSpecification = ((str_p("COLLATION")) >> CollationName >> !(str_p("FOR")) >> CharacterSetSpecificationList);;;
CharacterSetSpecificationList = ((CharacterSetSpecification%Comma));;;
ModuleContents = DeclareCursor  | DynamicDeclareCursor  | ExternallyInvokedProcedure;;;
ModuleNameClause = ((str_p("MODULE")) >> !SQLClientModuleName >> !ModuleCharacterSetSpecification);;;
ModuleCharacterSetSpecification =(str_p("NAMES")) >>(("ARE")) >> CharacterSetSpecification;;;
ExternallyInvokedProcedure =(str_p("PROCEDURE")) >> ProcedureName >> HostParameterDeclarationList >> Semicolon >> SQLProcedureStatement >> Semicolon;;;
HostParameterDeclarationList = (LeftParen >> (HostParameterDeclaration%Comma) >> RightParen);;;
HostParameterDeclaration = HostParameterName >> HostParameterDataType  | StatusParameter;;;
HostParameterDataType = (DataType >> !LocatorIndication);;;
StatusParameter =(str_p("SQLSTATE"));;;
SQLProcedureStatement = SQLExecutableStatement;;;
SQLExecutableStatement = SQLSchemaStatement  | SQLDataStatement  | SQLControlStatement  | SQLTransactionStatement  | SQLConnectionStatement  | SQLSessionStatement  | SQLDiagnosticsStatement  | SQLDynamicStatement;;;
SQLSchemaStatement = SQLSchemaDefinitionStatement  | SQLSchemaManipulationStatement;;;
SQLSchemaDefinitionStatement = SchemaDefinition  | TableDefinition  | ViewDefinition  | SQLInvokedRoutine  | GrantStatement  | RoleDefinition  | DomainDefinition  | CharacterSetDefinition  | CollationDefinition  | TransliterationDefinition  | AssertionDefinition  | TriggerDefinition  | UserDefinedTypeDefinition  | UserDefinedCastDefinition  | UserDefinedOrderingDefinition  | TransformDefinition  | SequenceGeneratorDefinition;;;
SQLSchemaManipulationStatement = DropSchemaStatement  | AlterTableStatement  | DropTableStatement  | DropViewStatement  | AlterRoutineStatement  | DropRoutineStatement  | DropUserDefinedCastStatement  | RevokeStatement  | DropRoleStatement  | AlterDomainStatement  | DropDomainStatement  | DropCharacterSetStatement  | DropCollationStatement  | DropTransliterationStatement  | DropAssertionStatement  | DropTriggerStatement  | AlterTypeStatement  | DropDataTypeStatement  | DropUserDefinedOrderingStatement  | AlterTransformStatement  | DropTransformStatement  | AlterSequenceGeneratorStatement  | DropSequenceGeneratorStatement;;;
SQLDataStatement = OpenStatement  | FetchStatement  | CloseStatement  | SelectStatementSingleRow  | FreeLocatorStatement  | HoldLocatorStatement  | SQLDataChangeStatement;;;
SQLDataChangeStatement = DeleteStatementPositioned  | DeleteStatementSearched  | InsertStatement  | UpdateStatementPositioned  | UpdateStatementSearched  | MergeStatement;;;
SQLControlStatement = CallStatement  | ReturnStatement;;;
SQLTransactionStatement = StartTransactionStatement  | SetTransactionStatement  | SetConstraintsModeStatement  | SavepointStatement  | ReleaseSavepointStatement  | CommitStatement  | RollbackStatement;;;
SQLConnectionStatement = ConnectStatement  | SetConnectionStatement  | DisconnectStatement;;;
SQLSessionStatement = SetSessionUserIdentifierStatement  | SetRoleStatement  | SetLocalTimeZoneStatement  | SetSessionCharacteristicsStatement  | SetCatalogStatement  | SetSchemaStatement  | SetNamesStatement  | SetPathStatement  | SetTransformGroupStatement  | SetSessionCollationStatement;;;
SQLDiagnosticsStatement = GetDiagnosticsStatement;;;
SQLDynamicStatement = SystemDescriptorStatement  | PrepareStatement  | DeallocatePreparedStatement  | DescribeStatement  | ExecuteStatement  | ExecuteImmediateStatement  | SQLDynamicDataStatement;;;
SQLDynamicDataStatement = AllocateCursorStatement  | DynamicOpenStatement  | DynamicFetchStatement  | DynamicCloseStatement  | DynamicDeleteStatementPositioned  | DynamicUpdateStatementPositioned;;;
SystemDescriptorStatement = AllocateDescriptorStatement  | DeallocateDescriptorStatement  | SetDescriptorStatement  | GetDescriptorStatement >> Table >> 16--Data >> type >> correspondences >> for >> C;;;
DeclareCursor = ((str_p("DECLARE")) >> CursorName >> !CursorSensitivity >> !CursorScrollability >>(("CURSOR")) >> !CursorHoldability >> !CursorReturnability >>(("FOR")) >> CursorSpecification);;;
CursorSensitivity =(str_p("SENSITIVE"))  |(("INSENSITIVE"))  |(("ASENSITIVE"));;;
CursorScrollability =(str_p("SCROLL"))  |(("NO")) >>(("SCROLL"));;;
CursorHoldability =(str_p("WITH")) >>(("HOLD"))  |(("WITHOUT")) >>(("HOLD"));;;
CursorReturnability =(str_p("WITH")) >>(("RETURN"))  |(("WITHOUT")) >>(("RETURN"));;;
CursorSpecification = (QueryExpression >> !OrderByClause >> !UpdatabilityClause);;;
UpdatabilityClause = ((str_p("FOR")) >>(("READ")) >>(("ONLY"))  | ((str_p("UPDATE")) >> !(str_p("OF")) >> ColumnNameList));;;
OrderByClause =(str_p("ORDER")) >>(("BY")) >> SortSpecificationList;;;
OpenStatement =(str_p("OPEN")) >> CursorName;;;
FetchStatement = ((str_p("FETCH")) >> !!(FetchOrientation >>(("FROM"))) >> CursorName >>(("INTO")) >> FetchTargetList);;;
FetchOrientation =(str_p("NEXT"))  |(("PRIOR"))  |(("FIRST"))  |(("LAST"))  | ((str_p("ABSOLUTE"))  |(("RELATIVE")) >> SimpleValueSpecification);;;
FetchTargetList = ((TargetSpecification%Comma) >> Close >> a >> cursor).;;;
CloseStatement =(str_p("CLOSE")) >> CursorName;;;
SelectStatementSingleRow = ((str_p("SELECT")) >> !SetQuantifier >> SelectList >>(("INTO")) >> SelectTargetList >> TableExpression);;;
SelectTargetList = ((TargetSpecification%Comma));;;
DeleteStatementPositioned =(str_p("DELETE")) >>(("FROM")) >> TargetTable >>(("WHERE")) >>(("CURRENT")) >>(("OF")) >> CursorName;;;
TargetTable = TableName  |(("ONLY")) >> LeftParen >> TableName >> RightParen;;;
DeleteStatementSearched = ((str_p("DELETE")) >>(("FROM")) >> TargetTable >> !(str_p("WHERE")) >> SearchCondition);;;
InsertStatement =(str_p("INSERT")) >>(("INTO")) >> InsertionTarget >> InsertColumnsAndSource;;;
InsertionTarget = TableName;;;
InsertColumnsAndSource = FromSubquery  | FromConstructor  | FromDefault;;;
FromSubquery = !(LeftParen >> InsertColumnList >> RightParen >> !OverrideClause >> QueryExpression);;;
FromConstructor = !(LeftParen >> InsertColumnList >> RightParen >> !OverrideClause >> ContextuallyTypedTableValueConstructor);;;
OverrideClause =(str_p("OVERRIDING")) >>(("USER")) >>(("VALUE"))  |(("OVERRIDING")) >>(("SYSTEM")) >>(("VALUE"));;;
FromDefault =(str_p("DEFAULT")) >>(("VALUES"));;;
InsertColumnList = ColumnNameList;;;
MergeStatement = ((str_p("MERGE")) >>(("INTO")) >> TargetTable >> !!((str_p("AS")) >> MergeCorrelationName) >>(("USING")) >> TableReference >>(("ON")) >> SearchCondition >> MergeOperationSpecification);;;
MergeCorrelationName = CorrelationName;;;
MergeOperationSpecification = +MergeWhenClause;;;
MergeWhenClause = MergeWhenMatchedClause  | MergeWhenNotMatchedClause;;;
MergeWhenMatchedClause =(str_p("WHEN")) >>(("MATCHED")) >>(("THEN")) >> MergeUpdateSpecification;;;
MergeWhenNotMatchedClause =(str_p("WHEN")) >>(("NOT")) >>(("MATCHED")) >>(("THEN")) >> MergeInsertSpecification;;;
MergeUpdateSpecification =(str_p("UPDATE")) >>(("SET")) >> SetClauseList;;;
MergeInsertSpecification = ((str_p("INSERT")) >> !LeftParen >> InsertColumnList >> RightParen >> !OverrideClause >>(("VALUES")) >> MergeInsertValueList);;;
MergeInsertValueList = (LeftParen >> (MergeInsertValueElement%Comma) >> RightParen);;;
MergeInsertValueElement = ValueExpression  | ContextuallyTypedValueSpecification;;;
UpdateStatementPositioned =(str_p("UPDATE")) >> TargetTable >>(("SET")) >> SetClauseList >>(("WHERE")) >>(("CURRENT")) >>(("OF")) >> CursorName;;;
UpdateStatementSearched = ((str_p("UPDATE")) >> TargetTable >>(("SET")) >> SetClauseList >> !(str_p("WHERE")) >> SearchCondition);;;
SetClauseList = ((SetClause%Comma));;;
SetClause = MultipleColumnAssignment  | SetTarget >> EqualsOperator >> UpdateSource;;;
SetTarget = UpdateTarget  | MutatedSetClause;;;
MultipleColumnAssignment = SetTargetList >> EqualsOperator >> AssignedRow;;;
SetTargetList = (LeftParen >> (SetTarget%Comma) >> RightParen);;;
AssignedRow = ContextuallyTypedRowValueExpression;;;
UpdateTarget = ObjectColumn  | ObjectColumn >> LeftBracketOrTrigraph >> SimpleValueSpecification >> RightBracketOrTrigraph;;;
ObjectColumn = ColumnName;;;
MutatedSetClause = MutatedTarget >> Period >> MethodName;;;
MutatedTarget = ObjectColumn  | MutatedSetClause;;;
UpdateSource = ValueExpression  | ContextuallyTypedValueSpecification;;;
TemporaryTableDeclaration = ((str_p("DECLARE")) >>(("LOCAL")) >>(("TEMPORARY")) >>(("TABLE")) >> TableName >> TableElementList >> !(str_p("ON")) >>(("COMMIT")) >> TableCommitAction >>(("ROWS")));;;
FreeLocatorStatement = ((str_p("FREE")) >>(("LOCATOR")) >> (LocatorReference%Comma));;;
LocatorReference = HostParameterName  | EmbeddedVariableName;;;
HoldLocatorStatement = ((str_p("HOLD")) >>(("LOCATOR")) >> (LocatorReference%Comma));;;
CallStatement =(str_p("CALL")) >> RoutineInvocation;;;
ReturnStatement =(str_p("RETURN")) >> ReturnValue;;;
ReturnValue = ValueExpression  |(("NULL"));;;
StartTransactionStatement = ((str_p("START")) >>(("TRANSACTION")) >> !((TransactionMode%Comma)));;;
TransactionMode = IsolationLevel  | TransactionAccessMode  | DiagnosticsSize;;;
TransactionAccessMode =(str_p("READ")) >>(("ONLY"))  |(("READ")) >>(("WRITE"));;;
IsolationLevel =(str_p("ISOLATION")) >>(("LEVEL")) >> LevelOfIsolation;;;
LevelOfIsolation =(str_p("READ")) >>(("UNCOMMITTED"))  |(("READ")) >>(("COMMITTED"))  |(("REPEATABLE")) >>(("READ"))  |(("SERIALIZABLE"));;;
DiagnosticsSize =(str_p("DIAGNOSTICS")) >>(("SIZE")) >> NumberOfConditions;;;
NumberOfConditions = SimpleValueSpecification;;;
SetTransactionStatement = ((str_p("SET")) >> !(str_p("LOCAL")) >> TransactionCharacteristics);;;
TransactionCharacteristics = ((str_p("TRANSACTION")) >> (TransactionMode%Comma));;;
SetConstraintsModeStatement = ((str_p("SET")) >>(("CONSTRAINTS")) >> ConstraintNameList >>(("DEFERRED"))  |(("IMMEDIATE")));;;
ConstraintNameList =(str_p("ALL"))  | ((ConstraintName%Comma));;;
SavepointStatement =(str_p("SAVEPOINT")) >> SavepointSpecifier;;;
SavepointSpecifier = SavepointName;;;
ReleaseSavepointStatement =(str_p("RELEASE")) >>(("SAVEPOINT")) >> SavepointSpecifier;;;
CommitStatement = ((str_p("COMMIT")) >> !(str_p("WORK")) >> !((str_p("AND")) >> !(str_p("NO")) >>(("CHAIN"))));;;
RollbackStatement = ((str_p("ROLLBACK")) >> !(str_p("WORK")) >> !((str_p("AND")) >> !(str_p("NO")) >>(("CHAIN"))) >> !SavepointClause);;;
SavepointClause =(str_p("TO")) >>(("SAVEPOINT")) >> SavepointSpecifier;;;
ConnectStatement =(str_p("CONNECT")) >>(("TO")) >> ConnectionTarget;;;
ConnectionTarget = (SQLServerName >> !(str_p("AS")) >> ConnectionName >> !(str_p("USER")) >> ConnectionUserName)  |(("DEFAULT"));;;
SetConnectionStatement =(str_p("SET")) >> CONNECTION >> ConnectionObject;;;
ConnectionObject =(str_p("DEFAULT"))  | ConnectionName;;;
DisconnectStatement =(str_p("DISCONNECT")) >> DisconnectObject;;;
DisconnectObject = ConnectionObject  |(("ALL"))  |(("CURRENT"));;;
SetSessionCharacteristicsStatement =(str_p("SET")) >>(("SESSION")) >>(("CHARACTERISTICS")) >>(("AS")) >> SessionCharacteristicList;;;
SessionCharacteristicList = ((SessionCharacteristic%Comma));;;
SessionCharacteristic = TransactionCharacteristics;;;
SetSessionUserIdentifierStatement =(str_p("SET")) >>(("SESSION")) >>(("AUTHORIZATION")) >> ValueSpecification;;;
SetRoleStatement =(str_p("SET")) >>(("ROLE")) >> RoleSpecification;;;
RoleSpecification = ValueSpecification  |(("NONE"));;;
SetLocalTimeZoneStatement =(str_p("SET")) >>(("TIME")) >>(("ZONE")) >> SetTimeZoneValue;;;
SetTimeZoneValue = IntervalValueExpression  |(("LOCAL"));;;
SetCatalogStatement =(str_p("SET")) >> CatalogNameCharacteristic;;;
CatalogNameCharacteristic =(str_p("CATALOG")) >> ValueSpecification;;;
SetSchemaStatement =(str_p("SET")) >> SchemaNameCharacteristic;;;
SchemaNameCharacteristic =(str_p("SCHEMA")) >> ValueSpecification;;;
SetNamesStatement =(str_p("SET")) >> CharacterSetNameCharacteristic;;;
CharacterSetNameCharacteristic =(str_p("NAMES")) >> ValueSpecification;;;
SetPathStatement =(str_p("SET")) >> SQLPathCharacteristic;;;
SQLPathCharacteristic =(str_p("PATH")) >> ValueSpecification;;;
SetTransformGroupStatement =(str_p("SET")) >> TransformGroupCharacteristic;;;
TransformGroupCharacteristic =(str_p("DEFAULT")) >>(("TRANSFORM")) >>(("GROUP")) >> ValueSpecification  |(("TRANSFORM")) >>(("GROUP")) >>(("FOR")) >>(("TYPE")) >> PathResolvedUserDefinedTypeName >> ValueSpecification;;;
SetSessionCollationStatement = ((str_p("SET")) >>(("COLLATION")) >> CollationSpecification >> !(str_p("FOR")) >> CharacterSetSpecificationList)  | ((str_p("SET")) >>(("NO")) >>(("COLLATION")) >> !(str_p("FOR")) >> CharacterSetSpecificationList);;;
CharacterSetSpecificationList = (CharacterSetSpecification >> !,+CharacterSetSpecification);;;
CollationSpecification = ValueSpecification;;;
AllocateDescriptorStatement = ((str_p("ALLOCATE")) >> !(str_p("SQL")) >>(("DESCRIPTOR")) >> DescriptorName >> !(str_p("WITH")) >>(("MAX")) >> Occurrences);;;
Occurrences = SimpleValueSpecification;;;
DeallocateDescriptorStatement = ((str_p("DEALLOCATE")) >> !(str_p("SQL")) >>(("DESCRIPTOR")) >> DescriptorName);;;
GetDescriptorStatement = ((str_p("GET")) >> !(str_p("SQL")) >>(("DESCRIPTOR")) >> DescriptorName >> GetDescriptorInformation);;;
GetDescriptorInformation = ((GetHeaderInformation%Comma))  | ((str_p("VALUE")) >> ItemNumber >> (GetItemInformation%Comma));;;
GetHeaderInformation = SimpleTargetSpecification1 >> EqualsOperator >> HeaderItemName;;;
HeaderItemName =(str_p("COUNT"))  |(("KEY_TYPE"))  |(("DYNAMIC_FUNCTION"))  |(("DYNAMIC_FUNCTION_CODE"))  |(("TOP_LEVEL_COUNT"));;;
GetItemInformation = SimpleTargetSpecification2 >> EqualsOperator >> DescriptorItemName;;;
ItemNumber = SimpleValueSpecification;;;
SimpleTargetSpecification1 = SimpleTargetSpecification;;;
SimpleTargetSpecification2 = SimpleTargetSpecification;;;
DescriptorItemName =(str_p("CARDINALITY"))  |(("CHARACTER_SET_CATALOG"))  |(("CHARACTER_SET_NAME"))  |(("CHARACTER_SET_SCHEMA"))  |(("COLLATION_CATALOG"))  |(("COLLATION_NAME"))  |(("COLLATION_SCHEMA"))  |(("DATA"))  |(("DATETIME_INTERVAL_CODE"))  |(("DATETIME_INTERVAL_PRECISION"))  |(("DEGREE"))  |(("INDICATOR"))  |(("KEY_MEMBER"))  |(("LENGTH"))  |(("LEVEL"))  |(("NAME"))  |(("NULLABLE"))  |(("OCTET_LENGTH"))  |(("PARAMETER_MODE"))  |(("PARAMETER_ORDINAL_POSITION"))  |(("PARAMETER_SPECIFIC_CATALOG"))  |(("PARAMETER_SPECIFIC_NAME"))  |(("PARAMETER_SPECIFIC_SCHEMA"))  |(("PRECISION"))  |(("RETURNED_CARDINALITY"))  |(("RETURNED_LENGTH"))  |(("RETURNED_OCTET_LENGTH"))  |(("SCALE"))  |(("SCOPE_CATALOG"))  |(("SCOPE_NAME"))  |(("SCOPE_SCHEMA"))  |(("TYPE"))  |(("UNNAMED"))  |(("USER_DEFINED_TYPE_CATALOG"))  |(("USER_DEFINED_TYPE_NAME"))  |(("USER_DEFINED_TYPE_SCHEMA"))  |(("USER_DEFINED_TYPE_CODE"));;;
SetDescriptorStatement = ((str_p("SET")) >> !(str_p("SQL")) >>(("DESCRIPTOR")) >> DescriptorName >> SetDescriptorInformation);;;
SetDescriptorInformation = ((SetHeaderInformation%Comma))  | ((str_p("VALUE")) >> ItemNumber >> (SetItemInformation%Comma));;;
SetHeaderInformation = HeaderItemName >> EqualsOperator >> SimpleValueSpecification1;;;
SetItemInformation = DescriptorItemName >> EqualsOperator >> SimpleValueSpecification2;;;
SimpleValueSpecification1 = SimpleValueSpecification;;;
SimpleValueSpecification2 = SimpleValueSpecification;;;
ItemNumber = SimpleValueSpecification;;;
PrepareStatement = ((str_p("PREPARE")) >> SQLStatementName >> !AttributesSpecification >>(("FROM")) >> SQLStatementVariable);;;
AttributesSpecification =(str_p("ATTRIBUTES")) >> AttributesVariable;;;
AttributesVariable = SimpleValueSpecification;;;
SQLStatementVariable = SimpleValueSpecification;;;
PreparableStatement = PreparableSQLDataStatement  | PreparableSQLSchemaStatement  | PreparableSQLTransactionStatement  | PreparableSQLControlStatement  | PreparableSQLSessionStatement  | PreparableImplementationDefinedStatement;;;
PreparableSQLDataStatement = DeleteStatementSearched  | DynamicSingleRowSelectStatement  | InsertStatement  | DynamicSelectStatement  | UpdateStatementSearched  | MergeStatement  | PreparableDynamicDeleteStatementPositioned  | PreparableDynamicUpdateStatementPositioned;;;
PreparableSQLSchemaStatement = SQLSchemaStatement;;;
PreparableSQLTransactionStatement = SQLTransactionStatement;;;
PreparableSQLControlStatement = SQLControlStatement;;;
PreparableSQLSessionStatement = SQLSessionStatement;;;
DynamicSelectStatement = CursorSpecification;;;
PreparableImplementationDefinedStatement = !!See >> the >> Syntax >> Rules.;;;
CursorAttributes = +CursorAttribute;;;
CursorAttribute = CursorSensitivity  | CursorScrollability  | CursorHoldability  | CursorReturnability;;;
DeallocatePreparedStatement =(str_p("DEALLOCATE")) >>(("PREPARE")) >> SQLStatementName;;;
DescribeStatement = DescribeInputStatement  | DescribeOutputStatement;;;
DescribeInputStatement = ((str_p("DESCRIBE")) >>(("INPUT")) >> SQLStatementName >> UsingDescriptor >> !NestingOption);;;
DescribeOutputStatement = ((str_p("DESCRIBE")) >> !(str_p("OUTPUT")) >> DescribedObject >> UsingDescriptor >> !NestingOption);;;
NestingOption =(str_p("WITH")) >>(("NESTING"))  |(("WITHOUT")) >>(("NESTING"));;;
UsingDescriptor = ((str_p("USING")) >> !(str_p("SQL")) >>(("DESCRIPTOR")) >> DescriptorName);;;
DescribedObject = SQLStatementName  |(("CURSOR")) >> ExtendedCursorName >>(("STRUCTURE"));;;
InputUsingClause = UsingArguments  | UsingInputDescriptor;;;
UsingArguments = ((str_p("USING")) >> (UsingArgument%Comma));;;
UsingArgument = GeneralValueSpecification;;;
UsingInputDescriptor = UsingDescriptor;;;
OutputUsingClause = IntoArguments  | IntoDescriptor;;;
IntoArguments = ((str_p("INTO")) >> (IntoArgument%Comma));;;
IntoArgument = TargetSpecification;;;
IntoDescriptor = ((str_p("INTO")) >> !(str_p("SQL")) >>(("DESCRIPTOR")) >> DescriptorName);;;
ExecuteStatement = ((str_p("EXECUTE")) >> SQLStatementName >> !ResultUsingClause >> !ParameterUsingClause);;;
ResultUsingClause = OutputUsingClause;;;
ParameterUsingClause = InputUsingClause;;;
ExecuteImmediateStatement =(str_p("EXECUTE")) >>(("IMMEDIATE")) >> SQLStatementVariable;;;
DynamicDeclareCursor = ((str_p("DECLARE")) >> CursorName >> !CursorSensitivity >> !CursorScrollability >>(("CURSOR")) >> !CursorHoldability >> !CursorReturnability >>(("FOR")) >> StatementName);;;
AllocateCursorStatement =(str_p("ALLOCATE")) >> ExtendedCursorName >> CursorIntent;;;
CursorIntent = StatementCursor  | ResultSetCursor;;;
StatementCursor = !(CursorSensitivity >> !CursorScrollability >>(("CURSOR")) >> !CursorHoldability >> !CursorReturnability >>(("FOR")) >> ExtendedStatementName);;;
ResultSetCursor =(str_p("FOR")) >>(("PROCEDURE")) >> SpecificRoutineDesignator;;;
DynamicOpenStatement = ((str_p("OPEN")) >> DynamicCursorName >> !InputUsingClause);;;
DynamicFetchStatement = ((str_p("FETCH")) >> !!(FetchOrientation >>(("FROM"))) >> DynamicCursorName >> OutputUsingClause);;;
DynamicSingleRowSelectStatement = QuerySpecification;;;
DynamicCloseStatement =(str_p("CLOSE")) >> DynamicCursorName;;;
DynamicDeleteStatementPositioned =(str_p("DELETE")) >>(("FROM")) >> TargetTable >>(("WHERE")) >>(("CURRENT")) >>(("OF")) >> DynamicCursorName;;;
DynamicUpdateStatementPositioned =(str_p("UPDATE")) >> TargetTable >>(("SET")) >> SetClauseList >>(("WHERE")) >>(("CURRENT")) >>(("OF")) >> DynamicCursorName;;;
PreparableDynamicDeleteStatementPositioned = ((str_p("DELETE")) >> !(str_p("FROM")) >> TargetTable >>(("WHERE")) >>(("CURRENT")) >>(("OF")) >> !ScopeOption >> CursorName);;;
PreparableDynamicUpdateStatementPositioned = ((str_p("UPDATE")) >> !TargetTable >>(("SET")) >> SetClauseList >>(("WHERE")) >>(("CURRENT")) >>(("OF")) >> !ScopeOption >> CursorName);;;
EmbeddedSQLHostProgram = EmbeddedSQLAdaProgram  | EmbeddedSQLCProgram  | EmbeddedSQLCOBOLProgram  | EmbeddedSQLFortranProgram  | EmbeddedSQLMUMPSProgram  | EmbeddedSQLPascalProgram  | EmbeddedSQLPLIProgram;;;
EmbeddedSQLStatement = (SQLPrefix >> StatementOrDeclaration >> !SQLTerminator);;;
StatementOrDeclaration = DeclareCursor  | DynamicDeclareCursor  | TemporaryTableDeclaration  | EmbeddedAuthorizationDeclaration  | EmbeddedPathSpecification  | EmbeddedTransformGroupSpecification  | EmbeddedCollationSpecification  | EmbeddedExceptionDeclaration  | HandlerDeclaration  | SQLProcedureStatement;;;
SQLPrefix =(str_p("EXEC")) >>(("SQL"))  | Ampersand >>(("SQL")) >> LeftParen;;;
SQLTerminator = ENDEXEC  | Semicolon  | RightParen;;;
EmbeddedAuthorizationDeclaration =(str_p("DECLARE")) >> EmbeddedAuthorizationClause;;;
EmbeddedAuthorizationClause =(str_p("SCHEMA")) >> SchemaName  | ((str_p("AUTHORIZATION")) >> EmbeddedAuthorizationIdentifier >> !((str_p("FOR")) >>(("STATIC")) >>(("ONLY"))  |(("AND")) >>(("DYNAMIC"))))  | ((str_p("SCHEMA")) >> SchemaName >>(("AUTHORIZATION")) >> EmbeddedAuthorizationIdentifier >> !((str_p("FOR")) >>(("STATIC")) >>(("ONLY"))  |(("AND")) >>(("DYNAMIC"))));;;
EmbeddedAuthorizationIdentifier = ModuleAuthorizationIdentifier;;;
EmbeddedPathSpecification = PathSpecification;;;
EmbeddedTransformGroupSpecification = TransformGroupSpecification;;;
EmbeddedCollationSpecification = ModuleCollations;;;
EmbeddedSQLDeclareSection = (EmbeddedSQLBeginDeclare >> !EmbeddedCharacterSetDeclaration >> *HostVariableDefinition >> EmbeddedSQLEndDeclare)  | EmbeddedSQLMUMPSDeclare;;;
EmbeddedCharacterSetDeclaration =(str_p("SQL")) >>(("NAMES")) >>(("ARE")) >> CharacterSetSpecification;;;
EmbeddedSQLBeginDeclare = (SQLPrefix >>(("BEGIN")) >>(("DECLARE")) >>(("SECTION")) >> !SQLTerminator);;;
EmbeddedSQLEndDeclare = (SQLPrefix >>(("END")) >>(("DECLARE")) >>(("SECTION")) >> !SQLTerminator);;;
EmbeddedSQLMUMPSDeclare = (SQLPrefix >>(("BEGIN")) >>(("DECLARE")) >>(("SECTION")) >> !EmbeddedCharacterSetDeclaration >> +HostVariableDefinition) >>(("END")) >>(("DECLARE")) >>(("SECTION")) >> SQLTerminator);;;
HostVariableDefinition = AdaVariableDefinition  | CVariableDefinition  | COBOLVariableDefinition  | FortranVariableDefinition  | MUMPSVariableDefinition  | PascalVariableDefinition  | PLIVariableDefinition;;;
EmbeddedVariableName = Colon >> HostIdentifier;;;
HostIdentifier = AdaHostIdentifier  | CHostIdentifier  | COBOLHostIdentifier  | FortranHostIdentifier  | MUMPSHostIdentifier  | PascalHostIdentifier  | PLIHostIdentifier;;;
EmbeddedExceptionDeclaration =(str_p("WHENEVER")) >> Condition >> ConditionAction;;;
Condition = SQLCondition;;;
SQLCondition = MajorCategory  | ((str_p("SQLSTATE")) >> (SQLSTATEClassValue >> !,SQLSTATESubclassValue))  |(("CONSTRAINT")) >> ConstraintName;;;
MajorCategory =(str_p("SQLEXCEPTION"))  |(("SQLWARNING"))  |(("NOT")) >>(("FOUND"));;;
SQLSTATEClassValue = SQLSTATEChar >> SQLSTATEChar!!See >> the >> Syntax >> Rules.;;;
SQLSTATESubclassValue = SQLSTATEChar >> SQLSTATEChar >> SQLSTATEChar!!See >> The >> Syntax >> Rules.;;;
SQLSTATEChar = SimpleLatinUpperCaseLetter  | Digit;;;
ConditionAction =(str_p("CONTINUE"))  | GoTo;;;
GoTo = ((str_p("GOTO"))  |(("GO")) >>(("TO")) >> GotoTarget);;;
GotoTarget = HostLabelIdentifier  | UnsignedInteger  | HostPLILabelVariable;;;
HostLabelIdentifier = !!See >> the >> Syntax >> Rules.;;;
HostPLILabelVariable = !!See >> The >> Syntax >> Rules.;;;
EmbeddedSQLAdaProgram = !!See >> The >> Syntax >> Rules.;;;
AdaVariableDefinition = ((AdaHostIdentifier%Comma) >> Colon >> AdaTypeSpecification >> !AdaInitialValue);;;
AdaInitialValue = (AdaAssignmentOperator >> +CharacterRepresentation);;;
AdaAssignmentOperator = Colon >> EqualsOperator;;;
AdaHostIdentifier = !!See >> The >> Syntax >> Rules.;;;
AdaTypeSpecification = AdaQualifiedTypeSpecification  | AdaUnqualifiedTypeSpecification  | AdaDerivedTypeSpecification;;;
AdaQualifiedTypeSpecification = Interfaces.((str_p("SQL")) >> Period >>(("CHAR")) >> !((str_p("CHARACTER")) >>(("SET")) >> !(str_p("IS")) >> CharacterSetSpecification) >> LeftParen >> 1 >> DoublePeriod >> Length >> RightParen)  | InterfacesSQL >> Period >>(("SMALLINT"))  | Interfaces.(str_p("SQL")) >> Period >>(("INT"))  | InterfacesSQL >> Period >>(("BIGINT"))  | Interfaces.(str_p("SQL")) >> Period >>(("REAL"))  | InterfacesSQL >> Period >> DOUBLE_PRECISION  | Interfaces.(str_p("SQL")) >> Period >>(("BOOLEAN"))  | InterfacesSQL >> Period >> SQLSTATE_TYPE  | Interfaces.(str_p("SQL")) >> Period >> INDICATOR_TYPE;;;
AdaUnqualifiedTypeSpecification =(str_p("CHAR")) >> LeftParen >> 1 >> DoublePeriod >> Length >> RightParen  |(("SMALLINT"))  |(("INT"))  |(("BIGINT"))  |(("REAL"))  | DOUBLE_PRECISION  |(("BOOLEAN"))  | SQLSTATE_TYPE  | INDICATOR_TYPE;;;
AdaDerivedTypeSpecification = AdaCLOBVariable  | AdaCLOBLocatorVariable  | AdaBLOBVariable  | AdaBLOBLocatorVariable  | AdaUserDefinedTypeVariable  | AdaUserDefinedTypeLocatorVariable  | AdaREFVariable  | AdaArrayLocatorVariable  | AdaMultisetLocatorVariable;;;
AdaCLOBVariable = ((str_p("SQL")) >>(("TYPE")) >>(("IS")) >>(("CLOB")) >> LeftParen >> LargeObjectLength >> RightParen >> !((str_p("CHARACTER")) >>(("SET")) >> !(str_p("IS")) >> CharacterSetSpecification));;;
AdaCLOBLocatorVariable =(str_p("SQL")) >>(("TYPE")) >>(("IS")) >>(("CLOB")) >>(("AS")) >>(("LOCATOR"));;;
AdaBLOBVariable =(str_p("SQL")) >>(("TYPE")) >>(("IS")) >>(("BLOB")) >> LeftParen >> LargeObjectLength >> RightParen;;;
AdaBLOBLocatorVariable =(str_p("SQL")) >>(("TYPE")) >>(("IS")) >>(("BLOB")) >>(("AS")) >>(("LOCATOR"));;;
AdaUserDefinedTypeVariable =(str_p("SQL")) >>(("TYPE")) >>(("IS")) >> PathResolvedUserDefinedTypeName >>(("AS")) >> PredefinedType;;;
AdaUserDefinedTypeLocatorVariable =(str_p("SQL")) >>(("TYPE")) >>(("IS")) >> PathResolvedUserDefinedTypeName >>(("AS")) >>(("LOCATOR"));;;
AdaREFVariable =(str_p("SQL")) >>(("TYPE")) >>(("IS")) >> ReferenceType;;;
AdaArrayLocatorVariable =(str_p("SQL")) >>(("TYPE")) >>(("IS")) >> ArrayType >>(("AS")) >>(("LOCATOR"));;;
AdaMultisetLocatorVariable =(str_p("SQL")) >>(("TYPE")) >>(("IS")) >> MultisetType >>(("AS")) >>(("LOCATOR"));;;
EmbeddedSQLCProgram = !!See >> The >> Syntax >> Rules.;;;
CVariableDefinition = !(CStorageClass >> !CClassModifier >> CVariableSpecification >> Semicolon);;;
CVariableSpecification = CNumericVariable  | CCharacterVariable  | CDerivedVariable;;;
CStorageClass = Auto  | Extern  | Static;;;
CClassModifier = const  | volatile;;;
CNumericVariable = (Long >> Long  | Long  | Short  | Float  | Double >> CHostIdentifier >> !CInitialValue >> *((Comma >> CHostIdentifier >> !CInitialValue)));;;
CCharacterVariable = (CCharacterType >> !((str_p("CHARACTER")) >>(("SET")) >> !(str_p("IS")) >> CharacterSetSpecification) >> CHostIdentifier >> CArraySpecification >> !CInitialValue >> *((Comma >> CHostIdentifier >> CArraySpecification >> !CInitialValue)));;;
CCharacterType = Char  | Unsigned >> Char  | Unsigned >> Short;;;
CArraySpecification = LeftBracket >> Length >> RightBracket;;;
CHostIdentifier = !!See >> the >> Syntax >> Rules.;;;
CDerivedVariable = CVARCHARVariable  | CNCHARVariable  | CNCHARVARYINGVariable  | CCLOBVariable  | CNCLOBVariable  | CBLOBVariable  | CUserDefinedTypeVariable  | CCLOBLocatorVariable  | CBLOBLocatorVariable  | CArrayLocatorVariable  | CMultisetLocatorVariable  | CUserDefinedTypeLocatorVariable  | CREFVariable;;;
CVARCHARVariable = ((str_p("VARCHAR")) >> !((str_p("CHARACTER")) >>(("SET")) >> !(str_p("IS")) >> CharacterSetSpecification) >> CHostIdentifier >> CArraySpecification >> !CInitialValue >> *((Comma >> CHostIdentifier >> CArraySpecification >> !CInitialValue)));;;
CNCHARVariable = ((str_p("NCHAR")) >> !((str_p("CHARACTER")) >>(("SET")) >> !(str_p("IS")) >> CharacterSetSpecification) >> CHostIdentifier >> CArraySpecification >> !CInitialValue >> *((Comma >> CHostIdentifier >> CArraySpecification >> !CInitialValue)));;;
CNCHARVARYINGVariable = ((str_p("NCHAR")) >>(("VARYING")) >> !((str_p("CHARACTER")) >>(("SET")) >> !(str_p("IS")) >> CharacterSetSpecification) >> CHostIdentifier >> CArraySpecification >> !CInitialValue >> *((Comma >> CHostIdentifier >> CArraySpecification >> !CInitialValue)));;;
CCLOBVariable = ((str_p("SQL")) >>(("TYPE")) >>(("IS")) >>(("CLOB")) >> LeftParen >> LargeObjectLength >> RightParen >> !((str_p("CHARACTER")) >>(("SET")) >> !(str_p("IS")) >> CharacterSetSpecification) >> CHostIdentifier >> !CInitialValue >> *((Comma >> CHostIdentifier >> !CInitialValue)));;;
CNCLOBVariable = ((str_p("SQL")) >>(("TYPE")) >>(("IS")) >>(("NCLOB")) >> LeftParen >> LargeObjectLength >> RightParen >> !((str_p("CHARACTER")) >>(("SET")) >> !(str_p("IS")) >> CharacterSetSpecification) >> CHostIdentifier >> !CInitialValue >> *((Comma >> CHostIdentifier >> !CInitialValue)));;;
CUserDefinedTypeVariable = ((str_p("SQL")) >>(("TYPE")) >>(("IS")) >> PathResolvedUserDefinedTypeName >>(("AS")) >> PredefinedType >> CHostIdentifier >> !CInitialValue >> *((Comma >> CHostIdentifier >> !CInitialValue)));;;
CBLOBVariable = ((str_p("SQL")) >>(("TYPE")) >>(("IS")) >>(("BLOB")) >> LeftParen >> LargeObjectLength >> RightParen >> CHostIdentifier >> !CInitialValue >> *((Comma >> CHostIdentifier >> !CInitialValue)));;;
CCLOBLocatorVariable = ((str_p("SQL")) >>(("TYPE")) >>(("IS")) >>(("CLOB")) >>(("AS")) >>(("LOCATOR")) >> CHostIdentifier >> !CInitialValue >> *((Comma >> CHostIdentifier >> !CInitialValue)));;;
CBLOBLocatorVariable = ((str_p("SQL")) >>(("TYPE")) >>(("IS")) >>(("BLOB")) >>(("AS")) >>(("LOCATOR")) >> CHostIdentifier >> !CInitialValue >> *((Comma >> CHostIdentifier >> !CInitialValue)));;;
CArrayLocatorVariable = ((str_p("SQL")) >>(("TYPE")) >>(("IS")) >> ArrayType >>(("AS")) >>(("LOCATOR")) >> CHostIdentifier >> !CInitialValue >> *((Comma >> CHostIdentifier >> !CInitialValue)));;;
CMultisetLocatorVariable = ((str_p("SQL")) >>(("TYPE")) >>(("IS")) >> MultisetType >>(("AS")) >>(("LOCATOR")) >> CHostIdentifier >> !CInitialValue >> *((Comma >> CHostIdentifier >> !CInitialValue)));;;
CUserDefinedTypeLocatorVariable = ((str_p("SQL")) >>(("TYPE")) >>(("IS")) >> PathResolvedUserDefinedTypeName >>(("AS")) >>(("LOCATOR")) >> CHostIdentifier >> !CInitialValue >> *((Comma >> CHostIdentifier >> !CInitialValue)));;;
CREFVariable =(str_p("SQL")) >>(("TYPE")) >>(("IS")) >> ReferenceType;;;
CInitialValue = (EqualsOperator >> +CharacterRepresentation);;;
EmbeddedSQLCOBOLProgram = !!See >> the >> Syntax >> Rules.;;;
COBOLVariableDefinition = (01  | 77 >> COBOLHostIdentifier >> COBOLTypeSpecification >> *CharacterRepresentation >> Period);;;
COBOLHostIdentifier = !!See >> The >> Syntax >> Rules.;;;
COBOLTypeSpecification = COBOLCharacterType  | COBOLNationalCharacterType  | COBOLNumericType  | COBOLIntegerType  | COBOLDerivedTypeSpecification;;;
COBOLDerivedTypeSpecification = COBOLCLOBVariable  | COBOLNCLOBVariable  | COBOLBLOBVariable  | COBOLUserDefinedTypeVariable  | COBOLCLOBLocatorVariable  | COBOLBLOBLocatorVariable  | COBOLArrayLocatorVariable  | COBOLMultisetLocatorVariable  | COBOLUserDefinedTypeLocatorVariable  | COBOLREFVariable;;;
COBOLCharacterType = !(((str_p("CHARACTER")) >>(("SET")) >> !(str_p("IS")) >> CharacterSetSpecification) >> PIC  | PICTURE >> !(str_p("IS")) >> +(X >> !LeftParen >> Length >> RightParen));;;
COBOLNationalCharacterType = !(((str_p("CHARACTER")) >>(("SET")) >> !(str_p("IS")) >> CharacterSetSpecification) >> PIC  | PICTURE >> !(str_p("IS")) >> +(N >> !LeftParen >> Length >> RightParen));;;
COBOLCLOBVariable = !(((str_p("USAGE")) >> !(str_p("IS"))) >>(("SQL")) >>(("TYPE")) >>(("IS")) >>(("CLOB")) >> LeftParen >> LargeObjectLength >> RightParen >> !((str_p("CHARACTER")) >>(("SET")) >> !(str_p("IS")) >> CharacterSetSpecification));;;
COBOLNCLOBVariable = !(((str_p("USAGE")) >> !(str_p("IS"))) >>(("SQL")) >>(("TYPE")) >>(("IS")) >>(("NCLOB")) >> LeftParen >> LargeObjectLength >> RightParen >> !((str_p("CHARACTER")) >>(("SET")) >> !(str_p("IS")) >> CharacterSetSpecification));;;
COBOLBLOBVariable = !(((str_p("USAGE")) >> !(str_p("IS"))) >>(("SQL")) >>(("TYPE")) >>(("IS")) >>(("BLOB")) >> LeftParen >> LargeObjectLength >> RightParen);;;
COBOLUserDefinedTypeVariable = !(((str_p("USAGE")) >> !(str_p("IS"))) >>(("SQL")) >>(("TYPE")) >>(("IS")) >> PathResolvedUserDefinedTypeName >>(("AS")) >> PredefinedType);;;
COBOLCLOBLocatorVariable = !(((str_p("USAGE")) >> !(str_p("IS"))) >>(("SQL")) >>(("TYPE")) >>(("IS")) >>(("CLOB")) >>(("AS")) >>(("LOCATOR")));;;
COBOLBLOBLocatorVariable = !(((str_p("USAGE")) >> !(str_p("IS"))) >>(("SQL")) >>(("TYPE")) >>(("IS")) >>(("BLOB")) >>(("AS")) >>(("LOCATOR")));;;
COBOLArrayLocatorVariable = !(((str_p("USAGE")) >> !(str_p("IS"))) >>(("SQL")) >>(("TYPE")) >>(("IS")) >> ArrayType >>(("AS")) >>(("LOCATOR")));;;
COBOLMultisetLocatorVariable = !(((str_p("USAGE")) >> !(str_p("IS"))) >>(("SQL")) >>(("TYPE")) >>(("IS")) >> MultisetType >>(("AS")) >>(("LOCATOR")));;;
COBOLUserDefinedTypeLocatorVariable = !(((str_p("USAGE")) >> !(str_p("IS"))) >>(("SQL")) >>(("TYPE")) >>(("IS")) >> PathResolvedUserDefinedTypeName >>(("AS")) >>(("LOCATOR")));;;
COBOLREFVariable = !(((str_p("USAGE")) >> !(str_p("IS"))) >>(("SQL")) >>(("TYPE")) >>(("IS")) >> ReferenceType);;;
COBOLNumericType = (PIC  | PICTURE >> !(str_p("IS")) >> S >> COBOLNinesSpecification >> !((str_p("USAGE")) >> !(str_p("IS"))) >> DISPLAY >> SIGN >>(("LEADING")) >> SEPARATE);;;
COBOLNinesSpecification = (COBOLNines >> !(V >> !COBOLNines))  | V >> COBOLNines;;;
COBOLIntegerType = COBOLBinaryInteger;;;
COBOLBinaryInteger = (PIC  | PICTURE >> !(str_p("IS")) >> S >> COBOLNines >> !((str_p("USAGE")) >> !(str_p("IS"))) >>(("BINARY")));;;
COBOLNines = +((9 >> !LeftParen >> Length >> RightParen));;;
EmbeddedSQLFortranProgram = !!See >> the >> Syntax >> Rules.;;;
FortranVariableDefinition = (FortranTypeSpecification >> (FortranHostIdentifier%Comma));;;
FortranHostIdentifier = !!See >> the >> Syntax >> Rules.;;;
FortranTypeSpecification = ((str_p("CHARACTER")) >> !Asterisk >> Length >> !((str_p("CHARACTER")) >>(("SET")) >> !(str_p("IS")) >> CharacterSetSpecification))  |(("CHARACTER")) >> KIND=(n >> !Asterisk >> Length >> !((str_p("CHARACTER")) >>(("SET")) >> !(str_p("IS")) >> CharacterSetSpecification))  |(("INTEGER"))  |(("REAL"))  |(("DOUBLE")) >>(("PRECISION"))  | LOGICAL  | FortranDerivedTypeSpecification;;;
FortranDerivedTypeSpecification = FortranCLOBVariable  | FortranBLOBVariable  | FortranUserDefinedTypeVariable  | FortranCLOBLocatorVariable  | FortranBLOBLocatorVariable  | FortranUserDefinedTypeLocatorVariable  | FortranArrayLocatorVariable  | FortranMultisetLocatorVariable  | FortranREFVariable;;;
FortranCLOBVariable = ((str_p("SQL")) >>(("TYPE")) >>(("IS")) >>(("CLOB")) >> LeftParen >> LargeObjectLength >> RightParen >> !((str_p("CHARACTER")) >>(("SET")) >> !(str_p("IS")) >> CharacterSetSpecification));;;
FortranBLOBVariable =(str_p("SQL")) >>(("TYPE")) >>(("IS")) >>(("BLOB")) >> LeftParen >> LargeObjectLength >> RightParen;;;
FortranUserDefinedTypeVariable =(str_p("SQL")) >>(("TYPE")) >>(("IS")) >> PathResolvedUserDefinedTypeName >>(("AS")) >> PredefinedType;;;
FortranCLOBLocatorVariable =(str_p("SQL")) >>(("TYPE")) >>(("IS")) >>(("CLOB")) >>(("AS")) >>(("LOCATOR"));;;
FortranBLOBLocatorVariable =(str_p("SQL")) >>(("TYPE")) >>(("IS")) >>(("BLOB")) >>(("AS")) >>(("LOCATOR"));;;
FortranUserDefinedTypeLocatorVariable =(str_p("SQL")) >>(("TYPE")) >>(("IS")) >> PathResolvedUserDefinedTypeName >>(("AS")) >>(("LOCATOR"));;;
FortranArrayLocatorVariable =(str_p("SQL")) >>(("TYPE")) >>(("IS")) >> ArrayType >>(("AS")) >>(("LOCATOR"));;;
FortranMultisetLocatorVariable =(str_p("SQL")) >>(("TYPE")) >>(("IS")) >> MultisetType >>(("AS")) >>(("LOCATOR"));;;
FortranREFVariable =(str_p("SQL")) >>(("TYPE")) >>(("IS")) >> ReferenceType;;;
EmbeddedSQLMUMPSProgram = !!See >> the >> Syntax >> Rules.;;;
MUMPSVariableDefinition = MUMPSNumericVariable >> Semicolon  | MUMPSCharacterVariable >> Semicolon  | MUMPSDerivedTypeSpecification >> Semicolon;;;
MUMPSCharacterVariable = ((str_p("VARCHAR")) >> MUMPSHostIdentifier >> MUMPSLengthSpecification >> *(Comma >> MUMPSHostIdentifier >> MUMPSLengthSpecification));;;
MUMPSHostIdentifier = !!See >> The >> Syntax >> Rules.;;;
MUMPSLengthSpecification = LeftParen >> Length >> RightParen;;;
MUMPSNumericVariable = (MUMPSTypeSpecification >> (MUMPSHostIdentifier%Comma));;;
MUMPSTypeSpecification =(str_p("INT"))  | ((str_p("DEC")) >> !(LeftParen >> Precision >> !Comma >> Scale >> RightParen))  |(("REAL"));;;
MUMPSDerivedTypeSpecification = MUMPSCLOBVariable  | MUMPSBLOBVariable  | MUMPSUserDefinedTypeVariable  | MUMPSCLOBLocatorVariable  | MUMPSBLOBLocatorVariable  | MUMPSUserDefinedTypeLocatorVariable  | MUMPSArrayLocatorVariable  | MUMPSMultisetLocatorVariable  | MUMPSREFVariable;;;
MUMPSCLOBVariable = ((str_p("SQL")) >>(("TYPE")) >>(("IS")) >>(("CLOB")) >> LeftParen >> LargeObjectLength >> RightParen >> !((str_p("CHARACTER")) >>(("SET")) >> !(str_p("IS")) >> CharacterSetSpecification));;;
MUMPSBLOBVariable =(str_p("SQL")) >>(("TYPE")) >>(("IS")) >>(("BLOB")) >> LeftParen >> LargeObjectLength >> RightParen;;;
MUMPSUserDefinedTypeVariable =(str_p("SQL")) >>(("TYPE")) >>(("IS")) >> PathResolvedUserDefinedTypeName >>(("AS")) >> PredefinedType;;;
MUMPSCLOBLocatorVariable =(str_p("SQL")) >>(("TYPE")) >>(("IS")) >>(("CLOB")) >>(("AS")) >>(("LOCATOR"));;;
MUMPSBLOBLocatorVariable =(str_p("SQL")) >>(("TYPE")) >>(("IS")) >>(("BLOB")) >>(("AS")) >>(("LOCATOR"));;;
MUMPSUserDefinedTypeLocatorVariable =(str_p("SQL")) >>(("TYPE")) >>(("IS")) >> PathResolvedUserDefinedTypeName >>(("AS")) >>(("LOCATOR"));;;
MUMPSArrayLocatorVariable =(str_p("SQL")) >>(("TYPE")) >>(("IS")) >> ArrayType >>(("AS")) >>(("LOCATOR"));;;
MUMPSMultisetLocatorVariable =(str_p("SQL")) >>(("TYPE")) >>(("IS")) >> MultisetType >>(("AS")) >>(("LOCATOR"));;;
MUMPSREFVariable =(str_p("SQL")) >>(("TYPE")) >>(("IS")) >> ReferenceType;;;
EmbeddedSQLPascalProgram = !!See >> The >> Syntax >> Rules.;;;
PascalVariableDefinition = ((PascalHostIdentifier%Comma) >> Colon >> PascalTypeSpecification >> Semicolon);;;
PascalHostIdentifier = !!See >> The >> Syntax >> Rules.;;;
PascalTypeSpecification = (PACKED >>(("ARRAY")) >> LeftBracket >> 1 >> DoublePeriod >> Length >> RightBracket >>(("OF")) >>(("CHAR")) >> !((str_p("CHARACTER")) >>(("SET")) >> !(str_p("IS")) >> CharacterSetSpecification))  |(("INTEGER"))  |(("REAL"))  | ((str_p("CHAR")) >> !((str_p("CHARACTER")) >>(("SET")) >> !(str_p("IS")) >> CharacterSetSpecification))  |(("BOOLEAN"))  | PascalDerivedTypeSpecification;;;
PascalDerivedTypeSpecification = PascalCLOBVariable  | PascalBLOBVariable  | PascalUserDefinedTypeVariable  | PascalCLOBLocatorVariable  | PascalBLOBLocatorVariable  | PascalUserDefinedTypeLocatorVariable  | PascalArrayLocatorVariable  | PascalMultisetLocatorVariable  | PascalREFVariable;;;
PascalCLOBVariable = ((str_p("SQL")) >>(("TYPE")) >>(("IS")) >>(("CLOB")) >> LeftParen >> LargeObjectLength >> RightParen >> !((str_p("CHARACTER")) >>(("SET")) >> !(str_p("IS")) >> CharacterSetSpecification));;;
PascalBLOBVariable =(str_p("SQL")) >>(("TYPE")) >>(("IS")) >>(("BLOB")) >> LeftParen >> LargeObjectLength >> RightParen;;;
PascalCLOBLocatorVariable =(str_p("SQL")) >>(("TYPE")) >>(("IS")) >>(("CLOB")) >>(("AS")) >>(("LOCATOR"));;;
PascalUserDefinedTypeVariable =(str_p("SQL")) >>(("TYPE")) >>(("IS")) >> PathResolvedUserDefinedTypeName >>(("AS")) >> PredefinedType;;;
PascalBLOBLocatorVariable =(str_p("SQL")) >>(("TYPE")) >>(("IS")) >>(("BLOB")) >>(("AS")) >>(("LOCATOR"));;;
PascalUserDefinedTypeLocatorVariable =(str_p("SQL")) >>(("TYPE")) >>(("IS")) >> PathResolvedUserDefinedTypeName >>(("AS")) >>(("LOCATOR"));;;
PascalArrayLocatorVariable =(str_p("SQL")) >>(("TYPE")) >>(("IS")) >> ArrayType >>(("AS")) >>(("LOCATOR"));;;
PascalMultisetLocatorVariable =(str_p("SQL")) >>(("TYPE")) >>(("IS")) >> MultisetType >>(("AS")) >>(("LOCATOR"));;;
PascalREFVariable =(str_p("SQL")) >>(("TYPE")) >>(("IS")) >> ReferenceType;;;
EmbeddedSQLPLIProgram = !!See >> The >> Syntax >> Rules.;;;
PLIVariableDefinition = (DCL  |(("DECLARE")) >> PLIHostIdentifier  | (LeftParen >> (PLIHostIdentifier%Comma) >> RightParen) >> PLITypeSpecification >> *CharacterRepresentation >> Semicolon);;;
PLIHostIdentifier = !!See >> The >> Syntax >> Rules.;;;
PLITypeSpecification = ((str_p("CHAR"))  |(("CHARACTER")) >> !(str_p("VARYING")) >> LeftParen >> Length >> RightParen >> !((str_p("CHARACTER")) >>(("SET")) >> !(str_p("IS")) >> CharacterSetSpecification))  | (PLITypeFixedDecimal >> LeftParen >> Precision >> !Comma >> Scale >> RightParen)  | (PLITypeFixedBinary >> !LeftParen >> Precision >> RightParen)  | PLITypeFloatBinary >> LeftParen >> Precision >> RightParen  | PLIDerivedTypeSpecification;;;
PLIDerivedTypeSpecification = PLICLOBVariable  | PLIBLOBVariable  | PLIUserDefinedTypeVariable  | PLICLOBLocatorVariable  | PLIBLOBLocatorVariable  | PLIUserDefinedTypeLocatorVariable  | PLIArrayLocatorVariable  | PLIMultisetLocatorVariable  | PLIREFVariable;;;
PLICLOBVariable = ((str_p("SQL")) >>(("TYPE")) >>(("IS")) >>(("CLOB")) >> LeftParen >> LargeObjectLength >> RightParen >> !((str_p("CHARACTER")) >>(("SET")) >> !(str_p("IS")) >> CharacterSetSpecification));;;
PLIBLOBVariable =(str_p("SQL")) >>(("TYPE")) >>(("IS")) >>(("BLOB")) >> LeftParen >> LargeObjectLength >> RightParen;;;
PLIUserDefinedTypeVariable =(str_p("SQL")) >>(("TYPE")) >>(("IS")) >> PathResolvedUserDefinedTypeName >>(("AS")) >> PredefinedType;;;
PLICLOBLocatorVariable =(str_p("SQL")) >>(("TYPE")) >>(("IS")) >>(("CLOB")) >>(("AS")) >>(("LOCATOR"));;;
PLIBLOBLocatorVariable =(str_p("SQL")) >>(("TYPE")) >>(("IS")) >>(("BLOB")) >>(("AS")) >>(("LOCATOR"));;;
PLIUserDefinedTypeLocatorVariable =(str_p("SQL")) >>(("TYPE")) >>(("IS")) >> PathResolvedUserDefinedTypeName >>(("AS")) >>(("LOCATOR"));;;
PLIArrayLocatorVariable =(str_p("SQL")) >>(("TYPE")) >>(("IS")) >> ArrayType >>(("AS")) >>(("LOCATOR"));;;
PLIMultisetLocatorVariable =(str_p("SQL")) >>(("TYPE")) >>(("IS")) >> MultisetType >>(("AS")) >>(("LOCATOR"));;;
PLIREFVariable =(str_p("SQL")) >>(("TYPE")) >>(("IS")) >> ReferenceType;;;
PLITypeFixedDecimal = ((str_p("DEC"))  |(("DECIMAL")) >> FIXED)  | (FIXED >>(("DEC"))  |(("DECIMAL")));;;
PLITypeFixedBinary = (BIN  |(("BINARY")) >> FIXED)  | (FIXED >> BIN  |(("BINARY")));;;
PLITypeFloatBinary = (BIN  |(("BINARY")) >>(("FLOAT")))  | ((str_p("FLOAT")) >> BIN  |(("BINARY")));;;
DirectSQLStatement = DirectlyExecutableStatement >> Semicolon;;;
DirectlyExecutableStatement = DirectSQLDataStatement  | SQLSchemaStatement  | SQLTransactionStatement  | SQLConnectionStatement  | SQLSessionStatement  | DirectImplementationDefinedStatement;;;
DirectSQLDataStatement = DeleteStatementSearched  | DirectSelectStatementMultipleRows  | InsertStatement  | UpdateStatementSearched  | MergeStatement  | TemporaryTableDeclaration;;;
DirectImplementationDefinedStatement = !!See >> the >> Syntax >> Rules;;;
DirectSelectStatementMultipleRows = CursorSpecification;;;
GetDiagnosticsStatement =(str_p("GET")) >>(("DIAGNOSTICS")) >> SQLDiagnosticsInformation;;;
SQLDiagnosticsInformation = StatementInformation  | ConditionInformation;;;
StatementInformation = ((StatementInformationItem%Comma));;;
StatementInformationItem = SimpleTargetSpecification >> EqualsOperator >> StatementInformationItemName;;;
StatementInformationItemName =(str_p("NUMBER"))  |(("MORE"))  |(("COMMAND_FUNCTION"))  |(("COMMAND_FUNCTION_CODE"))  |(("DYNAMIC_FUNCTION"))  |(("DYNAMIC_FUNCTION_CODE"))  |(("ROW_COUNT"))  |(("TRANSACTIONS_COMMITTED"))  |(("TRANSACTIONS_ROLLED_BACK"))  |(("TRANSACTION_ACTIVE"));;;
ConditionInformation = ((str_p("EXCEPTION"))  |(("CONDITION")) >> ConditionNumber >> (ConditionInformationItem%Comma));;;
ConditionInformationItem = SimpleTargetSpecification >> EqualsOperator >> ConditionInformationItemName;;;
ConditionInformationItemName =(str_p("CATALOG_NAME"))  |(("CLASS_ORIGIN"))  |(("COLUMN_NAME"))  |(("CONDITION_NUMBER"))  |(("CONNECTION_NAME"))  |(("CONSTRAINT_CATALOG"))  |(("CONSTRAINT_NAME"))  |(("CONSTRAINT_SCHEMA"))  |(("CURSOR_NAME"))  |(("MESSAGE_LENGTH"))  |(("MESSAGE_OCTET_LENGTH"))  |(("MESSAGE_TEXT"))  |(("PARAMETER_MODE"))  |(("PARAMETER_NAME"))  |(("PARAMETER_ORDINAL_POSITION"))  |(("RETURNED_SQLSTATE"))  |(("ROUTINE_CATALOG"))  |(("ROUTINE_NAME"))  |(("ROUTINE_SCHEMA"))  |(("SCHEMA_NAME"))  |(("SERVER_NAME"))  |(("SPECIFIC_NAME"))  |(("SUBCLASS_ORIGIN"))  |(("TABLE_NAME"))  |(("TRIGGER_CATALOG"))  |(("TRIGGER_NAME"))  |(("TRIGGER_SCHEMA"));;;
#504$5 Thu 08101604:43:03 jim@keyframe:~/work/xSWO
: