alasqlparser.jison

/*
//
// alasqlparser.jison
// SQL Parser for AlaSQL
// (c) 2014-2015, Andrey Gershun
//
//
*/

%lex
%options case-insensitive

%%

/*
\$\$(.+?)\$\$				            return 'DOLLARSTRING'
*/

\`\`([^\`])+\`\`						return 'JAVASCRIPT'
\[\?\]									return 'BRAQUESTION'
'@['									return 'ATLBRA'
'ARRAY['								return 'ARRAYLBRA'
\[([^\]'])*?\]							return 'BRALITERAL'
\`([^\`'])*?\`	   						return 'BRALITERAL'

N(['](\\.|[^']|\\\')*?['])+             return 'NSTRING'
X(['](\\.|[^']|\\\')*?['])+             return 'NSTRING'
(['](\\.|[^']|\\\')*?['])+              return 'STRING'
(["](\\.|[^"]|\\\")*?["])+              return 'STRING'


"--"(.*?)($|\r\n|\r|\n)							return /* its a COMMENT */

\s+                                             /* skip whitespace */
'||'											return 'BARBAR'
'|'												return 'BAR'
/* '&&'											return 'AMPERSANDAMPERSAND' */

VALUE\s+OF\s+SEARCH                          	yytext = 'VALUE';return 'SEARCH'
VALUE\s+OF\s+SELECT                          	yytext = 'VALUE';return 'SELECT'
ROW\s+OF\s+SELECT                           	yytext = 'ROW';return 'SELECT'
COLUMN\s+OF\s+SELECT                          	yytext = 'COLUMN';return 'SELECT'
MATRIX\s+OF\s+SELECT                          	yytext = 'MATRIX';return 'SELECT'
INDEX\s+OF\s+SELECT                           	yytext = 'INDEX';return 'SELECT'
RECORDSET\s+OF\s+SELECT                       	yytext = 'RECORDSET';return 'SELECT'
TEXT\s+OF\s+SELECT                           	yytext = 'TEXT';return 'SELECT'

'SELECT'                           				yytext = 'SELECT';return 'SELECT'

'ABSOLUTE'                                 		return 'ABSOLUTE'
'ACTION'                                      	return 'ACTION'
'ADD'                                      		return 'ADD'
'AFTER'                                      	return 'AFTER'
'AGGR'                                     		return 'AGGR'
'AGGREGATE'                                     return 'AGGREGATE'
'AGGREGATOR'                                    return 'AGGREGATE'
'ALL'                                      		return 'ALL'
'ALTER'                                    		return 'ALTER'
'AND'											return 'AND'
'ANTI'											return 'ANTI'
'ANY'											return 'ANY'
'APPLY'											return 'APPLY'
'ARRAY'                                     	return 'ARRAY'
'AS'                                      		return 'AS'
'ASSERT'                                      	return 'ASSERT'
'ASC'                                      		return 'DIRECTION'
'ATTACH'                                      	return 'ATTACH'
AUTO(_)?INCREMENT                               return 'IDENTITY'
'AVG'                                      		return 'AVG'

'BEFORE'                                      	return 'BEFORE'
'BEGIN'											return 'BEGIN'
'BETWEEN'										return 'BETWEEN'
'BREAK'											return 'BREAK'
NOT\s+BETWEEN									return 'NOT_BETWEEN'
NOT\s+LIKE									    return 'NOT_LIKE'
'BY'											return 'BY'

/* Postgres aliases */
'~~*'											return 'LIKE'
'!~~*'											return 'NOT_LIKE'
'~~'											return 'LIKE'
'!~~'											return 'NOT_LIKE'
'ILIKE'											return 'LIKE'
NOT\s+ILIKE										return 'NOT_LIKE'

'CALL'											return 'CALL'
'CASE'											return 'CASE'
'CASCADE'										return 'CASCADE'
'CAST'											return 'CAST'
'CHECK'											return 'CHECK'
'CLASS'											return 'CLASS'
'CLOSE'											return 'CLOSE'
'COLLATE'										return 'COLLATE'
COLUMN											return 'COLUMN'
COLUMNS 										return 'COLUMN'
"COMMIT"										return 'COMMIT'
"CONSTRAINT"									return 'CONSTRAINT'
"CONTENT"										return 'CONTENT'
"CONTINUE"										return 'CONTINUE'
"CONVERT"										return 'CONVERT'
"CORRESPONDING"									return 'CORRESPONDING'
"COUNT"											return 'COUNT'
'CREATE'										return 'CREATE'
"CROSS"											return 'CROSS'
'CUBE'											return 'CUBE'
"CURRENT_TIMESTAMP"								return 'CURRENT_TIMESTAMP'
"CURRENT_DATE"									return 'CURRENT_DATE'
"CURDATE"										return 'CURRENT_DATE'
"CURSOR"										return 'CURSOR'
DATABASE(S)?									return 'DATABASE'
'DATEADD'                                       return 'DATEADD'
'DATEDIFF'                                      return 'DATEDIFF'
'TIMESTAMPDIFF'                                      return 'TIMESTAMPDIFF'
'DECLARE'                                       return 'DECLARE'
'DEFAULT'                                       return 'DEFAULT'
'DELETE'                                        return 'DELETE'
'DELETED'                                       return 'DELETED'
'DESC'                                          return 'DIRECTION'
'DETACH'										return 'DETACH'
'DISTINCT'                                      return 'DISTINCT'
/* DOUBLE\s+PRECISION								return 'LITERAL' */
'DROP'											return 'DROP'
'ECHO'											return 'ECHO'
'EDGE'											return 'EDGE'
'END'											return 'END'
'ENUM'											return 'ENUM'
'ELSE'											return 'ELSE'
'ESCAPE'										return 'ESCAPE'
'EXCEPT'										return 'EXCEPT'
'EXEC'											return 'CALL'
'EXECUTE'										return 'CALL'
'EXISTS'										return 'EXISTS'
'EXPLAIN'                                       return 'EXPLAIN'
'FALSE'											return 'FALSE'
'FETCH'											return 'FETCH'
'FIRST'											return 'FIRST'
'FOR'											return 'FOR'
'FOREIGN'										return 'FOREIGN'
'FROM'                                          return 'FROM'
'FULL'											return 'FULL'
'FUNCTION'										return 'FUNCTION'
'GLOB'                                     		return 'GLOB'
'GO'                                      		return 'GO'
'GRAPH'                                      	return 'GRAPH'
'GROUP'                                      	return 'GROUP'
'GROUPING'                                     	return 'GROUPING'
'HAVING'                                        return 'HAVING'
/*'HELP'											return 'HELP'*/
'IF'											return 'IF'
'IDENTITY'										return 'IDENTITY'
'IGNORE'										return 'IGNORE'
'IS'											return 'IS'
'IN'											return 'IN'
'INDEX'											return 'INDEX'
'INDEXED'										return 'INDEXED'
'INNER'                                         return 'INNER'
'INSTEAD'                                       return 'INSTEAD'
'INSERT'                                        return 'INSERT'
'INSERTED'                                      return 'INSERTED'
'INTERSECT'                                     return 'INTERSECT'
'INTERVAL'                                      return 'INTERVAL'
'INTO'                                         	return 'INTO'
'ITERATE'										return 'ITERATE'
'JOIN'                                         	return 'JOIN'
'KEY'											return 'KEY'
'LAST'											return 'LAST'
'LET'											return 'LET'
'LEAVE'											return 'LEAVE'
'LEFT'											return 'LEFT'
'LIKE'											return 'LIKE'
'LIMIT'											return 'LIMIT'
'MATCHED'										return 'MATCHED'
'MATRIX'										return 'MATRIX'
'MAX'\s*/'('									return 'MAX'
'MAX'\s*/(','|')')								return 'MAXNUM'
'MIN'\s*/'('									return 'MIN'
"MERGE"											return 'MERGE'
"MINUS"											return 'EXCEPT'
"MODIFY"										return 'MODIFY'
'NATURAL'										return 'NATURAL'
'NEXT'											return 'NEXT'
'NEW'											return 'NEW'
'NOCASE'										return 'NOCASE'
'NO'											return 'NO'
'NOT'											return 'NOT'
'NULL'											return 'NULL'
'NULLS'											return 'NULLS'
'OFF'											return 'OFF'
'ON'											return 'ON'
'ONLY'											return 'ONLY'
'OF'											return 'OF'
'OFFSET'										return 'OFFSET'
'OPEN'											return 'OPEN'
'OPTION'										return 'OPTION'
'OR'											return 'OR'
'ORDER'	                                      	return 'ORDER'
'OUTER'											return 'OUTER'
'OUTPUT'										return 'OUTPUT'
'OVER'											return 'OVER'
'PATH'                                        	return 'PATH'
'PARTITION'										return 'PARTITION'
'PERCENT'                                       return 'PERCENT'
'PIVOT'                                        	return 'PIVOT'
'PLAN'                                        	return 'PLAN'
'PRIMARY'										return 'PRIMARY'
'PRINT'                                        	return 'PRINT'
'PRIOR'                                        	return 'PRIOR'
'QUERY'                                        	return 'QUERY'
'READ'		                                    return 'READ'
'RECORDSET'                                     return 'RECORDSET'
'REDUCE'                                        return 'REDUCE'
'RECURSIVE'                                     return 'RECURSIVE'
'REFERENCES'                                    return 'REFERENCES'
'REGEXP'		                                return 'REGEXP'
'REINDEX'		                                return 'REINDEX'
'RELATIVE'                                      return 'RELATIVE'
'REMOVE'                                        return 'REMOVE'
'RENAME'                                        return 'RENAME'
'REPEAT'										return 'REPEAT'
'REPLACE'										return 'REPLACE'
'RESTRICT'										return 'RESTRICT'
'REQUIRE'                                       return 'REQUIRE'
'RESTORE'                                       return 'RESTORE'
'RETURN'                                       	return 'RETURN'
'RETURNS'                                       return 'RETURN'
'RIGHT'                                        	return 'RIGHT'
'ROLLBACK'										return 'ROLLBACK'
'ROLLUP'										return 'ROLLUP'
'ROW'											return 'ROW'
'ROWS'											return 'ROWS'
SCHEMA(S)?                                      return 'DATABASE'
'SEARCH'                                        return 'SEARCH'

'SEMI'                                        	return 'SEMI'
SET 	                                       	return 'SET'
SETS                                        	return 'SET'
'SHOW'                                        	return 'SHOW'
'SOME'                                        	return 'SOME'
'SOURCE'										return 'SOURCE'
'STRATEGY'										return 'STRATEGY'
'STORE'                                        	return 'STORE'
'SUM'											return 'SUM'
'TOTAL'											return 'TOTAL'
'TABLE'											return 'TABLE'
'TABLES'										return 'TABLE'
'TARGET'										return 'TARGET'
'TEMP'											return 'TEMP'
'TEMPORARY'										return 'TEMP'
'TEXTSTRING'									return 'TEXTSTRING'
'THEN'											return 'THEN'
'TIMEOUT'										return 'TIMEOUT'
'TO'											return 'TO'
'TOP'											return 'TOP'
'TRAN'											return 'TRANSACTION'
'TRANSACTION'									return 'TRANSACTION'
'TRIGGER'										return 'TRIGGER'
'TRUE'						  					return 'TRUE'
'TRUNCATE'					  					return 'TRUNCATE'
'UNION'                                         return 'UNION'
'UNIQUE'                                        return 'UNIQUE'
'UNPIVOT'                                       return 'UNPIVOT'
'UPDATE'                                        return 'UPDATE'
'USE'											return 'USE'
/* 'USER'										return 'USER' */
'USING'                                         return 'USING'
'VALUE'                                      	return 'VALUE'
'VALUES'                                      	return 'VALUES'
'VERTEX'										return 'VERTEX'
'VIEW'											return 'VIEW'
'WHEN'                                          return 'WHEN'
'WHERE'                                         return 'WHERE'
'WHILE'                                         return 'WHILE'
'WITH'                                          return 'WITH'
'WORK'                                          return 'TRANSACTION'  /* Is this keyword required? */

/* LITERAL must come before NUMBER to match identifiers like 50k, 100x as single tokens */
[0-9]*[a-zA-Z_]+[a-zA-Z_0-9]* 					return 'LITERAL'
(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?(?![a-zA-Z_0-9])				return 'NUMBER'
'->'											return 'ARROW'
'#'												return 'SHARP'
'+'												return 'PLUS'
'-' 											return 'MINUS'
'*'												return 'STAR'
'/'												return 'SLASH'
'%'												return 'MODULO'
'!==='											return 'NEEQEQEQ'
'==='											return 'EQEQEQ'
'!=='											return 'NEEQEQ'
'=='											return 'EQEQ'
'>='											return 'GE'
'&'												return 'AMPERSAND'
'|'												return 'BAR'
'<<'											return 'LTLT'
'>>'											return 'GTGT'
'>'												return 'GT'
'<='											return 'LE'
'<>'											return 'NE'
'<'												return 'LT'
'='												return 'EQ'
'!='											return 'NE'
'('												return 'LPAR'
')'												return 'RPAR'
'{'												return 'LCUR'
'}'												return 'RCUR'

']'												return 'RBRA'

':-'											return 'COLONDASH'
'?-'											return 'QUESTIONDASH'
'..'											return 'DOTDOT'
'.'												return 'DOT'
','												return 'COMMA'
'::'											return 'DOUBLECOLON'
':'												return 'COLON'
';'												return 'SEMICOLON'
'$'												return 'DOLLAR'
'?'												return 'QUESTION'
'!'												return 'EXCLAMATION'
'^'												return 'CARET'

'~'												return 'TILDA'

'@'												return 'AT'
<<EOF>>               							return 'EOF'
.												return 'INVALID'

/lex
%left COMMA
%left DOUBLECOLON
%left OR
/* %left AND */
%left AND BETWEEN NOT_BETWEEN
/*%left AND*/
%left IN
%left NOT
%left GT GE LT LE EQ NE EQEQ NEEQEQ EQEQEQ NEEQEQEQ
%left IS
%left LIKE NOT_LIKE REGEXP GLOB
%left GTGT LTLT AMPERSAND BAR
%left PLUS MINUS
%left STAR SLASH MODULO
%left CARET
%left DOT ARROW EXCLAMATION
%left TILDA
%left SHARP

%left BARBAR

%ebnf
%start main
%%

Literal
	: LITERAL
		{
			if (alasql.options.casesensitive) $$ = $1;
			else $$ = $1.toLowerCase();
		}
	| BRALITERAL
		{ $$ = doubleq($1.substr(1,$1.length-2)); }
	| KEY
		{ $$ = $1.toLowerCase(); }
	| OPEN
		{ $$ = $1.toLowerCase(); }
	| error NonReserved
		{ $$ = $2.toLowerCase() }
	;

LiteralWithSpaces
	: LITERAL
		{ $$ = $1 }
	| LiteralWithSpaces LITERAL
		{ $$ = $2 ? $1 + ' ' + $2 : $1 }
	;

main
	: Statements EOF
		{ return new yy.Statements({statements:$1}); }
	;

Statements
	: Statements (SEMICOLON|GO) AStatement
		{ $$ = $1; if($3) $1.push($3); }
	| AStatement
		{ $$ = [$1]; }
	| ExplainStatement
		{ $$ = [$1]; }
	;

ExplainStatement
	: EXPLAIN AStatement
		{ $$ = $2; $2.explain = true; }
	| EXPLAIN QUERY PLAN AStatement
		{ $$ = $4;  $4.explain = true;}
	;

AStatement
	: Statement
		{
			$$ = $1;

			// TODO combine exists and queries
		    if(yy.exists) $$.exists = yy.exists;
		    delete yy.exists;
		    if(yy.queries) $$.queries = yy.queries;
			delete yy.queries;
		}
	;

Statement
	: { $$ = undefined; }
	| AlterTable
	| AttachDatabase
	| Call
	| CreateDatabase
	| CreateIndex
	| CreateGraph
	| CreateTable
	| CreateView
	| CreateEdge
	| CreateVertex
	| Declare
	| Delete
	| DetachDatabase
	| DropDatabase
	| DropIndex
	| DropTable
	| DropView
	| If
	| Insert
	| Merge
	| Reindex
	| RenameTable
	| Select
	| ShowCreateTable
	| ShowColumns
	| ShowDatabases
	| ShowIndex
	| ShowTables
	| TruncateTable
	| WithSelect

	| CreateTrigger
	| DropTrigger

	| BeginTransaction
	| CommitTransaction
	| RollbackTransaction
	| EndTransaction
	| UseDatabase
	| Update
	/*| Help*/
	| JavaScript

	| Source
	| Assert
	| While
	| Continue
	| Break
	| BeginEnd
	| Print
	| Require
	| SetVariable
	| ExpressionStatement
	| AddRule
	| Query

/* PLugins */

	| Echo

/*
	| Store
	| Restore

	| DeclareCursor
	| OpenCursor
	| FetchCursor
	| CloseCursor

	| SavePoint
	| StoreDatabase
	| StoreTable
	| RestoreDatabase
	| RestoreTable

	| While
	| BulkInsert

	| CreateFunction
	| CreateProcedure
	| Loop
	| ForLoop
*/

	| CreateFunction
	| CreateAggregate
	;

/* WITH */

WithSelect
	: WITH WithTablesList Select
		{ $$ = new yy.WithSelect({withs: $2, select:$3}); }
	;

WithTablesList
	: WithTablesList COMMA WithTable
		{ $1.push($3); $$=$1; }
	| WithTablesList COMMA RECURSIVE WithTable
		{ $4.recursive = true; $1.push($4); $$=$1; }
	| WithTable
		{ $$ = [$1]; }
	| RECURSIVE WithTable
		{ $2.recursive = true; $$ = [$2]; }
	;

WithTable
	: Literal AS LPAR Select RPAR
		{ $$ = {name:$1, select:$4}; }
	| Literal LPAR ColumnsList RPAR AS LPAR Select RPAR
		{ $$ = {name:$1, columns:$3, select:$7}; }
	;

/* SELECT */

Select
	: SelectClause RemoveClause? IntoClause FromClause PivotClause? WhereClause GroupClause  UnionClause OrderClause LimitClause
		{
			yy.extend($$,$1); yy.extend($$,$2); yy.extend($$,$3); yy.extend($$,$4);
		    yy.extend($$,$5); yy.extend($$,$6);yy.extend($$,$7);
		    yy.extend($$,$8); yy.extend($$,$9); yy.extend($$,$10);
		    $$ = $1;
		    if(yy.exists) $$.exists = yy.exists.slice();
/*		    if(yy.queries) $$.queries = yy.queries;
			delete yy.queries;
*/		}
	| SEARCH SearchSelector* IntoClause SearchFrom?
	/* SearchLimit? SearchStrategy? SearchTimeout? */
		{
			$$ = new yy.Search({selectors:$2, from:$4});
			yy.extend($$,$3);
		}
	;

SelectWithoutOrderOrLimit
	: SelectClause RemoveClause? IntoClause FromClause PivotClause? WhereClause GroupClause UnionClause
		{
			yy.extend($$,$1); yy.extend($$,$2); yy.extend($$,$3); yy.extend($$,$4);
		    yy.extend($$,$5); yy.extend($$,$6);yy.extend($$,$7);yy.extend($$,$8);
		    $$ = $1;
		    if(yy.exists) $$.exists = yy.exists.slice();
		}
	;

PivotClause
	: PIVOT LPAR Expression FOR Literal PivotClause2? RPAR AsLiteral?
		{ $$ = {pivot:{expr:$3, columnid:$5, inlist:$6, as:$8}}; }
	| UNPIVOT LPAR Literal FOR Literal IN LPAR ColumnsList RPAR RPAR AsLiteral?
		{ $$ = {unpivot:{tocolumnid:$3, forcolumnid:$5, inlist:$8, as:$11}}; }
	;

PivotClause2
	: IN LPAR AsList RPAR
		{ $$ = $3; }
	;

AsLiteral
	: AS Literal
		{ $$ = $2; }
	| Literal
		{ $$ = $1; }
	;

AsList
	: AsList COMMA AsPart
		{ $$ = $1; $$.push($3); }
	| AsPart
		{ $$ = [$1]; }
	;

AsPart
	: Expression
		{ $$ = {expr:$1}; }
	| Expression AS Literal
		{ $$ = {expr:$1,as:$3}; }
	;

RemoveClause
	: REMOVE COLUMN? RemoveColumnsList
		{ $$ = {removecolumns:$3}; }
	;

RemoveColumnsList
	: RemoveColumnsList COMMA RemoveColumn
		{ $$ = $1; $$.push($3); }
	| RemoveColumn
		{ $$ = [$1]; }
	;

RemoveColumn
	: Column
		{ $$ = $1; }
	| LIKE StringValue
		{ $$ = {like:$2}; }
	;

ArrowDot
	: ARROW
	| DOT
	;

SearchSelector
	: Literal
		{ $$ = {srchid:"PROP", args: [$1]}; }

	| ORDER BY LPAR OrderExpressionsList RPAR
		{ $$ = {srchid:"ORDERBY", args: $4}; }
	| ORDER BY LPAR DIRECTION? RPAR
		{
			var dir = $4;
			if(!dir) dir = 'ASC';
			$$ = {srchid:"ORDERBY", args: [{expression: new yy.Column({columnid:'_'}), direction:dir}]};
		}

	| DOTDOT
		{ $$ = {srchid:"PARENT"}; }
	| ArrowDot Literal
		{ $$ = {srchid:"APROP", args: [$2]}; }
	| CARET
		{ $$ = {selid:"ROOT"};}
	| EQ Expression
		{ $$ = {srchid:"EQ", args: [$2]}; }
	| LIKE Expression
		{ $$ = {srchid:"LIKE", args: [$2]}; }
	| LPAR SearchSelector+ RPAR
		{ $$ = {selid:"WITH", args: $2}; }
	| WITH LPAR SearchSelector+ RPAR
		{ $$ = {selid:"WITH", args: $3}; }
	| Literal LPAR ExprList? RPAR
		{ $$ = {srchid:$1.toUpperCase(), args:$3}; }
	| WHERE LPAR Expression RPAR
		{ $$ = {srchid:"WHERE", args:[$3]}; }
	| OF LPAR Expression RPAR
		{ $$ = {selid:"OF", args:[$3]}; }
	| CLASS LPAR Literal RPAR
		{ $$ = {srchid:"CLASS", args:[$3]}; }
	| NUMBER
		{ $$ = {srchid:"PROP", args: [$1]}; }
	| STRING
		{ $$ = {srchid:"NAME", args: [$1.substr(1,$1.length-2)]}; }
	| SLASH
		{ $$ = {srchid:"CHILD"}; }
	| VERTEX
		{ $$ = {srchid:"VERTEX"}; }
	| EDGE
		{ $$ = {srchid:"EDGE"}; }
	| EXCLAMATION
		{ $$ = {srchid:"REF"}; }
	| SHARP Literal
		{ $$ = {srchid:"SHARP", args:[$2]}; }
	| MODULO Literal
		{ $$ = {srchid:"ATTR", args:((typeof $2 == 'undefined')?undefined:[$2])}; }
	| MODULO SLASH
		{ $$ = {srchid:"ATTR"}; }
	| GT
		{ $$ = {srchid:"OUT"}; }
	| LT
		{ $$ = {srchid:"IN"}; }
	| GTGT
		{ $$ = {srchid:"OUTOUT"}; }
	| LTLT
		{ $$ = {srchid:"ININ"}; }
	| DOLLAR
		{ $$ = {srchid:"CONTENT"}; } /* TODO Decide! */
/*	| DELETE LPAR RPAR
		{ $$ = {srchid:"DELETE"}; }
*/	| Json
		{ $$ = {srchid:"EX",args:[new yy.Json({value:$1})]}; }
	| AT Literal
		{ $$ = {srchid:"AT", args:[$2]}; }
	| AS AT Literal
		{ $$ = {srchid:"AS", args:[$3]}; }
	| SET LPAR SetColumnsList RPAR
		{ $$ = {srchid:"SET", args:$3}; }

	| TO AT Literal
		{ $$ = {selid:"TO", args:[$3]}; }
	| VALUE
		{ $$ = {srchid:"VALUE"}; }
	| ROW LPAR ExprList RPAR
		{ $$ = {srchid:"ROW", args:$3}; }
	| COLON Literal
		{ $$ = {srchid:"CLASS", args:[$2]}; }
	| SearchSelector PlusStar
		{ $$ = {selid:$2,args:[$1] }; }

	| NOT LPAR SearchSelector* RPAR
		{ $$ = {selid:"NOT",args:$3 }; }
	| IF LPAR SearchSelector* RPAR
		{ $$ = {selid:"IF",args:$3 }; }
	| Aggregator LPAR SearchSelector* RPAR
		{ $$ = {selid:$1,args:$3 }; }
	| (DISTINCT|UNIQUE) LPAR SearchSelector* RPAR
		{ $$ = {selid:'DISTINCT',args:$3 }; }
	| UNION LPAR SearchSelectorList RPAR
		{ $$ = {selid:'UNION',args:$3 }; }
	| UNION ALL LPAR SearchSelectorList RPAR
		{ $$ = {selid:'UNIONALL',args:$4 }; }
	| ALL LPAR SearchSelector* RPAR
		{ $$ = {selid:'ALL',args:[$3] }; }
	| ANY LPAR SearchSelector* RPAR
		{ $$ = {selid:'ANY',args:[$3] }; }
	| INTERSECT LPAR SearchSelectorList RPAR
		{ $$ = {selid:'INTERSECT',args:$3 }; }
	| EXCEPT LPAR SearchSelectorList RPAR
		{ $$ = {selid:'EXCEPT',args:$3 }; }
	| AND LPAR SearchSelectorList RPAR
		{ $$ = {selid:'AND',args:$3 }; }
	| OR LPAR SearchSelectorList RPAR
		{ $$ = {selid:'OR',args:$3 }; }
	| PATH LPAR SearchSelector RPAR
		{ $$ = {selid:'PATH',args:[$3] }; }
	| RETURN LPAR ResultColumns RPAR
		{ $$ = {srchid:'RETURN',args:$3 }; }
	| REPEAT LPAR SearchSelector* COMMA ExprList RPAR
		{ $$ = {selid:'REPEAT',sels:$3, args:$5 }; }
	;

SearchSelectorList
	: SearchSelectorList COMMA SearchSelector*
		{ $$ = $1; $$.push($3);}
	| SearchSelector*
		{ $$ = [$1]; }
	;

PlusStar
	: PLUS
		{ $$ = "PLUS"; }
	| STAR
		{ $$ = "STAR"; }
	| QUESTION
		{ $$ = "QUESTION"; }
	;

SearchFrom
	: FROM Expression
		{ $$ = $2; }
	;

/*
SearchLet
	: LET
	;

SearchWhile
	: WHILE Expression
	;
SearchLimit
	: LIMIT Expression
	;

SearchStrategy
	: STRATEGY Literal
	;

SearchTimeout
	: TIMEOUT Expression
	;

*/

SelectClause
	:
	/*

		{ $$ = new yy.Select({ columns:new yy.Column({columnid:'_'}), modifier: 'COLUMN' }); }
	|
*/

	SelectModifier DISTINCT TopClause ResultColumns
		{ $$ = new yy.Select({ columns:$4, distinct: true }); yy.extend($$, $1); yy.extend($$, $3); }
	| SelectModifier UNIQUE TopClause ResultColumns
		{ $$ = new yy.Select({ columns:$4, distinct: true }); yy.extend($$, $1);yy.extend($$, $3); }
	| SelectModifier  ALL TopClause ResultColumns
		{ $$ = new yy.Select({ columns:$4, all:true }); yy.extend($$, $1);yy.extend($$, $3); }
	| SelectModifier TopClause ResultColumns?
		{
			if(!$3) {
				$$ = new yy.Select({columns:[new yy.Column({columnid:'_',})], modifier:'COLUMN'});
			} else {
				$$ = new yy.Select({ columns:$3 }); yy.extend($$, $1);yy.extend($$, $2);
			}
		}
/*	|
		{ $$ = new yy.Select({columns:[new yy.Column({columnid:'_', modifier:'COLUMN'})]});}
*/	;

SelectModifier
	: SELECT
		{ if($1=='SELECT') $$ = undefined; else $$ = {modifier: $1};  }
	| SELECT VALUE
		{ $$ = {modifier:'VALUE'}}
	| SELECT ROW
		{ $$ = {modifier:'ROW'}}
	| SELECT COLUMN
		{ $$ = {modifier:'COLUMN'}}
	| SELECT MATRIX
		{ $$ = {modifier:'MATRIX'}}
	| SELECT TEXTSTRING
		{ $$ = {modifier:'TEXTSTRING'}}
	| SELECT INDEX
		{ $$ = {modifier:'INDEX'}}
	| SELECT RECORDSET
		{ $$ = {modifier:'RECORDSET'}}
	;

TopClause
	: TOP NumValue PERCENT?
		{ $$ = {top: $2, percent:(typeof $3 != 'undefined'?true:undefined)}; }
	| TOP LPAR NumValue RPAR
		{ $$ = {top: $3}; }
	| { $$ = undefined; }
	;

IntoClause
	: {$$ = undefined; }
	| INTO Table
		{$$ = {into: $2} }
	| INTO FuncValue
		{$$ = {into: $2} }
	| INTO ParamValue
		{$$ = {into: $2} }
	| INTO VarValue
		{$$ = {into: $2} }
	| INTO STRING
		{
			var s = $2;
			s = s.substr(1,s.length-2);
			var x3 = s.substr(-3).toUpperCase();
			var x4 = s.substr(-4).toUpperCase();
			if(s[0] == '#') {
				$$ = {into: new yy.FuncValue({funcid: 'HTML', args:[new yy.StringValue({value: s}), new yy.Json({value:{headers:true}})]})};
			} else if(x3=='XLS' || x3 == 'CSV' || x3=='TAB') {
				$$ = {into: new yy.FuncValue({funcid: x3, args:[new yy.StringValue({value: s}), new yy.Json({value:{headers:true}})]})};
			} else if(x4=='XLSX' || x4 == 'JSON') {
				$$ = {into: new yy.FuncValue({funcid: x4, args:[new yy.StringValue({value: s}), new yy.Json({value:{headers:true}})]})};
			}
		}
	;

FromClause
	: FROM FromTablesList
		{ $$ = { from: $2 }; }
/*	| FROM FromTable JoinTablesList
		{ $$ = { from: [$2], joins: $3 }; }
*/	| FROM FromTablesList JoinTablesList
		{ $$ = { from: $2, joins: $3 }; }
	| FROM FromTablesList JoinTablesList COMMA FromTablesList
		{ 
			// Convert comma-separated tables after joins into CROSS JOINs
			var joins = $3;
			$5.forEach(t => {
				var join = new yy.Join({joinmode:"CROSS"});
				if(t.tableid) {
					join.table = new yy.Table({databaseid:t.databaseid, tableid:t.tableid});
				} else if(t instanceof yy.Select) {
					join.select = t;
				} else if(t instanceof yy.Search) {
					join.search = t;
				} else if(t instanceof yy.ParamValue) {
					join.param = t;
				} else if(t instanceof yy.VarValue) {
					join.variable = t.variable;
				} else if(t instanceof yy.FuncValue) {
					join.func = t;
				} else if(t instanceof yy.Json) {
					join.json = t;
				}
				if(t.as) join.as = t.as;
				joins.push(join);
			});
			$$ = { from: $2, joins: joins }; 
		}
/*	| FROM LPAR FromTable JoinTablesList RPAR
		{ $$ = { from: [$3], joins: $4 }; }
*/	| FROM LPAR FromTablesList JoinTablesList RPAR
		{ $$ = { from: $3, joins: $4 }; }
	|
		{ $$ = undefined; }
	;

ApplyClause
	: CROSS APPLY LPAR Select RPAR Literal
		{ $$ = new yy.Apply({select: $4, applymode:'CROSS', as:$6}); }
	| CROSS APPLY LPAR Select RPAR AS Literal
		{ $$ = new yy.Apply({select: $4, applymode:'CROSS', as:$7}); }
/*		{
			if(!yy.exists) yy.exists = [];
			$$ = new yy.Apply({select: $4, applymode:'CROSS', as:$7,existsidx:yy.exists.length});
			yy.exists.push($3);

		 }
*/	| OUTER APPLY LPAR Select RPAR Literal
		{ $$ = new yy.Apply({select: $4, applymode:'OUTER', as:$6}); }
	| OUTER APPLY LPAR Select RPAR AS Literal
		{ $$ = new yy.Apply({select: $4, applymode:'OUTER', as:$7}); }
	;

FromTablesList
	: FromTable
		{ $$ = [$1]; }
	| FromTablesList COMMA FromTable
		{ $$ = $1; $1.push($3); }
	;

FromTable
	: LPAR Select RPAR Literal
		{ $$ = $2; $$.as = $4 }
	| LPAR Select RPAR AS Literal
		{ $$ = $2; $$.as = $5 }
	| LPAR Select RPAR /* default alias */
		{ $$ = $2; $$.as = 'default' }

	| Json AS? Literal?
		{ $$ = new yy.Json({value:$1}); $1.as = $3 }

	| Table Literal
		{ $$ = $1; $1.as = $2 }
	| Table AS Literal
		{ $$ = $1; $1.as = $3 }
	| Table
		{ $$ = $1; }
	| Table NOT INDEXED
		{ $$ = $1; }
	| ParamValue Literal
		{ $$ = $1; $1.as = $2; }
	| ParamValue AS Literal
		{ $$ = $1; $1.as = $3; }
	| ParamValue
		{ $$ = $1; $1.as = 'default'; }

	| FuncValue
		{ $$ = $1; $1.as = 'default'; }
	| FuncValue Literal
		{ $$ = $1; $1.as = $2; }
	| FuncValue AS Literal
		{ $$ = $1; $1.as = $3; }

	| INSERTED
		{ $$ = {inserted:true}; }

	| VarValue
		{ $$ = $1; $1.as = 'default'; }
	| VarValue Literal
		{ $$ = $1; $1.as = $2; }
	| VarValue AS Literal
		{ $$ = $1; $1.as = $3; }

	| FromString
		{ $$ = $1; $1.as = 'default'; }
	| FromString Literal
		{ $$ = $1; $1.as = $2; }
	| FromString AS Literal
		{ $$ = $1; $1.as = $3; }
	;

FromString
	: STRING
		{
			var s = $1;
			s = s.substr(1,s.length-2);
			var x3 = s.substr(-3).toUpperCase();
			var x4 = s.substr(-4).toUpperCase();
			var r;
			if(s[0] == '#') {
				r = new yy.FuncValue({funcid: 'HTML', args:[new yy.StringValue({value: s}), new yy.Json({value:{headers:true}})]});
			} else if(x3=='XLS' || x3 == 'CSV' || x3=='TAB') {
				r = new yy.FuncValue({funcid: x3, args:[new yy.StringValue({value: s}), new yy.Json({value:{headers:true}})]});
			} else if(x4=='XLSX' || x4 == 'JSON') {
				r = new yy.FuncValue({funcid: x4, args:[new yy.StringValue({value: s}), new yy.Json({value:{headers:true}})]});
			} else {
				throw new Error('Unknown string in FROM clause');
			};
			$$ = r;
		}
	;

Table
	: Literal DOT Literal
		{
			if($1 == 'INFORMATION_SCHEMA') {
				$$ = new yy.FuncValue({funcid: $1, args:[new yy.StringValue({value:$3})]});
			} else {
				$$ = new yy.Table({databaseid: $1, tableid:$3});
			}
		}
	| Literal
		{ $$ = new yy.Table({tableid: $1});}
	;

TargetTable
	: Table
		{ $$ = $1; }
	| ParamValue
		{ $$ = $1; }
	;

JoinTablesList
	: JoinTablesList JoinTable
		{ $$ = $1; $1.push($2); }
	| JoinTablesList ApplyClause
		{ $$ = $1; $1.push($2); }
	| JoinTable
	 	{ $$ = [$1]; }
	| ApplyClause
	 	{ $$ = [$1]; }
	;

JoinTable
	: JoinMode JoinTableAs OnClause
		{ $$ = new yy.Join($1); yy.extend($$, $2); yy.extend($$, $3); }
	;

JoinTableAs
	: Table
		{ $$ = {table: $1}; }
	| Table Literal
		{ $$ = {table: $1, as: $2 } ; }
	| Table AS Literal
		{ $$ = {table: $1, as: $3 } ; }
	| Json AS? Literal?
		{ $$ = {json:new yy.Json({value:$1,as:$3})}; }
	| ParamValue Literal
		{ $$ = {param: $1, as: $2 } ; }
	| ParamValue AS Literal
		{ $$ = {param: $1, as: $3 } ; }
	| LPAR Select RPAR Literal
		{ $$ = {select: $2, as: $4} ; }
	| LPAR Select RPAR AS Literal
		{ $$ = {select: $2, as: $5 } ; }
	| FuncValue
		{ $$ = {func:$1, as:'default'}; }
	| FuncValue Literal
		{ $$ = {func:$1, as: $2}; }
	| FuncValue AS Literal
		{ $$ = {func:$1, as: $3}; }

	| VarValue
		{ $$ = {variable:$1,as:'default'}; }
	| VarValue Literal
		{ $$ = {variable:$1,as:$2}; }
	| VarValue AS Literal
		{ $$ = {variable:$1,as:$3} }
	;

JoinMode
	: JoinModeMode
		{ $$ = { joinmode: $1 } ; }
	| NATURAL JoinModeMode
		{ $$ = {joinmode: $1, natural:true} ; }
	;

JoinModeMode
	: JOIN
		{ $$ = "INNER"; }
	| INNER JOIN
		{ $$ = "INNER"; }
	| LEFT JOIN
		{ $$ = "LEFT"; }
	| LEFT OUTER JOIN
		{ $$ = "LEFT"; }
	| RIGHT JOIN
		{ $$ = "RIGHT"; }
	| RIGHT OUTER JOIN
		{ $$ = "RIGHT"; }
	| OUTER JOIN
		{ $$ = "OUTER"; }
	| FULL OUTER JOIN
		{ $$ = "OUTER"; }
	| SEMI JOIN
		{ $$ = "SEMI"; }
	| ANTI JOIN
		{ $$ = "ANTI"; }
	| CROSS JOIN
		{ $$ = "CROSS"; }
	;

OnClause
	: ON Expression
		{ $$ = {on: $2}; }
	| USING ColumnsList
		{ $$ = {using: $2}; }
	| USING LPAR ColumnsList RPAR
		{ $$ = {using: $3}; }
	|
		{ $$ = undefined; }
	;

WhereClause
	: { $$ = undefined; }
	| WHERE Expression
		{ $$ = {where: new yy.Expression({expression:$2})}; }
	;

GroupClause
	: { $$ = undefined; }
	| GROUP BY GroupExpressionsList HavingClause
		{ $$ = {group:$3}; yy.extend($$,$4); }
	| GROUP BY GroupExpressionsList WITH ROLLUP HavingClause
		{ $$ = {group:[new yy.GroupExpression({type:'ROLLUP', group: $3})]}; yy.extend($$,$6); }
	| GROUP BY GroupExpressionsList WITH CUBE HavingClause
		{ $$ = {group:[new yy.GroupExpression({type:'CUBE', group: $3})]}; yy.extend($$,$6); }
	;

GroupExpressionsList
	: GroupExpression
		{ $$ = [$1]; }
	| GroupExpressionsList COMMA GroupExpression
		{ $$ = $1; $1.push($3); }
	;

GroupExpression
	: GROUPING SET LPAR GroupExpressionsList RPAR
		{ $$ = new yy.GroupExpression({type:'GROUPING SETS', group: $4}); }
	| ROLLUP LPAR GroupExpressionsList RPAR
		{ $$ = new yy.GroupExpression({type:'ROLLUP', group: $3}); }
	| CUBE LPAR GroupExpressionsList RPAR
		{ $$ = new yy.GroupExpression({type:'CUBE', group: $3}); }
	| Expression
		{ $$ = $1; }
	;


HavingClause
	: { $$ = undefined; }
	| HAVING Expression
		{ $$ = {having:$2}}
	;

UnionClause
	:   { $$ = undefined; }
	| UNION SelectWithoutOrderOrLimit
		{ $$ = {union: $2} ; }
	| UNION ALL SelectWithoutOrderOrLimit
		{ $$ = {unionall: $3} ; }
	| EXCEPT SelectWithoutOrderOrLimit
		{ $$ = {except: $2} ; }
	| INTERSECT SelectWithoutOrderOrLimit
		{ $$ = {intersect: $2} ; }
	| UNION CORRESPONDING SelectWithoutOrderOrLimit
		{ $$ = {union: $3, corresponding:true} ; }
	| UNION ALL CORRESPONDING SelectWithoutOrderOrLimit
		{ $$ = {unionall: $4, corresponding:true} ; }
	| EXCEPT CORRESPONDING SelectWithoutOrderOrLimit
		{ $$ = {except: $3, corresponding:true} ; }
	| INTERSECT CORRESPONDING SelectWithoutOrderOrLimit
		{ $$ = {intersect: $3, corresponding:true} ; }
	;

OrderClause
	: { $$ = undefined; }
	| ORDER BY OrderExpressionsList
		{ $$ = {order:$3}}
	;

OrderExpressionsList
	: OrderExpression
		{ $$ = [$1]; }
	| OrderExpressionsList COMMA OrderExpression
		{ $$ = $1; $1.push($3)}
	;

NullsOrder
	:  NULLS FIRST
		{ $$ = {nullsOrder: 'FIRST'}; }
	|  NULLS LAST
		{ $$ = {nullsOrder: 'LAST'}; }
	;

OrderExpression
	: Expression
		{ $$ = new yy.Expression({expression: $1, direction:'ASC'}) }
	| Expression DIRECTION
		{ $$ = new yy.Expression({expression: $1, direction:$2.toUpperCase()}) }
	| Expression DIRECTION NullsOrder
		{ $$ = new yy.Expression({expression: $1, direction:$2.toUpperCase()}); yy.extend($$, $3) }
	| Expression COLLATE NOCASE
		{ $$ = new yy.Expression({expression: $1, direction:'ASC', nocase:true}) }
	| Expression COLLATE NOCASE DIRECTION
		{ $$ = new yy.Expression({expression: $1, direction:$4.toUpperCase(), nocase:true}) }
	;

LimitClause
	: { $$ = undefined; }
	| LIMIT NumValue OffsetClause
		{ $$ = {limit:$2}; yy.extend($$, $3); }
	| OFFSET NumValue ROWS? FETCH NEXT? NumValue ROWS? ONLY?
		{ $$ = {limit:$6,offset:$2}; }
	;

OffsetClause
	: { $$ = undefined; }
	| OFFSET NumValue
		{ $$ = {offset:$2}; }
	;


ResultColumns
	: ResultColumns COMMA ResultColumn
		{ $1.push($3); $$ = $1; }
	| ResultColumn
		{ $$ = [$1]; }
	;

ResultColumn
	: Expression AS Literal
		{ $1.as = $3; $$ = $1;}
	| Expression Literal
		{ $1.as = $2; $$ = $1;}
	| Expression AS NUMBER
		{ $1.as = $3; $$ = $1;}
	| Expression NUMBER
		{ $1.as = $2; $$ = $1;}
	| Expression AS StringValue
		{ $1.as = $3.value; $$ = $1;}
	| Expression StringValue
		{ $1.as = $2.value; $$ = $1;}
	| Expression
		{ $$ = $1; }
	;

Star
	: Literal DOT Literal DOT STAR
		{ $$ = new yy.Column({columid: $5, tableid: $3, databaseid:$1}); }
	| Literal DOT STAR
		{ $$ = new yy.Column({columnid: $3, tableid: $1}); }
	| INSERTED DOT STAR
		{ $$ = new yy.Column({columnid: $3, tableid: 'INSERTED'}); }
	| DELETED DOT STAR
		{ $$ = new yy.Column({columnid: $3, tableid: 'DELETED'}); }
	| STAR
		{ $$ = new yy.Column({columnid:$1}); }
	;

Column
	: Literal DOT Literal DOT Literal
		{ $$ = new yy.Column({columnid: $5, tableid: $3, databaseid:$1});}
	// INSERTED/DELETED DOT Literal must come before Literal DOT Literal
	// to match OUTPUT clause pseudo-tables (INSERTED.*, DELETED.*)
	| INSERTED DOT Literal
		{ $$ = new yy.Column({columnid: $3, tableid: 'INSERTED'});}
	| DELETED DOT Literal
		{ $$ = new yy.Column({columnid: $3, tableid: 'DELETED'});}
	| Literal DOT Literal
		{ $$ = new yy.Column({columnid: $3, tableid: $1});}
	| Literal DOT VALUE
		{ $$ = new yy.Column({columnid: $3, tableid: $1});}
	| Literal DOT AT Literal
		{ $$ = new yy.Column({columnid: '@'+$4, tableid: $1});}
	// Standalone INSERTED/DELETED are treated as regular identifiers (lowercase)
	// when not followed by DOT, allowing use as column/table names.
	// Lowercase matches SQL case-insensitive identifier behavior.
	| INSERTED
		{ $$ = new yy.Column({columnid: 'inserted'});}
	| DELETED
		{ $$ = new yy.Column({columnid: 'deleted'});}
	| Literal
		{ $$ = new yy.Column({columnid: $1});}
	;

Expression
	: AggrValue
		{ $$ = $1; }
	| FuncValue
		{ $$ = $1; }
	| Op
		{ $$ = $1; }
	| Column
		{ $$ = $1; }
	| Star
		{ $$ = $1; }
	| NumValue
		{ $$ = $1; }
	| LogicValue
		{ $$ = $1; }
	| StringValue
		{ $$ = $1; }
	| NullValue
		{ $$ = $1; }
	| ParamValue
		{ $$ = $1; }
	| VarValue
		{ $$ = $1; }
	| ExistsValue
		{ $$ = $1; }
	| CaseValue
		{ $$ = $1; }
	| CastClause
		{ $$ = $1; }
	| VALUE
		{ $$ = new yy.DomainValueValue(); }
	| Json
		{ $$ = new yy.Json({value:$1}); }
	| ArrayValue
		{ $$ = $1; }
/*	| ATLBRA JsonArray
		{ $$ = new yy.Json({value:$2}); }
*/	| NewClause
		{ $$ = $1; }
/*	| AT LPAR Expression RPAR
		{ $$ = new yy.FuncValue({funcid: 'CLONEDEEP', args:[$3]}); }
*/
/*	| AT LPAR Json RPAR
		{ $$ = new yy.Json({value:$3}); }
*/	| LPAR Select RPAR
		{
			if(!yy.queries) yy.queries = [];
			yy.queries.push($2);
			$2.queriesidx = yy.queries.length;
			$$ = $2;
		}
	| LPAR Insert RPAR
		{
			if(!yy.queries) yy.queries = [];
			yy.queries.push($2);
			$2.queriesidx = yy.queries.length;
			$$ = $2;
		}
	| LPAR (CreateVertex|CreateEdge) RPAR
		{
			if(!yy.queries) yy.queries = [];
			yy.queries.push($2);
			$2.queriesidx = yy.queries.length;
			$$ = $2;
		}

	| JavaScript
		{$$ = $1}
	| CURRENT_TIMESTAMP
		{ $$ = new yy.FuncValue({funcid:'CURRENT_TIMESTAMP'});}
	| CURRENT_DATE
		{ $$ = new yy.FuncValue({funcid:'CURRENT_DATE'});}
/*	| USER
		{ $$ = new yy.FuncValue({funcid:'USER'});}
*/	;

JavaScript
	: JAVASCRIPT
		{ $$ = new yy.JavaScript({value:$1.substr(2,$1.length-4)}); }
	;

CreateFunction
	: CREATE FUNCTION LITERAL AS JAVASCRIPT
		{ $$ = new yy.JavaScript({value:'alasql.fn["'+$3+'"] = '+$5.substr(2,$5.length-4)}); }
	;

CreateAggregate
	: CREATE AGGREGATE LITERAL AS JAVASCRIPT
		{ $$ = new yy.JavaScript({value:'alasql.aggr["'+$3+'"] = '+$5.substr(2,$5.length-4)}); }
	;


NewClause
	: NEW Literal
		{ $$ = new yy.FuncValue({funcid:$2, newid:true}); }
	| NEW FuncValue
		{ $$ = $2; yy.extend($$,{newid:true}); }
	;


CastClause
	: CAST LPAR Expression AS ColumnType RPAR
		{ $$ = new yy.Convert({expression:$3}) ; yy.extend($$,$5) ; }
	| CAST LPAR Expression AS ColumnType COMMA NUMBER RPAR
		{ $$ = new yy.Convert({expression:$3, style:$7}) ; yy.extend($$,$5) ; }
	| CONVERT LPAR ColumnType COMMA Expression RPAR
		{ $$ = new yy.Convert({expression:$5}) ; yy.extend($$,$3) ; }
	| CONVERT LPAR ColumnType COMMA Expression COMMA NUMBER RPAR
		{ $$ = new yy.Convert({expression:$5, style:$7}) ; yy.extend($$,$3) ; }
	;

PrimitiveValue
	: NumValue
		{ $$ = $1; }
	| StringValue
		{ $$ = $1; }
	| LogicValue
		{ $$ = $1; }
	| NullValue
		{ $$ = $1; }
	| ParamValue
		{ $$ = $1; }
	| FuncValue
		{ $$ = $1; }
	| CURRENT_TIMESTAMP
		{ $$ = new yy.FuncValue({funcid:'CURRENT_TIMESTAMP'}); }
	| CURRENT_DATE
		{ $$ = new yy.FuncValue({funcid:'CURRENT_DATE'}); }
/*	| USER
		{ $$ = new yy.FuncValue({funcid:'USER'}); }
*/	;


AggrValue
	: Aggregator LPAR ExprList RPAR OverClause
		{
		  if($3.length > 1 && ($1.toUpperCase() == 'MAX' || $1.toUpperCase() == 'MIN')) {
		  	$$ = new yy.FuncValue({funcid:$1,args:$3});
		  } else {
			$$ = new yy.AggrValue({aggregatorid: $1.toUpperCase(), expression: $3.pop(), over:$5});
		  }
		}
	| Aggregator LPAR DISTINCT Expression RPAR OverClause
		{ $$ = new yy.AggrValue({aggregatorid: $1.toUpperCase(), expression: $4, distinct:true, over:$6}); }
	| Aggregator LPAR ALL Expression RPAR OverClause
		{ $$ = new yy.AggrValue({aggregatorid: $1.toUpperCase(), expression: $4,
		 over:$6}); }
	;

OverClause
	:
		{$$ = undefined; }
	| OVER LPAR OverPartitionClause RPAR
		{ $$ = new yy.Over(); yy.extend($$,$3); }
	| OVER LPAR OverOrderByClause RPAR
		{ $$ = new yy.Over(); yy.extend($$,$3); }
	| OVER LPAR OverPartitionClause OverOrderByClause RPAR
		{ $$ = new yy.Over(); yy.extend($$,$3); yy.extend($$,$4);}
	;

OverPartitionClause
	: PARTITION BY GroupExpressionsList
		{ $$ = {partition:$3}; }
	;
OverOrderByClause
	: ORDER BY OrderExpressionsList
		{ $$ = {order:$3}; }
	;
Aggregator
	: SUM { $$ = "SUM"; }
	| TOTAL { $$ = "TOTAL"; }
	| COUNT { $$ = "COUNT"; }
	| MIN { $$ = "MIN"; }
	| MAX { $$ = "MAX"; }
	| AVG { $$ = "AVG"; }
	| FIRST { $$ = "FIRST"; }
	| LAST { $$ = "LAST"; }
	| AGGR { $$ = "AGGR"; }
	| ARRAY { $$ = "ARRAY"; }
/*	| REDUCE { $$ = "REDUCE"; } */
	;

FuncValue
	: Literal LPAR (DISTINCT|ALL)? ExprList RPAR OverClause
		{
			var funcid = $1;
			var exprlist = $4;
			if(exprlist.length > 1 && (funcid.toUpperCase() == 'MIN' || funcid.toUpperCase() == 'MAX')) {
					$$ = new yy.FuncValue({funcid: funcid, args: exprlist, over: $6});
			} else if(alasql.aggr[$1]) {
		    	$$ = new yy.AggrValue({aggregatorid: 'REDUCE',
                      funcid: funcid, expression: exprlist.pop(),distinct:($3=='DISTINCT'), over: $6 });
		    } else {
			    $$ = new yy.FuncValue({funcid: funcid, args: exprlist, over: $6});
			};
		}
	| Literal LPAR RPAR OverClause
		{ $$ = new yy.FuncValue({ funcid: $1, over: $4 }) }
	| IF LPAR ExprList RPAR
		{ $$ = new yy.FuncValue({ funcid: 'IIF', args:$3 }) }
	| REPLACE LPAR ExprList RPAR
		{ $$ = new yy.FuncValue({ funcid: 'REPLACE', args:$3 }) }
	| CURRENT_DATE LPAR RPAR
		{ $$ = new yy.FuncValue({ funcid: $1 }) }
	| DATEADD LPAR Literal COMMA Expression COMMA Expression RPAR
		{ $$ = new yy.FuncValue({ funcid: 'DATEADD', args:[new yy.StringValue({value:$3}),$5,$7]}) }
	| DATEADD LPAR STRING COMMA Expression COMMA Expression RPAR
		{ $$ = new yy.FuncValue({ funcid: 'DATEADD', args:[$3,$5,$7]}) }
	| DATEDIFF LPAR Literal COMMA Expression COMMA Expression RPAR
		{ $$ = new yy.FuncValue({ funcid: 'DATEDIFF', args:[new yy.StringValue({value:$3}),$5,$7]}) }
	| DATEDIFF LPAR STRING COMMA Expression COMMA Expression RPAR
		{ $$ = new yy.FuncValue({ funcid: 'DATEDIFF', args:[$3,$5,$7]}) }
	| TIMESTAMPDIFF LPAR Expression COMMA Expression COMMA Expression RPAR
		{ $$ = new yy.FuncValue({ funcid: 'TIMESTAMPDIFF', args:[new yy.StringValue({value:$3}),$5,$7]}) }
	| INTERVAL Expression Literal
		{ $$ = new yy.FuncValue({ funcid: 'INTERVAL', args:[$2,new yy.StringValue({value:($3).toLowerCase()})]}); }
	;

ExprList
	: Expression
		{ $$ = [$1]; }
	| ExprList COMMA Expression
		{ $1.push($3); $$ = $1 }
	;

NumValue
	: NUMBER
		{ $$ = new yy.NumValue({value:+$1}); }
	;

LogicValue
	: TRUE
		{ $$ = new yy.LogicValue({value:true}); }
	| FALSE
		{ $$ = new yy.LogicValue({value:false}); }
	;

StringValue
	: STRING
		{ $$ = new yy.StringValue({value: $1.substr(1,$1.length-2).replace(/(\\\')/g,"'").replace(/(\'\')/g,"'")}); }
	| NSTRING
		{ $$ = new yy.StringValue({value: $1.substr(2,$1.length-3).replace(/(\\\')/g,"'").replace(/(\'\')/g,"'")}); }
	;

NullValue
	: NULL
		{ $$ = new yy.NullValue({value:undefined}); }
	;

VarValue
	: AT Literal
		{ $$ = new yy.VarValue({variable:$2}); }
	;

ExistsValue
	: EXISTS LPAR Select RPAR
		{
			if(!yy.exists) yy.exists = [];
			$$ = new yy.ExistsValue({value:$3, existsidx:yy.exists.length});
			yy.exists.push($3);
		}
	;

ArrayValue
	: ARRAYLBRA ExprList RBRA
		{ $$ = new yy.ArrayValue({value:$2}); }
	;

ParamValue
	: DOLLAR (Literal|NUMBER)
		{ $$ = new yy.ParamValue({param: $2}); }
/*	| DOLLAR NUMBER
		{ $$ = new yy.ParamValue({param: $2}); }
*/	| COLON Literal
		{ $$ = new yy.ParamValue({param: $2}); }
	| QUESTION
		{
			if(typeof yy.question == 'undefined') yy.question = 0;
			$$ = new yy.ParamValue({param: yy.question++});
		}
	| BRAQUESTION
		{
			if(typeof yy.question == 'undefined') yy.question = 0;
			$$ = new yy.ParamValue({param: yy.question++, array:true});
		}
	;


CaseValue
	: CASE Expression WhensList ElseClause END
		{ $$ = new yy.CaseValue({expression:$2, whens: $3, elses: $4}); }
	| CASE WhensList ElseClause END
		{ $$ = new yy.CaseValue({whens: $2, elses: $3}); }
	;

WhensList
	: WhensList When
		{ $$ = $1; $$.push($2); }
	| When
		{ $$ = [$1]; }
	;

When
	: WHEN Expression THEN Expression
		{ $$ = {when: $2, then: $4 }; }
	;

ElseClause
	: ELSE Expression
		{ $$ = $2; }
	|
		{ $$ = undefined; }
	;

Op
	: Expression REGEXP Expression
		{ $$ = new yy.Op({left:$1, op:'REGEXP', right:$3}); }
	| Expression TILDA Expression
		{ $$ = new yy.Op({left:$1, op:'REGEXP', right:$3}); }
	| Expression GLOB Expression
		{ $$ = new yy.Op({left:$1, op:'GLOB', right:$3}); }
	| Expression LIKE Expression
		{ $$ = new yy.Op({left:$1, op:'LIKE', right:$3}); }
	| Expression LIKE Expression ESCAPE Expression
		{ $$ = new yy.Op({left:$1, op:'LIKE', right:$3, escape:$5}); }
	| Expression NOT_LIKE Expression
		{ $$ = new yy.Op({left:$1, op:'NOT LIKE', right:$3 }); }
	| Expression NOT_LIKE Expression ESCAPE Expression
		{ $$ = new yy.Op({left:$1, op:'NOT LIKE', right:$3, escape:$5 }); }
	| Expression BARBAR Expression
		{ $$ = new yy.Op({left:$1, op:'||', right:$3}); }
	| Expression PLUS Expression
		{ $$ = new yy.Op({left:$1, op:'+', right:$3}); }
	| Expression MINUS Expression
		{ $$ = new yy.Op({left:$1, op:'-', right:$3}); }
	| Expression STAR Expression
		{ $$ = new yy.Op({left:$1, op:'*', right:$3}); }
	| Expression SLASH Expression
		{ $$ = new yy.Op({left:$1, op:'/', right:$3}); }
	| Expression MODULO Expression
		{ $$ = new yy.Op({left:$1, op:'%', right:$3}); }
	| Expression CARET Expression
		{ $$ = new yy.Op({left:$1, op:'^', right:$3}); }

	| Expression GTGT Expression
		{ $$ = new yy.Op({left:$1, op:'>>', right:$3}); }
	| Expression LTLT Expression
		{ $$ = new yy.Op({left:$1, op:'<<', right:$3}); }
	| Expression AMPERSAND Expression
		{ $$ = new yy.Op({left:$1, op:'&', right:$3}); }
	| Expression BAR Expression
		{ $$ = new yy.Op({left:$1, op:'|', right:$3}); }

	| Expression ArrowDot Literal
		{ $$ = new yy.Op({left:$1, op:'->' , right:$3}); }
	| Expression ArrowDot NumValue
		{ $$ = new yy.Op({left:$1, op:'->' , right:$3}); }
	| Expression ArrowDot LPAR Expression RPAR
		{ $$ = new yy.Op({left:$1, op:'->' , right:$4}); }
	| Expression ArrowDot FuncValue
		{ $$ = new yy.Op({left:$1, op:'->' , right:$3}); }

	| Expression EXCLAMATION Literal
		{ $$ = new yy.Op({left:$1, op:'!' , right:$3}); }
	| Expression EXCLAMATION NumValue
		{ $$ = new yy.Op({left:$1, op:'!' , right:$3}); }
	| Expression EXCLAMATION LPAR Expression RPAR
		{ $$ = new yy.Op({left:$1, op:'!' , right:$4}); }
	| Expression EXCLAMATION FuncValue
		{ $$ = new yy.Op({left:$1, op:'!' , right:$3}); }




	| Expression GT Expression
		{ $$ = new yy.Op({left:$1, op:'>' , right:$3}); }
	| Expression GE Expression
		{ $$ = new yy.Op({left:$1, op:'>=' , right:$3}); }
	| Expression LT Expression
		{ $$ = new yy.Op({left:$1, op:'<' , right:$3}); }
	| Expression LE Expression
		{ $$ = new yy.Op({left:$1, op:'<=' , right:$3}); }
	| Expression EQ Expression
		{ $$ = new yy.Op({left:$1, op:'=' , right:$3}); }
	| Expression EQEQ Expression
		{ $$ = new yy.Op({left:$1, op:'==' , right:$3}); }
	| Expression EQEQEQ Expression
		{ $$ = new yy.Op({left:$1, op:'===' , right:$3}); }
	| Expression NE Expression
		{ $$ = new yy.Op({left:$1, op:'!=' , right:$3}); }
	| Expression NEEQEQ Expression
		{ $$ = new yy.Op({left:$1, op:'!==' , right:$3}); }
	| Expression NEEQEQEQ Expression
		{ $$ = new yy.Op({left:$1, op:'!===' , right:$3}); }

	| Expression CondOp AllSome LPAR Select RPAR
		{
			if(!yy.queries) yy.queries = [];
			// Collect any nested queries that belong to this SELECT
			var nestedQueries = yy.queries.slice();
			yy.queries = [];
			// Assign nested queries to the SELECT
			if(nestedQueries.length > 0) {
				$5.queries = nestedQueries;
			}
			// Now add this SELECT to parent queries
			yy.queries.push($5);
			$$ = new yy.Op({left:$1, op:$2 , allsome:$3, right:$5, queriesidx: yy.queries.length - 1});
		}

	| Expression CondOp AllSome LPAR ExprList RPAR
		{
			$$ = new yy.Op({left:$1, op:$2 , allsome:$3, right:$5});
		}

	| Expression AND Expression
		{
			if($1.op == 'BETWEEN1') {

				if($1.left.op == 'AND') {
					$$ = new yy.Op({left:$1.left.left,op:'AND',right:
						new yy.Op({left:$1.left.right, op:'BETWEEN',
							right1:$1.right, right2:$3})
					});
				} else {
					$$ = new yy.Op({left:$1.left, op:'BETWEEN',
						right1:$1.right, right2:$3});
				}

			} else if($1.op == 'NOT BETWEEN1') {
				if($1.left.op == 'AND') {
					$$ = new yy.Op({left:$1.left.left,op:'AND',right:
						new yy.Op({left:$1.left.right, op:'NOT BETWEEN',
							right1:$1.right, right2:$3})
					});
				} else {
					$$ = new yy.Op({left:$1.left, op:'NOT BETWEEN',
						right1:$1.right, right2:$3});
				}
			} else {
				$$ = new yy.Op({left:$1, op:'AND', right:$3});
			}


		}
	| Expression OR Expression
		{ $$ = new yy.Op({left:$1, op:'OR' , right:$3}); }
	| NOT Expression
		{ $$ = new yy.UniOp({op:'NOT' , right:$2}); }
	| MINUS Expression
		{ $$ = new yy.UniOp({op:'-' , right:$2}); }
	| PLUS Expression
		{ $$ = new yy.UniOp({op:'+' , right:$2}); }
	| TILDA Expression
		{ $$ = new yy.UniOp({op:'~' , right:$2}); }
	| SHARP Expression
		{ $$ = new yy.UniOp({op:'#' , right:$2}); }
	| LPAR Expression RPAR
		{ $$ = new yy.UniOp({right: $2}); }

	| Expression IN LPAR Select RPAR
		{
			if(!yy.queries) yy.queries = [];
			// Collect any nested queries that belong to this SELECT
			var nestedQueries = yy.queries.slice();
			yy.queries = [];
			// Assign nested queries to the SELECT
			if(nestedQueries.length > 0) {
				$4.queries = nestedQueries;
			}
			// Now add this SELECT to parent queries
			yy.queries.push($4);
			$$ = new yy.Op({left: $1, op:'IN', right:$4, queriesidx: yy.queries.length - 1});
		}

	| Expression NOT IN LPAR Select RPAR
		{
			if(!yy.queries) yy.queries = [];
			// Collect any nested queries that belong to this SELECT
			var nestedQueries = yy.queries.slice();
			yy.queries = [];
			// Assign nested queries to the SELECT
			if(nestedQueries.length > 0) {
				$5.queries = nestedQueries;
			}
			// Now add this SELECT to parent queries
			yy.queries.push($5);
			$$ = new yy.Op({left: $1, op:'NOT IN', right:$5, queriesidx: yy.queries.length - 1});
		}

	| Expression IN LPAR ExprList RPAR
		{ $$ = new yy.Op({left: $1, op:'IN', right:$4}); }

	| Expression NOT IN LPAR ExprList RPAR
		{ $$ = new yy.Op({left: $1, op:'NOT IN', right:$5}); }

	| Expression IN LPAR RPAR
		{ $$ = new yy.Op({left: $1, op:'IN', right:[]}); }

	| Expression NOT IN LPAR RPAR
		{ $$ = new yy.Op({left: $1, op:'NOT IN', right:[]}); }

	| Expression IN ColFunc
		{ $$ = new yy.Op({left: $1, op:'IN', right:$3}); }

	| Expression NOT IN ColFunc
		{ $$ = new yy.Op({left: $1, op:'NOT IN', right:$4}); }

	| Expression IN VarValue
		{ $$ = new yy.Op({left: $1, op:'IN', right:$3}); }

	| Expression NOT IN VarValue
		{ $$ = new yy.Op({left: $1, op:'NOT IN', right:$4}); }

	/*
		Hack - it impossimle to parse BETWEEN AND and AND expressions with grammar.
		At least, I do not know how.
	*/
	| Expression BETWEEN Expression
		{
/*			var expr = $3;
			if(expr.left && expr.left.op == 'AND') {
				$$ = new yy.Op({left:new yy.Op({left:$1, op:'BETWEEN', right:expr.left}), op:'AND', right:expr.right });
			} else {
*/
				$$ = new yy.Op({left:$1, op:'BETWEEN1', right:$3 });
//			}
		}
	| Expression NOT_BETWEEN Expression
		{
//			var expr = $3;
//			if(expr.left && expr.left.op == 'AND') {
//				$$ = new yy.Op({left:new yy.Op({left:$1, op:'NOT BETWEEN', right:expr.left}), op:'AND', right:expr.right });
//			} else {
				$$ = new yy.Op({left:$1, op:'NOT BETWEEN1', right:$3 });
//			}
		}
	| Expression IS Expression
		{ $$ = new yy.Op({op:'IS' , left:$1, right:$3}); }
	| Expression NOT NULL
		{
			$$ = new yy.Op({
				op:'IS',
				left:$1,
				right: new yy.UniOp({
					op:'NOT',
					right:new yy.NullValue({value:undefined})
				})
			});
		}
	| Expression DOUBLECOLON ColumnType
		{ $$ = new yy.Convert({expression:$1}) ; yy.extend($$,$3) ; }
	;

ColFunc
	: Column
		{ $$ = $1;}
	| FuncValue
		{ $$ = $1;}
	| AT LPAR Expression RPAR
		{ $$ = $3;}
	;

CondOp
	: GT { $$ = $1; }
	| GE { $$ = $1; }
	| LT { $$ = $1; }
	| LE { $$ = $1; }
	| EQ { $$ = $1; }
	| NE { $$ = $1; }
	;

AllSome
	: ALL
		{ $$ = 'ALL'; }
	| SOME
		{ $$ = 'SOME'; }
	| ANY
		{ $$ = 'ANY'; }
	;

/* PART TWO */

/* UPDATE */

Update
	: UPDATE TargetTable SET SetColumnsList WHERE Expression OutputClause
		{ $$ = new yy.Update({table:$2, columns:$4, where:$6}); yy.extend($$,$7); }
	| UPDATE TargetTable SET SetColumnsList OutputClause
		{ $$ = new yy.Update({table:$2, columns:$4}); yy.extend($$,$5); }
	;

SetColumnsList
	: SetColumn
		{ $$ = [$1]; }
	| SetColumnsList COMMA SetColumn
		{ $$ = $1; $1.push($3); }
	;

SetColumn
	: Column EQ Expression
/* TODO Replace columnid with column */
		{ $$ = new yy.SetColumn({column:$1, expression:$3})}
	| (AT|DOLLAR) Literal EQ Expression
		{ $$ = new yy.SetColumn({variable:$2, expression:$4, method:$1})}
	;

/* DELETE */

Delete
	: DELETE FROM TargetTable WHERE Expression OutputClause
		{ $$ = new yy.Delete({table:$3, where:$5}); yy.extend($$,$6);}
	| DELETE FROM TargetTable OutputClause
		{ $$ = new yy.Delete({table:$3}); yy.extend($$,$4);}
	;

/* INSERT */

Insert
        : INSERT Into TargetTable Values  ValuesListsList OutputClause
                { $$ = new yy.Insert({into:$3, values: $5}); yy.extend($$,$6); }
        | INSERT Into TargetTable ValuesListsList OutputClause
                { $$ = new yy.Insert({into:$3, values: $4}); yy.extend($$,$5); }
        | INSERT IGNORE Into TargetTable Values  ValuesListsList OutputClause
                { $$ = new yy.Insert({into:$4, values: $6, ignore:true}); yy.extend($$,$7); }
        | INSERT IGNORE Into TargetTable ValuesListsList OutputClause
                { $$ = new yy.Insert({into:$4, values: $5, ignore:true}); yy.extend($$,$6); }
        | INSERT IGNORE Into TargetTable LPAR ColumnsList RPAR Values  ValuesListsList OutputClause
                { $$ = new yy.Insert({into:$4, columns: $6, values: $9, ignore:true}); yy.extend($$,$10); }
        | INSERT IGNORE Into TargetTable LPAR ColumnsList RPAR ValuesListsList OutputClause
                { $$ = new yy.Insert({into:$4, columns: $6, values: $8, ignore:true}); yy.extend($$,$9); }
        | INSERT IGNORE Into TargetTable Select OutputClause
                { $$ = new yy.Insert({into:$4, select: $5, ignore:true}); yy.extend($$,$6); }
        | INSERT IGNORE Into TargetTable LPAR ColumnsList RPAR Select OutputClause
                { $$ = new yy.Insert({into:$4, columns: $6, select: $8, ignore:true}); yy.extend($$,$9); }
        | INSERT OR REPLACE Into TargetTable Values  ValuesListsList OutputClause
                { $$ = new yy.Insert({into:$5, values: $7, orreplace:true}); yy.extend($$,$8); }
        | INSERT OR REPLACE Into TargetTable ValuesListsList OutputClause
                { $$ = new yy.Insert({into:$5, values: $6, orreplace:true}); yy.extend($$,$7); }
        | REPLACE Into TargetTable Values  ValuesListsList OutputClause
                { $$ = new yy.Insert({into:$3, values: $5, orreplace:true}); yy.extend($$,$6); }
        | REPLACE Into TargetTable ValuesListsList OutputClause
                { $$ = new yy.Insert({into:$3, values: $4, orreplace:true}); yy.extend($$,$5); }
        | INSERT Into TargetTable DEFAULT Values OutputClause
                { $$ = new yy.Insert({into:$3, "default": true}); yy.extend($$,$6); }
        | INSERT Into TargetTable LPAR ColumnsList RPAR Values  ValuesListsList OutputClause
                { $$ = new yy.Insert({into:$3, columns: $5, values: $8}); yy.extend($$,$9); }
        | INSERT Into TargetTable LPAR ColumnsList RPAR ValuesListsList OutputClause
                { $$ = new yy.Insert({into:$3, columns: $5, values: $7}); yy.extend($$,$9); }
        | INSERT Into TargetTable Select OutputClause
                { $$ = new yy.Insert({into:$3, select: $4}); yy.extend($$,$5); }
        | INSERT OR REPLACE Into TargetTable Select OutputClause
                { $$ = new yy.Insert({into:$5, select: $6, orreplace:true}); yy.extend($$,$7); }
        | INSERT Into TargetTable LPAR ColumnsList RPAR Select OutputClause
                { $$ = new yy.Insert({into:$3, columns: $5, select: $7}); yy.extend($$,$9); }
        | INSERT Into TargetTable SET SetColumnsList OutputClause
                { $$ = new yy.Insert({into:$3, setcolumns: $5}); yy.extend($$,$6); }
        ;

Values
        : VALUES
        | VALUE
        ;

Into
	:
	| INTO
	;
/*
TableParamFunc
	: Table
		{ $$ = $1; }
	| ParamValue
		{ $$ = $1; }
	| FuncValue
		{ $$ = $1; }
	;
*/

ValuesListsList
	: LPAR ValuesList RPAR
		{ $$ = [$2]; }
	| Json
		{ $$ = [$1]; }
	| ParamValue
		{ $$ = [$1]; }
	| ValuesListsList COMMA LPAR ValuesList RPAR
		{$$ = $1; $1.push($4)}
	| ValuesListsList COMMA Json
		{$$ = $1; $1.push($3)}
	| ValuesListsList COMMA ParamValue
		{$$ = $1; $1.push($3)}
	;

ValuesList
	: Expression
		{ $$ = [$1]; }
	| ValuesList COMMA Expression
		{$$ = $1; $1.push($3)}
	;

Value
	: NumValue
	| StringValue
	| LogicValue
	| NullValue
	| DateValue
	| ParamValue
	;

ColumnsList
	: Column
		{ $$ = [$1]; }
	| ColumnsList COMMA Column
		{$$ = $1; $1.push($3)}
	;

/* CREATE TABLE */

CreateTable
	:  CREATE TemporaryClause TableClass IfNotExists Table LPAR CreateTableDefClause RPAR CreateTableOptionsClause
		{
			$$ = new yy.CreateTable({table:$5});
			yy.extend($$,$2);
			yy.extend($$,$3);
			yy.extend($$,$4);
			yy.extend($$,$7);
			yy.extend($$,$9);
		}
	| CREATE TemporaryClause TableClass IfNotExists Table
		{
			$$ = new yy.CreateTable({table:$5});
			yy.extend($$,$2);
			yy.extend($$,$3);
			yy.extend($$,$4);
		}
;

TableClass
	: TABLE
		{ $$ = undefined; }
	| CLASS
		{ $$ = {class:true}; }
	;

CreateTableOptionsClause
	:
	| CreateTableOptions
	;

CreateTableOptions
	: CreateTableOptions CreateTableOption
	| CreateTableOption
	;

/* TODO: Remove this section */
CreateTableOption
	: DEFAULT
	| LITERAL EQ Literal
	| IDENTITY EQ NumValue
	| COLLATE EQ Literal
	;

TemporaryClause
	: { $$ = undefined; }
	| TEMP
		{ $$ = {temporary:true}; }
	;

IfNotExists
	: { $$ = undefined; }
	| IF NOT EXISTS
		{ $$ = {ifnotexists: true}; }
	;

CreateTableDefClause
	: ColumnDefsList COMMA ConstraintsList
		{ $$ = {columns: $1, constraints: $3}; }
	| ColumnDefsList
		{ $$ = {columns: $1}; }
	| AS Select
		{ $$ = {as: $2} }
	;

ConstraintsList
	: Constraint
		{ $$ = [$1];}
	| ConstraintsList COMMA Constraint
		{ $1.push($3); $$ = $1; }
	;

Constraint
	: ConstraintName PrimaryKey
		{ $2.constraintid = $1; $$ = $2; }
	| ConstraintName ForeignKey
		{ $2.constraintid = $1; $$ = $2; }
	| ConstraintName UniqueKey
		{ $2.constraintid = $1; $$ = $2; }
	| ConstraintName IndexKey
		{ $2.constraintid = $1; $$ = $2; }
	| ConstraintName Check
		{ $2.constraintid = $1; $$ = $2; }
	;

ConstraintName
	:   { $$ = undefined; }
	| CONSTRAINT Literal
		{ $$ = $2; }
	;

Check
 	: CHECK LPAR Expression RPAR
		{ $$ = {type: 'CHECK', expression: $3}; }
	;

PrimaryKey
	: PRIMARY KEY Literal? LPAR ColsList RPAR
		{ $$ = {type: 'PRIMARY KEY', columns: $5, clustered:($3+'').toUpperCase()}; }
	;

ForeignKey
	: FOREIGN KEY LPAR ColsList RPAR REFERENCES Table ParColsList?
	     OnReferentialActions
		{ $$ = {type: 'FOREIGN KEY', columns: $4, fktable: $7, fkcolumns: $8}; yy.extend($$, $9); }
	;

ParColsList
	: LPAR ColsList RPAR
		{ $$ = $2; }
	;

OnReferentialActions
	:
		{$$ = {}; }
	| OnDeleteClause
		{$$ = {ondelete: $1}; }
	| OnUpdateClause
		{$$ = {onupdate: $1}; }
	| OnDeleteClause OnUpdateClause
		{$$ = {ondelete: $1, onupdate: $2}; }
	| OnUpdateClause OnDeleteClause
		{$$ = {ondelete: $2, onupdate: $1}; }
	;

OnDeleteClause
	: ON DELETE ReferentialAction
		{$$ = $3; }
	;
OnUpdateClause
	: ON UPDATE ReferentialAction
		{$$ = $3; }
	;

ReferentialAction
	: CASCADE
		{$$ = 'CASCADE'; }
	| SET NULL
		{$$ = 'SET NULL'; }
	| SET DEFAULT
		{$$ = 'SET DEFAULT'; }
	| RESTRICT
		{$$ = 'RESTRICT'; }
	| NO ACTION
		{$$ = 'NO ACTION'; }
	;

UniqueKey
	: UNIQUE KEY? Literal? LPAR OrderExpressionsList RPAR
		{
			$$ = {type: 'UNIQUE', columns: $5, clustered:($3+'').toUpperCase()};
		}
	;

IndexKey
	: INDEX Literal LPAR ColsList RPAR
		{ $$ = {type: 'INDEX', indexid: $2, columns: $4}; }
	;
ColsList
	: Literal
		{ $$ = [$1]; }
	| STRING
		{ $$ = [$1]; }
	| ColsList COMMA Literal
		{ $$ = $1; $1.push($3); }
	| ColsList COMMA STRING
		{ $$ = $1; $1.push($3); }
	;

/*
OrderedColsList
	: Literal
		{ $$ = [$1]; }
	| STRING
		{ $$ = [$1]; }
	| OrderedColsList COMMA Literal
		{ $$ = $1; $1.push($3); }
	| OrderedColsList COMMA STRING
		{ $$ = $1; $1.push($3); }
	;
*/
ColumnDefsList
	: ColumnDef
		{ $$ = [$1];}
	| ColumnDefsList COMMA ColumnDef
		{ $1.push($3); $$ = $1; }
	;

ColumnDef
	: Literal ColumnType ColumnConstraintsClause
		{ $$ = new yy.ColumnDef({columnid:$1}); yy.extend($$,$2); yy.extend($$,$3);}
	| Literal ColumnConstraints
		{ $$ = new yy.ColumnDef({columnid:$1}); yy.extend($$,$2); }
	| Literal
		{ $$ = new yy.ColumnDef({columnid:$1, dbtypeid: ''}); }
	;

/*
ColumnType
	: LITERAL LPAR NumberMax COMMA NUMBER RPAR
		{ $$ = {dbtypeid: $1, dbsize: $3, dbprecision: +$5} }
	| LITERAL LPAR NumberMax RPAR
		{ $$ = {dbtypeid: $1, dbsize: $3} }
	| LITERAL
		{ $$ = {dbtypeid: $1} }
	| ENUM LPAR ValuesList RPAR
		{ $$ = {dbtypeid: 'ENUM', enumvalues: $3} }
	;
*/
SingularColumnType
	: LiteralWithSpaces LPAR NumberMax COMMA NUMBER RPAR
		{ $$ = {dbtypeid: $1, dbsize: $3, dbprecision: +$5} }
	| LiteralWithSpaces LPAR NumberMax RPAR
		{ $$ = {dbtypeid: $1, dbsize: $3} }
	| LiteralWithSpaces
		{ $$ = {dbtypeid: $1} }
	| ENUM LPAR ValuesList RPAR
		{ $$ = {dbtypeid: 'ENUM', enumvalues: $3} }
	;

ColumnType
	: SingularColumnType BRALITERAL /* text[] */
		{ $$ = $1; $1.dbtypeid += '[' + $2 + ']'; }
	| SingularColumnType
		{ $$ = $1; }
	;


NumberMax
	: NUMBER
		{ $$ = +$1; }
	| MAXNUM
		{ $$ = "MAX"; }
	;

ColumnConstraintsClause
	: {$$ = undefined}
	| ColumnConstraintsList
		{ $$ = $1; }
	;


ColumnConstraintsList
	: ColumnConstraintsList ColumnConstraint
		{
			yy.extend($1,$2); $$ = $1;
		}
	| ColumnConstraint
		{ $$ = $1; }
	;

ParLiteral
	: LPAR Literal RPAR
		{ $$ = $2; }
	;

ColumnConstraint
	: PRIMARY KEY
		{$$ = {primarykey:true};}
	| FOREIGN KEY REFERENCES Table ParLiteral? OnReferentialActions
		{$$ = {foreignkey:{table:$4, columnid: $5}}; yy.extend($$.foreignkey, $6);}
	| REFERENCES Table ParLiteral? OnReferentialActions
		{$$ = {foreignkey:{table:$2, columnid: $3}}; yy.extend($$.foreignkey, $4);}
	| IDENTITY LPAR NumValue COMMA NumValue RPAR
		{ $$ = {identity: {value:$3,step:$5}} }
	| IDENTITY
		{ $$ = {identity: {value:1,step:1}} }
	| DEFAULT PrimitiveValue
		{$$ = {"default":$2};}
	| DEFAULT LPAR Expression RPAR
		{$$ = {"default":$3};}
	| DEFAULT FuncValue
		{$$ = {"default":$2};}
	| NULL
		{$$ = {null:true}; }
	| NOT NULL
		{$$ = {notnull:true}; }
	| Check
		{$$ = {check:$1}; }
	| UNIQUE
		{$$ = {unique:true}; }
	| ON UPDATE PrimitiveValue
		{$$ = {"onupdate":$3};}
	| ON UPDATE LPAR Expression RPAR
		{$$ = {"onupdate":$4};}
	;

/* DROP TABLE */

DropTable
	: DROP (TABLE|CLASS) IfExists TablesList
		{ $$ = new yy.DropTable({tables:$4,type:$2}); yy.extend($$, $3); }
	;

TablesList
	: TablesList COMMA Table
		{ $1.push($3); $$=$1; }
	| Table
		{ $$ = [$1]; }
	;


IfExists
	: { $$ = undefined; }
	| IF EXISTS
		{ $$ = {ifexists: true};}
	;

/* ALTER TABLE */

AlterTable
	: ALTER TABLE Table RENAME TO Literal
		{ $$ = new yy.AlterTable({table:$3, renameto: $6});}
	| ALTER TABLE Table ADD COLUMN ColumnDef
		{ $$ = new yy.AlterTable({table:$3, addcolumn: $6});}
	| ALTER TABLE Table MODIFY COLUMN ColumnDef
		{ $$ = new yy.AlterTable({table:$3, modifycolumn: $6});}
	| ALTER TABLE Table RENAME COLUMN Literal TO Literal
		{ $$ = new yy.AlterTable({table:$3, renamecolumn: $6, to: $8});}
	| ALTER TABLE Table DROP COLUMN Literal
		{ $$ = new yy.AlterTable({table:$3, dropcolumn: $6});}
	;

RenameTable
	: RENAME TABLE Table TO Literal
		{ $$ = new yy.AlterTable({table:$3, renameto: $5});}
	;

/* DATABASES */

AttachDatabase
	: ATTACH Literal DATABASE Literal
		{ $$ = new yy.AttachDatabase({databaseid:$4, engineid:$2.toUpperCase() });}
	| ATTACH Literal DATABASE Literal LPAR ExprList RPAR
		{ $$ = new yy.AttachDatabase({databaseid:$4, engineid:$2.toUpperCase(), args:$6 });}
	| ATTACH Literal DATABASE Literal AS Literal
		{ $$ = new yy.AttachDatabase({databaseid:$4, engineid:$2.toUpperCase(), as:$6 });}
	| ATTACH Literal DATABASE Literal LPAR ExprList RPAR AS Literal
		{ $$ = new yy.AttachDatabase({databaseid:$4, engineid:$2.toUpperCase(), as:$9, args:$6});}
	;

DetachDatabase
	: DETACH DATABASE Literal
		{ $$ = new yy.DetachDatabase({databaseid:$3});}
	;

CreateDatabase
	: CREATE DATABASE IfNotExists Literal
		{ $$ = new yy.CreateDatabase({databaseid:$4 }); yy.extend($$,$4); }
	| CREATE Literal DATABASE IfNotExists Literal AsClause
		{ $$ = new yy.CreateDatabase({engineid:$2.toUpperCase(), databaseid:$5, as:$6 }); yy.extend($$,$4); }
	| CREATE Literal DATABASE IfNotExists Literal LPAR ExprList RPAR AsClause
		{ $$ = new yy.CreateDatabase({engineid:$2.toUpperCase(), databaseid:$5, args:$7, as:$9 }); yy.extend($$,$4); }
	| CREATE Literal DATABASE IfNotExists StringValue AsClause
		{ $$ = new yy.CreateDatabase({engineid:$2.toUpperCase(),
		    as:$6, args:[$5] }); yy.extend($$,$4); }
	;

AsClause
	:
		{$$ = undefined;}
	| AS Literal
		{ $$ = $1; }
	;

UseDatabase
	: USE DATABASE Literal
		{ $$ = new yy.UseDatabase({databaseid: $3 });}
	| USE Literal
		{ $$ = new yy.UseDatabase({databaseid: $2 });}
	;

DropDatabase
	: DROP DATABASE IfExists Literal
		{ $$ = new yy.DropDatabase({databaseid: $4 }); yy.extend($$,$3); }
	| DROP Literal DATABASE IfExists Literal
		{ $$ = new yy.DropDatabase({databaseid: $5, engineid:$2.toUpperCase() }); yy.extend($$,$4); }
	| DROP Literal DATABASE IfExists StringValue
		{ $$ = new yy.DropDatabase({databaseid: $5, engineid:$2.toUpperCase() }); yy.extend($$,$4); }
	;

/* INDEXES */

CreateIndex
	:
	 CREATE INDEX Literal ON Table LPAR OrderExpressionsList RPAR
		{ $$ = new yy.CreateIndex({indexid:$3, table:$5, columns:$7})}
	|

	CREATE UNIQUE INDEX Literal ON Table LPAR OrderExpressionsList RPAR
		{ $$ = new yy.CreateIndex({indexid:$4, table:$6, columns:$8, unique:true})}
	;

DropIndex
	: DROP INDEX Literal
		{ $$ = new yy.DropIndex({indexid:$3});}
	;

/* SHOW COMMAND */

ShowDatabases
	: SHOW DATABASE
		{ $$ = new yy.ShowDatabases();}
	| SHOW DATABASE LIKE StringValue
		{ $$ = new yy.ShowDatabases({like:$4});}
	| SHOW Literal DATABASE
		{ $$ = new yy.ShowDatabases({engineid:$2.toUpperCase() });}
	| SHOW Literal DATABASE LIKE StringValue
		{ $$ = new yy.ShowDatabases({engineid:$2.toUpperCase() , like:$5});}
	;

ShowTables
	: SHOW TABLE
		{ $$ = new yy.ShowTables();}
	| SHOW TABLE LIKE StringValue
		{ $$ = new yy.ShowTables({like:$4});}
	| SHOW TABLE FROM Literal
		{ $$ = new yy.ShowTables({databaseid: $4});}
	| SHOW TABLE FROM Literal LIKE StringValue
		{ $$ = new yy.ShowTables({like:$6, databaseid: $4});}
	;

ShowColumns
	: SHOW COLUMN FROM Table
		{ $$ = new yy.ShowColumns({table: $4});}
	| SHOW COLUMN FROM Table FROM Literal
		{ $$ = new yy.ShowColumns({table: $4, databaseid:$6});}
	;

ShowIndex
	: SHOW INDEX FROM Table
		{ $$ = new yy.ShowIndex({table: $4});}
	| SHOW INDEX FROM Table FROM Literal
		{ $$ = new yy.ShowIndex({table: $4, databaseid: $6});}
	;

ShowCreateTable
	: SHOW CREATE TABLE Table
		{ $$ = new yy.ShowCreateTable({table: $4});}
	| SHOW CREATE TABLE Table FROM Literal
		{ $$ = new yy.ShowCreateTable({table: $4, databaseid:$6});}
	;

CreateView
	:  CREATE TemporaryClause VIEW IfNotExists Table LPAR ColumnsList RPAR AS Select SubqueryRestriction?
		{
			$$ = new yy.CreateTable({table:$5,view:true,select:$10,viewcolumns:$7});
			yy.extend($$,$2);
			yy.extend($$,$4);
		}
	| CREATE TemporaryClause VIEW IfNotExists Table AS Select SubqueryRestriction?
		{
			$$ = new yy.CreateTable({table:$5,view:true,select:$7});
			yy.extend($$,$2);
			yy.extend($$,$4);
		}
	;

SubqueryRestriction
	: WITH READ ONLY
	| WITH CHECK OPTION
	| WITH CHECK OPTION CONSTRAINT Constraint
	;


DropView
	: DROP VIEW IfExists TablesList
		{ $$ = new yy.DropTable({tables:$4, view:true}); yy.extend($$, $3); }
	;
/*
DeclareCursor
	: DECLARE Literal CURSOR FOR Select
		{ $$ = new yy.DeclareCursor({cursorid:$2, select:$5}); }
	;

OpenCursor
	: OPEN Literal
		{ $$ = new yy.OpenCursor({cursorid:$2}); }
	;

CloseCursor
	: CLOSE Literal
		{ $$ = new yy.CloseCursor({cursorid:$2}); }
	;

FetchCursor
	: FETCH FetchDirection FROM Literal
		{ $$ = new yy.FetchCursor({cursorid:$4}); yy.extend($$,$2); }
	;

FetchDirection
	: NEXT
		{ $$ = {direction: 'NEXT'}; }
	| PRIOR
		{ $$ = {direction: 'PRIOR'}; }
	| FIRST
		{ $$ = {direction: 'FIRST'}; }
	| LAST
		{ $$ = {direction: 'LAST'}; }
	| ABSOLUTE NumValue
		{ $$ = {direction: 'ABSOLUTE', num:$2}; }
	| RELATIVE NumValue
		{ $$ = {direction: 'RELATIVE', num:$2}; }
	;
*/

/*
Help
	: HELP StringValue
		{ $$ = new yy.Help({subject:$2.value.toUpperCase()} ) ; }
	| HELP
		{ $$ = new yy.Help() ; }
	;
*/

ExpressionStatement
	: EQ Expression
		{ $$ = new yy.ExpressionStatement({expression:$2}); }
	;

Source
	: SOURCE StringValue
		{ $$ = new yy.Source({url:$2.value}); }
	;

Assert
	: ASSERT Json
		{ $$ = new yy.Assert({value:$2}); }
	| ASSERT PrimitiveValue
		{ $$ = new yy.Assert({value:$2.value}); }
	| ASSERT STRING COMMA Json
		{ $$ = new yy.Assert({value:$4, message:$2}); }
	;

Json
	: AT LPAR Expression RPAR
		{ $$ = $3; }
	| AT StringValue
		{ $$ = $2.value; }
	| AT NumValue
		{ $$ = +$2.value; }
	| AT LogicValue
		{ $$ = (!!$2.value); }
	| AT ParamValue
		{ $$ = $2; }
	| JsonObject
		{ $$ = $1; }
	| AT JsonObject
		{ $$ = $2; }
	| ATLBRA JsonArray
		{ $$ = $2; }
	;

JsonValue
	: Json
		{ $$ = $1; }
	| JsonPrimitiveValue
		{ $$ = $1; }
	;

JsonPrimitiveValue
	: NumValue
		{ $$ = +$1.value; }
	| MINUS NumValue
		{ $$ = -$2.value; }
	| StringValue
		{ $$ = ""+$1.value; }
	| LogicValue
		{ $$ = $1.value; }
	| Column
		{ $$ = $1; }
	| NullValue
		{ $$ = $1.value; }
	| ParamValue
		{ $$ = $1; }
	| FuncValue
		{ $$ = $1; }
	| LPAR Expression RPAR
		{ $$ = $2; }
	;


JsonObject
	: LCUR JsonPropertiesList RCUR
		{ $$ = $2; }
	| LCUR JsonPropertiesList COMMA RCUR
		{ $$ = $2; }
	| LCUR RCUR
		{ $$ = {}; }
	;

JsonArray
	: JsonElementsList RBRA
		{ $$ = $1; }
	| JsonElementsList COMMA RBRA
		{ $$ = $1; }
	| RBRA
		{ $$ = []; }
	;

JsonPropertiesList
	: JsonPropertiesList COMMA JsonProperty
		{ yy.extend($1,$3); $$ = $1; }
	| JsonProperty
		{ $$ = $1; }
	;

JsonProperty
	: STRING COLON JsonValue
		{ $$ = {}; $$[$1.substr(1,$1.length-2)] = $3; }
	| NUMBER COLON JsonValue
		{ $$ = {}; $$[$1] = $3; }
	| Literal COLON JsonValue
		{ $$ = {}; $$[$1] = $3; }
	| STRING COLONDASH NumValue
		{ $$ = {}; $$[$1.substr(1,$1.length-2)] = -$3.value; }
	| NUMBER COLONDASH NumValue
		{ $$ = {}; $$[$1] = -$3.value; }
	| Literal COLONDASH NumValue
		{ $$ = {}; $$[$1] = -$3.value; }
/*	| STRING COLON ParamValue
		{ $$ = {}; $$[$1.substr(1,$1.length-2)] = $3; }
	| NUMBER COLON ParamValue
		{ $$ = {}; $$[$1] = $3; }
	| LITERAL COLON ParamValue
		{ $$ = {}; $$[$1] = $3; }
*/	;

JsonElementsList
	: JsonElementsList COMMA JsonValue
		{ $1.push($3); $$ = $1; }
	| JsonValue
		{ $$ = [$1]; }
	;

SetVariable
	: SET Literal EQ OnOff
		{ $$ = new yy.SetVariable({variable:$2.toLowerCase(), value:$4});}
	| SET Literal OnOff
		{ $$ = new yy.SetVariable({variable:$2.toLowerCase(), value:$3});}
	| SET Literal EQ Expression
		{ $$ = new yy.SetVariable({variable:$2, expression:$4});}
	| SET Literal SetPropsList EQ Expression
		{ $$ = new yy.SetVariable({variable:$2, props: $3, expression:$5});}
	| SET AtDollar Literal EQ Expression
		{ $$ = new yy.SetVariable({variable:$3, expression:$5, method:$2});}
	| SET AtDollar Literal SetPropsList EQ Expression
		{ $$ = new yy.SetVariable({variable:$3, props: $4, expression:$6, method:$2});}
	;

AtDollar
	: AT
		{$$ = '@'; }
	| DOLLAR
		{$$ = '$'; }
	;

SetPropsList
	: SetPropsList ArrowDot SetProp
		{ $1.push($3); $$ = $1; }
	| ArrowDot SetProp
		{ $$ = [$2]; }
	;

SetProp
	: Literal
		{ $$ = $1; }
	| NUMBER
		{ $$ = $1; }
	| LPAR Expression RPAR
		{ $$ = $2; }
	;

OnOff
	: ON
		{ $$ = true; }
	| OFF
		{ $$ = false; }
	;

CommitTransaction
	: COMMIT TRANSACTION
		{ $$ = new yy.CommitTransaction(); }
	;

RollbackTransaction
	: ROLLBACK TRANSACTION
		{ $$ = new yy.RollbackTransaction(); }
	;

BeginTransaction
	: BEGIN TRANSACTION
		{ $$ = new yy.BeginTransaction(); }
	;

/*
Store
	: STORE
		{ $$ = new yy.Store(); }
	| STORE Literal
		{ $$ = new yy.Store({databaseid: $2}); }
	;

Restore
	: RESTORE
		{ $$ = new yy.Restore(); }
	| RESTORE Literal
		{ $$ = new yy.Restore({databaseid: $2}); }
	;
*/

If
	:
/*	IF Expression AStatement
		{ $$ = new yy.If({expression:$2,thenstat:$3});
			if($3.exists) $$.exists = $3.exists;
			if($3.queries) $$.queries = $3.queries;
		}
	|

*/
	IF Expression AStatement ElseStatement
		{ $$ = new yy.If({expression:$2,thenstat:$3, elsestat:$4});
			if($3.exists) $$.exists = $3.exists;
			if($3.queries) $$.queries = $3.queries;
		}

	| IF Expression AStatement
		{
			$$ = new yy.If({expression:$2,thenstat:$3});
			if($3.exists) $$.exists = $3.exists;
			if($3.queries) $$.queries = $3.queries;
		}
	;

ElseStatement
	: ELSE AStatement
		{$$ = $2;}
	;

While
	: WHILE Expression AStatement
		{ $$ = new yy.While({expression:$2,loopstat:$3});
			if($3.exists) $$.exists = $3.exists;
			if($3.queries) $$.queries = $3.queries;
		}
	;

Continue
	: CONTINUE
		{ $$ = new yy.Continue(); }
	| ITERATE
		{ $$ = new yy.Continue(); }
	;

Break
	: BREAK
		{ $$ = new yy.Break(); }
	| LEAVE
		{ $$ = new yy.Break(); }
	;

BeginEnd
	: BEGIN Statements END
		{ $$ = new yy.BeginEnd({statements:$2}); }
	;

Print
	: PRINT ExprList
		{ $$ = new yy.Print({exprs:$2});}
	| PRINT Select
		{ $$ = new yy.Print({select:$2});}
	;

Require
	: REQUIRE StringValuesList
		{ $$ = new yy.Require({paths:$2}); }
	| REQUIRE PluginsList
		{ $$ = new yy.Require({plugins:$2}); }
	;

/* For test plugin system */

Plugin
	: ECHO {$$ = $1.toUpperCase(); }
	| Literal {$$ = $1.toUpperCase(); }
	;

Echo
	: ECHO Expression
		{ $$ = new yy.Echo({expr:$2}); }
	;


StringValuesList
	: StringValuesList COMMA StringValue
		{ $1.push($3); $$ = $1; }
	| StringValue
		{ $$ = [$1]; }
	;

PluginsList
	: PluginsList COMMA Plugin
		{ $1.push($3); $$ = $1; }
	| Plugin
		{ $$ = [$1]; }
	;


Declare
	: DECLARE DeclaresList
		{ $$ = new yy.Declare({declares:$2}); }
	;

DeclaresList
	: DeclareItem
		{ $$ = [$1]; }
	| DeclaresList COMMA DeclareItem
		{ $1.push($3); $$ = $1; }
	;

DeclareItem
	: AT Literal ColumnType
		{ $$ = {variable: $2}; yy.extend($$,$3); }
	| AT Literal AS ColumnType
		{ $$ = {variable: $2}; yy.extend($$,$4); }
	| AT Literal ColumnType EQ Expression
		{ $$ = {variable: $2, expression:$5}; yy.extend($$,$3);}
	| AT Literal AS ColumnType EQ Expression
		{ $$ = {variable: $2, expression:$6}; yy.extend($$,$4);}
	;

TruncateTable
	: TRUNCATE TABLE Table
		{ $$ = new yy.TruncateTable({table:$3});}
	;

Merge
	: MERGE MergeInto MergeUsing MergeOn MergeMatchedList OutputClause
		{
			$$ = new yy.Merge(); yy.extend($$,$2); yy.extend($$,$3);
			yy.extend($$,$4);
			yy.extend($$,{matches:$5});yy.extend($$,$6);
		}
	;

MergeInto
	: FromTable
		{ $$ = {into: $1}; }
	| INTO FromTable
		{ $$ = {into: $2}; }
	;

MergeUsing
	: USING FromTable
		{ $$ = {using: $2}; }
	| USING LPAR FromTable RPAR
		{ $$ = {using: $3}; }
	;

MergeOn
	: ON Expression
		{ $$ = {on:$2}; }
	;

MergeMatchedList
	: MergeMatchedList MergeMatched
		{ $$ = $1; $$.push($2); }
	| MergeMatchedList MergeNotMatched
		{ $$ = $1; $$.push($2); }
	| MergeMatched
		{ $$ = [$1]; }
	| MergeNotMatched
		{ $$ = [$1]; }
	;

MergeMatched
	: WHEN MATCHED THEN MergeMatchedAction
		{ $$ = {matched:true, action:$4} }
	| WHEN MATCHED AND Expression THEN MergeMatchedAction
		{ $$ = {matched:true, expr: $4, action:$6} }
	;

MergeMatchedAction
	: DELETE
		{ $$ = {delete:true}; }
	| UPDATE SET SetColumnsList
		{ $$ = {update:$3}; }
	;

MergeNotMatched
	: WHEN NOT MATCHED THEN MergeNotMatchedAction
		{ $$ = {matched:false, bytarget: true, action:$5} }
	| WHEN NOT MATCHED BY TARGET THEN MergeNotMatchedAction
		{ $$ = {matched:false, bytarget: true, action:$7} }
	| WHEN NOT MATCHED AND Expression THEN MergeNotMatchedAction
		{ $$ = {matched:false, bytarget: true, expr:$5, action:$7} }
	| WHEN NOT MATCHED BY TARGET AND Expression THEN MergeNotMatchedAction
		{ $$ = {matched:false, bytarget: true, expr:$7, action:$9} }
	| WHEN NOT MATCHED BY SOURCE THEN MergeNotMatchedAction
		{ $$ = {matched:false, bysource: true, action:$7} }
	| WHEN NOT MATCHED BY SOURCE AND Expression THEN MergeMatchedAction
		{ $$ = {matched:false, bysource: true, expr:$7, action:$9} }
	;

MergeNotMatchedAction
	: INSERT VALUES ValuesListsList
		{ $$ = {insert:true, values:$3}; }
	| INSERT LPAR ColumnsList RPAR VALUES ValuesListsList
		{ $$ = {insert:true, values:$6, columns:$3}; }
	| INSERT DEFAULT VALUES
		{ $$ = {insert:true, defaultvalues:true}; }
	| INSERT LPAR ColumnsList RPAR DEFAULT VALUES
		{ $$ = {insert:true, defaultvalues:true, columns:$3}; }
	;

OutputClause
	:
	| OUTPUT ResultColumns
		{ $$ = {output:{columns:$2}} }
	| OUTPUT ResultColumns INTO AtDollar Literal
		{ $$ = {output:{columns:$2, intovar: $5, method:$4}} }
	| OUTPUT ResultColumns INTO Table
		{ $$ = {output:{columns:$2, intotable: $4}} }
	| OUTPUT ResultColumns INTO Table LPAR ColumnsList RPAR
		{ $$ = {output:{columns:$2, intotable: $4, intocolumns:$6}} }
	;

/*
CreateVertex
	: CREATE VERTEX
		{ $$ = new yy.CreateVertex(); }
	| CREATE VERTEX SET SetColumnsList
		{ $$ = new yy.CreateVertex({set: $4}); }
	| CREATE VERTEX Literal SET SetColumnsList
		{ $$ = new yy.CreateVertex({class:$3, set: $5}); }
	| CREATE VERTEX CONTENT ExprList
		{ $$ = new yy.CreateVertex({content: $4}); }
	| CREATE VERTEX Literal CONTENT ExprList
		{ $$ = new yy.CreateVertex({class:$3, content: $5}); }
	| CREATE VERTEX Literal Select
		{ $$ = new yy.CreateVertex({class:$3, select:$4}); }
	| CREATE VERTEX Select
		{ $$ = new yy.CreateVertex({select:$4}); }
	;
*/
CreateVertex
	: CREATE VERTEX Literal? SharpValue? StringValue? CreateVertexSet
		{
			$$ = new yy.CreateVertex({class:$3,sharp:$4, name:$5});
			yy.extend($$,$6);
		}
	;

SharpValue
	: SHARP Literal
		{ $$ = $2; }
	;

CreateVertexSet
	:
		{$$ = undefined; }
	| SET SetColumnsList
		{ $$ = {sets:$2}; }
	| CONTENT ExprList
		{ $$ = {content:$2}; }
	| Select
		{ $$ = {select:$1}; }
	;

CreateEdge
	: CREATE EDGE StringValue? FROM Expression TO Expression CreateVertexSet
		{
			$$ = new yy.CreateEdge({from:$5,to:$7,name:$3});
			yy.extend($$,$8);
		}
/*	| CREATE EDGE StringValue? FROM Expression TO Expression
		{
			$$ = new yy.CreateEdge({from:$5,to:$7,name:$3});
		}
*/	;


/*
CreateEdge
	: CREATE EDGE Literal?
	FROM Expression
	TO Expression
	(SET SetColumnsList | CONTENT Expression)?

	{
		$$ = new yy.CreateEdge({class:$3, from:$5, to:$7});
		if(typeof $8 != 'undefined') {
			$$.type = $8;
			$$.expre = $9;
		}
	}

	;
*/

CreateGraph
	: CREATE GRAPH GraphList
		{ $$ = new yy.CreateGraph({graph:$3}); }
	| CREATE GRAPH FROM Expression
		{ $$ = new yy.CreateGraph({from:$4}); }
	;

GraphList
	: GraphList COMMA GraphVertexEdge
		{ $$ = $1; $$.push($3); }
	| GraphVertexEdge
		{ $$ = [$1]; }
	;

GraphVertexEdge
	: GraphElement Json? GraphAsClause?
		{
			$$ = $1;
			if($2) $$.json = new yy.Json({value:$2});
			if($3) $$.as = $3;
		}
	| GraphElementVar GT GraphElement Json? GraphAsClause? GT GraphElementVar
		{
			$$ = {source:$1, target: $7};
			if($4) $$.json = new yy.Json({value:$4});
			if($5) $$.as = $5;
			yy.extend($$,$3);
		}
	| GraphElementVar GT Json GraphAsClause? GT GraphElementVar
		{
			$$ = {source:$1, target: $6};
			if($4) $$.json = new yy.Json({value:$3});
			if($5) $$.as = $4;
		}
	| GraphElementVar GTGT GraphElementVar
		{
			$$ = {source:$1, target: $3};
		}
	| Literal LPAR GraphList RPAR
	;

GraphElementVar
	: GraphElement { $$ = $1; }
	| GraphVar { $$ = $1; }
	;

GraphVar
	: AtDollar Literal
		{ $$ = {vars:$2, method:$1}; }
	;

GraphAsClause
	: AS AtDollar Literal
		{ $$ = $3; }
	;

GraphAtClause
	: AtDollar Literal
		{ $$ = $2; }
	;

GraphElement2
	:  Literal? SharpLiteral? STRING? ColonLiteral?
		{
			var s3 = $3;
			$$ = {prop:$1, sharp:$2, name:(typeof s3 == 'undefined')?undefined:s3.substr(1,s3.length-2), class:$4};
		}
	;

GraphElement
	:  Literal SharpLiteral? STRING? ColonLiteral?
		{
			var s3 = $3;
			$$ = {prop:$1, sharp:$2, name:(typeof s3 == 'undefined')?undefined:s3.substr(1,s3.length-2), class:$4};
		}
	|  SharpLiteral STRING? ColonLiteral?
		{
			var s2 = $2;
			$$ = {sharp:$1, name:(typeof s2 == 'undefined')?undefined:s2.substr(1,s2.length-2), class:$3};
		}
	|  STRING ColonLiteral?
		{
			var s1 = $1;
			$$ = {name:(typeof s1 == 'undefined')?undefined:s1.substr(1,s1.length-2), class:$2};
		}
	|  ColonLiteral
		{
			$$ = {class:$1};
		}
	;



ColonLiteral
	: COLON Literal
		{ $$ = $2; }
	;

SharpLiteral
	:	SHARP Literal
		{ $$ = $2; }
	|	SHARP NUMBER
		{ $$ = +$2; }
	;

DeleteVertex
	: DELETE VERTEX Expression (WHERE Expression)?
	;

DeleteEdge
	: DELETE EDGE Expression (FROM Expression)? (TO Expression)? (WHERE Expression)?
	;

AddRule
	: Term COLONDASH TermsList
		{ $$ = new yy.AddRule({left:$1, right:$3}); }
	| COLONDASH TermsList
		{ $$ = new yy.AddRule({right:$2}); }
	;

TermsList
	: TermsList COMMA Term
		{ $$ = $1; $$.push($3); }
	| Term
		{ $$ = [$1]; }
	;

Term
    : Literal
        { $$ = {termid: $1}; }
    | Literal LPAR TermsList RPAR
        { $$ = {termid:$1, args:$3}; }
    ;
Query
	: QUESTIONDASH FuncValue
	;

Call
	: CALL FuncValue
		{ $$ = new yy.ExpressionStatement({expression:$2}); }
	;

CreateTrigger
	: CREATE TRIGGER Literal BeforeAfter InsertDeleteUpdate ON Table AS? AStatement
		{
			$$ = new yy.CreateTrigger({trigger:$3, when:$4, action:$5, table:$7, statement:$9});
			if($9.exists) $$.exists = $9.exists;
			if($9.queries) $$.queries = $9.queries;
		}
	| CREATE TRIGGER Literal BeforeAfter InsertDeleteUpdate ON Table Literal
		{
			$$ = new yy.CreateTrigger({trigger:$3, when:$4, action:$5, table:$7, funcid:$8});
		}
	| CREATE TRIGGER Literal ON Table BeforeAfter InsertDeleteUpdate AS? AStatement
		{
			$$ = new yy.CreateTrigger({trigger:$3, when:$5, action:$6, table:$4, statement:$9});
			if($9.exists) $$.exists = $9.exists;
			if($9.queries) $$.queries = $9.queries;
		}
	;

BeforeAfter
	:
		{ $$ = 'AFTER'; }
	| FOR
		{ $$ = 'AFTER'; }
	| BEFORE
		{ $$ = 'BEFORE'; }
	| AFTER
		{ $$ = 'AFTER'; }
	| INSTEAD OF
		{ $$ = 'INSTEADOF'; }
	;

InsertDeleteUpdate
	: INSERT { $$ = 'INSERT'; }
	| DELETE { $$ = 'DELETE'; }
	| UPDATE { $$ = 'UPDATE'; }
	;

DropTrigger
	: DROP TRIGGER Literal
		{ $$ = new yy.DropTrigger({trigger:$3}); }
	;

Reindex
	: REINDEX Literal
		{ $$ = new yy.Reindex({indexid:$2});}
	;

NonReserved
	: A
	|ABSENT
	|ABSOLUTE
	|ACCORDING
	|ACTION
	|ADA
	|ADD
	|ADMIN
	|AFTER
	|ALWAYS
	|ASC
	|ASSERTION
	|ASSIGNMENT
	|ATTRIBUTE
	|ATTRIBUTES
	|BASE64
	|BEFORE
	|BERNOULLI
	|BLOCKED
	|BOM
	|BREADTH
	|C
	|CASCADE
	|CATALOG
	|CATALOG_NAME
	|CHAIN
	|CHARACTERISTICS
	|CHARACTERS
	|CHARACTER_SET_CATALOG
	|CHARACTER_SET_NAME
	|CHARACTER_SET_SCHEMA
	|CLASS_ORIGIN
	|COBOL
	|COLLATION
	|COLLATION_CATALOG
	|COLLATION_NAME
	|COLLATION_SCHEMA
	|COLUMNS
	|COLUMN_NAME
	|COMMAND_FUNCTION
	|COMMAND_FUNCTION_CODE
	|COMMITTED
	|CONDITION_NUMBER
	|CONNECTION
	|CONNECTION_NAME
	|CONSTRAINTS
	|CONSTRAINT_CATALOG
	|CONSTRAINT_NAME
	|CONSTRAINT_SCHEMA
	|CONSTRUCTOR
	|CONTENT
	|CONTINUE
	|CONTROL
	|CURSOR_NAME
	|DATA
	|DATETIME_INTERVAL_CODE
	|DATETIME_INTERVAL_PRECISION
	|DB
	|DEFAULTS
	|DEFERRABLE
	|DEFERRED
	|DEFINED
	|DEFINER
	|DEGREE
	|DELETED
	|DEPTH
	|DERIVED
	|DESC
	|DESCRIPTOR
	|DIAGNOSTICS
	|DISPATCH
	|DOCUMENT
	|DOMAIN
	|DYNAMIC_FUNCTION
	|DYNAMIC_FUNCTION_CODE
	|EMPTY
	|ENCODING
	|ENFORCED
	|EXCLUDE
	|EXCLUDING
	|EXPRESSION
	|FILE
	|FINAL
	|FIRST
	|FLAG
	|FOLLOWING
	|FORTRAN
	|FOUND
	|FS
	|G
	|GENERAL
	|GENERATED
	|GO
	|GOTO
	|GRANTED
	|HEX
	|HIERARCHY
	|ID
	|IGNORE
	|IMMEDIATE
	|IMMEDIATELY
	|IMPLEMENTATION
	|INCLUDING
	|INCREMENT
	|INDENT
	|INITIALLY
	|INPUT
	|INSERTED
	|INSTANCE
	|INSTANTIABLE
	|INSTEAD
	|INTEGRITY
	|INVOKER
	|ISOLATION
	|K
	|KEY
	|KEY_MEMBER
	|KEY_TYPE
	|LAST
	|LENGTH
	|LEVEL
	|LIBRARY
	|LIMIT
	|LINK
	|LOCATION
	|LOCATOR
	|M
	|MAP
	|MAPPING
	|MATCHED
	|MAXVALUE
	|MESSAGE_LENGTH
	|MESSAGE_OCTET_LENGTH
	|MESSAGE_TEXT
	|MINVALUE
	|MORE
	|MUMPS
	|NAME
	|NAMES
	|NAMESPACE
	|NESTING
	|NEXT
	|NFC
	|NFD
	|NFKC
	|NFKD
	|NIL
	|NORMALIZED
	|NULLABLE
	|NULLS
	|NUMBER
	|OBJECT
	|OCTETS
	|OFF
	|OPEN
	|OPTION
	|OPTIONS
	|ORDER
	|ORDERING
	|ORDINALITY
	|OTHERS
	|OUTPUT
	|OVERRIDING
	|P
	|PAD
	|PARAMETER_MODE
	|PARAMETER_NAME
	|PARAMETER_ORDINAL_POSITION
	|PARAMETER_SPECIFIC_CATALOG
	|PARAMETER_SPECIFIC_NAME
	|PARAMETER_SPECIFIC_SCHEMA
	|PARTIAL
	|PASCAL
	|PASSING
	|PASSTHROUGH
	|PATH
	|PERMISSION
	|PLACING
	|PLI
	|PRECEDING
	|PRESERVE
	|PRIOR
	|PRIVILEGES
	|PUBLIC
	|READ
	|RECOVERY
	|RELATIVE
	|REPEATABLE
	|REQUIRING
	|RESPECT
	|RESTART
	|RESTORE
	|RESTRICT
	|RETURNED_CARDINALITY
	|RETURNED_LENGTH
	|RETURNED_OCTET_LENGTH
	|RETURNED_SQLSTATE
	|RETURNING
	|ROLE
	|ROUTINE
	|ROUTINE_CATALOG
	|ROUTINE_NAME
	|ROUTINE_SCHEMA
	|ROW_COUNT
	|SCALE
	|SCHEMA
	|SCHEMA_NAME
	|SCOPE_CATALOG
	|SCOPE_NAME
	|SCOPE_SCHEMA
	|SECTION
	|SECURITY
	|SELECTIVE
	|SELF
	|SEQUENCE
	|SERIALIZABLE
	|SERVER
	|SERVER_NAME
	|SESSION
	|SETS
	|SIMPLE
	|SIZE
	|SOURCE
	|SPACE
	|SPECIFIC_NAME
	|STANDALONE
	|STATE
	|STATEMENT
	|STRIP
	|STRUCTURE
	|STYLE
	|SUBCLASS_ORIGIN
	|T
	|TABLE_NAME
	|TEMPORARY
	|TIES
	|TOKEN
	|TOP_LEVEL_COUNT
	|TRANSACTION
	|TRANSACTIONS_COMMITTED
	|TRANSACTIONS_ROLLED_BACK
	|TRANSACTION_ACTIVE
	|TRANSFORM
	|TRANSFORMS
	|TRIGGER_CATALOG
	|TRIGGER_NAME
	|TRIGGER_SCHEMA
	|TYPE
	|UNBOUNDED
	|UNCOMMITTED
	|UNDER
	|UNLINK
	|UNNAMED
	|UNTYPED
	|URI
	|USAGE
	|USER_DEFINED_TYPE_CATALOG
	|USER_DEFINED_TYPE_CODE
	|USER_DEFINED_TYPE_NAME
	|USER_DEFINED_TYPE_SCHEMA
	|VALID
	|VERSION
	|VIEW
	|WHITESPACE
	|WORK
	|WRAPPER
	|WRITE
	|XMLDECLARATION
	|XMLSCHEMA
	|YES
	|ZONE
	;
%%

// from https://www.postgresql.org/docs/current/static/sql-keywords-appendix.html
// JSON.stringify([].slice.call(document.querySelectorAll('tr')).filter(x => x.children.length == 5 && x.children[2].innerText == 'reserved').map(x => x.children[0].innerText))

var nonReserved = ["A"
	,"ABSENT"
	,"ABSOLUTE"
	,"ACCORDING"
	,"ACTION"
	,"ADA"
	,"ADD"
	,"ADMIN"
	,"AFTER"
	,"ALWAYS"
	,"ASC"
	,"ASSERTION"
	,"ASSIGNMENT"
	,"ATTRIBUTE"
	,"ATTRIBUTES"
	,"BASE64"
	,"BEFORE"
	,"BERNOULLI"
	,"BLOCKED"
	,"BOM"
	,"BREADTH"
	,"C"
	,"CASCADE"
	,"CATALOG"
	,"CATALOG_NAME"
	,"CHAIN"
	,"CHARACTERISTICS"
	,"CHARACTERS"
	,"CHARACTER_SET_CATALOG"
	,"CHARACTER_SET_NAME"
	,"CHARACTER_SET_SCHEMA"
	,"CLASS_ORIGIN"
	,"COBOL"
	,"COLLATION"
	,"COLLATION_CATALOG"
	,"COLLATION_NAME"
	,"COLLATION_SCHEMA"
	,"COLUMNS"
	,"COLUMN_NAME"
	,"COMMAND_FUNCTION"
	,"COMMAND_FUNCTION_CODE"
	,"COMMITTED"
	,"CONDITION_NUMBER"
	,"CONNECTION"
	,"CONNECTION_NAME"
	,"CONSTRAINTS"
	,"CONSTRAINT_CATALOG"
	,"CONSTRAINT_NAME"
	,"CONSTRAINT_SCHEMA"
	,"CONSTRUCTOR"
	,"CONTENT"
	,"CONTINUE"
	,"CONTROL"
	,"CURSOR_NAME"
	,"DATA"
	,"DATETIME_INTERVAL_CODE"
	,"DATETIME_INTERVAL_PRECISION"
	,"DB"
	,"DEFAULTS"
	,"DEFERRABLE"
	,"DEFERRED"
	,"DEFINED"
	,"DEFINER"
	,"DEGREE"
	,"DELETED"
	,"DEPTH"
	,"DERIVED"
	,"DESC"
	,"DESCRIPTOR"
	,"DIAGNOSTICS"
	,"DISPATCH"
	,"DOCUMENT"
	,"DOMAIN"
	,"DYNAMIC_FUNCTION"
	,"DYNAMIC_FUNCTION_CODE"
	,"EMPTY"
	,"ENCODING"
	,"ENFORCED"
	,"EXCLUDE"
	,"EXCLUDING"
	,"EXPRESSION"
	,"FILE"
	,"FINAL"
	,"FIRST"
	,"FLAG"
	,"FOLLOWING"
	,"FORTRAN"
	,"FOUND"
	,"FS"
	,"G"
	,"GENERAL"
	,"GENERATED"
	,"GO"
	,"GOTO"
	,"GRANTED"
	,"HEX"
	,"HIERARCHY"
	,"ID"
	,"IGNORE"
	,"IMMEDIATE"
	,"IMMEDIATELY"
	,"IMPLEMENTATION"
	,"INCLUDING"
	,"INCREMENT"
	,"INDENT"
	,"INITIALLY"
	,"INPUT"
	,"INSERTED"
	,"INSTANCE"
	,"INSTANTIABLE"
	,"INSTEAD"
	,"INTEGRITY"
	,"INVOKER"
	,"ISOLATION"
	,"K"
	,"KEY"
	,"KEY_MEMBER"
	,"KEY_TYPE"
	,"LAST"
	,"LENGTH"
	,"LEVEL"
	,"LIBRARY"
	,"LIMIT"
	,"LINK"
	,"LOCATION"
	,"LOCATOR"
	,"M"
	,"MAP"
	,"MAPPING"
	,"MATCHED"
	,"MAXVALUE"
	,"MESSAGE_LENGTH"
	,"MESSAGE_OCTET_LENGTH"
	,"MESSAGE_TEXT"
	,"MINVALUE"
	,"MORE"
	,"MUMPS"
	,"NAME"
	,"NAMES"
	,"NAMESPACE"
	,"NESTING"
	,"NEXT"
	,"NFC"
	,"NFD"
	,"NFKC"
	,"NFKD"
	,"NIL"
	,"NORMALIZED"
	,"NULLABLE"
	,"NULLS"
	,"NUMBER"
	,"OBJECT"
	,"OCTETS"
	,"OFF"
	,"OPEN"
	,"OPTION"
	,"OPTIONS"
	,"ORDER"
	,"ORDERING"
	,"ORDINALITY"
	,"OTHERS"
	,"OUTPUT"
	,"OVERRIDING"
	,"P"
	,"PAD"
	,"PARAMETER_MODE"
	,"PARAMETER_NAME"
	,"PARAMETER_ORDINAL_POSITION"
	,"PARAMETER_SPECIFIC_CATALOG"
	,"PARAMETER_SPECIFIC_NAME"
	,"PARAMETER_SPECIFIC_SCHEMA"
	,"PARTIAL"
	,"PASCAL"
	,"PASSING"
	,"PASSTHROUGH"
	,"PATH"
	,"PERMISSION"
	,"PLACING"
	,"PLI"
	,"PRECEDING"
	,"PRESERVE"
	,"PRIOR"
	,"PRIVILEGES"
	,"PUBLIC"
	,"READ"
	,"RECOVERY"
	,"RELATIVE"
	,"REPEATABLE"
	,"REQUIRING"
	,"RESPECT"
	,"RESTART"
	,"RESTORE"
	,"RESTRICT"
	,"RETURNED_CARDINALITY"
	,"RETURNED_LENGTH"
	,"RETURNED_OCTET_LENGTH"
	,"RETURNED_SQLSTATE"
	,"RETURNING"
	,"ROLE"
	,"ROUTINE"
	,"ROUTINE_CATALOG"
	,"ROUTINE_NAME"
	,"ROUTINE_SCHEMA"
	,"ROW_COUNT"
	,"SCALE"
	,"SCHEMA"
	,"SCHEMA_NAME"
	,"SCOPE_CATALOG"
	,"SCOPE_NAME"
	,"SCOPE_SCHEMA"
	,"SECTION"
	,"SECURITY"
	,"SELECTIVE"
	,"SELF"
	,"SEQUENCE"
	,"SERIALIZABLE"
	,"SERVER"
	,"SERVER_NAME"
	,"SESSION"
	,"SETS"
	,"SIMPLE"
	,"SIZE"
	,"SOURCE"
	,"SPACE"
	,"SPECIFIC_NAME"
	,"STANDALONE"
	,"STATE"
	,"STATEMENT"
	,"STRIP"
	,"STRUCTURE"
	,"STYLE"
	,"SUBCLASS_ORIGIN"
	,"T"
	,"TABLE_NAME"
	,"TEMPORARY"
	,"TIES"
	,"TOKEN"
	,"TOP_LEVEL_COUNT"
	,"TRANSACTION"
	,"TRANSACTIONS_COMMITTED"
	,"TRANSACTIONS_ROLLED_BACK"
	,"TRANSACTION_ACTIVE"
	,"TRANSFORM"
	,"TRANSFORMS"
	,"TRIGGER_CATALOG"
	,"TRIGGER_NAME"
	,"TRIGGER_SCHEMA"
	,"TYPE"
	,"UNBOUNDED"
	,"UNCOMMITTED"
	,"UNDER"
	,"UNLINK"
	,"UNNAMED"
	,"UNTYPED"
	,"URI"
	,"USAGE"
	,"USER_DEFINED_TYPE_CATALOG"
	,"USER_DEFINED_TYPE_CODE"
	,"USER_DEFINED_TYPE_NAME"
	,"USER_DEFINED_TYPE_SCHEMA"
	,"VALID"
	,"VERSION"
	,"VIEW"
	,"WHITESPACE"
	,"WORK"
	,"WRAPPER"
	,"WRITE"
	,"XMLDECLARATION"
	,"XMLSCHEMA"
	,"YES"
	,"ZONE"
]

parser.parseError = function(str, hash) {
	if (hash.expected && hash.expected.indexOf("'LITERAL'") > -1 && /[a-zA-Z_][a-zA-Z_0-9]*/.test(hash.token) && nonReserved.indexOf(hash.token) > -1) {
		return
	}
	throw new SyntaxError(str)
}