OmniSciDB  16c4e035a1
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Parser_wnd_pregen.cpp
Go to the documentation of this file.
1 #define YY_Parser_h_included
2 
3 /* with Bison++ version bison++ version 1.21-45, adapted from GNU Bison by
4  * coetmeur@icdc.fr
5  */
6 
7 #line 1 "/usr/local/mapd-deps/20210608/lib/bison.cc"
8 /* -*-C-*- Note some compilers choke on comments on `#line' lines. */
9 /* Skeleton output parser for bison,
10  Copyright (C) 1984, 1989, 1990 Bob Corbett and Richard Stallman
11 
12  This program is free software; you can redistribute it and/or modify
13  it under the terms of the GNU General Public License as published by
14  the Free Software Foundation; either version 1, or (at your option)
15  any later version.
16 
17  This program is distributed in the hope that it will be useful,
18  but WITHOUT ANY WARRANTY; without even the implied warranty of
19  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20  GNU General Public License for more details.
21 
22  You should have received a copy of the GNU General Public License
23  along with this program; if not, write to the Free Software
24  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
25 
26 /* HEADER SECTION */
27 #if defined(_MSDOS) || defined(MSDOS) || defined(__MSDOS__)
28 #define __MSDOS_AND_ALIKE
29 #endif
30 #if defined(_WINDOWS) && defined(_MSC_VER)
31 #define __HAVE_NO_ALLOCA
32 #define __MSDOS_AND_ALIKE
33 #endif
34 
35 #ifndef alloca
36 #if defined(__GNUC__)
37 #define alloca __builtin_alloca
38 
39 #elif (!defined(__STDC__) && defined(sparc)) || defined(__sparc__) || \
40  defined(__sparc) || defined(__sgi)
41 #include <alloca.h>
42 
43 #elif defined(__MSDOS_AND_ALIKE)
44 #include <malloc.h>
45 #ifndef __TURBOC__
46 /* MS C runtime lib */
47 #define alloca _alloca
48 #endif
49 
50 #elif defined(_AIX)
51 #include <malloc.h>
52 #pragma alloca
53 
54 #elif defined(__hpux)
55 #ifdef __cplusplus
56 extern "C" {
57 void* alloca(unsigned int);
58 };
59 #else /* not __cplusplus */
60 void* alloca();
61 #endif /* not __cplusplus */
62 
63 #endif /* not _AIX not MSDOS, or __TURBOC__ or _AIX, not sparc. */
64 #endif /* alloca not defined. */
65 #ifdef c_plusplus
66 #ifndef __cplusplus
67 #define __cplusplus
68 #endif
69 #endif
70 #ifdef __cplusplus
71 #ifndef YY_USE_CLASS
72 #define YY_USE_CLASS
73 #endif
74 #else
75 #ifndef __STDC__
76 #define const
77 #endif
78 #endif
79 #include <stdio.h>
80 #define YYBISON 1
81 
82 /* #line 73 "/usr/local/mapd-deps/20210608/lib/bison.cc" */
83 #define YY_Parser_CLASS SQLParser
84 #define YY_Parser_LVAL yylval
85 #define YY_Parser_CONSTRUCTOR_INIT : lexer(yylval)
86 #define YY_Parser_MEMBERS \
87  virtual ~SQLParser() {} \
88  int parse(const std::string& inputStrOrig, \
89  std::list<std::unique_ptr<Stmt>>& parseTrees, \
90  std::string& lastParsed) { \
91  auto inputStr = boost::algorithm::trim_right_copy_if( \
92  inputStrOrig, boost::is_any_of(";") || boost::is_space()) + \
93  ";"; \
94  boost::regex create_view_expr{ \
95  R"(CREATE\s+VIEW\s+(IF\s+NOT\s+EXISTS\s+)?([A-Za-z_][A-Za-z0-9\$_]*)\s+AS\s+(.*);?)", \
96  boost::regex::extended | boost::regex::icase}; \
97  std::lock_guard<std::mutex> lock(mutex_); \
98  boost::smatch what; \
99  const auto trimmed_input = boost::algorithm::trim_copy(inputStr); \
100  if (boost::regex_match( \
101  trimmed_input.cbegin(), trimmed_input.cend(), what, create_view_expr)) { \
102  const bool if_not_exists = what[1].length() > 0; \
103  const auto view_name = what[2].str(); \
104  const auto select_query = what[3].str(); \
105  parseTrees.emplace_back( \
106  new CreateViewStmt(view_name, select_query, if_not_exists)); \
107  return 0; \
108  } \
109  std::istringstream ss(inputStr); \
110  lexer.switch_streams(&ss, 0); \
111  yyparse(parseTrees); \
112  lastParsed = lexer.YYText(); \
113  if (!errors_.empty()) { \
114  throw std::runtime_error(errors_[0]); \
115  } \
116  return yynerrs; \
117  } \
118  \
119  private: \
120  SQLLexer lexer; \
121  std::mutex mutex_; \
122  std::vector<std::string> errors_;
123 #define YY_Parser_LEX_BODY \
124  { return lexer.yylex(); }
125 #define YY_Parser_ERROR_BODY \
126  {} /*{ std::cerr << "Syntax error on line " << lexer.lineno() << ". Last word parsed: \
127  " << lexer.YYText() << std::endl; } */
128 
129 #include <FlexLexer.h>
130 #include <boost/algorithm/string/predicate.hpp>
131 #include <boost/algorithm/string/trim.hpp>
132 #include <boost/regex.hpp>
133 #include <cstdlib>
134 #include <fstream>
135 #include <iostream>
136 #include <list>
137 #include <mutex>
138 #include <sstream>
139 #include <stdexcept>
140 #include <string>
141 #include <utility>
142 #include "ParserNode.h"
143 #include "ReservedKeywords.h"
144 #include "TrackedPtr.h"
145 
146 #ifdef DELETE
147 #undef DELETE
148 #endif
149 
150 #ifdef IN
151 #undef IN
152 #endif
153 
154 using namespace Parser;
155 #define YY_Parser_PARSE_PARAM std::list<std::unique_ptr<Stmt>>& parseTrees
156 
157 typedef union {
158  bool boolval;
159  int64_t intval;
160  float floatval;
161  double doubleval;
169 #define YY_Parser_STYPE yy_Parser_stype
170 
171 class SQLLexer : public yyFlexLexer {
172  public:
173  SQLLexer(YY_Parser_STYPE& lval) : yylval(lval){};
175  std::vector<std::unique_ptr<TrackedPtr<std::string>>> parsed_str_tokens_{};
176  std::vector<std::unique_ptr<TrackedListPtr<std::string>>> parsed_str_list_tokens_{};
177  std::vector<std::unique_ptr<TrackedPtr<Node>>> parsed_node_tokens_{};
178  std::vector<std::unique_ptr<TrackedListPtr<Node>>> parsed_node_list_tokens_{};
179 };
180 
181 #line 73 "/usr/local/mapd-deps/20210608/lib/bison.cc"
182 /* %{ and %header{ and %union, during decl */
183 #define YY_Parser_BISON 1
184 #ifndef YY_Parser_COMPATIBILITY
185 #ifndef YY_USE_CLASS
186 #define YY_Parser_COMPATIBILITY 1
187 #else
188 #define YY_Parser_COMPATIBILITY 0
189 #endif
190 #endif
191 
192 #if YY_Parser_COMPATIBILITY != 0
193 /* backward compatibility */
194 #ifdef YYLTYPE
195 #ifndef YY_Parser_LTYPE
196 #define YY_Parser_LTYPE YYLTYPE
197 #endif
198 #endif
199 #ifdef YYSTYPE
200 #ifndef YY_Parser_STYPE
201 #define YY_Parser_STYPE YYSTYPE
202 #endif
203 #endif
204 #ifdef YYDEBUG
205 #ifndef YY_Parser_DEBUG
206 #define YY_Parser_DEBUG YYDEBUG
207 #endif
208 #endif
209 #ifdef YY_Parser_STYPE
210 #ifndef yystype
211 #define yystype YY_Parser_STYPE
212 #endif
213 #endif
214 /* use goto to be compatible */
215 #ifndef YY_Parser_USE_GOTO
216 #define YY_Parser_USE_GOTO 1
217 #endif
218 #endif
219 
220 /* use no goto to be clean in C++ */
221 #ifndef YY_Parser_USE_GOTO
222 #define YY_Parser_USE_GOTO 0
223 #endif
224 
225 #ifndef YY_Parser_PURE
226 
227 /* #line 117 "/usr/local/mapd-deps/20210608/lib/bison.cc" */
228 
229 #line 117 "/usr/local/mapd-deps/20210608/lib/bison.cc"
230 /* YY_Parser_PURE */
231 #endif
232 
233 /* section apres lecture def, avant lecture grammaire S2 */
234 
235 /* #line 121 "/usr/local/mapd-deps/20210608/lib/bison.cc" */
236 
237 #line 121 "/usr/local/mapd-deps/20210608/lib/bison.cc"
238 /* prefix */
239 #ifndef YY_Parser_DEBUG
240 
241 /* #line 123 "/usr/local/mapd-deps/20210608/lib/bison.cc" */
242 
243 #line 123 "/usr/local/mapd-deps/20210608/lib/bison.cc"
244 /* YY_Parser_DEBUG */
245 #endif
246 
247 #ifndef YY_Parser_LSP_NEEDED
248 
249 /* #line 128 "/usr/local/mapd-deps/20210608/lib/bison.cc" */
250 
251 #line 128 "/usr/local/mapd-deps/20210608/lib/bison.cc"
252 /* YY_Parser_LSP_NEEDED*/
253 #endif
254 
255 /* DEFAULT LTYPE*/
256 #ifdef YY_Parser_LSP_NEEDED
257 #ifndef YY_Parser_LTYPE
258 typedef struct yyltype {
259  int timestamp;
260  int first_line;
261  int first_column;
262  int last_line;
263  int last_column;
264  char* text;
265 } yyltype;
266 
267 #define YY_Parser_LTYPE yyltype
268 #endif
269 #endif
270 /* DEFAULT STYPE*/
271 /* We used to use `unsigned long' as YY_Parser_STYPE on MSDOS,
272  but it seems better to be consistent.
273  Most programs should declare their own type anyway. */
274 
275 #ifndef YY_Parser_STYPE
276 #define YY_Parser_STYPE int
277 #endif
278 /* DEFAULT MISCELANEOUS */
279 #ifndef YY_Parser_PARSE
280 #define YY_Parser_PARSE yyparse
281 #endif
282 #ifndef YY_Parser_LEX
283 #define YY_Parser_LEX yylex
284 #endif
285 #ifndef YY_Parser_LVAL
286 #define YY_Parser_LVAL yylval
287 #endif
288 #ifndef YY_Parser_LLOC
289 #define YY_Parser_LLOC yylloc
290 #endif
291 #ifndef YY_Parser_CHAR
292 #define YY_Parser_CHAR yychar
293 #endif
294 #ifndef YY_Parser_NERRS
295 #define YY_Parser_NERRS yynerrs
296 #endif
297 #ifndef YY_Parser_DEBUG_FLAG
298 #define YY_Parser_DEBUG_FLAG yydebug
299 #endif
300 #ifndef YY_Parser_ERROR
301 #define YY_Parser_ERROR yyerror
302 #endif
303 #ifndef YY_Parser_PARSE_PARAM
304 #ifndef __STDC__
305 #ifndef __cplusplus
306 #ifndef YY_USE_CLASS
307 #define YY_Parser_PARSE_PARAM
308 #ifndef YY_Parser_PARSE_PARAM_DEF
309 #define YY_Parser_PARSE_PARAM_DEF
310 #endif
311 #endif
312 #endif
313 #endif
314 #ifndef YY_Parser_PARSE_PARAM
315 #define YY_Parser_PARSE_PARAM void
316 #endif
317 #endif
318 #if YY_Parser_COMPATIBILITY != 0
319 /* backward compatibility */
320 #ifdef YY_Parser_LTYPE
321 #ifndef YYLTYPE
322 #define YYLTYPE YY_Parser_LTYPE
323 #else
324 /* WARNING obsolete !!! user defined YYLTYPE not reported into generated header */
325 #endif
326 #endif
327 #ifndef YYSTYPE
328 #define YYSTYPE YY_Parser_STYPE
329 #else
330 /* WARNING obsolete !!! user defined YYSTYPE not reported into generated header */
331 #endif
332 #ifdef YY_Parser_PURE
333 #ifndef YYPURE
334 #define YYPURE YY_Parser_PURE
335 #endif
336 #endif
337 #ifdef YY_Parser_DEBUG
338 #ifndef YYDEBUG
339 #define YYDEBUG YY_Parser_DEBUG
340 #endif
341 #endif
342 #ifndef YY_Parser_ERROR_VERBOSE
343 #ifdef YYERROR_VERBOSE
344 #define YY_Parser_ERROR_VERBOSE YYERROR_VERBOSE
345 #endif
346 #endif
347 #ifndef YY_Parser_LSP_NEEDED
348 #ifdef YYLSP_NEEDED
349 #define YY_Parser_LSP_NEEDED YYLSP_NEEDED
350 #endif
351 #endif
352 #endif
353 #ifndef YY_USE_CLASS
354 /* TOKEN C */
355 
356 /* #line 236 "/usr/local/mapd-deps/20210608/lib/bison.cc" */
357 #define NAME 258
358 #define DASHEDNAME 259
359 #define EMAIL 260
360 #define STRING 261
361 #define FWDSTR 262
362 #define SELECTSTRING 263
363 #define QUOTED_IDENTIFIER 264
364 #define INTNUM 265
365 #define FIXEDNUM 266
366 #define OR 267
367 #define AND 268
368 #define NOT 269
369 #define EQUAL 270
370 #define COMPARISON 271
371 #define UMINUS 272
372 #define ADD 273
373 #define ALL 274
374 #define ALTER 275
375 #define AMMSC 276
376 #define ANY 277
377 #define ARCHIVE 278
378 #define ARRAY 279
379 #define AS 280
380 #define ASC 281
381 #define AUTHORIZATION 282
382 #define BETWEEN 283
383 #define BIGINT 284
384 #define BOOLEAN 285
385 #define BY 286
386 #define CASE 287
387 #define CAST 288
388 #define CHAR_LENGTH 289
389 #define CHARACTER 290
390 #define CHECK 291
391 #define CLOSE 292
392 #define CLUSTER 293
393 #define COLUMN 294
394 #define COMMIT 295
395 #define CONTINUE 296
396 #define COPY 297
397 #define CREATE 298
398 #define CURRENT 299
399 #define CURSOR 300
400 #define DATABASE 301
401 #define DATAFRAME 302
402 #define DATE 303
403 #define DATETIME 304
404 #define DATE_TRUNC 305
405 #define DECIMAL 306
406 #define DECLARE 307
407 #define DEFAULT 308
408 #define DELETE 309
409 #define DESC 310
410 #define DICTIONARY 311
411 #define DISTINCT 312
412 #define DOUBLE 313
413 #define DROP 314
414 #define DUMP 315
415 #define ELSE 316
416 #define END 317
417 #define EXISTS 318
418 #define EXTRACT 319
419 #define FETCH 320
420 #define FIRST 321
421 #define FLOAT 322
422 #define FOR 323
423 #define FOREIGN 324
424 #define FOUND 325
425 #define FROM 326
426 #define GEOGRAPHY 327
427 #define GEOMETRY 328
428 #define GRANT 329
429 #define GROUP 330
430 #define HAVING 331
431 #define IF 332
432 #define ILIKE 333
433 #define IN 334
434 #define INSERT 335
435 #define INTEGER 336
436 #define INTO 337
437 #define IS 338
438 #define LANGUAGE 339
439 #define LAST 340
440 #define LENGTH 341
441 #define LIKE 342
442 #define LIMIT 343
443 #define LINESTRING 344
444 #define MOD 345
445 #define MULTIPOLYGON 346
446 #define NOW 347
447 #define NULLX 348
448 #define NUMERIC 349
449 #define OF 350
450 #define OFFSET 351
451 #define ON 352
452 #define OPEN 353
453 #define OPTIMIZE 354
454 #define OPTIMIZED 355
455 #define OPTION 356
456 #define ORDER 357
457 #define PARAMETER 358
458 #define POINT 359
459 #define POLYGON 360
460 #define PRECISION 361
461 #define PRIMARY 362
462 #define PRIVILEGES 363
463 #define PROCEDURE 364
464 #define SERVER 365
465 #define SMALLINT 366
466 #define SOME 367
467 #define TABLE 368
468 #define TEMPORARY 369
469 #define TEXT 370
470 #define THEN 371
471 #define TIME 372
472 #define TIMESTAMP 373
473 #define TINYINT 374
474 #define TO 375
475 #define TRUNCATE 376
476 #define UNION 377
477 #define USAGE 378
478 #define PUBLIC 379
479 #define REAL 380
480 #define REFERENCES 381
481 #define RENAME 382
482 #define RESTORE 383
483 #define REVOKE 384
484 #define ROLE 385
485 #define ROLLBACK 386
486 #define SCHEMA 387
487 #define SELECT 388
488 #define SET 389
489 #define SHARD 390
490 #define SHARED 391
491 #define SHOW 392
492 #define UNIQUE 393
493 #define UPDATE 394
494 #define USER 395
495 #define VALIDATE 396
496 #define VALUES 397
497 #define VIEW 398
498 #define WHEN 399
499 #define WHENEVER 400
500 #define WHERE 401
501 #define WITH 402
502 #define WORK 403
503 #define EDIT 404
504 #define ACCESS 405
505 #define DASHBOARD 406
506 #define SQL 407
507 #define EDITOR 408
508 
509 #line 236 "/usr/local/mapd-deps/20210608/lib/bison.cc"
510 /* #defines tokens */
511 #else
512 /* CLASS */
513 #ifndef YY_Parser_CLASS
514 #define YY_Parser_CLASS Parser
515 #endif
516 #ifndef YY_Parser_INHERIT
517 #define YY_Parser_INHERIT
518 #endif
519 #ifndef YY_Parser_MEMBERS
520 #define YY_Parser_MEMBERS
521 #endif
522 #ifndef YY_Parser_LEX_BODY
523 #define YY_Parser_LEX_BODY
524 #endif
525 #ifndef YY_Parser_ERROR_BODY
526 #define YY_Parser_ERROR_BODY
527 #endif
528 #ifndef YY_Parser_CONSTRUCTOR_PARAM
529 #define YY_Parser_CONSTRUCTOR_PARAM
530 #endif
531 #ifndef YY_Parser_CONSTRUCTOR_CODE
532 #define YY_Parser_CONSTRUCTOR_CODE
533 #endif
534 #ifndef YY_Parser_CONSTRUCTOR_INIT
535 #define YY_Parser_CONSTRUCTOR_INIT
536 #endif
537 /* choose between enum and const */
538 #ifndef YY_Parser_USE_CONST_TOKEN
539 #define YY_Parser_USE_CONST_TOKEN 0
540 /* yes enum is more compatible with flex, */
541 /* so by default we use it */
542 #endif
543 #if YY_Parser_USE_CONST_TOKEN != 0
544 #ifndef YY_Parser_ENUM_TOKEN
545 #define YY_Parser_ENUM_TOKEN yy_Parser_enum_token
546 #endif
547 #endif
548 
549 class YY_Parser_CLASS YY_Parser_INHERIT {
550  public:
551 #if YY_Parser_USE_CONST_TOKEN != 0
552  /* static const int token ... */
553 
554  /* #line 280 "/usr/local/mapd-deps/20210608/lib/bison.cc" */
555  static const int NAME;
556  static const int DASHEDNAME;
557  static const int EMAIL;
558  static const int STRING;
559  static const int FWDSTR;
560  static const int SELECTSTRING;
561  static const int QUOTED_IDENTIFIER;
562  static const int INTNUM;
563  static const int FIXEDNUM;
564  static const int OR;
565  static const int AND;
566  static const int NOT;
567  static const int EQUAL;
568  static const int COMPARISON;
569  static const int UMINUS;
570  static const int ADD;
571  static const int ALL;
572  static const int ALTER;
573  static const int AMMSC;
574  static const int ANY;
575  static const int ARCHIVE;
576  static const int ARRAY;
577  static const int AS;
578  static const int ASC;
579  static const int AUTHORIZATION;
580  static const int BETWEEN;
581  static const int BIGINT;
582  static const int BOOLEAN;
583  static const int BY;
584  static const int CASE;
585  static const int CAST;
586  static const int CHAR_LENGTH;
587  static const int CHARACTER;
588  static const int CHECK;
589  static const int CLOSE;
590  static const int CLUSTER;
591  static const int COLUMN;
592  static const int COMMIT;
593  static const int CONTINUE;
594  static const int COPY;
595  static const int CREATE;
596  static const int CURRENT;
597  static const int CURSOR;
598  static const int DATABASE;
599  static const int DATAFRAME;
600  static const int DATE;
601  static const int DATETIME;
602  static const int DATE_TRUNC;
603  static const int DECIMAL;
604  static const int DECLARE;
605  static const int DEFAULT;
606  static const int DELETE;
607  static const int DESC;
608  static const int DICTIONARY;
609  static const int DISTINCT;
610  static const int DOUBLE;
611  static const int DROP;
612  static const int DUMP;
613  static const int ELSE;
614  static const int END;
615  static const int EXISTS;
616  static const int EXTRACT;
617  static const int FETCH;
618  static const int FIRST;
619  static const int FLOAT;
620  static const int FOR;
621  static const int FOREIGN;
622  static const int FOUND;
623  static const int FROM;
624  static const int GEOGRAPHY;
625  static const int GEOMETRY;
626  static const int GRANT;
627  static const int GROUP;
628  static const int HAVING;
629  static const int IF;
630  static const int ILIKE;
631  static const int IN;
632  static const int INSERT;
633  static const int INTEGER;
634  static const int INTO;
635  static const int IS;
636  static const int LANGUAGE;
637  static const int LAST;
638  static const int LENGTH;
639  static const int LIKE;
640  static const int LIMIT;
641  static const int LINESTRING;
642  static const int MOD;
643  static const int MULTIPOLYGON;
644  static const int NOW;
645  static const int NULLX;
646  static const int NUMERIC;
647  static const int OF;
648  static const int OFFSET;
649  static const int ON;
650  static const int OPEN;
651  static const int OPTIMIZE;
652  static const int OPTIMIZED;
653  static const int OPTION;
654  static const int ORDER;
655  static const int PARAMETER;
656  static const int POINT;
657  static const int POLYGON;
658  static const int PRECISION;
659  static const int PRIMARY;
660  static const int PRIVILEGES;
661  static const int PROCEDURE;
662  static const int SERVER;
663  static const int SMALLINT;
664  static const int SOME;
665  static const int TABLE;
666  static const int TEMPORARY;
667  static const int TEXT;
668  static const int THEN;
669  static const int TIME;
670  static const int TIMESTAMP;
671  static const int TINYINT;
672  static const int TO;
673  static const int TRUNCATE;
674  static const int UNION;
675  static const int USAGE;
676  static const int PUBLIC;
677  static const int REAL;
678  static const int REFERENCES;
679  static const int RENAME;
680  static const int RESTORE;
681  static const int REVOKE;
682  static const int ROLE;
683  static const int ROLLBACK;
684  static const int SCHEMA;
685  static const int SELECT;
686  static const int SET;
687  static const int SHARD;
688  static const int SHARED;
689  static const int SHOW;
690  static const int UNIQUE;
691  static const int UPDATE;
692  static const int USER;
693  static const int VALIDATE;
694  static const int VALUES;
695  static const int VIEW;
696  static const int WHEN;
697  static const int WHENEVER;
698  static const int WHERE;
699  static const int WITH;
700  static const int WORK;
701  static const int EDIT;
702  static const int ACCESS;
703  static const int DASHBOARD;
704  static const int SQL;
705  static const int EDITOR;
706 
707 #line 280 "/usr/local/mapd-deps/20210608/lib/bison.cc"
708  /* decl const */
709 #else
710  enum YY_Parser_ENUM_TOKEN {
711  YY_Parser_NULL_TOKEN = 0
712 
713  /* #line 283 "/usr/local/mapd-deps/20210608/lib/bison.cc" */
714  ,
715  NAME = 258,
716  DASHEDNAME = 259,
717  EMAIL = 260,
718  STRING = 261,
719  FWDSTR = 262,
720  SELECTSTRING = 263,
721  QUOTED_IDENTIFIER = 264,
722  INTNUM = 265,
723  FIXEDNUM = 266,
724  OR = 267,
725  AND = 268,
726  NOT = 269,
727  EQUAL = 270,
728  COMPARISON = 271,
729  UMINUS = 272,
730  ADD = 273,
731  ALL = 274,
732  ALTER = 275,
733  AMMSC = 276,
734  ANY = 277,
735  ARCHIVE = 278,
736  ARRAY = 279,
737  AS = 280,
738  ASC = 281,
739  AUTHORIZATION = 282,
740  BETWEEN = 283,
741  BIGINT = 284,
742  BOOLEAN = 285,
743  BY = 286,
744  CASE = 287,
745  CAST = 288,
746  CHAR_LENGTH = 289,
747  CHARACTER = 290,
748  CHECK = 291,
749  CLOSE = 292,
750  CLUSTER = 293,
751  COLUMN = 294,
752  COMMIT = 295,
753  CONTINUE = 296,
754  COPY = 297,
755  CREATE = 298,
756  CURRENT = 299,
757  CURSOR = 300,
758  DATABASE = 301,
759  DATAFRAME = 302,
760  DATE = 303,
761  DATETIME = 304,
762  DATE_TRUNC = 305,
763  DECIMAL = 306,
764  DECLARE = 307,
765  DEFAULT = 308,
766  DELETE = 309,
767  DESC = 310,
768  DICTIONARY = 311,
769  DISTINCT = 312,
770  DOUBLE = 313,
771  DROP = 314,
772  DUMP = 315,
773  ELSE = 316,
774  END = 317,
775  EXISTS = 318,
776  EXTRACT = 319,
777  FETCH = 320,
778  FIRST = 321,
779  FLOAT = 322,
780  FOR = 323,
781  FOREIGN = 324,
782  FOUND = 325,
783  FROM = 326,
784  GEOGRAPHY = 327,
785  GEOMETRY = 328,
786  GRANT = 329,
787  GROUP = 330,
788  HAVING = 331,
789  IF = 332,
790  ILIKE = 333,
791  IN = 334,
792  INSERT = 335,
793  INTEGER = 336,
794  INTO = 337,
795  IS = 338,
796  LANGUAGE = 339,
797  LAST = 340,
798  LENGTH = 341,
799  LIKE = 342,
800  LIMIT = 343,
801  LINESTRING = 344,
802  MOD = 345,
803  MULTIPOLYGON = 346,
804  NOW = 347,
805  NULLX = 348,
806  NUMERIC = 349,
807  OF = 350,
808  OFFSET = 351,
809  ON = 352,
810  OPEN = 353,
811  OPTIMIZE = 354,
812  OPTIMIZED = 355,
813  OPTION = 356,
814  ORDER = 357,
815  PARAMETER = 358,
816  POINT = 359,
817  POLYGON = 360,
818  PRECISION = 361,
819  PRIMARY = 362,
820  PRIVILEGES = 363,
821  PROCEDURE = 364,
822  SERVER = 365,
823  SMALLINT = 366,
824  SOME = 367,
825  TABLE = 368,
826  TEMPORARY = 369,
827  TEXT = 370,
828  THEN = 371,
829  TIME = 372,
830  TIMESTAMP = 373,
831  TINYINT = 374,
832  TO = 375,
833  TRUNCATE = 376,
834  UNION = 377,
835  USAGE = 378,
836  PUBLIC = 379,
837  REAL = 380,
838  REFERENCES = 381,
839  RENAME = 382,
840  RESTORE = 383,
841  REVOKE = 384,
842  ROLE = 385,
843  ROLLBACK = 386,
844  SCHEMA = 387,
845  SELECT = 388,
846  SET = 389,
847  SHARD = 390,
848  SHARED = 391,
849  SHOW = 392,
850  UNIQUE = 393,
851  UPDATE = 394,
852  USER = 395,
853  VALIDATE = 396,
854  VALUES = 397,
855  VIEW = 398,
856  WHEN = 399,
857  WHENEVER = 400,
858  WHERE = 401,
859  WITH = 402,
860  WORK = 403,
861  EDIT = 404,
862  ACCESS = 405,
863  DASHBOARD = 406,
864  SQL = 407,
865  EDITOR = 408
866 
867 #line 283 "/usr/local/mapd-deps/20210608/lib/bison.cc"
868  /* enum token */
869  }; /* end of enum declaration */
870 #endif
871  public:
873  virtual void YY_Parser_ERROR(const char* msg) YY_Parser_ERROR_BODY;
874 #ifdef YY_Parser_PURE
875 #ifdef YY_Parser_LSP_NEEDED
877  YY_Parser_LTYPE* YY_Parser_LLOC) YY_Parser_LEX_BODY;
878 #else
879  virtual int YY_Parser_LEX(YY_Parser_STYPE* YY_Parser_LVAL) YY_Parser_LEX_BODY;
880 #endif
881 #else
882  virtual int YY_Parser_LEX() YY_Parser_LEX_BODY;
884 #ifdef YY_Parser_LSP_NEEDED
885  YY_Parser_LTYPE YY_Parser_LLOC;
886 #endif
887  int YY_Parser_NERRS;
888  int YY_Parser_CHAR;
889 #endif
890 #if YY_Parser_DEBUG != 0
891  int YY_Parser_DEBUG_FLAG; /* nonzero means print parse trace */
892 #endif
893  public:
894  YY_Parser_CLASS(YY_Parser_CONSTRUCTOR_PARAM);
895 
896  public:
898 };
899 /* other declare folow */
900 #if YY_Parser_USE_CONST_TOKEN != 0
901 
902 /* #line 314 "/usr/local/mapd-deps/20210608/lib/bison.cc" */
903 const int YY_Parser_CLASS::NAME = 258;
904 const int YY_Parser_CLASS::DASHEDNAME = 259;
905 const int YY_Parser_CLASS::EMAIL = 260;
906 const int YY_Parser_CLASS::STRING = 261;
907 const int YY_Parser_CLASS::FWDSTR = 262;
908 const int YY_Parser_CLASS::SELECTSTRING = 263;
909 const int YY_Parser_CLASS::QUOTED_IDENTIFIER = 264;
910 const int YY_Parser_CLASS::INTNUM = 265;
911 const int YY_Parser_CLASS::FIXEDNUM = 266;
912 const int YY_Parser_CLASS::OR = 267;
913 const int YY_Parser_CLASS::AND = 268;
914 const int YY_Parser_CLASS::NOT = 269;
915 const int YY_Parser_CLASS::EQUAL = 270;
916 const int YY_Parser_CLASS::COMPARISON = 271;
917 const int YY_Parser_CLASS::UMINUS = 272;
918 const int YY_Parser_CLASS::ADD = 273;
919 const int YY_Parser_CLASS::ALL = 274;
920 const int YY_Parser_CLASS::ALTER = 275;
921 const int YY_Parser_CLASS::AMMSC = 276;
922 const int YY_Parser_CLASS::ANY = 277;
923 const int YY_Parser_CLASS::ARCHIVE = 278;
924 const int YY_Parser_CLASS::ARRAY = 279;
925 const int YY_Parser_CLASS::AS = 280;
926 const int YY_Parser_CLASS::ASC = 281;
927 const int YY_Parser_CLASS::AUTHORIZATION = 282;
928 const int YY_Parser_CLASS::BETWEEN = 283;
929 const int YY_Parser_CLASS::BIGINT = 284;
930 const int YY_Parser_CLASS::BOOLEAN = 285;
931 const int YY_Parser_CLASS::BY = 286;
932 const int YY_Parser_CLASS::CASE = 287;
933 const int YY_Parser_CLASS::CAST = 288;
934 const int YY_Parser_CLASS::CHAR_LENGTH = 289;
935 const int YY_Parser_CLASS::CHARACTER = 290;
936 const int YY_Parser_CLASS::CHECK = 291;
937 const int YY_Parser_CLASS::CLOSE = 292;
938 const int YY_Parser_CLASS::CLUSTER = 293;
939 const int YY_Parser_CLASS::COLUMN = 294;
940 const int YY_Parser_CLASS::COMMIT = 295;
941 const int YY_Parser_CLASS::CONTINUE = 296;
942 const int YY_Parser_CLASS::COPY = 297;
943 const int YY_Parser_CLASS::CREATE = 298;
944 const int YY_Parser_CLASS::CURRENT = 299;
945 const int YY_Parser_CLASS::CURSOR = 300;
946 const int YY_Parser_CLASS::DATABASE = 301;
947 const int YY_Parser_CLASS::DATAFRAME = 302;
948 const int YY_Parser_CLASS::DATE = 303;
949 const int YY_Parser_CLASS::DATETIME = 304;
950 const int YY_Parser_CLASS::DATE_TRUNC = 305;
951 const int YY_Parser_CLASS::DECIMAL = 306;
952 const int YY_Parser_CLASS::DECLARE = 307;
953 const int YY_Parser_CLASS::DEFAULT = 308;
954 const int YY_Parser_CLASS::DELETE = 309;
955 const int YY_Parser_CLASS::DESC = 310;
956 const int YY_Parser_CLASS::DICTIONARY = 311;
957 const int YY_Parser_CLASS::DISTINCT = 312;
958 const int YY_Parser_CLASS::DOUBLE = 313;
959 const int YY_Parser_CLASS::DROP = 314;
960 const int YY_Parser_CLASS::DUMP = 315;
961 const int YY_Parser_CLASS::ELSE = 316;
962 const int YY_Parser_CLASS::END = 317;
963 const int YY_Parser_CLASS::EXISTS = 318;
964 const int YY_Parser_CLASS::EXTRACT = 319;
965 const int YY_Parser_CLASS::FETCH = 320;
966 const int YY_Parser_CLASS::FIRST = 321;
967 const int YY_Parser_CLASS::FLOAT = 322;
968 const int YY_Parser_CLASS::FOR = 323;
969 const int YY_Parser_CLASS::FOREIGN = 324;
970 const int YY_Parser_CLASS::FOUND = 325;
971 const int YY_Parser_CLASS::FROM = 326;
972 const int YY_Parser_CLASS::GEOGRAPHY = 327;
973 const int YY_Parser_CLASS::GEOMETRY = 328;
974 const int YY_Parser_CLASS::GRANT = 329;
975 const int YY_Parser_CLASS::GROUP = 330;
976 const int YY_Parser_CLASS::HAVING = 331;
977 const int YY_Parser_CLASS::IF = 332;
978 const int YY_Parser_CLASS::ILIKE = 333;
979 const int YY_Parser_CLASS::IN = 334;
980 const int YY_Parser_CLASS::INSERT = 335;
981 const int YY_Parser_CLASS::INTEGER = 336;
982 const int YY_Parser_CLASS::INTO = 337;
983 const int YY_Parser_CLASS::IS = 338;
984 const int YY_Parser_CLASS::LANGUAGE = 339;
985 const int YY_Parser_CLASS::LAST = 340;
986 const int YY_Parser_CLASS::LENGTH = 341;
987 const int YY_Parser_CLASS::LIKE = 342;
988 const int YY_Parser_CLASS::LIMIT = 343;
989 const int YY_Parser_CLASS::LINESTRING = 344;
990 const int YY_Parser_CLASS::MOD = 345;
991 const int YY_Parser_CLASS::MULTIPOLYGON = 346;
992 const int YY_Parser_CLASS::NOW = 347;
993 const int YY_Parser_CLASS::NULLX = 348;
994 const int YY_Parser_CLASS::NUMERIC = 349;
995 const int YY_Parser_CLASS::OF = 350;
996 const int YY_Parser_CLASS::OFFSET = 351;
997 const int YY_Parser_CLASS::ON = 352;
998 const int YY_Parser_CLASS::OPEN = 353;
999 const int YY_Parser_CLASS::OPTIMIZE = 354;
1000 const int YY_Parser_CLASS::OPTIMIZED = 355;
1001 const int YY_Parser_CLASS::OPTION = 356;
1002 const int YY_Parser_CLASS::ORDER = 357;
1003 const int YY_Parser_CLASS::PARAMETER = 358;
1004 const int YY_Parser_CLASS::POINT = 359;
1005 const int YY_Parser_CLASS::POLYGON = 360;
1006 const int YY_Parser_CLASS::PRECISION = 361;
1007 const int YY_Parser_CLASS::PRIMARY = 362;
1008 const int YY_Parser_CLASS::PRIVILEGES = 363;
1009 const int YY_Parser_CLASS::PROCEDURE = 364;
1010 const int YY_Parser_CLASS::SERVER = 365;
1011 const int YY_Parser_CLASS::SMALLINT = 366;
1012 const int YY_Parser_CLASS::SOME = 367;
1013 const int YY_Parser_CLASS::TABLE = 368;
1014 const int YY_Parser_CLASS::TEMPORARY = 369;
1015 const int YY_Parser_CLASS::TEXT = 370;
1016 const int YY_Parser_CLASS::THEN = 371;
1017 const int YY_Parser_CLASS::TIME = 372;
1018 const int YY_Parser_CLASS::TIMESTAMP = 373;
1019 const int YY_Parser_CLASS::TINYINT = 374;
1020 const int YY_Parser_CLASS::TO = 375;
1021 const int YY_Parser_CLASS::TRUNCATE = 376;
1022 const int YY_Parser_CLASS::UNION = 377;
1023 const int YY_Parser_CLASS::USAGE = 378;
1024 const int YY_Parser_CLASS::PUBLIC = 379;
1025 const int YY_Parser_CLASS::REAL = 380;
1026 const int YY_Parser_CLASS::REFERENCES = 381;
1027 const int YY_Parser_CLASS::RENAME = 382;
1028 const int YY_Parser_CLASS::RESTORE = 383;
1029 const int YY_Parser_CLASS::REVOKE = 384;
1030 const int YY_Parser_CLASS::ROLE = 385;
1031 const int YY_Parser_CLASS::ROLLBACK = 386;
1032 const int YY_Parser_CLASS::SCHEMA = 387;
1033 const int YY_Parser_CLASS::SELECT = 388;
1034 const int YY_Parser_CLASS::SET = 389;
1035 const int YY_Parser_CLASS::SHARD = 390;
1036 const int YY_Parser_CLASS::SHARED = 391;
1037 const int YY_Parser_CLASS::SHOW = 392;
1038 const int YY_Parser_CLASS::UNIQUE = 393;
1039 const int YY_Parser_CLASS::UPDATE = 394;
1040 const int YY_Parser_CLASS::USER = 395;
1041 const int YY_Parser_CLASS::VALIDATE = 396;
1042 const int YY_Parser_CLASS::VALUES = 397;
1043 const int YY_Parser_CLASS::VIEW = 398;
1044 const int YY_Parser_CLASS::WHEN = 399;
1045 const int YY_Parser_CLASS::WHENEVER = 400;
1046 const int YY_Parser_CLASS::WHERE = 401;
1047 const int YY_Parser_CLASS::WITH = 402;
1048 const int YY_Parser_CLASS::WORK = 403;
1049 const int YY_Parser_CLASS::EDIT = 404;
1050 const int YY_Parser_CLASS::ACCESS = 405;
1051 const int YY_Parser_CLASS::DASHBOARD = 406;
1052 const int YY_Parser_CLASS::SQL = 407;
1053 const int YY_Parser_CLASS::EDITOR = 408;
1054 
1055 #line 314 "/usr/local/mapd-deps/20210608/lib/bison.cc"
1056 /* const YY_Parser_CLASS::token */
1057 #endif
1058 /*apres const */
1059 YY_Parser_CLASS::YY_Parser_CLASS(YY_Parser_CONSTRUCTOR_PARAM) YY_Parser_CONSTRUCTOR_INIT {
1060 #if YY_Parser_DEBUG != 0
1062 #endif
1063  YY_Parser_CONSTRUCTOR_CODE;
1064 };
1065 #endif
1066 
1067 /* #line 325 "/usr/local/mapd-deps/20210608/lib/bison.cc" */
1068 
1069 #define YYFINAL 512
1070 #define YYFLAG -32768
1071 #define YYNTBASE 168
1072 
1073 #define YYTRANSLATE(x) ((unsigned)(x) <= 408 ? yytranslate[x] : 258)
1074 
1075 static const short yytranslate[] = {
1076  0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1077  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1078  2, 2, 2, 21, 2, 2, 161, 162, 19, 17, 160, 18, 167, 20, 2, 2, 2,
1079  2, 2, 2, 2, 2, 2, 2, 2, 159, 2, 2, 2, 2, 2, 2, 2, 2,
1080  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1081  2, 2, 2, 2, 2, 2, 163, 2, 164, 2, 2, 2, 2, 2, 2, 2, 2,
1082  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1083  2, 2, 2, 2, 165, 2, 166, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1084  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1085  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1086  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1087  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1088  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1089  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1090  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1091  2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
1092  22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
1093  39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
1094  56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
1095  73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
1096  90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106,
1097  107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123,
1098  124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140,
1099  141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157,
1100  158};
1101 
1102 #if YY_Parser_DEBUG != 0
1103 static const short yyprhs[] = {
1104  0, 0, 3, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 29, 33, 37,
1105  38, 40, 41, 51, 62, 65, 66, 71, 78, 87, 88, 90, 92, 96, 103, 111,
1106  116, 118, 122, 126, 132, 134, 138, 140, 142, 146, 151, 154, 160, 161, 164, 168,
1107  173, 176, 179, 182, 187, 190, 196, 201, 207, 215, 226, 232, 243, 248, 250, 254,
1108  259, 260, 265, 266, 270, 271, 275, 277, 281, 285, 289, 290, 292, 294, 295, 298,
1109  301, 303, 305, 307, 309, 311, 316, 325, 326, 328, 330, 332, 336, 340, 346, 347,
1110  349, 352, 355, 356, 359, 363, 364, 369, 371, 375, 380, 382, 386, 394, 396, 398,
1111  401, 403, 407, 409, 412, 415, 416, 420, 422, 426, 427, 430, 434, 438, 441, 445,
1112  447, 449, 451, 453, 455, 457, 459, 461, 463, 467, 471, 478, 484, 490, 495, 501,
1113  506, 507, 510, 515, 519, 524, 528, 535, 541, 543, 547, 552, 557, 559, 561, 563,
1114  565, 567, 570, 574, 579, 585, 588, 589, 594, 603, 610, 615, 620, 625, 629, 633,
1115  637, 641, 645, 652, 655, 658, 660, 662, 664, 668, 675, 677, 679, 681, 682, 684,
1116  687, 691, 692, 694, 698, 700, 702, 707, 713, 719, 724, 726, 728, 732, 737, 739,
1117  741, 743, 746, 750, 755, 757, 759, 763, 764, 766, 768, 770, 771, 773, 775, 777,
1118  779, 781, 783, 787, 789, 791, 793, 797, 799, 801, 803, 807, 809, 812, 814, 816,
1119  818, 820, 822, 824, 826, 828, 830, 832, 834, 836, 839, 842, 845, 848, 851, 854,
1120  857, 860, 863, 866, 869, 872, 876, 878, 880, 882, 884, 886, 888, 890, 892, 896,
1121  900, 902, 904, 906, 908, 910, 915, 917, 922, 929, 931, 936, 943, 945, 947, 949,
1122  951, 953, 956, 958, 960, 962, 967, 969, 974, 976, 978, 982, 987, 989, 991, 993,
1123  995, 1000, 1007, 1012, 1019, 1021, 1023};
1124 
1125 static const short yyrhs[] = {
1126  169, 159, 0, 168, 169, 159, 0, 174, 0, 194, 0, 176, 0, 177, 0, 178, 0,
1127  181, 0, 182, 0, 185, 0, 171, 0, 170, 160, 171, 0, 3, 15, 247, 0, 82,
1128  14, 68, 0, 0, 119, 0, 0, 48, 173, 118, 172, 250, 161, 186, 162, 193, 0,
1129  48, 48, 3, 118, 172, 250, 161, 186, 162, 193, 0, 82, 68, 0, 0, 64, 118,
1130  175, 250, 0, 25, 118, 250, 132, 125, 250, 0, 25, 118, 250, 132, 44, 256, 125,
1131  256, 0, 0, 44, 0, 188, 0, 180, 160, 188, 0, 25, 118, 250, 23, 179, 188,
1132  0, 25, 118, 250, 23, 161, 180, 162, 0, 25, 118, 250, 183, 0, 184, 0, 183,
1133  160, 184, 0, 64, 179, 256, 0, 25, 118, 250, 139, 171, 0, 187, 0, 186, 160,
1134  187, 0, 188, 0, 191, 0, 256, 253, 189, 0, 256, 253, 190, 189, 0, 3, 3,
1135  0, 3, 3, 161, 10, 162, 0, 0, 14, 98, 0, 14, 98, 143, 0, 14, 98,
1136  112, 3, 0, 58, 247, 0, 58, 98, 0, 58, 145, 0, 41, 161, 223, 162, 0,
1137  131, 250, 0, 131, 250, 161, 256, 162, 0, 143, 161, 192, 162, 0, 112, 3, 161,
1138  192, 162, 0, 74, 3, 161, 192, 162, 131, 250, 0, 74, 3, 161, 192, 162, 131,
1139  250, 161, 192, 162, 0, 140, 3, 161, 256, 162, 0, 141, 61, 161, 256, 162, 131,
1140  250, 161, 256, 162, 0, 41, 161, 223, 162, 0, 256, 0, 192, 160, 256, 0, 152,
1141  161, 170, 162, 0, 0, 64, 148, 175, 250, 0, 0, 161, 192, 162, 0, 0, 107,
1142  36, 197, 0, 198, 0, 197, 160, 198, 0, 10, 199, 200, 0, 251, 199, 200, 0,
1143  0, 31, 0, 60, 0, 0, 98, 71, 0, 98, 90, 0, 201, 0, 202, 0, 203,
1144  0, 211, 0, 207, 0, 59, 76, 250, 208, 0, 85, 87, 250, 195, 147, 161, 231,
1145  162, 0, 0, 24, 0, 62, 0, 206, 0, 205, 160, 206, 0, 256, 15, 223, 0,
1146  144, 250, 139, 205, 208, 0, 0, 219, 0, 93, 10, 0, 93, 24, 0, 0, 101,
1147  10, 0, 101, 10, 3, 0, 0, 212, 196, 209, 210, 0, 213, 0, 212, 127, 213,
1148  0, 212, 127, 24, 213, 0, 214, 0, 161, 212, 162, 0, 138, 204, 215, 216, 208,
1149  220, 222, 0, 244, 0, 19, 0, 76, 217, 0, 218, 0, 217, 160, 218, 0, 250,
1150  0, 250, 257, 0, 151, 223, 0, 0, 80, 36, 221, 0, 223, 0, 221, 160, 223,
1151  0, 0, 81, 223, 0, 223, 12, 223, 0, 223, 13, 223, 0, 14, 223, 0, 161,
1152  223, 162, 0, 224, 0, 225, 0, 226, 0, 227, 0, 229, 0, 230, 0, 232, 0,
1153  235, 0, 242, 0, 242, 233, 242, 0, 242, 233, 236, 0, 242, 14, 33, 242, 13,
1154  242, 0, 242, 33, 242, 13, 242, 0, 242, 14, 92, 245, 228, 0, 242, 92, 245,
1155  228, 0, 242, 14, 83, 245, 228, 0, 242, 83, 245, 228, 0, 0, 3, 245, 0,
1156  251, 88, 14, 98, 0, 251, 88, 98, 0, 242, 14, 84, 236, 0, 242, 84, 236,
1157  0, 242, 14, 84, 161, 231, 162, 0, 242, 84, 161, 231, 162, 0, 245, 0, 231,
1158  160, 245, 0, 242, 233, 234, 236, 0, 242, 233, 234, 242, 0, 15, 0, 16, 0,
1159  27, 0, 24, 0, 117, 0, 68, 236, 0, 161, 214, 162, 0, 149, 223, 121, 223,
1160  0, 237, 149, 223, 121, 223, 0, 66, 223, 0, 0, 37, 237, 238, 67, 0, 82,
1161  161, 223, 160, 223, 160, 223, 162, 0, 82, 161, 223, 160, 223, 162, 0, 39, 161,
1162  242, 162, 0, 91, 161, 242, 162, 0, 251, 163, 242, 164, 0, 242, 17, 242, 0,
1163  242, 18, 242, 0, 242, 19, 242, 0, 242, 20, 242, 0, 242, 21, 242, 0, 95,
1164  161, 242, 160, 242, 162, 0, 17, 242, 0, 18, 242, 0, 245, 0, 251, 0, 246,
1165  0, 161, 242, 162, 0, 38, 161, 223, 30, 253, 162, 0, 239, 0, 240, 0, 241,
1166  0, 0, 223, 0, 223, 3, 0, 223, 30, 3, 0, 0, 243, 0, 244, 160, 243,
1167  0, 247, 0, 145, 0, 3, 161, 19, 162, 0, 3, 161, 62, 223, 162, 0, 3,
1168  161, 24, 223, 162, 0, 3, 161, 223, 162, 0, 6, 0, 10, 0, 97, 161, 162,
1169  0, 54, 161, 223, 162, 0, 11, 0, 72, 0, 63, 0, 253, 6, 0, 165, 249,
1170  166, 0, 29, 163, 249, 164, 0, 98, 0, 247, 0, 248, 160, 247, 0, 0, 248,
1171  0, 3, 0, 9, 0, 0, 250, 0, 3, 0, 5, 0, 4, 0, 9, 0, 0,
1172  0, 0, 160, 0, 0, 3, 0, 4, 0, 0, 0, 0, 160, 0, 0, 0, 0,
1173  0, 0, 0, 0, 0, 160, 0, 0, 24, 0, 24, 113, 0, 48, 0, 138, 0,
1174  85, 0, 126, 0, 144, 0, 59, 0, 25, 0, 64, 0, 148, 0, 154, 0, 155,
1175  0, 128, 0, 115, 128, 0, 25, 115, 0, 48, 115, 0, 48, 118, 0, 48, 148,
1176  0, 138, 148, 0, 64, 148, 0, 64, 115, 0, 48, 156, 0, 154, 156, 0, 148,
1177  156, 0, 59, 156, 0, 148, 157, 158, 0, 51, 0, 118, 0, 156, 0, 148, 0,
1178  115, 0, 3, 0, 10, 0, 3, 0, 3, 167, 3, 0, 3, 167, 19, 0, 10,
1179  0, 34, 0, 120, 0, 35, 0, 40, 0, 40, 161, 252, 162, 0, 99, 0, 99,
1180  161, 252, 162, 0, 99, 161, 252, 160, 252, 162, 0, 56, 0, 56, 161, 252, 162,
1181  0, 56, 161, 252, 160, 252, 162, 0, 86, 0, 124, 0, 116, 0, 72, 0, 130,
1182  0, 63, 111, 0, 63, 0, 53, 0, 122, 0, 122, 161, 252, 162, 0, 123, 0,
1183  123, 161, 252, 162, 0, 254, 0, 255, 0, 253, 163, 164, 0, 253, 163, 252, 164,
1184  0, 109, 0, 94, 0, 110, 0, 96, 0, 77, 161, 254, 162, 0, 77, 161, 254,
1185  160, 10, 162, 0, 78, 161, 254, 162, 0, 78, 161, 254, 160, 10, 162, 0, 3,
1186  0, 9, 0, 3, 0};
1187 
1188 #endif
1189 
1190 #if YY_Parser_DEBUG != 0
1191 static const short yyrline[] = {
1192  0, 120, 122, 130, 132, 133, 134, 135, 136, 137, 138, 141, 146, 152, 155, 157,
1193  160, 162, 165, 170, 176, 178, 181, 187, 194, 201, 202, 204, 206, 213, 218, 224,
1194  228, 230, 233, 236, 243, 245, 252, 254, 257, 260, 264, 272, 279, 282, 284, 285,
1195  291, 292, 293, 294, 295, 296, 299, 302, 308, 315, 321, 329, 336, 340, 342, 349,
1196  352, 356, 363, 365, 368, 370, 373, 375, 382, 385, 389, 391, 392, 395, 397, 398,
1197  403, 406, 412, 415, 417, 420, 425, 432, 434, 435, 438, 441, 448, 453, 458, 460,
1198  463, 465, 466, 468, 470, 477, 483, 490, 492, 494, 498, 500, 503, 515, 517, 520,
1199  524, 526, 533, 535, 538, 542, 544, 547, 549, 556, 558, 563, 566, 568, 570, 571,
1200  574, 576, 577, 578, 579, 580, 581, 582, 585, 588, 595, 598, 602, 605, 607, 609,
1201  613, 615, 627, 629, 632, 635, 647, 649, 653, 655, 662, 667, 673, 675, 678, 680,
1202  681, 684, 688, 692, 697, 703, 705, 708, 712, 717, 724, 726, 731, 739, 741, 742,
1203  743, 744, 745, 746, 747, 748, 749, 750, 751, 752, 754, 755, 756, 759, 761, 762,
1204  763, 766, 768, 769, 776, 778, 791, 793, 794, 795, 798, 800, 801, 802, 803, 804,
1205  805, 806, 807, 808, 809, 812, 814, 821, 823, 828, 838, 841, 843, 845, 846, 846,
1206  846, 849, 851, 858, 859, 862, 864, 871, 872, 875, 877, 884, 886, 887, 888, 889,
1207  890, 891, 892, 893, 894, 895, 896, 897, 898, 899, 900, 901, 902, 903, 904, 905,
1208  906, 907, 908, 909, 910, 911, 914, 916, 917, 918, 919, 922, 924, 928, 930, 931,
1209  935, 945, 947, 948, 949, 950, 951, 952, 953, 954, 955, 956, 957, 958, 959, 960,
1210  962, 963, 964, 965, 966, 967, 968, 969, 970, 972, 973, 980, 990, 991, 992, 993,
1211  996, 998, 1002, 1004, 1010, 1019, 1022};
1212 
1213 static const char* const yytname[] = {"$",
1214  "error",
1215  "$illegal.",
1216  "NAME",
1217  "DASHEDNAME",
1218  "EMAIL",
1219  "STRING",
1220  "FWDSTR",
1221  "SELECTSTRING",
1222  "QUOTED_IDENTIFIER",
1223  "INTNUM",
1224  "FIXEDNUM",
1225  "OR",
1226  "AND",
1227  "NOT",
1228  "EQUAL",
1229  "COMPARISON",
1230  "'+'",
1231  "'-'",
1232  "'*'",
1233  "'/'",
1234  "'%'",
1235  "UMINUS",
1236  "ADD",
1237  "ALL",
1238  "ALTER",
1239  "AMMSC",
1240  "ANY",
1241  "ARCHIVE",
1242  "ARRAY",
1243  "AS",
1244  "ASC",
1245  "AUTHORIZATION",
1246  "BETWEEN",
1247  "BIGINT",
1248  "BOOLEAN",
1249  "BY",
1250  "CASE",
1251  "CAST",
1252  "CHAR_LENGTH",
1253  "CHARACTER",
1254  "CHECK",
1255  "CLOSE",
1256  "CLUSTER",
1257  "COLUMN",
1258  "COMMIT",
1259  "CONTINUE",
1260  "COPY",
1261  "CREATE",
1262  "CURRENT",
1263  "CURSOR",
1264  "DATABASE",
1265  "DATAFRAME",
1266  "DATE",
1267  "DATETIME",
1268  "DATE_TRUNC",
1269  "DECIMAL",
1270  "DECLARE",
1271  "DEFAULT",
1272  "DELETE",
1273  "DESC",
1274  "DICTIONARY",
1275  "DISTINCT",
1276  "DOUBLE",
1277  "DROP",
1278  "DUMP",
1279  "ELSE",
1280  "END",
1281  "EXISTS",
1282  "EXTRACT",
1283  "FETCH",
1284  "FIRST",
1285  "FLOAT",
1286  "FOR",
1287  "FOREIGN",
1288  "FOUND",
1289  "FROM",
1290  "GEOGRAPHY",
1291  "GEOMETRY",
1292  "GRANT",
1293  "GROUP",
1294  "HAVING",
1295  "IF",
1296  "ILIKE",
1297  "IN",
1298  "INSERT",
1299  "INTEGER",
1300  "INTO",
1301  "IS",
1302  "LANGUAGE",
1303  "LAST",
1304  "LENGTH",
1305  "LIKE",
1306  "LIMIT",
1307  "LINESTRING",
1308  "MOD",
1309  "MULTIPOLYGON",
1310  "NOW",
1311  "NULLX",
1312  "NUMERIC",
1313  "OF",
1314  "OFFSET",
1315  "ON",
1316  "OPEN",
1317  "OPTIMIZE",
1318  "OPTIMIZED",
1319  "OPTION",
1320  "ORDER",
1321  "PARAMETER",
1322  "POINT",
1323  "POLYGON",
1324  "PRECISION",
1325  "PRIMARY",
1326  "PRIVILEGES",
1327  "PROCEDURE",
1328  "SERVER",
1329  "SMALLINT",
1330  "SOME",
1331  "TABLE",
1332  "TEMPORARY",
1333  "TEXT",
1334  "THEN",
1335  "TIME",
1336  "TIMESTAMP",
1337  "TINYINT",
1338  "TO",
1339  "TRUNCATE",
1340  "UNION",
1341  "USAGE",
1342  "PUBLIC",
1343  "REAL",
1344  "REFERENCES",
1345  "RENAME",
1346  "RESTORE",
1347  "REVOKE",
1348  "ROLE",
1349  "ROLLBACK",
1350  "SCHEMA",
1351  "SELECT",
1352  "SET",
1353  "SHARD",
1354  "SHARED",
1355  "SHOW",
1356  "UNIQUE",
1357  "UPDATE",
1358  "USER",
1359  "VALIDATE",
1360  "VALUES",
1361  "VIEW",
1362  "WHEN",
1363  "WHENEVER",
1364  "WHERE",
1365  "WITH",
1366  "WORK",
1367  "EDIT",
1368  "ACCESS",
1369  "DASHBOARD",
1370  "SQL",
1371  "EDITOR",
1372  "';'",
1373  "','",
1374  "'('",
1375  "')'",
1376  "'['",
1377  "']'",
1378  "'{'",
1379  "'}'",
1380  "'.'",
1381  "sql_list",
1382  "sql",
1383  "name_eq_value_list",
1384  "name_eq_value",
1385  "opt_if_not_exists",
1386  "opt_temporary",
1387  "create_table_statement",
1388  "opt_if_exists",
1389  "drop_table_statement",
1390  "rename_table_statement",
1391  "rename_column_statement",
1392  "opt_column",
1393  "column_defs",
1394  "add_column_statement",
1395  "drop_column_statement",
1396  "drop_columns",
1397  "drop_column",
1398  "alter_table_param_statement",
1399  "base_table_element_commalist",
1400  "base_table_element",
1401  "column_def",
1402  "opt_compression",
1403  "column_constraint_def",
1404  "table_constraint_def",
1405  "column_commalist",
1406  "opt_with_option_list",
1407  "drop_view_statement",
1408  "opt_column_commalist",
1409  "opt_order_by_clause",
1410  "ordering_spec_commalist",
1411  "ordering_spec",
1412  "opt_asc_desc",
1413  "opt_null_order",
1414  "manipulative_statement",
1415  "delete_statement",
1416  "insert_statement",
1417  "opt_all_distinct",
1418  "assignment_commalist",
1419  "assignment",
1420  "update_statement",
1421  "opt_where_clause",
1422  "opt_limit_clause",
1423  "opt_offset_clause",
1424  "select_statement",
1425  "query_exp",
1426  "query_term",
1427  "query_spec",
1428  "selection",
1429  "from_clause",
1430  "table_ref_commalist",
1431  "table_ref",
1432  "where_clause",
1433  "opt_group_by_clause",
1434  "exp_commalist",
1435  "opt_having_clause",
1436  "general_exp",
1437  "predicate",
1438  "comparison_predicate",
1439  "between_predicate",
1440  "like_predicate",
1441  "opt_escape",
1442  "test_for_null",
1443  "in_predicate",
1444  "atom_commalist",
1445  "all_or_any_predicate",
1446  "comparison",
1447  "any_all_some",
1448  "existence_test",
1449  "subquery",
1450  "when_then_list",
1451  "opt_else_expr",
1452  "case_exp",
1453  "charlength_exp",
1454  "array_at_exp",
1455  "scalar_exp",
1456  "select_entry",
1457  "select_entry_commalist",
1458  "atom",
1459  "function_ref",
1460  "literal",
1461  "literal_commalist",
1462  "opt_literal_commalist",
1463  "table",
1464  "column_ref",
1465  "non_neg_int",
1466  "data_type",
1467  "geo_type",
1468  "geometry_type",
1469  "column",
1470  "range_variable",
1471  "\37777777740$\37777777626"};
1472 #endif
1473 
1474 static const short yyr1[] = {
1475  0, 168, 168, 169, 169, 169, 169, 169, 169, 169, 169, 170, 170, 171, 172, 172, 173,
1476  173, 174, 174, 175, 175, 176, 177, 178, 179, 179, 180, 180, 181, 181, 182, 183, 183,
1477  184, 185, 186, 186, 187, 187, 188, 188, 189, 189, 189, 190, 190, 190, 190, 190, 190,
1478  190, 190, 190, 191, 191, 191, 191, 191, 191, 191, 192, 192, 193, 193, 194, 195, 195,
1479  196, 196, 197, 197, 198, 198, 199, 199, 199, 200, 200, 200, 169, 201, 201, 201, 201,
1480  202, 203, 204, 204, 204, 205, 205, 206, 207, 208, 208, 209, 209, 209, 210, 210, 210,
1481  211, 212, 212, 212, 213, 213, 214, 215, 215, 216, 217, 217, 218, 218, 219, 220, 220,
1482  221, 221, 222, 222, 223, 223, 223, 223, 223, 224, 224, 224, 224, 224, 224, 224, 224,
1483  225, 225, 226, 226, 227, 227, 227, 227, 228, 228, 229, 229, 230, 230, 230, 230, 231,
1484  231, 232, 232, 233, 233, 234, 234, 234, 235, 236, 237, 237, 238, 238, 239, 239, 239,
1485  240, 240, 241, 242, 242, 242, 242, 242, 242, 242, 242, 242, 242, 242, 242, 242, 242,
1486  242, 242, 243, 243, 243, 243, 244, 244, 244, 245, 245, 246, 246, 246, 246, 247, 247,
1487  247, 247, 247, 247, 247, 247, 247, 247, 247, 248, 248, 249, 249, 250, 250, -1, -1,
1488  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1489  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1490  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 251, 251, 251,
1491  252, 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, 253,
1492  253, 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, 254, 254, 254, 254, -1, -1,
1493  255, 255, 256, 256, 257};
1494 
1495 static const short yyr2[] = {
1496  0, 2, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 3, 3, 0, 1, 0, 9, 10, 2, 0, 4, 6, 8, 0,
1497  1, 1, 3, 6, 7, 4, 1, 3, 3, 5, 1, 3, 1, 1, 3, 4, 2, 5, 0, 2, 3, 4, 2, 2, 2, 4,
1498  2, 5, 4, 5, 7, 10, 5, 10, 4, 1, 3, 4, 0, 4, 0, 3, 0, 3, 1, 3, 3, 3, 0, 1, 1, 0,
1499  2, 2, 1, 1, 1, 1, 1, 4, 8, 0, 1, 1, 1, 3, 3, 5, 0, 1, 2, 2, 0, 2, 3, 0, 4, 1,
1500  3, 4, 1, 3, 7, 1, 1, 2, 1, 3, 1, 2, 2, 0, 3, 1, 3, 0, 2, 3, 3, 2, 3, 1, 1, 1,
1501  1, 1, 1, 1, 1, 1, 3, 3, 6, 5, 5, 4, 5, 4, 0, 2, 4, 3, 4, 3, 6, 5, 1, 3, 4, 4,
1502  1, 1, 1, 1, 1, 2, 3, 4, 5, 2, 0, 4, 8, 6, 4, 4, 4, 3, 3, 3, 3, 3, 6, 2, 2, 1,
1503  1, 1, 3, 6, 1, 1, 1, 0, 1, 2, 3, 0, 1, 3, 1, 1, 4, 5, 5, 4, 1, 1, 3, 4, 1, 1,
1504  1, 2, 3, 4, 1, 1, 3, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 3, 1, 1, 1,
1505  3, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1506  2, 3, 1, 1, 1, 1, 1, 1, 1, 1, 3, 3, 1, 1, 1, 1, 1, 4, 1, 4, 6, 1, 4, 6, 1, 1,
1507  1, 1, 1, 2, 1, 1, 1, 4, 1, 4, 1, 1, 3, 4, 1, 1, 1, 1, 4, 6, 4, 6, 1, 1, 1};
1508 
1509 static const short yydefact[] = {
1510  0, 0, 17, 0, 0, 0, 87, 0, 0, 0, 0, 3, 5, 6, 7, 8, 9,
1511  10, 4, 80, 81, 82, 84, 83, 68, 103, 106, 0, 0, 16, 0, 0, 21, 21,
1512  0, 88, 89, 189, 217, 218, 0, 0, 0, 1, 0, 0, 98, 0, 0, 15, 94,
1513  0, 0, 0, 66, 269, 202, 203, 206, 0, 0, 0, 110, 0, 273, 275, 0, 0,
1514  0, 276, 291, 0, 281, 208, 0, 207, 0, 0, 284, 0, 301, 0, 303, 0, 212,
1515  278, 300, 302, 286, 274, 292, 294, 285, 288, 197, 0, 215, 0, 190, 127, 128, 129,
1516  130, 131, 132, 133, 134, 186, 187, 188, 135, 194, 109, 181, 183, 196, 182, 0, 296,
1517  297, 0, 107, 2, 0, 0, 104, 0, 101, 25, 25, 0, 0, 31, 32, 15, 0,
1518  0, 0, 85, 95, 20, 22, 65, 0, 0, 0, 0, 125, 0, 179, 182, 180, 215,
1519  0, 166, 0, 0, 0, 0, 0, 289, 0, 161, 0, 0, 0, 0, 0, 0, 0,
1520  0, 0, 135, 213, 216, 0, 0, 94, 191, 0, 0, 0, 0, 156, 157, 0, 0,
1521  0, 0, 0, 0, 0, 0, 0, 0, 189, 0, 0, 209, 0, 308, 309, 94, 90,
1522  0, 269, 74, 69, 70, 74, 105, 96, 97, 0, 102, 26, 0, 0, 0, 0, 0,
1523  0, 35, 0, 0, 0, 0, 116, 0, 61, 0, 0, 0, 0, 0, 270, 271, 0,
1524  0, 0, 0, 0, 0, 0, 0, 272, 0, 0, 0, 0, 0, 0, 0, 0, 204,
1525  0, 0, 0, 126, 184, 0, 210, 111, 112, 114, 117, 123, 124, 192, 0, 0, 0,
1526  0, 173, 174, 175, 176, 177, 0, 144, 0, 149, 144, 159, 158, 160, 0, 0, 137,
1527  136, 195, 0, 147, 0, 298, 0, 0, 93, 0, 75, 76, 77, 0, 77, 99, 0,
1528  27, 0, 29, 34, 0, 23, 0, 33, 0, 14, 0, 0, 67, 0, 198, 0, 0,
1529  201, 211, 0, 165, 0, 167, 0, 170, 277, 205, 0, 282, 162, 0, 306, 0, 171,
1530  0, 0, 279, 293, 295, 214, 0, 310, 115, 0, 121, 0, 144, 0, 148, 144, 0,
1531  0, 143, 0, 152, 141, 154, 155, 146, 172, 299, 91, 92, 0, 72, 71, 73, 100,
1532  0, 30, 290, 287, 44, 0, 13, 0, 0, 0, 0, 0, 0, 0, 0, 36, 38,
1533  39, 62, 0, 200, 199, 163, 0, 0, 0, 0, 0, 0, 0, 113, 0, 0, 108,
1534  0, 142, 0, 140, 139, 145, 0, 151, 78, 79, 28, 0, 0, 0, 0, 0, 40,
1535  44, 24, 0, 0, 0, 0, 0, 0, 0, 0, 64, 86, 164, 185, 283, 307, 0,
1536  169, 178, 280, 118, 119, 122, 138, 150, 153, 42, 45, 0, 49, 50, 48, 52, 41,
1537  64, 0, 0, 0, 0, 0, 0, 37, 0, 18, 0, 0, 0, 0, 46, 0, 0,
1538  19, 60, 0, 0, 0, 0, 54, 0, 168, 120, 0, 47, 51, 0, 0, 55, 58,
1539  0, 0, 11, 43, 53, 0, 0, 0, 63, 56, 0, 12, 0, 0, 0, 0, 57,
1540  59, 0, 0};
1541 
1542 static const short yydefgoto[] = {
1543  9, 10, 494, 222, 136, 30, 11, 52, 12, 13, 14, 217, 305, 15, 16,
1544  132, 133, 17, 388, 389, 390, 424, 425, 391, 228, 468, 18, 144, 46, 207,
1545  208, 301, 370, 19, 20, 21, 37, 202, 203, 22, 138, 127, 214, 23, 24,
1546  25, 26, 97, 177, 262, 263, 139, 350, 445, 407, 98, 99, 100, 101, 102,
1547  358, 103, 104, 359, 105, 194, 287, 106, 162, 154, 242, 107, 108, 109, 110,
1548  111, 112, 113, 114, 115, 174, 175, 264, 116, 246, 117, 118, 119, 307, 348};
1549 
1550 static const short yypact[] = {
1551  301, -92, 30, 52, -37, 32, 11, 202, 43, 59,
1552  -95, -32768, -32768, -32768, -32768, -32768, -32768, -32768, -32768, -32768,
1553  -32768, -32768, -32768, -32768, 115, -32768, -32768, 202, 121, -32768,
1554  34, 202, 119, 119, 202, -32768, -32768, 518, -32768, -32768,
1555  85, -88, 135, -32768, 213, 23, 215, 82, 219, 251,
1556  169, 283, 202, 202, 198, 87, -32768, -32768, -32768, 748,
1557  942, 942, -32768, 194, -32768, -32768, 223, 203, 214, 227,
1558  -32768, 237, 247, 2, 249, -1, 250, 254, -32768, 258,
1559  -32768, 262, -32768, 265, -32768, 267, -32768, -32768, -32768, -32768,
1560  268, 270, -32768, -32768, -32768, 748, 1351, 286, 73, -32768,
1561  -32768, -32768, -32768, -32768, -32768, -32768, -32768, -32768, -32768, -32768,
1562  1437, -32768, 208, -32768, -32768, -32768, -67, 25, -32768, -32768,
1563  269, -32768, -32768, 289, 43, -32768, 199, 275, -28, 340,
1564  -32, 390, 244, -32768, 251, 386, 202, 748, -32768, -32768,
1565  -32768, -32768, -32768, 269, 278, 403, 231, -32768, 942, -32768,
1566  271, -32768, 1351, 748, -12, 748, 942, 420, 748, 420,
1567  -32768, 295, -32768, 197, 748, 942, 942, 273, 420, 420,
1568  420, 28, 212, -32768, 276, 280, 202, 169, -32768, 748,
1569  748, 441, 206, -32768, -32768, 942, 942, 942, 942, 942,
1570  942, 1195, 287, 1195, 633, 748, -8, 942, -32768, 0,
1571  -32768, -32768, 137, -32768, 432, 282, 60, 290, -32768, 60,
1572  -32768, -32768, -32768, 442, -32768, -32768, 269, 269, 269, 269,
1573  202, 436, -32768, 389, 202, 387, 293, 333, 75, -32768,
1574  299, 296, 748, 748, 38, -32768, -32768, 174, 300, 6,
1575  748, 748, 394, 58, 240, -32768, 305, 40, 143, 306,
1576  151, 20, 245, 264, -32768, 159, 307, 308, -32768, -32768,
1577  1351, -32768, 303, -32768, 469, 393, 461, -32768, -32768, 942,
1578  1195, 315, 1195, 281, 281, -32768, -32768, -32768, 297, 474,
1579  1117, -32768, 474, -32768, -32768, -32768, 845, 1039, -32768, 323,
1580  -32768, 380, -32768, 122, -32768, 316, 269, -32768, 748, -32768,
1581  -32768, 381, 289, 381, 479, 172, -32768, 1312, -32768, -32768,
1582  358, -32768, 1351, -32768, 325, -32768, 238, 269, -32768, 1195,
1583  -32768, 44, 48, -32768, -32768, 748, 333, 86, -32768, 1312,
1584  -32768, -32768, -32768, 420, -32768, -32768, 477, -32768, 748, -32768,
1585  942, 420, -32768, -32768, -32768, -32768, 202, -32768, -32768, 448,
1586  407, 310, 474, 1117, -32768, 474, 942, 1195, -32768, 196,
1587  -32768, -32768, -32768, 323, -32768, -32768, -32768, -32768, 333, 4,
1588  -32768, -32768, -32768, -32768, 269, -32768, 379, -32768, 14, 269,
1589  -32768, 238, 332, 492, 493, 500, 443, 344, 201, -32768,
1590  -32768, -32768, -32768, 207, -32768, -32768, 333, 748, 90, 345,
1591  346, 36, 256, 347, -32768, 748, 748, -32768, 942, -32768,
1592  211, -32768, 323, -32768, 1195, -32768, -32768, -32768, -32768, 503,
1593  412, 350, 1273, 202, -32768, 511, -32768, 220, 748, 354,
1594  355, 356, 357, 269, 238, 368, -32768, 333, -32768, -32768,
1595  -32768, 748, -32768, -32768, -32768, 362, 333, 333, 323, -32768,
1596  -32768, 369, -54, 748, -32768, -32768, -32768, 370, -32768, 368,
1597  50, 269, 269, 269, 269, 225, -32768, 373, -32768, 54,
1598  748, 528, 536, -32768, 56, 269, -32768, -32768, 229, 232,
1599  378, 382, -32768, 390, -32768, 333, 383, -32768, -32768, 384,
1600  410, -32768, -32768, 411, 239, -32768, -32768, -32768, 202, 202,
1601  390, -32768, 388, 398, -32768, 269, 269, 243, 392, -32768,
1602  -32768, 543, -32768};
1603 
1604 static const short yypgoto[] = {
1605  -32768, 541, -32768, -264, 417, -32768, -32768, 527, -32768, -32768,
1606  -32768, 433, -32768, -32768, -32768, -32768, 338, -32768, 182, 131,
1607  -214, 141, -32768, -32768, -218, 108, -32768, -32768, -32768, -32768,
1608  274, 360, 272, -32768, -32768, -32768, -32768, -32768, 277, -32768,
1609  -94, -32768, -32768, -32768, 562, -23, -154, -32768, -32768, -32768,
1610  233, -32768, -32768, -32768, -32768, -58, -32768, -32768, -32768, -32768,
1611  -202, -32768, -32768, -237, -32768, -32768, -32768, -32768, -156, -32768,
1612  -32768, -32768, -32768, -32768, -18, 385, -32768, -168, -32768, -87,
1613  -32768, 425, -7, -31, -155, -193, 415, -32768, -109, -32768};
1614 
1615 #define YYLAST 1529
1616 
1617 static const short yytable[] = {
1618  40, 147, 306, 308, 248, -287, 291, 249, -290, 173, 245, 204, 219, 255, 256, 257,
1619  215, 419, 179, 180, 47, 196, 125, 279, 50, 282, 27, 54, 420, 150, 150, 198,
1620  179, 180, 229, 35, 281, 171, 288, 45, 179, 180, 149, 151, 295, 141, 142, 124,
1621  179, 180, 179, 180, 179, 180, 240, 421, 179, 180, 472, 511, 179, 180, 179, 180,
1622  43, 173, 179, 180, 179, 180, 179, 180, 422, 36, 121, 416, 178, 172, 28, 227,
1623  361, 32, 393, 265, 1, 179, 180, 234, 329, 473, 292, 299, 209, 220, 417, 239,
1624  197, 243, 179, 180, 247, 210, 352, 181, 355, 128, 251, 2, 297, 309, 310, 33,
1625  360, 160, 378, 354, 410, 150, 3, 34, 300, 266, 267, 4, 48, 150, 249, 325,
1626  31, 226, 237, 362, 249, 216, 150, 150, 398, 241, 244, 185, 186, 187, 188, 189,
1627  5, 423, 129, 252, 253, 29, 409, 360, 49, 411, 150, 150, 150, 150, 150, 150,
1628  418, 6, -287, 150, 294, -290, 150, 273, 274, 275, 276, 277, 278, 345, 321, 322,
1629  289, 199, 399, 293, 338, 6, 326, 327, 8, 360, 403, 204, 199, 413, 258, 185,
1630  186, 187, 188, 189, 441, 6, 442, 249, 323, 51, 332, 7, 8, 38, 394, 397,
1631  392, 211, 395, 39, 477, 311, 130, 465, 484, 314, 488, 495, 8, 131, 44, 212,
1632  120, 380, 182, 183, 184, 185, 186, 187, 188, 189, 235, 317, 504, 318, 150, 269,
1633  368, 200, 45, 478, 479, 190, 450, 201, 145, 123, 236, 351, 438, 199, 146, 150,
1634  150, 185, 186, 187, 188, 189, 185, 186, 187, 188, 189, 396, 237, 363, 426, 209,
1635  200, 185, 186, 187, 188, 189, 201, 382, 401, 185, 186, 187, 188, 189, 365, 507,
1636  137, 270, 271, 80, 205, 82, 122, 191, 192, 296, 272, 206, 187, 188, 189, 333,
1637  193, 334, 86, 87, 126, 150, 356, 336, 383, 337, 185, 186, 187, 188, 189, 341,
1638  137, 342, 402, 408, 229, 150, 1, 185, 186, 187, 188, 189, 374, 135, 375, 456,
1639  259, 134, 412, 437, 185, 186, 187, 188, 189, 179, 180, 446, 447, 2, 384, 140,
1640  229, 229, 480, 481, 414, 152, 415, 143, 3, 434, 176, 435, 155, 4, 489, 414,
1641  195, 436, 460, 414, 153, 449, 259, 156, 213, 150, 385, 386, 434, 387, 459, 469,
1642  215, 317, 5, 482, 157, 317, 448, 490, 317, 221, 491, 474, 229, 508, 158, 500,
1643  225, 501, 330, 317, 223, 509, 55, 339, 159, 56, 161, 163, 485, 57, 58, 164,
1644  457, 59, 443, 165, 60, 61, 231, 166, 340, 230, 167, 232, 168, 169, 245, 170,
1645  63, 6, 197, 254, 260, 64, 65, 6, 66, 67, 68, 69, 268, 7, 261, 298,
1646  280, 146, 302, 312, 304, 129, 316, 315, 70, 71, 320, 72, 319, 328, 8, 346,
1647  324, 233, 73, 331, 335, 343, 344, 74, 347, 349, 180, 75, 353, 357, 364, 369,
1648  366, 76, 373, 379, 405, 77, 381, 400, 406, 78, 160, 502, 503, 428, 79, 429,
1649  430, 80, 81, 82, 83, 84, 85, 431, 432, 433, 451, 439, 440, 444, 452, 453,
1650  86, 87, 419, 461, 462, 463, 464, 88, 467, 55, 470, 89, 56, 90, 91, 92,
1651  57, 58, 471, 475, 59, 93, 483, 60, 61, 62, 486, 487, 492, 498, 499, 512,
1652  493, 496, 497, 63, 94, 505, 42, 224, 64, 65, 510, 66, 67, 68, 69, 506,
1653  53, 313, 218, 427, 95, 466, 458, 476, 96, 303, 41, 70, 71, 367, 72, 372,
1654  371, 238, 250, 404, 290, 73, 0, 0, 0, 0, 74, 0, 0, 0, 75, 0,
1655  0, 0, 0, 0, 76, 0, 0, 0, 77, 0, 0, 0, 78, 0, 0, 0,
1656  0, 79, 0, 0, 80, 81, 82, 83, 84, 85, 0, 0, 0, 0, 0, 0,
1657  0, 0, 0, 86, 87, 0, 0, 0, 0, 0, 88, 0, 55, 0, 89, 56,
1658  90, 91, 92, 57, 58, 0, 0, 0, 93, 0, 60, 61, 0, 0, 0, 0,
1659  0, 283, 0, 0, 284, 0, 63, 94, 0, 0, 0, 64, 65, 0, 66, 67,
1660  68, 69, 0, 0, 0, 0, 0, 95, 0, 0, 0, 96, 0, 0, 70, 71,
1661  0, 72, 0, 0, 0, 0, 0, 0, 73, 0, 0, 0, 0, 0, 0, 0,
1662  0, 75, 0, 0, 0, 0, 0, 76, 0, 0, 0, 77, 0, 0, 0, 78,
1663  0, 0, 0, 0, 79, 0, 0, 80, 81, 82, 83, 84, 85, 0, 0, 0,
1664  0, 0, 0, 0, 0, 0, 86, 87, 0, 0, 0, 0, 0, 88, 285, 55,
1665  0, 89, 56, 90, 91, 92, 57, 58, 0, 0, 59, 93, 0, 60, 61, 0,
1666  0, 0, 0, 0, 0, 0, 0, 0, 0, 63, 94, 0, 0, 0, 64, 65,
1667  0, 66, 67, 68, 69, 0, 0, 0, 0, 0, 286, 0, 0, 0, 96, 0,
1668  0, 70, 71, 0, 72, 0, 0, 0, 0, 0, 0, 73, 0, 0, 0, 0,
1669  74, 0, 0, 0, 75, 0, 0, 0, 0, 0, 76, 0, 0, 0, 77, 0,
1670  0, 0, 78, 0, 0, 0, 0, 79, 0, 0, 80, 81, 82, 83, 84, 85,
1671  55, 0, 0, 56, 0, 0, 0, 57, 58, 86, 87, 0, 0, 0, 60, 61,
1672  88, 0, 0, 0, 89, 0, 90, 91, 92, 0, 63, 0, 0, 0, 93, 64,
1673  65, 0, 66, 67, 68, 69, 0, 0, 0, 0, 0, 0, 0, 94, 0, 0,
1674  0, 0, 70, 71, 0, 72, 0, 0, 0, 0, 0, 0, 73, 95, 0, 0,
1675  0, 96, 0, 0, 0, 75, 0, 0, 0, 0, 0, 76, 0, 0, 0, 77,
1676  0, 0, 0, 78, 0, 0, 0, 0, 79, 0, 0, 80, 81, 82, 83, 84,
1677  85, 55, 0, 0, 56, 0, 0, 0, 57, 58, 86, 87, 0, 0, 0, 60,
1678  61, 88, 0, 0, 0, 89, 0, 90, 91, 92, 0, 63, 0, 0, 0, 93,
1679  64, 65, 0, 66, 67, 68, 69, 6, 0, 0, 0, 0, 0, 0, 94, 0,
1680  0, 0, 0, 70, 71, 0, 72, 0, 0, 0, 0, 0, 0, 73, 148, 0,
1681  0, 0, 96, 0, 0, 0, 75, 0, 0, 0, 0, 0, 76, 0, 0, 0,
1682  77, 0, 0, 0, 78, 0, 0, 0, 0, 79, 0, 0, 80, 81, 82, 83,
1683  84, 85, 55, 0, 0, 56, 0, 0, 0, 57, 58, 86, 87, 0, 0, 0,
1684  60, 61, 88, 0, 0, 0, 89, 0, 90, 91, 92, 0, 63, 0, 0, 0,
1685  93, 64, 65, 0, 66, 67, 68, 69, 0, 0, 0, 0, 0, 0, 0, 94,
1686  0, 0, 0, 0, 70, 71, 0, 72, 0, 0, 0, 0, 0, 0, 73, 148,
1687  0, 0, 0, 96, 0, 0, 0, 75, 0, 0, 0, 0, 0, 76, 0, 0,
1688  0, 77, 0, 56, 0, 78, 0, 57, 58, 0, 79, 0, 0, 80, 81, 82,
1689  83, 84, 85, 0, 0, 0, 0, 0, 0, 0, 63, 0, 86, 87, 0, 64,
1690  65, 0, 0, 88, 0, 69, 0, 89, 0, 90, 91, 92, 0, 0, 0, 0,
1691  0, 93, 70, 71, 0, 72, 0, 0, 0, 0, 0, 0, 73, 0, 0, 0,
1692  94, 0, 0, 0, 0, 75, 0, 0, 0, 0, 0, 76, 0, 0, 0, 0,
1693  286, 56, 0, 78, 96, 57, 58, 0, 0, 0, 0, 80, 0, 82, 83, 84,
1694  85, 0, 0, 0, 0, 0, 0, 0, 63, 0, 86, 87, 0, 64, 65, 0,
1695  0, 88, 0, 69, 0, 89, 0, 90, 91, 92, 0, 0, 0, 0, 0, 93,
1696  70, 71, 0, 72, 0, 0, 0, 6, 0, 0, 73, 0, 0, 0, 94, 0,
1697  0, 0, 0, 75, 0, 0, 0, 0, 0, 76, 0, 0, 0, 0, 0, 56,
1698  0, 78, 96, 57, 58, 0, 0, 0, 0, 80, 0, 82, 83, 84, 85, 0,
1699  0, 0, 0, 0, 0, 0, 63, 0, 86, 87, 0, 64, 65, 0, 0, 88,
1700  0, 69, 0, 89, 0, 90, 91, 92, 0, 0, 0, 0, 0, 93, 70, 71,
1701  0, 72, 0, 0, 0, 0, 0, 0, 73, 0, 0, 0, 94, 0, 0, 0,
1702  0, 75, 64, 65, 0, 0, 0, 76, 69, 0, 0, 0, 0, 56, 0, 78,
1703  96, 57, 58, 0, 0, 70, 0, 80, 72, 82, 83, 454, 85, 0, 0, 376,
1704  0, 0, 0, 0, 63, 0, 86, 87, 377, 64, 65, 0, 0, 88, 76, 69,
1705  0, 89, 0, 90, 91, 92, 78, 0, 0, 0, 0, 93, 70, 71, 80, 72,
1706  82, 0, 0, 85, 0, 0, 73, 0, 0, 0, 455, 0, 0, 86, 87, 75,
1707  0, 0, 0, 0, 88, 76, 0, 0, 89, 0, 90, 91, 92, 78, 96, 0,
1708  0, 0, 93, 0, 0, 80, 0, 82, 83, 84, 85, 182, 183, 184, 185, 186,
1709  187, 188, 189, 0, 86, 87, 0, 0, 0, 0, 0, 88, 0, 0, 190, 89,
1710  0, 90, 91, 92, 0, 0, 0, 0, 0, 93, 0, 0, 0, 0, 0, 0,
1711  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1712  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 96, 0, 0, 0,
1713  191, 192, 0, 0, 0, 0, 0, 0, 0, 193};
1714 
1715 static const short yycheck[] = {
1716  7, 59, 216, 217, 159, 6, 14, 161, 6, 96, 10, 120, 44, 168, 169, 170, 44,
1717  3, 12, 13, 27, 88, 45, 191, 31, 193, 118, 34, 14, 60, 61, 6, 12, 13,
1718  143, 24, 192, 95, 194, 127, 12, 13, 60, 61, 199, 52, 53, 24, 12, 13, 12,
1719  13, 12, 13, 66, 41, 12, 13, 112, 0, 12, 13, 12, 13, 159, 152, 12, 13,
1720  12, 13, 12, 13, 58, 62, 162, 71, 3, 95, 48, 137, 282, 118, 319, 177, 25,
1721  12, 13, 145, 30, 143, 98, 31, 123, 125, 90, 153, 163, 155, 12, 13, 158, 124,
1722  270, 30, 272, 23, 164, 48, 202, 218, 219, 148, 280, 111, 307, 271, 353, 148, 59,
1723  87, 60, 179, 180, 64, 3, 156, 280, 121, 76, 136, 148, 287, 286, 161, 165, 166,
1724  329, 149, 156, 17, 18, 19, 20, 21, 85, 131, 64, 165, 166, 119, 352, 319, 118,
1725  355, 185, 186, 187, 188, 189, 190, 374, 138, 163, 194, 164, 163, 197, 185, 186, 187,
1726  188, 189, 190, 260, 232, 233, 194, 163, 333, 197, 160, 138, 240, 241, 161, 353, 341,
1727  296, 163, 357, 162, 17, 18, 19, 20, 21, 160, 138, 162, 353, 162, 82, 162, 144,
1728  161, 3, 162, 121, 317, 10, 162, 9, 162, 220, 132, 433, 162, 224, 162, 483, 161,
1729  139, 107, 24, 139, 312, 14, 15, 16, 17, 18, 19, 20, 21, 3, 160, 500, 162,
1730  269, 33, 298, 3, 127, 461, 462, 33, 414, 9, 161, 36, 19, 269, 162, 163, 167,
1731  286, 287, 17, 18, 19, 20, 21, 17, 18, 19, 20, 21, 325, 286, 287, 379, 302,
1732  3, 17, 18, 19, 20, 21, 9, 41, 338, 17, 18, 19, 20, 21, 164, 505, 151,
1733  83, 84, 94, 3, 96, 159, 83, 84, 160, 92, 10, 19, 20, 21, 160, 92, 162,
1734  109, 110, 93, 340, 13, 160, 74, 162, 17, 18, 19, 20, 21, 160, 151, 162, 340,
1735  13, 433, 356, 25, 17, 18, 19, 20, 21, 160, 82, 162, 422, 162, 118, 356, 397,
1736  17, 18, 19, 20, 21, 12, 13, 405, 406, 48, 112, 68, 461, 462, 463, 464, 160,
1737  163, 162, 161, 59, 160, 76, 162, 161, 64, 475, 160, 160, 162, 428, 160, 149, 162,
1738  162, 161, 101, 408, 140, 141, 160, 143, 162, 441, 44, 160, 85, 162, 161, 160, 408,
1739  162, 160, 3, 162, 453, 505, 506, 161, 160, 14, 162, 162, 160, 160, 162, 3, 162,
1740  161, 6, 161, 161, 470, 10, 11, 161, 423, 14, 162, 161, 17, 18, 19, 161, 160,
1741  147, 161, 24, 161, 161, 10, 161, 29, 138, 163, 162, 160, 34, 35, 138, 37, 38,
1742  39, 40, 3, 144, 166, 15, 161, 167, 160, 15, 10, 64, 161, 68, 53, 54, 162,
1743  56, 161, 67, 161, 160, 164, 62, 63, 162, 162, 162, 162, 68, 3, 80, 13, 72,
1744  161, 3, 98, 98, 164, 78, 3, 125, 36, 82, 161, 10, 81, 86, 111, 498, 499,
1745  161, 91, 3, 3, 94, 95, 96, 97, 98, 99, 3, 61, 161, 3, 162, 162, 162,
1746  98, 161, 109, 110, 3, 161, 161, 161, 161, 116, 152, 3, 160, 120, 6, 122, 123,
1747  124, 10, 11, 161, 161, 14, 130, 161, 17, 18, 19, 10, 3, 162, 131, 131, 0,
1748  162, 162, 162, 29, 145, 161, 9, 134, 34, 35, 162, 37, 38, 39, 40, 161, 33,
1749  223, 129, 381, 161, 434, 425, 459, 165, 209, 8, 53, 54, 296, 56, 303, 302, 152,
1750  163, 346, 195, 63, -1, -1, -1, -1, 68, -1, -1, -1, 72, -1, -1, -1, -1,
1751  -1, 78, -1, -1, -1, 82, -1, -1, -1, 86, -1, -1, -1, -1, 91, -1, -1,
1752  94, 95, 96, 97, 98, 99, -1, -1, -1, -1, -1, -1, -1, -1, -1, 109, 110,
1753  -1, -1, -1, -1, -1, 116, -1, 3, -1, 120, 6, 122, 123, 124, 10, 11, -1,
1754  -1, -1, 130, -1, 17, 18, -1, -1, -1, -1, -1, 24, -1, -1, 27, -1, 29,
1755  145, -1, -1, -1, 34, 35, -1, 37, 38, 39, 40, -1, -1, -1, -1, -1, 161,
1756  -1, -1, -1, 165, -1, -1, 53, 54, -1, 56, -1, -1, -1, -1, -1, -1, 63,
1757  -1, -1, -1, -1, -1, -1, -1, -1, 72, -1, -1, -1, -1, -1, 78, -1, -1,
1758  -1, 82, -1, -1, -1, 86, -1, -1, -1, -1, 91, -1, -1, 94, 95, 96, 97,
1759  98, 99, -1, -1, -1, -1, -1, -1, -1, -1, -1, 109, 110, -1, -1, -1, -1,
1760  -1, 116, 117, 3, -1, 120, 6, 122, 123, 124, 10, 11, -1, -1, 14, 130, -1,
1761  17, 18, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 29, 145, -1, -1, -1,
1762  34, 35, -1, 37, 38, 39, 40, -1, -1, -1, -1, -1, 161, -1, -1, -1, 165,
1763  -1, -1, 53, 54, -1, 56, -1, -1, -1, -1, -1, -1, 63, -1, -1, -1, -1,
1764  68, -1, -1, -1, 72, -1, -1, -1, -1, -1, 78, -1, -1, -1, 82, -1, -1,
1765  -1, 86, -1, -1, -1, -1, 91, -1, -1, 94, 95, 96, 97, 98, 99, 3, -1,
1766  -1, 6, -1, -1, -1, 10, 11, 109, 110, -1, -1, -1, 17, 18, 116, -1, -1,
1767  -1, 120, -1, 122, 123, 124, -1, 29, -1, -1, -1, 130, 34, 35, -1, 37, 38,
1768  39, 40, -1, -1, -1, -1, -1, -1, -1, 145, -1, -1, -1, -1, 53, 54, -1,
1769  56, -1, -1, -1, -1, -1, -1, 63, 161, -1, -1, -1, 165, -1, -1, -1, 72,
1770  -1, -1, -1, -1, -1, 78, -1, -1, -1, 82, -1, -1, -1, 86, -1, -1, -1,
1771  -1, 91, -1, -1, 94, 95, 96, 97, 98, 99, 3, -1, -1, 6, -1, -1, -1,
1772  10, 11, 109, 110, -1, -1, -1, 17, 18, 116, -1, -1, -1, 120, -1, 122, 123,
1773  124, -1, 29, -1, -1, -1, 130, 34, 35, -1, 37, 38, 39, 40, 138, -1, -1,
1774  -1, -1, -1, -1, 145, -1, -1, -1, -1, 53, 54, -1, 56, -1, -1, -1, -1,
1775  -1, -1, 63, 161, -1, -1, -1, 165, -1, -1, -1, 72, -1, -1, -1, -1, -1,
1776  78, -1, -1, -1, 82, -1, -1, -1, 86, -1, -1, -1, -1, 91, -1, -1, 94,
1777  95, 96, 97, 98, 99, 3, -1, -1, 6, -1, -1, -1, 10, 11, 109, 110, -1,
1778  -1, -1, 17, 18, 116, -1, -1, -1, 120, -1, 122, 123, 124, -1, 29, -1, -1,
1779  -1, 130, 34, 35, -1, 37, 38, 39, 40, -1, -1, -1, -1, -1, -1, -1, 145,
1780  -1, -1, -1, -1, 53, 54, -1, 56, -1, -1, -1, -1, -1, -1, 63, 161, -1,
1781  -1, -1, 165, -1, -1, -1, 72, -1, -1, -1, -1, -1, 78, -1, -1, -1, 82,
1782  -1, 6, -1, 86, -1, 10, 11, -1, 91, -1, -1, 94, 95, 96, 97, 98, 99,
1783  -1, -1, -1, -1, -1, -1, -1, 29, -1, 109, 110, -1, 34, 35, -1, -1, 116,
1784  -1, 40, -1, 120, -1, 122, 123, 124, -1, -1, -1, -1, -1, 130, 53, 54, -1,
1785  56, -1, -1, -1, -1, -1, -1, 63, -1, -1, -1, 145, -1, -1, -1, -1, 72,
1786  -1, -1, -1, -1, -1, 78, -1, -1, -1, -1, 161, 6, -1, 86, 165, 10, 11,
1787  -1, -1, -1, -1, 94, -1, 96, 97, 98, 99, -1, -1, -1, -1, -1, -1, -1,
1788  29, -1, 109, 110, -1, 34, 35, -1, -1, 116, -1, 40, -1, 120, -1, 122, 123,
1789  124, -1, -1, -1, -1, -1, 130, 53, 54, -1, 56, -1, -1, -1, 138, -1, -1,
1790  63, -1, -1, -1, 145, -1, -1, -1, -1, 72, -1, -1, -1, -1, -1, 78, -1,
1791  -1, -1, -1, -1, 6, -1, 86, 165, 10, 11, -1, -1, -1, -1, 94, -1, 96,
1792  97, 98, 99, -1, -1, -1, -1, -1, -1, -1, 29, -1, 109, 110, -1, 34, 35,
1793  -1, -1, 116, -1, 40, -1, 120, -1, 122, 123, 124, -1, -1, -1, -1, -1, 130,
1794  53, 54, -1, 56, -1, -1, -1, -1, -1, -1, 63, -1, -1, -1, 145, -1, -1,
1795  -1, -1, 72, 34, 35, -1, -1, -1, 78, 40, -1, -1, -1, -1, 6, -1, 86,
1796  165, 10, 11, -1, -1, 53, -1, 94, 56, 96, 97, 98, 99, -1, -1, 63, -1,
1797  -1, -1, -1, 29, -1, 109, 110, 72, 34, 35, -1, -1, 116, 78, 40, -1, 120,
1798  -1, 122, 123, 124, 86, -1, -1, -1, -1, 130, 53, 54, 94, 56, 96, -1, -1,
1799  99, -1, -1, 63, -1, -1, -1, 145, -1, -1, 109, 110, 72, -1, -1, -1, -1,
1800  116, 78, -1, -1, 120, -1, 122, 123, 124, 86, 165, -1, -1, -1, 130, -1, -1,
1801  94, -1, 96, 97, 98, 99, 14, 15, 16, 17, 18, 19, 20, 21, -1, 109, 110,
1802  -1, -1, -1, -1, -1, 116, -1, -1, 33, 120, -1, 122, 123, 124, -1, -1, -1,
1803  -1, -1, 130, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1804  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1805  -1, -1, -1, 165, -1, -1, -1, 83, 84, -1, -1, -1, -1, -1, -1, -1, 92};
1806 
1807 #line 325 "/usr/local/mapd-deps/20210608/lib/bison.cc"
1808 /* fattrs + tables */
1809 
1810 /* parser code folow */
1811 
1812 /* This is the parser code that is written into each bison parser
1813  when the %semantic_parser declaration is not specified in the grammar.
1814  It was written by Richard Stallman by simplifying the hairy parser
1815  used when %semantic_parser is specified. */
1816 
1817 /* Note: dollar marks section change
1818  the next is replaced by the list of actions, each action
1819  as one case of the switch. */
1820 
1821 #if YY_Parser_USE_GOTO != 0
1822 /*
1823  SUPRESSION OF GOTO : on some C++ compiler (sun c++)
1824  the goto is strictly forbidden if any constructor/destructor
1825  is used in the whole function (very stupid isn't it ?)
1826  so goto are to be replaced with a 'while/switch/case construct'
1827  here are the macro to keep some apparent compatibility
1828 */
1829 #define YYGOTO(lb) \
1830  { \
1831  yy_gotostate = lb; \
1832  continue; \
1833  }
1834 #define YYBEGINGOTO \
1835  enum yy_labels yy_gotostate = yygotostart; \
1836  for (;;) \
1837  switch (yy_gotostate) { \
1838  case yygotostart: {
1839 #define YYLABEL(lb) \
1840  } \
1841  case lb: {
1842 #define YYENDGOTO \
1843  } \
1844  }
1845 #define YYBEGINDECLARELABEL enum yy_labels { yygotostart
1846 #define YYDECLARELABEL(lb) , lb
1847 #define YYENDDECLARELABEL \
1848  } \
1849  ;
1850 #else
1851 /* macro to keep goto */
1852 #define YYGOTO(lb) goto lb
1853 #define YYBEGINGOTO
1854 #define YYLABEL(lb) \
1855  lb:
1856 #define YYENDGOTO
1857 #define YYBEGINDECLARELABEL
1858 #define YYDECLARELABEL(lb)
1859 #define YYENDDECLARELABEL
1860 #endif
1861 /* LABEL DECLARATION */
1863 YYDECLARELABEL(yynewstate)
1864 YYDECLARELABEL(yybackup)
1865 /* YYDECLARELABEL(yyresume) */
1866 YYDECLARELABEL(yydefault)
1867 YYDECLARELABEL(yyreduce)
1868 YYDECLARELABEL(yyerrlab) /* here on detecting error */
1869 YYDECLARELABEL(yyerrlab1) /* here on error raised explicitly by an action */
1871  yyerrdefault) /* current state does not do anything special for the error token. */
1873  yyerrpop) /* pop the current state because it cannot handle the error token */
1874 YYDECLARELABEL(yyerrhandle)
1876 /* ALLOCA SIMULATION */
1877 /* __HAVE_NO_ALLOCA */
1878 #ifdef __HAVE_NO_ALLOCA
1879 int __alloca_free_ptr(char* ptr, char* ref) {
1880  if (ptr != ref)
1881  free(ptr);
1882  return 0;
1883 }
1884 
1885 #define __ALLOCA_alloca(size) malloc(size)
1886 #define __ALLOCA_free(ptr, ref) __alloca_free_ptr((char*)ptr, (char*)ref)
1887 
1888 #ifdef YY_Parser_LSP_NEEDED
1889 #define __ALLOCA_return(num) \
1890  return (__ALLOCA_free(yyss, yyssa) + __ALLOCA_free(yyvs, yyvsa) + \
1891  __ALLOCA_free(yyls, yylsa) + (num))
1892 #else
1893 #define __ALLOCA_return(num) \
1894  return (__ALLOCA_free(yyss, yyssa) + __ALLOCA_free(yyvs, yyvsa) + (num))
1895 #endif
1896 #else
1897 #define __ALLOCA_return(num) return (num)
1898 #define __ALLOCA_alloca(size) alloca(size)
1899 #define __ALLOCA_free(ptr, ref)
1900 #endif
1901 
1902 /* ENDALLOCA SIMULATION */
1903 
1904 #define yyerrok (yyerrstatus = 0)
1905 #define yyclearin (YY_Parser_CHAR = YYEMPTY)
1906 #define YYEMPTY -2
1907 #define YYEOF 0
1908 #define YYACCEPT __ALLOCA_return(0)
1909 #define YYABORT __ALLOCA_return(1)
1910 #define YYERROR YYGOTO(yyerrlab1)
1911 /* Like YYERROR except do call yyerror.
1912  This remains here temporarily to ease the
1913  transition to the new meaning of YYERROR, for GCC.
1914  Once GCC version 2 has supplanted version 1, this can go. */
1915 #define YYFAIL YYGOTO(yyerrlab)
1916 #define YYRECOVERING() (!!yyerrstatus)
1917 #define YYBACKUP(token, value) \
1918  do \
1919  if (YY_Parser_CHAR == YYEMPTY && yylen == 1) { \
1920  YY_Parser_CHAR = (token), YY_Parser_LVAL = (value); \
1921  yychar1 = YYTRANSLATE(YY_Parser_CHAR); \
1922  YYPOPSTACK; \
1923  YYGOTO(yybackup); \
1924  } else { \
1925  YY_Parser_ERROR("syntax error: cannot back up"); \
1926  YYERROR; \
1927  } \
1928  while (0)
1929 
1930 #define YYTERROR 1
1931 #define YYERRCODE 256
1932 
1933 #ifndef YY_Parser_PURE
1934 /* UNPURE */
1935 #define YYLEX YY_Parser_LEX()
1936 #ifndef YY_USE_CLASS
1937 /* If nonreentrant, and not class , generate the variables here */
1938 int YY_Parser_CHAR; /* the lookahead symbol */
1939 YY_Parser_STYPE YY_Parser_LVAL; /* the semantic value of the */
1940  /* lookahead symbol */
1941 int YY_Parser_NERRS; /* number of parse errors so far */
1942 #ifdef YY_Parser_LSP_NEEDED
1943 YY_Parser_LTYPE YY_Parser_LLOC; /* location data for the lookahead */
1944  /* symbol */
1945 #endif
1946 #endif
1947 
1948 #else
1949 /* PURE */
1950 #ifdef YY_Parser_LSP_NEEDED
1951 #define YYLEX YY_Parser_LEX(&YY_Parser_LVAL, &YY_Parser_LLOC)
1952 #else
1953 #define YYLEX YY_Parser_LEX(&YY_Parser_LVAL)
1954 #endif
1955 #endif
1956 #ifndef YY_USE_CLASS
1957 #if YY_Parser_DEBUG != 0
1958 int YY_Parser_DEBUG_FLAG; /* nonzero means print parse trace */
1959 /* Since this is uninitialized, it does not stop multiple parsers
1960  from coexisting. */
1961 #endif
1962 #endif
1963 
1964 /* YYINITDEPTH indicates the initial size of the parser's stacks */
1965 
1966 #ifndef YYINITDEPTH
1967 #define YYINITDEPTH 200
1968 #endif
1969 
1970 /* YYMAXDEPTH is the maximum size the stacks can grow to
1971  (effective only if the built-in stack extension method is used). */
1972 
1973 #if YYMAXDEPTH == 0
1974 #undef YYMAXDEPTH
1975 #endif
1976 
1977 #ifndef YYMAXDEPTH
1978 #define YYMAXDEPTH 10000
1979 #endif
1980 
1981 #if __GNUC__ > 1 /* GNU C and GNU C++ define this. */
1982 #define __yy_bcopy(FROM, TO, COUNT) __builtin_memcpy(TO, FROM, COUNT)
1983 #else /* not GNU C or C++ */
1984 
1985 /* This is the most reliable way to avoid incompatibilities
1986  in available built-in functions on various systems. */
1987 
1988 #ifdef __cplusplus
1989 static void __yy_bcopy(char* from, char* to, int count)
1990 #else
1991 #ifdef __STDC__
1992 static void __yy_bcopy(char* from, char* to, int count)
1993 #else
1994 static void __yy_bcopy(from, to, count) char* from;
1995 char* to;
1996 int count;
1997 #endif
1998 #endif
1999 {
2000  char* f = from;
2001  char* t = to;
2002  int i = count;
2003 
2004  while (i-- > 0)
2005  *t++ = *f++;
2006 }
2007 #endif
2008 
2009 int
2010 #ifdef YY_USE_CLASS
2011  YY_Parser_CLASS::
2012 #endif
2014 #ifndef __STDC__
2015 #ifndef __cplusplus
2016 #ifndef YY_USE_CLASS
2017 /* parameter definition without protypes */
2019 #endif
2020 #endif
2021 #endif
2023  int yystate;
2024  int yyn;
2025  short* yyssp;
2027  int yyerrstatus; /* number of tokens to shift before error messages enabled */
2028  int yychar1 = 0; /* lookahead token as an internal (translated) token number */
2029 
2030  short yyssa[YYINITDEPTH]; /* the state stack */
2031  YY_Parser_STYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */
2032 
2033  short* yyss = yyssa; /* refer to the stacks thru separate pointers */
2034  YY_Parser_STYPE* yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */
2035 
2036 #ifdef YY_Parser_LSP_NEEDED
2037  YY_Parser_LTYPE yylsa[YYINITDEPTH]; /* the location stack */
2038  YY_Parser_LTYPE* yyls = yylsa;
2039  YY_Parser_LTYPE* yylsp;
2040 
2041 #define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)
2042 #else
2043 #define YYPOPSTACK (yyvsp--, yyssp--)
2044 #endif
2045 
2047 
2048 #ifdef YY_Parser_PURE
2049  int YY_Parser_CHAR;
2051  int YY_Parser_NERRS;
2052 #ifdef YY_Parser_LSP_NEEDED
2053  YY_Parser_LTYPE YY_Parser_LLOC;
2054 #endif
2055 #endif
2056 
2057  YY_Parser_STYPE yyval; /* the variable used to return */
2058  /* semantic values from the action */
2059  /* routines */
2060 
2061  int yylen;
2062  /* start loop, in which YYGOTO may be used. */
2063  YYBEGINGOTO
2064 
2065 #if YY_Parser_DEBUG != 0
2067  fprintf(stderr, "Starting parse\n");
2068 #endif
2069  yystate = 0;
2070  yyerrstatus = 0;
2071  YY_Parser_NERRS = 0;
2072  YY_Parser_CHAR = YYEMPTY; /* Cause a token to be read. */
2073 
2074  /* Initialize stack pointers.
2075  Waste one element of value and location stack
2076  so that they stay on the same level as the state stack.
2077  The wasted elements are never initialized. */
2078 
2079  yyssp = yyss - 1;
2080  yyvsp = yyvs;
2081 #ifdef YY_Parser_LSP_NEEDED
2082  yylsp = yyls;
2083 #endif
2084 
2085  /* Push a new state, which is found in yystate . */
2086  /* In all cases, when you get here, the value and location stacks
2087  have just been pushed. so pushing a state here evens the stacks. */
2088  YYLABEL(yynewstate)
2089 
2090  *++yyssp = yystate;
2091 
2092  if (yyssp >= yyss + yystacksize - 1) {
2093  /* Give user a chance to reallocate the stack */
2094  /* Use copies of these so that the &'s don't force the real ones into memory. */
2095  YY_Parser_STYPE* yyvs1 = yyvs;
2096  short* yyss1 = yyss;
2097 #ifdef YY_Parser_LSP_NEEDED
2098  YY_Parser_LTYPE* yyls1 = yyls;
2099 #endif
2100 
2101  /* Get the current used size of the three stacks, in elements. */
2102  int size = yyssp - yyss + 1;
2103 
2104 #ifdef yyoverflow
2105  /* Each stack pointer address is followed by the size of
2106  the data in use in that stack, in bytes. */
2107 #ifdef YY_Parser_LSP_NEEDED
2108  /* This used to be a conditional around just the two extra args,
2109  but that might be undefined if yyoverflow is a macro. */
2110  yyoverflow("parser stack overflow",
2111  &yyss1,
2112  size * sizeof(*yyssp),
2113  &yyvs1,
2114  size * sizeof(*yyvsp),
2115  &yyls1,
2116  size * sizeof(*yylsp),
2117  &yystacksize);
2118 #else
2119  yyoverflow("parser stack overflow",
2120  &yyss1,
2121  size * sizeof(*yyssp),
2122  &yyvs1,
2123  size * sizeof(*yyvsp),
2124  &yystacksize);
2125 #endif
2126 
2127  yyss = yyss1;
2128  yyvs = yyvs1;
2129 #ifdef YY_Parser_LSP_NEEDED
2130  yyls = yyls1;
2131 #endif
2132 #else /* no yyoverflow */
2133  /* Extend the stack our own way. */
2134  if (yystacksize >= YYMAXDEPTH) {
2135  YY_Parser_ERROR("parser stack overflow");
2136  __ALLOCA_return(2);
2137  }
2138  yystacksize *= 2;
2139  if (yystacksize > YYMAXDEPTH)
2140  yystacksize = YYMAXDEPTH;
2141  yyss = (short*)__ALLOCA_alloca(yystacksize * sizeof(*yyssp));
2142  __yy_bcopy((char*)yyss1, (char*)yyss, size * sizeof(*yyssp));
2143  __ALLOCA_free(yyss1, yyssa);
2144  yyvs = (YY_Parser_STYPE*)__ALLOCA_alloca(yystacksize * sizeof(*yyvsp));
2145  __yy_bcopy((char*)yyvs1, (char*)yyvs, size * sizeof(*yyvsp));
2146  __ALLOCA_free(yyvs1, yyvsa);
2147 #ifdef YY_Parser_LSP_NEEDED
2148  yyls = (YY_Parser_LTYPE*)__ALLOCA_alloca(yystacksize * sizeof(*yylsp));
2149  __yy_bcopy((char*)yyls1, (char*)yyls, size * sizeof(*yylsp));
2150  __ALLOCA_free(yyls1, yylsa);
2151 #endif
2152 #endif /* no yyoverflow */
2153 
2154  yyssp = yyss + size - 1;
2155  yyvsp = yyvs + size - 1;
2156 #ifdef YY_Parser_LSP_NEEDED
2157  yylsp = yyls + size - 1;
2158 #endif
2159 
2160 #if YY_Parser_DEBUG != 0
2162  fprintf(stderr, "Stack size increased to %d\n", yystacksize);
2163 #endif
2164 
2165  if (yyssp >= yyss + yystacksize - 1)
2166  YYABORT;
2167  }
2168 
2169 #if YY_Parser_DEBUG != 0
2171  fprintf(stderr, "Entering state %d\n", yystate);
2172 #endif
2173 
2174  YYGOTO(yybackup);
2175  YYLABEL(yybackup)
2176 
2177  /* Do appropriate processing given the current state. */
2178  /* Read a lookahead token if we need one and don't already have one. */
2179  /* YYLABEL(yyresume) */
2180 
2181  /* First try to decide what to do without reference to lookahead token. */
2182 
2183  yyn = yypact[yystate];
2184  if (yyn == YYFLAG)
2185  YYGOTO(yydefault);
2186 
2187  /* Not known => get a lookahead token if don't already have one. */
2188 
2189  /* yychar is either YYEMPTY or YYEOF
2190  or a valid token in external form. */
2191 
2192  if (YY_Parser_CHAR == YYEMPTY) {
2193 #if YY_Parser_DEBUG != 0
2195  fprintf(stderr, "Reading a token: ");
2196 #endif
2197  YY_Parser_CHAR = YYLEX;
2198  }
2199 
2200  /* Convert token to internal form (in yychar1) for indexing tables with */
2201 
2202  if (YY_Parser_CHAR <= 0) /* This means end of input. */
2203  {
2204  yychar1 = 0;
2205  YY_Parser_CHAR = YYEOF; /* Don't call YYLEX any more */
2206 
2207 #if YY_Parser_DEBUG != 0
2209  fprintf(stderr, "Now at end of input.\n");
2210 #endif
2211  } else {
2212  yychar1 = YYTRANSLATE(YY_Parser_CHAR);
2213 
2214 #if YY_Parser_DEBUG != 0
2215  if (YY_Parser_DEBUG_FLAG) {
2216  fprintf(stderr, "Next token is %d (%s", YY_Parser_CHAR, yytname[yychar1]);
2217  /* Give the individual parser a way to print the precise meaning
2218  of a token, for further debugging info. */
2219 #ifdef YYPRINT
2220  YYPRINT(stderr, YY_Parser_CHAR, YY_Parser_LVAL);
2221 #endif
2222  fprintf(stderr, ")\n");
2223  }
2224 #endif
2225  }
2226 
2227  yyn += yychar1;
2228  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
2229  YYGOTO(yydefault);
2230 
2231  yyn = yytable[yyn];
2232 
2233  /* yyn is what to do for this token type in this state.
2234  Negative => reduce, -yyn is rule number.
2235  Positive => shift, yyn is new state.
2236  New state is final state => don't bother to shift,
2237  just return success.
2238  0, or most negative number => error. */
2239 
2240  if (yyn < 0) {
2241  if (yyn == YYFLAG)
2242  YYGOTO(yyerrlab);
2243  yyn = -yyn;
2244  YYGOTO(yyreduce);
2245  } else if (yyn == 0)
2246  YYGOTO(yyerrlab);
2247 
2248  if (yyn == YYFINAL)
2250 
2251  /* Shift the lookahead token. */
2252 
2253 #if YY_Parser_DEBUG != 0
2255  fprintf(stderr, "Shifting token %d (%s), ", YY_Parser_CHAR, yytname[yychar1]);
2256 #endif
2257 
2258  /* Discard the token being shifted unless it is eof. */
2259  if (YY_Parser_CHAR != YYEOF)
2260  YY_Parser_CHAR = YYEMPTY;
2261 
2262  *++yyvsp = YY_Parser_LVAL;
2263 #ifdef YY_Parser_LSP_NEEDED
2264  *++yylsp = YY_Parser_LLOC;
2265 #endif
2266 
2267  /* count tokens shifted since error; after three, turn off error status. */
2268  if (yyerrstatus)
2269  yyerrstatus--;
2270 
2271  yystate = yyn;
2272  YYGOTO(yynewstate);
2273 
2274  /* Do the default action for the current state. */
2275  YYLABEL(yydefault)
2276 
2277  yyn = yydefact[yystate];
2278  if (yyn == 0)
2279  YYGOTO(yyerrlab);
2280 
2281  /* Do a reduction. yyn is the number of a rule to reduce with. */
2282  YYLABEL(yyreduce)
2283  yylen = yyr2[yyn];
2284  if (yylen > 0)
2285  yyval = yyvsp[1 - yylen]; /* implement default value of the action */
2286 
2287 #if YY_Parser_DEBUG != 0
2288  if (YY_Parser_DEBUG_FLAG) {
2289  int i;
2290 
2291  fprintf(stderr, "Reducing via rule %d (line %d), ", yyn, yyrline[yyn]);
2292 
2293  /* Print the symbols being reduced, and their result. */
2294  for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
2295  fprintf(stderr, "%s ", yytname[yyrhs[i]]);
2296  fprintf(stderr, " -> %s\n", yytname[yyr1[yyn]]);
2297  }
2298 #endif
2299 
2300  /* #line 811 "/usr/local/mapd-deps/20210608/lib/bison.cc" */
2301 
2302  switch (yyn) {
2303  case 1: {
2304  parseTrees.emplace_front(dynamic_cast<Stmt*>((yyvsp[-1].nodeval)->release()));
2305  ;
2306  break;
2307  }
2308  case 2: {
2309  parseTrees.emplace_front(dynamic_cast<Stmt*>((yyvsp[-1].nodeval)->release()));
2310  ;
2311  break;
2312  }
2313  case 3: {
2314  yyval.nodeval = yyvsp[0].nodeval;
2315  ;
2316  break;
2317  }
2318  case 4: {
2319  yyval.nodeval = yyvsp[0].nodeval;
2320  ;
2321  break;
2322  }
2323  case 5: {
2324  yyval.nodeval = yyvsp[0].nodeval;
2325  ;
2326  break;
2327  }
2328  case 6: {
2329  yyval.nodeval = yyvsp[0].nodeval;
2330  ;
2331  break;
2332  }
2333  case 7: {
2334  yyval.nodeval = yyvsp[0].nodeval;
2335  ;
2336  break;
2337  }
2338  case 8: {
2339  yyval.nodeval = yyvsp[0].nodeval;
2340  ;
2341  break;
2342  }
2343  case 9: {
2344  yyval.nodeval = yyvsp[0].nodeval;
2345  ;
2346  break;
2347  }
2348  case 10: {
2349  yyval.nodeval = yyvsp[0].nodeval;
2350  ;
2351  break;
2352  }
2353  case 11: {
2354  yyval.listval =
2355  TrackedListPtr<Node>::make(lexer.parsed_node_list_tokens_, 1, yyvsp[0].nodeval);
2356  ;
2357  break;
2358  }
2359  case 12: {
2360  yyval.listval = yyvsp[-2].listval;
2361  yyval.listval->push_back(yyvsp[0].nodeval);
2362  ;
2363  break;
2364  }
2365  case 13: {
2366  yyval.nodeval = TrackedPtr<Node>::make(
2367  lexer.parsed_node_tokens_,
2368  new NameValueAssign((yyvsp[-2].stringval)->release(),
2369  dynamic_cast<Literal*>((yyvsp[0].nodeval)->release())));
2370  ;
2371  break;
2372  }
2373  case 14: {
2374  yyval.boolval = true;
2375  ;
2376  break;
2377  }
2378  case 15: {
2379  yyval.boolval = false;
2380  ;
2381  break;
2382  }
2383  case 16: {
2384  yyval.boolval = true;
2385  ;
2386  break;
2387  }
2388  case 17: {
2389  yyval.boolval = false;
2390  ;
2391  break;
2392  }
2393  case 18: {
2394  yyval.nodeval = TrackedPtr<Node>::make(
2395  lexer.parsed_node_tokens_,
2396  new CreateTableStmt(
2397  (yyvsp[-4].stringval)->release(),
2398  nullptr,
2399  reinterpret_cast<std::list<TableElement*>*>((yyvsp[-2].listval)->release()),
2400  yyvsp[-7].boolval,
2401  yyvsp[-5].boolval,
2402  reinterpret_cast<std::list<NameValueAssign*>*>(
2403  (yyvsp[0].listval)->release())));
2404  ;
2405  break;
2406  }
2407  case 19: {
2408  yyval.nodeval = TrackedPtr<Node>::make(
2409  lexer.parsed_node_tokens_,
2410  new CreateTableStmt(
2411  (yyvsp[-5].stringval)->release(),
2412  (yyvsp[-8].stringval)->release(),
2413  reinterpret_cast<std::list<TableElement*>*>((yyvsp[-3].listval)->release()),
2414  false,
2415  yyvsp[-6].boolval,
2416  reinterpret_cast<std::list<NameValueAssign*>*>(
2417  (yyvsp[-1].listval)->release())));
2418  ;
2419  break;
2420  }
2421  case 20: {
2422  yyval.boolval = true;
2423  ;
2424  break;
2425  }
2426  case 21: {
2427  yyval.boolval = false;
2428  ;
2429  break;
2430  }
2431  case 22: {
2432  yyval.nodeval = TrackedPtr<Node>::make(
2433  lexer.parsed_node_tokens_,
2434  new DropTableStmt((yyvsp[0].stringval)->release(), yyvsp[-1].boolval));
2435  ;
2436  break;
2437  }
2438  case 23: {
2439  yyval.nodeval =
2440  TrackedPtr<Node>::make(lexer.parsed_node_tokens_,
2441  new RenameTableStmt((yyvsp[-3].stringval)->release(),
2442  (yyvsp[0].stringval)->release()));
2443  ;
2444  break;
2445  }
2446  case 24: {
2447  yyval.nodeval =
2448  TrackedPtr<Node>::make(lexer.parsed_node_tokens_,
2449  new RenameColumnStmt((yyvsp[-5].stringval)->release(),
2450  (yyvsp[-2].stringval)->release(),
2451  (yyvsp[0].stringval)->release()));
2452  ;
2453  break;
2454  }
2455  case 27: {
2456  yyval.listval =
2457  TrackedListPtr<Node>::make(lexer.parsed_node_list_tokens_, 1, yyvsp[0].nodeval);
2458  ;
2459  break;
2460  }
2461  case 28: {
2462  yyval.listval = yyvsp[-2].listval;
2463  yyval.listval->push_back(yyvsp[0].nodeval);
2464  ;
2465  break;
2466  }
2467  case 29: {
2468  yyval.nodeval = TrackedPtr<Node>::make(
2469  lexer.parsed_node_tokens_,
2470  new AddColumnStmt((yyvsp[-3].stringval)->release(),
2471  dynamic_cast<ColumnDef*>((yyvsp[0].nodeval)->release())));
2472  ;
2473  break;
2474  }
2475  case 30: {
2476  yyval.nodeval = TrackedPtr<Node>::make(
2477  lexer.parsed_node_tokens_,
2478  new AddColumnStmt(
2479  (yyvsp[-4].stringval)->release(),
2480  reinterpret_cast<std::list<ColumnDef*>*>((yyvsp[-1].listval)->release())));
2481  ;
2482  break;
2483  }
2484  case 31: {
2485  yyval.nodeval =
2486  TrackedPtr<Node>::make(lexer.parsed_node_tokens_,
2487  new DropColumnStmt((yyvsp[-1].stringval)->release(),
2488  (yyvsp[0].slistval)->release()));
2489  ;
2490  break;
2491  }
2492  case 32: {
2493  yyval.listval =
2494  TrackedListPtr<Node>::make(lexer.parsed_node_list_tokens_, 1, yyvsp[0].nodeval);
2495  ;
2496  break;
2497  }
2498  case 33: {
2499  (yyvsp[-2].listval)->push_back(yyvsp[0].nodeval);
2500  ;
2501  break;
2502  }
2503  case 34: {
2504  yyval.stringval = yyvsp[0].stringval;
2505  ;
2506  break;
2507  }
2508  case 35: {
2509  yyval.nodeval = TrackedPtr<Node>::make(
2510  lexer.parsed_node_tokens_,
2511  new AlterTableParamStmt(
2512  (yyvsp[-2].stringval)->release(),
2513  reinterpret_cast<NameValueAssign*>((yyvsp[0].nodeval)->release())));
2514  ;
2515  break;
2516  }
2517  case 36: {
2518  yyval.listval =
2519  TrackedListPtr<Node>::make(lexer.parsed_node_list_tokens_, 1, yyvsp[0].nodeval);
2520  ;
2521  break;
2522  }
2523  case 37: {
2524  yyval.listval = yyvsp[-2].listval;
2525  yyval.listval->push_back(yyvsp[0].nodeval);
2526  ;
2527  break;
2528  }
2529  case 38: {
2530  yyval.nodeval = yyvsp[0].nodeval;
2531  ;
2532  break;
2533  }
2534  case 39: {
2535  yyval.nodeval = yyvsp[0].nodeval;
2536  ;
2537  break;
2538  }
2539  case 40: {
2540  yyval.nodeval = TrackedPtr<Node>::make(
2541  lexer.parsed_node_tokens_,
2542  new ColumnDef((yyvsp[-2].stringval)->release(),
2543  dynamic_cast<SQLType*>((yyvsp[-1].nodeval)->release()),
2544  dynamic_cast<CompressDef*>((yyvsp[0].nodeval)->release()),
2545  nullptr));
2546  ;
2547  break;
2548  }
2549  case 41: {
2550  yyval.nodeval = TrackedPtr<Node>::make(
2551  lexer.parsed_node_tokens_,
2552  new ColumnDef(
2553  (yyvsp[-3].stringval)->release(),
2554  dynamic_cast<SQLType*>((yyvsp[-2].nodeval)->release()),
2555  dynamic_cast<CompressDef*>((yyvsp[0].nodeval)->release()),
2556  dynamic_cast<ColumnConstraintDef*>((yyvsp[-1].nodeval)->release())));
2557  ;
2558  break;
2559  }
2560  case 42: {
2561  if (!boost::iequals(*(yyvsp[-1].stringval)->get(), "encoding"))
2562  throw std::runtime_error("Invalid identifier " + *(yyvsp[-1].stringval)->get() +
2563  " in column definition.");
2564  delete (yyvsp[-1].stringval)->release();
2565  yyval.nodeval = TrackedPtr<Node>::make(
2566  lexer.parsed_node_tokens_, new CompressDef((yyvsp[0].stringval)->release(), 0));
2567  ;
2568  break;
2569  }
2570  case 43: {
2571  if (!boost::iequals(*(yyvsp[-4].stringval)->get(), "encoding"))
2572  throw std::runtime_error("Invalid identifier " + *(yyvsp[-4].stringval)->get() +
2573  " in column definition.");
2574  delete (yyvsp[-4].stringval)->release();
2575  yyval.nodeval = TrackedPtr<Node>::make(
2576  lexer.parsed_node_tokens_,
2577  new CompressDef((yyvsp[-3].stringval)->release(), (int)yyvsp[-1].intval));
2578  ;
2579  break;
2580  }
2581  case 44: {
2582  yyval.nodeval = TrackedPtr<Node>::makeEmpty();
2583  ;
2584  break;
2585  }
2586  case 45: {
2587  yyval.nodeval =
2588  TrackedPtr<Node>::make(lexer.parsed_node_tokens_,
2589  new ColumnConstraintDef(true, false, false, nullptr));
2590  ;
2591  break;
2592  }
2593  case 46: {
2594  yyval.nodeval = TrackedPtr<Node>::make(
2595  lexer.parsed_node_tokens_, new ColumnConstraintDef(true, true, false, nullptr));
2596  ;
2597  break;
2598  }
2599  case 47: {
2600  if (!boost::iequals(*(yyvsp[0].stringval)->get(), "key"))
2601  throw std::runtime_error("Syntax error at " + *(yyvsp[0].stringval)->get());
2602  yyval.nodeval = TrackedPtr<Node>::make(
2603  lexer.parsed_node_tokens_, new ColumnConstraintDef(true, true, true, nullptr));
2604  ;
2605  break;
2606  }
2607  case 48: {
2608  yyval.nodeval = TrackedPtr<Node>::make(
2609  lexer.parsed_node_tokens_,
2610  new ColumnConstraintDef(false,
2611  false,
2612  false,
2613  dynamic_cast<Literal*>((yyvsp[0].nodeval)->release())));
2614  ;
2615  break;
2616  }
2617  case 49: {
2618  yyval.nodeval = TrackedPtr<Node>::make(
2619  lexer.parsed_node_tokens_,
2620  new ColumnConstraintDef(false, false, false, new NullLiteral()));
2621  ;
2622  break;
2623  }
2624  case 50: {
2625  yyval.nodeval = TrackedPtr<Node>::make(
2626  lexer.parsed_node_tokens_,
2627  new ColumnConstraintDef(false, false, false, new UserLiteral()));
2628  ;
2629  break;
2630  }
2631  case 51: {
2632  yyval.nodeval = TrackedPtr<Node>::make(
2633  lexer.parsed_node_tokens_,
2634  new ColumnConstraintDef(dynamic_cast<Expr*>((yyvsp[-1].nodeval)->release())));
2635  ;
2636  break;
2637  }
2638  case 52: {
2639  yyval.nodeval = TrackedPtr<Node>::make(
2640  lexer.parsed_node_tokens_,
2641  new ColumnConstraintDef((yyvsp[0].stringval)->release(), nullptr));
2642  ;
2643  break;
2644  }
2645  case 53: {
2646  yyval.nodeval = TrackedPtr<Node>::make(
2647  lexer.parsed_node_tokens_,
2648  new ColumnConstraintDef((yyvsp[-3].stringval)->release(),
2649  (yyvsp[-1].stringval)->release()));
2650  ;
2651  break;
2652  }
2653  case 54: {
2654  yyval.nodeval =
2655  TrackedPtr<Node>::make(lexer.parsed_node_tokens_,
2656  new UniqueDef(false, (yyvsp[-1].slistval)->release()));
2657  ;
2658  break;
2659  }
2660  case 55: {
2661  if (!boost::iequals(*(yyvsp[-3].stringval)->get(), "key"))
2662  throw std::runtime_error("Syntax error at " + *(yyvsp[-3].stringval)->get());
2663  yyval.nodeval =
2664  TrackedPtr<Node>::make(lexer.parsed_node_tokens_,
2665  new UniqueDef(true, (yyvsp[-1].slistval)->release()));
2666  ;
2667  break;
2668  }
2669  case 56: {
2670  if (!boost::iequals(*(yyvsp[-5].stringval)->get(), "key"))
2671  throw std::runtime_error("Syntax error at " + *(yyvsp[-5].stringval)->get());
2672  yyval.nodeval = TrackedPtr<Node>::make(
2673  lexer.parsed_node_tokens_,
2674  new ForeignKeyDef(
2675  (yyvsp[-3].slistval)->release(), (yyvsp[0].stringval)->release(), nullptr));
2676  ;
2677  break;
2678  }
2679  case 57: {
2680  if (!boost::iequals(*(yyvsp[-8].stringval)->get(), "key"))
2681  throw std::runtime_error("Syntax error at " + *(yyvsp[-8].stringval)->get());
2682  yyval.nodeval =
2683  TrackedPtr<Node>::make(lexer.parsed_node_tokens_,
2684  new ForeignKeyDef((yyvsp[-6].slistval)->release(),
2685  (yyvsp[-3].stringval)->release(),
2686  (yyvsp[-1].slistval)->release()));
2687  ;
2688  break;
2689  }
2690  case 58: {
2691  if (!boost::iequals(*(yyvsp[-3].stringval)->get(), "key"))
2692  throw std::runtime_error("Syntax error at " + *(yyvsp[-3].stringval)->get());
2693  yyval.nodeval = TrackedPtr<Node>::make(
2694  lexer.parsed_node_tokens_, new ShardKeyDef(*(yyvsp[-1].stringval)->get()));
2695  delete (yyvsp[-3].stringval)->release();
2696  delete (yyvsp[-1].stringval)->release();
2697  ;
2698  break;
2699  }
2700  case 59: {
2701  yyval.nodeval =
2702  TrackedPtr<Node>::make(lexer.parsed_node_tokens_,
2703  new SharedDictionaryDef(*(yyvsp[-6].stringval)->get(),
2704  *(yyvsp[-3].stringval)->get(),
2705  *(yyvsp[-1].stringval)->get()));
2706  delete (yyvsp[-6].stringval)->release();
2707  delete (yyvsp[-3].stringval)->release();
2708  delete (yyvsp[-1].stringval)->release();
2709  ;
2710  break;
2711  }
2712  case 60: {
2713  yyval.nodeval = TrackedPtr<Node>::make(
2714  lexer.parsed_node_tokens_,
2715  new CheckDef(dynamic_cast<Expr*>((yyvsp[-1].nodeval)->release())));
2716  ;
2717  break;
2718  }
2719  case 61: {
2720  yyval.slistval = TrackedListPtr<std::string>::make(
2721  lexer.parsed_str_list_tokens_, 1, yyvsp[0].stringval);
2722  ;
2723  break;
2724  }
2725  case 62: {
2726  yyval.slistval = yyvsp[-2].slistval;
2727  yyval.slistval->push_back(yyvsp[0].stringval);
2728  ;
2729  break;
2730  }
2731  case 63: {
2732  yyval.listval = yyvsp[-1].listval;
2733  ;
2734  break;
2735  }
2736  case 64: {
2737  yyval.listval = TrackedListPtr<Node>::makeEmpty();
2738  ;
2739  break;
2740  }
2741  case 65: {
2742  yyval.nodeval = TrackedPtr<Node>::make(
2743  lexer.parsed_node_tokens_,
2744  new DropViewStmt((yyvsp[0].stringval)->release(), yyvsp[-1].boolval));
2745  ;
2746  break;
2747  }
2748  case 66: {
2749  yyval.slistval = TrackedListPtr<std::string>::makeEmpty();
2750  ;
2751  break;
2752  }
2753  case 67: {
2754  yyval.slistval = yyvsp[-1].slistval;
2755  ;
2756  break;
2757  }
2758  case 68: {
2759  yyval.listval = TrackedListPtr<Node>::makeEmpty();
2760  ;
2761  break;
2762  }
2763  case 69: {
2764  yyval.listval = yyvsp[0].listval;
2765  ;
2766  break;
2767  }
2768  case 70: {
2769  yyval.listval =
2770  TrackedListPtr<Node>::make(lexer.parsed_node_list_tokens_, 1, yyvsp[0].nodeval);
2771  ;
2772  break;
2773  }
2774  case 71: {
2775  yyval.listval = yyvsp[-2].listval;
2776  yyval.listval->push_back(yyvsp[0].nodeval);
2777  ;
2778  break;
2779  }
2780  case 72: {
2781  yyval.nodeval = TrackedPtr<Node>::make(
2782  lexer.parsed_node_tokens_,
2783  new OrderSpec(yyvsp[-2].intval, nullptr, yyvsp[-1].boolval, yyvsp[0].boolval));
2784  ;
2785  break;
2786  }
2787  case 73: {
2788  yyval.nodeval = TrackedPtr<Node>::make(
2789  lexer.parsed_node_tokens_,
2790  new OrderSpec(0,
2791  dynamic_cast<ColumnRef*>((yyvsp[-2].nodeval)->release()),
2792  yyvsp[-1].boolval,
2793  yyvsp[0].boolval));
2794  ;
2795  break;
2796  }
2797  case 74: {
2798  yyval.boolval = false; /* default is ASC */
2799  ;
2800  break;
2801  }
2802  case 75: {
2803  yyval.boolval = false;
2804  ;
2805  break;
2806  }
2807  case 76: {
2808  yyval.boolval = true;
2809  ;
2810  break;
2811  }
2812  case 77: {
2813  yyval.boolval = false; /* default is NULL LAST */
2814  ;
2815  break;
2816  }
2817  case 78: {
2818  yyval.boolval = true;
2819  ;
2820  break;
2821  }
2822  case 79: {
2823  yyval.boolval = false;
2824  ;
2825  break;
2826  }
2827  case 85: {
2828  yyval.nodeval = TrackedPtr<Node>::make(
2829  lexer.parsed_node_tokens_,
2830  new DeleteStmt((yyvsp[-1].stringval)->release(),
2831  dynamic_cast<Expr*>((yyvsp[0].nodeval)->release())));
2832  ;
2833  break;
2834  }
2835  case 86: {
2836  yyval.nodeval = TrackedPtr<Node>::make(
2837  lexer.parsed_node_tokens_,
2838  new InsertValuesStmt(
2839  (yyvsp[-5].stringval)->release(),
2840  (yyvsp[-4].slistval)->release(),
2841  reinterpret_cast<std::list<Expr*>*>((yyvsp[-1].listval)->release())));
2842  ;
2843  break;
2844  }
2845  case 87: {
2846  yyval.boolval = false;
2847  ;
2848  break;
2849  }
2850  case 88: {
2851  yyval.boolval = false;
2852  ;
2853  break;
2854  }
2855  case 89: {
2856  yyval.boolval = true;
2857  ;
2858  break;
2859  }
2860  case 90: {
2861  yyval.listval =
2862  TrackedListPtr<Node>::make(lexer.parsed_node_list_tokens_, 1, yyvsp[0].nodeval);
2863  ;
2864  break;
2865  }
2866  case 91: {
2867  yyval.listval = yyvsp[-2].listval;
2868  yyval.listval->push_back(yyvsp[0].nodeval);
2869  ;
2870  break;
2871  }
2872  case 92: {
2873  yyval.nodeval = TrackedPtr<Node>::make(
2874  lexer.parsed_node_tokens_,
2875  new Assignment((yyvsp[-2].stringval)->release(),
2876  dynamic_cast<Expr*>((yyvsp[0].nodeval)->release())));
2877  ;
2878  break;
2879  }
2880  case 93: {
2881  yyval.nodeval = TrackedPtr<Node>::make(
2882  lexer.parsed_node_tokens_,
2883  new UpdateStmt(
2884  (yyvsp[-3].stringval)->release(),
2885  reinterpret_cast<std::list<Assignment*>*>((yyvsp[-1].listval)->release()),
2886  dynamic_cast<Expr*>((yyvsp[0].nodeval)->release())));
2887  ;
2888  break;
2889  }
2890  case 94: {
2891  yyval.nodeval = TrackedPtr<Node>::makeEmpty();
2892  ;
2893  break;
2894  }
2895  case 95: {
2896  yyval.nodeval = yyvsp[0].nodeval;
2897  ;
2898  break;
2899  }
2900  case 96: {
2901  yyval.intval = yyvsp[0].intval;
2902  if (yyval.intval <= 0)
2903  throw std::runtime_error("LIMIT must be positive.");
2904  ;
2905  break;
2906  }
2907  case 97: {
2908  yyval.intval = 0; /* 0 means ALL */
2909  ;
2910  break;
2911  }
2912  case 98: {
2913  yyval.intval = 0; /* 0 means ALL */
2914  ;
2915  break;
2916  }
2917  case 99: {
2918  yyval.intval = yyvsp[0].intval;
2919  ;
2920  break;
2921  }
2922  case 100: {
2923  if (!boost::iequals(*(yyvsp[0].stringval)->get(), "row") &&
2924  !boost::iequals(*(yyvsp[0].stringval)->get(), "rows"))
2925  throw std::runtime_error("Invalid word in OFFSET clause " +
2926  *(yyvsp[0].stringval)->get());
2927  delete (yyvsp[0].stringval)->release();
2928  yyval.intval = yyvsp[-1].intval;
2929  ;
2930  break;
2931  }
2932  case 101: {
2933  yyval.intval = 0;
2934  ;
2935  break;
2936  }
2937  case 102: {
2938  yyval.nodeval = TrackedPtr<Node>::make(
2939  lexer.parsed_node_tokens_,
2940  new SelectStmt(
2941  dynamic_cast<QueryExpr*>((yyvsp[-3].nodeval)->release()),
2942  reinterpret_cast<std::list<OrderSpec*>*>((yyvsp[-2].listval)->release()),
2943  yyvsp[-1].intval,
2944  yyvsp[0].intval));
2945  ;
2946  break;
2947  }
2948  case 103: {
2949  yyval.nodeval = yyvsp[0].nodeval;
2950  ;
2951  break;
2952  }
2953  case 104: {
2954  yyval.nodeval = TrackedPtr<Node>::make(
2955  lexer.parsed_node_tokens_,
2956  new UnionQuery(false,
2957  dynamic_cast<QueryExpr*>((yyvsp[-2].nodeval)->release()),
2958  dynamic_cast<QueryExpr*>((yyvsp[0].nodeval)->release())));
2959  ;
2960  break;
2961  }
2962  case 105: {
2963  yyval.nodeval = TrackedPtr<Node>::make(
2964  lexer.parsed_node_tokens_,
2965  new UnionQuery(true,
2966  dynamic_cast<QueryExpr*>((yyvsp[-3].nodeval)->release()),
2967  dynamic_cast<QueryExpr*>((yyvsp[0].nodeval)->release())));
2968  ;
2969  break;
2970  }
2971  case 106: {
2972  yyval.nodeval = yyvsp[0].nodeval;
2973  ;
2974  break;
2975  }
2976  case 107: {
2977  yyval.nodeval = yyvsp[-1].nodeval;
2978  ;
2979  break;
2980  }
2981  case 108: {
2982  yyval.nodeval = TrackedPtr<Node>::make(
2983  lexer.parsed_node_tokens_,
2984  new QuerySpec(
2985  yyvsp[-5].boolval,
2986  reinterpret_cast<std::list<SelectEntry*>*>((yyvsp[-4].listval)->release()),
2987  reinterpret_cast<std::list<TableRef*>*>((yyvsp[-3].listval)->release()),
2988  dynamic_cast<Expr*>((yyvsp[-2].nodeval)->release()),
2989  reinterpret_cast<std::list<Expr*>*>((yyvsp[-1].listval)->release()),
2990  dynamic_cast<Expr*>((yyvsp[0].nodeval)->release())));
2991  ;
2992  break;
2993  }
2994  case 109: {
2995  yyval.listval = yyvsp[0].listval;
2996  ;
2997  break;
2998  }
2999  case 110: {
3000  yyval.listval = TrackedListPtr<Node>::makeEmpty(); /* nullptr means SELECT * */
3001  ;
3002  break;
3003  }
3004  case 111: {
3005  yyval.listval = yyvsp[0].listval;
3006  ;
3007  break;
3008  }
3009  case 112: {
3010  yyval.listval =
3011  TrackedListPtr<Node>::make(lexer.parsed_node_list_tokens_, 1, yyvsp[0].nodeval);
3012  ;
3013  break;
3014  }
3015  case 113: {
3016  yyval.listval = yyvsp[-2].listval;
3017  yyval.listval->push_back(yyvsp[0].nodeval);
3018  ;
3019  break;
3020  }
3021  case 114: {
3022  yyval.nodeval = TrackedPtr<Node>::make(
3023  lexer.parsed_node_tokens_, new TableRef((yyvsp[0].stringval)->release()));
3024  ;
3025  break;
3026  }
3027  case 115: {
3028  yyval.nodeval =
3029  TrackedPtr<Node>::make(lexer.parsed_node_tokens_,
3030  new TableRef((yyvsp[-1].stringval)->release(),
3031  (yyvsp[0].stringval)->release()));
3032  ;
3033  break;
3034  }
3035  case 116: {
3036  yyval.nodeval = yyvsp[0].nodeval;
3037  ;
3038  break;
3039  }
3040  case 117: {
3041  yyval.listval = TrackedListPtr<Node>::makeEmpty();
3042  ;
3043  break;
3044  }
3045  case 118: {
3046  yyval.listval = yyvsp[0].listval;
3047  ;
3048  break;
3049  }
3050  case 119: {
3051  yyval.listval =
3052  TrackedListPtr<Node>::make(lexer.parsed_node_list_tokens_, 1, yyvsp[0].nodeval);
3053  ;
3054  break;
3055  }
3056  case 120: {
3057  yyval.listval = yyvsp[-2].listval;
3058  yyval.listval->push_back(yyvsp[0].nodeval);
3059  ;
3060  break;
3061  }
3062  case 121: {
3063  yyval.nodeval = TrackedPtr<Node>::makeEmpty();
3064  ;
3065  break;
3066  }
3067  case 122: {
3068  yyval.nodeval = yyvsp[0].nodeval;
3069  ;
3070  break;
3071  }
3072  case 123: {
3073  yyval.nodeval = TrackedPtr<Node>::make(
3074  lexer.parsed_node_tokens_,
3075  new OperExpr(kOR,
3076  dynamic_cast<Expr*>((yyvsp[-2].nodeval)->release()),
3077  dynamic_cast<Expr*>((yyvsp[0].nodeval)->release())));
3078  ;
3079  break;
3080  }
3081  case 124: {
3082  yyval.nodeval = TrackedPtr<Node>::make(
3083  lexer.parsed_node_tokens_,
3084  new OperExpr(kAND,
3085  dynamic_cast<Expr*>((yyvsp[-2].nodeval)->release()),
3086  dynamic_cast<Expr*>((yyvsp[0].nodeval)->release())));
3087  ;
3088  break;
3089  }
3090  case 125: {
3091  yyval.nodeval = TrackedPtr<Node>::make(
3092  lexer.parsed_node_tokens_,
3093  new OperExpr(
3094  kNOT, dynamic_cast<Expr*>((yyvsp[0].nodeval)->release()), nullptr));
3095  ;
3096  break;
3097  }
3098  case 126: {
3099  yyval.nodeval = yyvsp[-1].nodeval;
3100  ;
3101  break;
3102  }
3103  case 127: {
3104  yyval.nodeval = yyvsp[0].nodeval;
3105  ;
3106  break;
3107  }
3108  case 128: {
3109  yyval.nodeval = yyvsp[0].nodeval;
3110  ;
3111  break;
3112  }
3113  case 129: {
3114  yyval.nodeval = yyvsp[0].nodeval;
3115  ;
3116  break;
3117  }
3118  case 130: {
3119  yyval.nodeval = yyvsp[0].nodeval;
3120  ;
3121  break;
3122  }
3123  case 131: {
3124  yyval.nodeval = yyvsp[0].nodeval;
3125  ;
3126  break;
3127  }
3128  case 132: {
3129  yyval.nodeval = yyvsp[0].nodeval;
3130  ;
3131  break;
3132  }
3133  case 133: {
3134  yyval.nodeval = yyvsp[0].nodeval;
3135  ;
3136  break;
3137  }
3138  case 134: {
3139  yyval.nodeval = yyvsp[0].nodeval;
3140  ;
3141  break;
3142  }
3143  case 135: {
3144  yyval.nodeval = yyvsp[0].nodeval;
3145  ;
3146  break;
3147  }
3148  case 136: {
3149  yyval.nodeval = TrackedPtr<Node>::make(
3150  lexer.parsed_node_tokens_,
3151  new OperExpr(yyvsp[-1].opval,
3152  dynamic_cast<Expr*>((yyvsp[-2].nodeval)->release()),
3153  dynamic_cast<Expr*>((yyvsp[0].nodeval)->release())));
3154  ;
3155  break;
3156  }
3157  case 137: {
3158  yyval.nodeval = TrackedPtr<Node>::make(
3159  lexer.parsed_node_tokens_,
3160  new OperExpr(yyvsp[-1].opval,
3161  kONE,
3162  dynamic_cast<Expr*>((yyvsp[-2].nodeval)->release()),
3163  dynamic_cast<Expr*>((yyvsp[0].nodeval)->release())));
3164  /* subquery can only return a single result */
3165  ;
3166  break;
3167  }
3168  case 138: {
3169  yyval.nodeval = TrackedPtr<Node>::make(
3170  lexer.parsed_node_tokens_,
3171  new BetweenExpr(true,
3172  dynamic_cast<Expr*>((yyvsp[-5].nodeval)->release()),
3173  dynamic_cast<Expr*>((yyvsp[-2].nodeval)->release()),
3174  dynamic_cast<Expr*>((yyvsp[0].nodeval)->release())));
3175  ;
3176  break;
3177  }
3178  case 139: {
3179  yyval.nodeval = TrackedPtr<Node>::make(
3180  lexer.parsed_node_tokens_,
3181  new BetweenExpr(false,
3182  dynamic_cast<Expr*>((yyvsp[-4].nodeval)->release()),
3183  dynamic_cast<Expr*>((yyvsp[-2].nodeval)->release()),
3184  dynamic_cast<Expr*>((yyvsp[0].nodeval)->release())));
3185  ;
3186  break;
3187  }
3188  case 140: {
3189  yyval.nodeval = TrackedPtr<Node>::make(
3190  lexer.parsed_node_tokens_,
3191  new LikeExpr(true,
3192  false,
3193  dynamic_cast<Expr*>((yyvsp[-4].nodeval)->release()),
3194  dynamic_cast<Expr*>((yyvsp[-1].nodeval)->release()),
3195  dynamic_cast<Expr*>((yyvsp[0].nodeval)->release())));
3196  ;
3197  break;
3198  }
3199  case 141: {
3200  yyval.nodeval = TrackedPtr<Node>::make(
3201  lexer.parsed_node_tokens_,
3202  new LikeExpr(false,
3203  false,
3204  dynamic_cast<Expr*>((yyvsp[-3].nodeval)->release()),
3205  dynamic_cast<Expr*>((yyvsp[-1].nodeval)->release()),
3206  dynamic_cast<Expr*>((yyvsp[0].nodeval)->release())));
3207  ;
3208  break;
3209  }
3210  case 142: {
3211  yyval.nodeval = TrackedPtr<Node>::make(
3212  lexer.parsed_node_tokens_,
3213  new LikeExpr(true,
3214  true,
3215  dynamic_cast<Expr*>((yyvsp[-4].nodeval)->release()),
3216  dynamic_cast<Expr*>((yyvsp[-1].nodeval)->release()),
3217  dynamic_cast<Expr*>((yyvsp[0].nodeval)->release())));
3218  ;
3219  break;
3220  }
3221  case 143: {
3222  yyval.nodeval = TrackedPtr<Node>::make(
3223  lexer.parsed_node_tokens_,
3224  new LikeExpr(false,
3225  true,
3226  dynamic_cast<Expr*>((yyvsp[-3].nodeval)->release()),
3227  dynamic_cast<Expr*>((yyvsp[-1].nodeval)->release()),
3228  dynamic_cast<Expr*>((yyvsp[0].nodeval)->release())));
3229  ;
3230  break;
3231  }
3232  case 144: {
3233  yyval.nodeval = TrackedPtr<Node>::makeEmpty();
3234  ;
3235  break;
3236  }
3237  case 145: {
3238  std::string escape_tok = *(yyvsp[-1].stringval)->get();
3239  std::transform(escape_tok.begin(), escape_tok.end(), escape_tok.begin(), ::tolower);
3240  if (escape_tok != "escape") {
3241  throw std::runtime_error("Syntax error: wrong escape specifier");
3242  }
3243  delete (yyvsp[-1].stringval)->release();
3244  yyval.nodeval = yyvsp[0].nodeval;
3245  ;
3246  break;
3247  }
3248  case 146: {
3249  yyval.nodeval = TrackedPtr<Node>::make(
3250  lexer.parsed_node_tokens_,
3251  new IsNullExpr(true, dynamic_cast<Expr*>((yyvsp[-3].nodeval)->release())));
3252  ;
3253  break;
3254  }
3255  case 147: {
3256  yyval.nodeval = TrackedPtr<Node>::make(
3257  lexer.parsed_node_tokens_,
3258  new IsNullExpr(false, dynamic_cast<Expr*>((yyvsp[-2].nodeval)->release())));
3259  ;
3260  break;
3261  }
3262  case 148: {
3263  yyval.nodeval = TrackedPtr<Node>::make(
3264  lexer.parsed_node_tokens_,
3265  new InSubquery(true,
3266  dynamic_cast<Expr*>((yyvsp[-3].nodeval)->release()),
3267  dynamic_cast<SubqueryExpr*>((yyvsp[0].nodeval)->release())));
3268  ;
3269  break;
3270  }
3271  case 149: {
3272  yyval.nodeval = TrackedPtr<Node>::make(
3273  lexer.parsed_node_tokens_,
3274  new InSubquery(false,
3275  dynamic_cast<Expr*>((yyvsp[-2].nodeval)->release()),
3276  dynamic_cast<SubqueryExpr*>((yyvsp[0].nodeval)->release())));
3277  ;
3278  break;
3279  }
3280  case 150: {
3281  yyval.nodeval = TrackedPtr<Node>::make(
3282  lexer.parsed_node_tokens_,
3283  new InValues(
3284  true,
3285  dynamic_cast<Expr*>((yyvsp[-5].nodeval)->release()),
3286  reinterpret_cast<std::list<Expr*>*>((yyvsp[-1].listval)->release())));
3287  ;
3288  break;
3289  }
3290  case 151: {
3291  yyval.nodeval = TrackedPtr<Node>::make(
3292  lexer.parsed_node_tokens_,
3293  new InValues(
3294  false,
3295  dynamic_cast<Expr*>((yyvsp[-4].nodeval)->release()),
3296  reinterpret_cast<std::list<Expr*>*>((yyvsp[-1].listval)->release())));
3297  ;
3298  break;
3299  }
3300  case 152: {
3301  yyval.listval =
3302  TrackedListPtr<Node>::make(lexer.parsed_node_list_tokens_, 1, yyvsp[0].nodeval);
3303  ;
3304  break;
3305  }
3306  case 153: {
3307  yyval.listval = yyvsp[-2].listval;
3308  yyval.listval->push_back(yyvsp[0].nodeval);
3309  ;
3310  break;
3311  }
3312  case 154: {
3313  yyval.nodeval = TrackedPtr<Node>::make(
3314  lexer.parsed_node_tokens_,
3315  new OperExpr(yyvsp[-2].opval,
3316  yyvsp[-1].qualval,
3317  dynamic_cast<Expr*>((yyvsp[-3].nodeval)->release()),
3318  dynamic_cast<Expr*>((yyvsp[0].nodeval)->release())));
3319  ;
3320  break;
3321  }
3322  case 155: {
3323  yyval.nodeval = TrackedPtr<Node>::make(
3324  lexer.parsed_node_tokens_,
3325  new OperExpr(yyvsp[-2].opval,
3326  yyvsp[-1].qualval,
3327  dynamic_cast<Expr*>((yyvsp[-3].nodeval)->release()),
3328  dynamic_cast<Expr*>((yyvsp[0].nodeval)->release())));
3329  ;
3330  break;
3331  }
3332  case 156: {
3333  yyval.opval = yyvsp[0].opval;
3334  ;
3335  break;
3336  }
3337  case 157: {
3338  yyval.opval = yyvsp[0].opval;
3339  ;
3340  break;
3341  }
3342  case 161: {
3343  yyval.nodeval = TrackedPtr<Node>::make(
3344  lexer.parsed_node_tokens_,
3345  new ExistsExpr(dynamic_cast<QuerySpec*>((yyvsp[0].nodeval)->release())));
3346  ;
3347  break;
3348  }
3349  case 162: {
3350  yyval.nodeval = TrackedPtr<Node>::make(
3351  lexer.parsed_node_tokens_,
3352  new SubqueryExpr(dynamic_cast<QuerySpec*>((yyvsp[-1].nodeval)->release())));
3353  ;
3354  break;
3355  }
3356  case 163: {
3357  yyval.listval = TrackedListPtr<Node>::make(
3358  lexer.parsed_node_list_tokens_,
3359  1,
3360  new ExprPair(dynamic_cast<Expr*>((yyvsp[-2].nodeval)->release()),
3361  dynamic_cast<Expr*>((yyvsp[0].nodeval)->release())));
3362  ;
3363  break;
3364  }
3365  case 164: {
3366  yyval.listval = yyvsp[-4].listval;
3367  yyval.listval->push_back(
3368  new ExprPair(dynamic_cast<Expr*>((yyvsp[-2].nodeval)->release()),
3369  dynamic_cast<Expr*>((yyvsp[0].nodeval)->release())));
3370  ;
3371  break;
3372  }
3373  case 165: {
3374  yyval.nodeval = yyvsp[0].nodeval;
3375  ;
3376  break;
3377  }
3378  case 166: {
3379  yyval.nodeval = TrackedPtr<Node>::makeEmpty();
3380  ;
3381  break;
3382  }
3383  case 167: {
3384  yyval.nodeval = TrackedPtr<Node>::make(
3385  lexer.parsed_node_tokens_,
3386  new CaseExpr(
3387  reinterpret_cast<std::list<ExprPair*>*>((yyvsp[-2].listval)->release()),
3388  dynamic_cast<Expr*>((yyvsp[-1].nodeval)->release())));
3389  ;
3390  break;
3391  }
3392  case 168: {
3393  std::list<ExprPair*>* when_then_list = new std::list<ExprPair*>(
3394  1,
3395  new ExprPair(dynamic_cast<Expr*>((yyvsp[-5].nodeval)->release()),
3396  dynamic_cast<Expr*>((yyvsp[-3].nodeval)->release())));
3397  yyval.nodeval = TrackedPtr<Node>::make(
3398  lexer.parsed_node_tokens_,
3399  new CaseExpr(when_then_list,
3400  dynamic_cast<Expr*>((yyvsp[-1].nodeval)->release())));
3401  ;
3402  break;
3403  }
3404  case 169: {
3405  std::list<ExprPair*>* when_then_list = new std::list<ExprPair*>(
3406  1,
3407  new ExprPair(dynamic_cast<Expr*>((yyvsp[-3].nodeval)->release()),
3408  dynamic_cast<Expr*>((yyvsp[-1].nodeval)->release())));
3409  yyval.nodeval = TrackedPtr<Node>::make(lexer.parsed_node_tokens_,
3410  new CaseExpr(when_then_list, nullptr));
3411  ;
3412  break;
3413  }
3414  case 170: {
3415  yyval.nodeval = TrackedPtr<Node>::make(
3416  lexer.parsed_node_tokens_,
3417  new CharLengthExpr(dynamic_cast<Expr*>((yyvsp[-1].nodeval)->release()), true));
3418  ;
3419  break;
3420  }
3421  case 171: {
3422  yyval.nodeval = TrackedPtr<Node>::make(
3423  lexer.parsed_node_tokens_,
3424  new CharLengthExpr(dynamic_cast<Expr*>((yyvsp[-1].nodeval)->release()), false));
3425  ;
3426  break;
3427  }
3428  case 172: {
3429  yyval.nodeval = TrackedPtr<Node>::make(
3430  lexer.parsed_node_tokens_,
3431  new OperExpr(kARRAY_AT,
3432  dynamic_cast<Expr*>((yyvsp[-3].nodeval)->release()),
3433  dynamic_cast<Expr*>((yyvsp[-1].nodeval)->release())));
3434  ;
3435  break;
3436  }
3437  case 173: {
3438  yyval.nodeval = TrackedPtr<Node>::make(
3439  lexer.parsed_node_tokens_,
3440  new OperExpr(kPLUS,
3441  dynamic_cast<Expr*>((yyvsp[-2].nodeval)->release()),
3442  dynamic_cast<Expr*>((yyvsp[0].nodeval)->release())));
3443  ;
3444  break;
3445  }
3446  case 174: {
3447  yyval.nodeval = TrackedPtr<Node>::make(
3448  lexer.parsed_node_tokens_,
3449  new OperExpr(kMINUS,
3450  dynamic_cast<Expr*>((yyvsp[-2].nodeval)->release()),
3451  dynamic_cast<Expr*>((yyvsp[0].nodeval)->release())));
3452  ;
3453  break;
3454  }
3455  case 175: {
3456  yyval.nodeval = TrackedPtr<Node>::make(
3457  lexer.parsed_node_tokens_,
3458  new OperExpr(kMULTIPLY,
3459  dynamic_cast<Expr*>((yyvsp[-2].nodeval)->release()),
3460  dynamic_cast<Expr*>((yyvsp[0].nodeval)->release())));
3461  ;
3462  break;
3463  }
3464  case 176: {
3465  yyval.nodeval = TrackedPtr<Node>::make(
3466  lexer.parsed_node_tokens_,
3467  new OperExpr(kDIVIDE,
3468  dynamic_cast<Expr*>((yyvsp[-2].nodeval)->release()),
3469  dynamic_cast<Expr*>((yyvsp[0].nodeval)->release())));
3470  ;
3471  break;
3472  }
3473  case 177: {
3474  yyval.nodeval = TrackedPtr<Node>::make(
3475  lexer.parsed_node_tokens_,
3476  new OperExpr(kMODULO,
3477  dynamic_cast<Expr*>((yyvsp[-2].nodeval)->release()),
3478  dynamic_cast<Expr*>((yyvsp[0].nodeval)->release())));
3479  ;
3480  break;
3481  }
3482  case 178: {
3483  yyval.nodeval = TrackedPtr<Node>::make(
3484  lexer.parsed_node_tokens_,
3485  new OperExpr(kMODULO,
3486  dynamic_cast<Expr*>((yyvsp[-3].nodeval)->release()),
3487  dynamic_cast<Expr*>((yyvsp[-1].nodeval)->release())));
3488  ;
3489  break;
3490  }
3491  case 179: {
3492  yyval.nodeval = yyvsp[0].nodeval;
3493  ;
3494  break;
3495  }
3496  case 180: {
3497  yyval.nodeval = TrackedPtr<Node>::make(
3498  lexer.parsed_node_tokens_,
3499  new OperExpr(
3500  kUMINUS, dynamic_cast<Expr*>((yyvsp[0].nodeval)->release()), nullptr));
3501  ;
3502  break;
3503  }
3504  case 181: {
3505  yyval.nodeval = yyvsp[0].nodeval;
3506  ;
3507  break;
3508  }
3509  case 182: {
3510  yyval.nodeval = yyvsp[0].nodeval;
3511  ;
3512  break;
3513  }
3514  case 183: {
3515  yyval.nodeval = yyvsp[0].nodeval;
3516  ;
3517  break;
3518  }
3519  case 184: {
3520  yyval.nodeval = yyvsp[-1].nodeval;
3521  ;
3522  break;
3523  }
3524  case 185: {
3525  yyval.nodeval = TrackedPtr<Node>::make(
3526  lexer.parsed_node_tokens_,
3527  new CastExpr(dynamic_cast<Expr*>((yyvsp[-3].nodeval)->release()),
3528  dynamic_cast<SQLType*>((yyvsp[-1].nodeval)->release())));
3529  ;
3530  break;
3531  }
3532  case 186: {
3533  yyval.nodeval = yyvsp[0].nodeval;
3534  ;
3535  break;
3536  }
3537  case 187: {
3538  yyval.nodeval = yyvsp[0].nodeval;
3539  ;
3540  break;
3541  }
3542  case 188: {
3543  yyval.nodeval = yyvsp[0].nodeval;
3544  ;
3545  break;
3546  }
3547  case 189: {
3548  throw std::runtime_error("Empty select entry");
3549  ;
3550  break;
3551  }
3552  case 190: {
3553  yyval.nodeval = TrackedPtr<Node>::make(
3554  lexer.parsed_node_tokens_,
3555  new SelectEntry(dynamic_cast<Expr*>((yyvsp[0].nodeval)->release()), nullptr));
3556  ;
3557  break;
3558  }
3559  case 191: {
3560  yyval.nodeval = TrackedPtr<Node>::make(
3561  lexer.parsed_node_tokens_,
3562  new SelectEntry(dynamic_cast<Expr*>((yyvsp[-1].nodeval)->release()),
3563  (yyvsp[0].stringval)->release()));
3564  ;
3565  break;
3566  }
3567  case 192: {
3568  yyval.nodeval = TrackedPtr<Node>::make(
3569  lexer.parsed_node_tokens_,
3570  new SelectEntry(dynamic_cast<Expr*>((yyvsp[-2].nodeval)->release()),
3571  (yyvsp[0].stringval)->release()));
3572  ;
3573  break;
3574  }
3575  case 193: {
3576  throw std::runtime_error("Empty select entry list");
3577  ;
3578  break;
3579  }
3580  case 194: {
3581  yyval.listval =
3582  TrackedListPtr<Node>::make(lexer.parsed_node_list_tokens_, 1, yyvsp[0].nodeval);
3583  ;
3584  break;
3585  }
3586  case 195: {
3587  yyval.listval = yyvsp[-2].listval;
3588  yyval.listval->push_back(yyvsp[0].nodeval);
3589  ;
3590  break;
3591  }
3592  case 196: {
3593  yyval.nodeval = yyvsp[0].nodeval;
3594  ;
3595  break;
3596  }
3597  case 197: {
3598  yyval.nodeval =
3599  TrackedPtr<Node>::make(lexer.parsed_node_tokens_, new UserLiteral());
3600  ;
3601  break;
3602  }
3603  case 198: {
3604  yyval.nodeval = TrackedPtr<Node>::make(
3605  lexer.parsed_node_tokens_, new FunctionRef((yyvsp[-3].stringval)->release()));
3606  ;
3607  break;
3608  }
3609  case 199: {
3610  yyval.nodeval = TrackedPtr<Node>::make(
3611  lexer.parsed_node_tokens_,
3612  new FunctionRef((yyvsp[-4].stringval)->release(),
3613  true,
3614  dynamic_cast<Expr*>((yyvsp[-1].nodeval)->release())));
3615  ;
3616  break;
3617  }
3618  case 200: {
3619  yyval.nodeval = TrackedPtr<Node>::make(
3620  lexer.parsed_node_tokens_,
3621  new FunctionRef((yyvsp[-4].stringval)->release(),
3622  dynamic_cast<Expr*>((yyvsp[-1].nodeval)->release())));
3623  ;
3624  break;
3625  }
3626  case 201: {
3627  yyval.nodeval = TrackedPtr<Node>::make(
3628  lexer.parsed_node_tokens_,
3629  new FunctionRef((yyvsp[-3].stringval)->release(),
3630  dynamic_cast<Expr*>((yyvsp[-1].nodeval)->release())));
3631  ;
3632  break;
3633  }
3634  case 202: {
3635  yyval.nodeval = TrackedPtr<Node>::make(
3636  lexer.parsed_node_tokens_, new StringLiteral((yyvsp[0].stringval)->release()));
3637  ;
3638  break;
3639  }
3640  case 203: {
3641  yyval.nodeval = TrackedPtr<Node>::make(lexer.parsed_node_tokens_,
3642  new IntLiteral(yyvsp[0].intval));
3643  ;
3644  break;
3645  }
3646  case 204: {
3647  yyval.nodeval =
3648  TrackedPtr<Node>::make(lexer.parsed_node_tokens_, new TimestampLiteral());
3649  ;
3650  break;
3651  }
3652  case 205: {
3653  delete dynamic_cast<Expr*>((yyvsp[-1].nodeval)->release());
3654  yyval.nodeval =
3655  TrackedPtr<Node>::make(lexer.parsed_node_tokens_, new TimestampLiteral());
3656  ;
3657  break;
3658  }
3659  case 206: {
3660  yyval.nodeval = TrackedPtr<Node>::make(
3661  lexer.parsed_node_tokens_, new FixedPtLiteral((yyvsp[0].stringval)->release()));
3662  ;
3663  break;
3664  }
3665  case 207: {
3666  yyval.nodeval = TrackedPtr<Node>::make(lexer.parsed_node_tokens_,
3667  new FloatLiteral(yyvsp[0].floatval));
3668  ;
3669  break;
3670  }
3671  case 208: {
3672  yyval.nodeval = TrackedPtr<Node>::make(lexer.parsed_node_tokens_,
3673  new DoubleLiteral(yyvsp[0].doubleval));
3674  ;
3675  break;
3676  }
3677  case 209: {
3678  yyval.nodeval = TrackedPtr<Node>::make(
3679  lexer.parsed_node_tokens_,
3680  new CastExpr(new StringLiteral((yyvsp[0].stringval)->release()),
3681  dynamic_cast<SQLType*>((yyvsp[-1].nodeval)->release())));
3682  ;
3683  break;
3684  }
3685  case 210: {
3686  yyval.nodeval = TrackedPtr<Node>::make(
3687  lexer.parsed_node_tokens_,
3688  new ArrayLiteral(
3689  reinterpret_cast<std::list<Expr*>*>((yyvsp[-1].listval)->release())));
3690  ;
3691  break;
3692  }
3693  case 211: {
3694  yyval.nodeval = TrackedPtr<Node>::make(
3695  lexer.parsed_node_tokens_,
3696  new ArrayLiteral(
3697  reinterpret_cast<std::list<Expr*>*>((yyvsp[-1].listval)->release())));
3698  ;
3699  break;
3700  }
3701  case 212: {
3702  yyval.nodeval =
3703  TrackedPtr<Node>::make(lexer.parsed_node_tokens_, new NullLiteral());
3704  ;
3705  break;
3706  }
3707  case 213: {
3708  yyval.listval =
3709  TrackedListPtr<Node>::make(lexer.parsed_node_list_tokens_, 1, yyvsp[0].nodeval);
3710  ;
3711  break;
3712  }
3713  case 214: {
3714  yyval.listval = yyvsp[-2].listval;
3715  yyval.listval->push_back(yyvsp[0].nodeval);
3716  ;
3717  break;
3718  }
3719  case 215: {
3720  yyval.listval = TrackedListPtr<Node>::make(lexer.parsed_node_list_tokens_, 0);
3721  ;
3722  break;
3723  }
3724  case 217: {
3725  const auto uc_col_name =
3726  boost::to_upper_copy<std::string>(*(yyvsp[0].stringval)->get());
3727  if (reserved_keywords.find(uc_col_name) != reserved_keywords.end()) {
3728  errors_.push_back("Cannot use a reserved keyword as table name: " +
3729  *(yyvsp[0].stringval)->get());
3730  }
3731  yyval.stringval = yyvsp[0].stringval;
3732  ;
3733  break;
3734  }
3735  case 218: {
3736  yyval.stringval = yyvsp[0].stringval;
3737  ;
3738  break;
3739  }
3740  case 219: {
3741  yyval.nodeval = TrackedPtr<Node>::makeEmpty();
3742  ;
3743  break;
3744  }
3745  case 225: {
3746  yyval.slistval = TrackedListPtr<std::string>::make(
3747  lexer.parsed_str_list_tokens_, 1, yyvsp[0].stringval);
3748  ;
3749  break;
3750  }
3751  case 226: {
3752  yyval.slistval = yyvsp[-2].slistval;
3753  yyval.slistval->push_back(yyvsp[0].stringval);
3754  ;
3755  break;
3756  }
3757  case 229: {
3758  yyval.slistval = TrackedListPtr<std::string>::make(
3759  lexer.parsed_str_list_tokens_, 1, yyvsp[0].stringval);
3760  ;
3761  break;
3762  }
3763  case 230: {
3764  yyval.slistval = yyvsp[-2].slistval;
3765  yyval.slistval->push_back(yyvsp[0].stringval);
3766  ;
3767  break;
3768  }
3769  case 233: {
3770  yyval.slistval = TrackedListPtr<std::string>::make(
3771  lexer.parsed_str_list_tokens_, 1, yyvsp[0].stringval);
3772  ;
3773  break;
3774  }
3775  case 234: {
3776  yyval.slistval = yyvsp[-2].slistval;
3777  yyval.slistval->push_back(yyvsp[0].stringval);
3778  ;
3779  break;
3780  }
3781  case 235: {
3782  yyval.stringval = TrackedPtr<std::string>::make(lexer.parsed_str_tokens_, "ALL");
3783  ;
3784  break;
3785  }
3786  case 236: {
3787  yyval.stringval = TrackedPtr<std::string>::make(lexer.parsed_str_tokens_, "ALL");
3788  ;
3789  break;
3790  }
3791  case 237: {
3792  yyval.stringval = TrackedPtr<std::string>::make(lexer.parsed_str_tokens_, "CREATE");
3793  ;
3794  break;
3795  }
3796  case 238: {
3797  yyval.stringval = TrackedPtr<std::string>::make(lexer.parsed_str_tokens_, "SELECT");
3798  ;
3799  break;
3800  }
3801  case 239: {
3802  yyval.stringval = TrackedPtr<std::string>::make(lexer.parsed_str_tokens_, "INSERT");
3803  ;
3804  break;
3805  }
3806  case 240: {
3807  yyval.stringval =
3808  TrackedPtr<std::string>::make(lexer.parsed_str_tokens_, "TRUNCATE");
3809  ;
3810  break;
3811  }
3812  case 241: {
3813  yyval.stringval = TrackedPtr<std::string>::make(lexer.parsed_str_tokens_, "UPDATE");
3814  ;
3815  break;
3816  }
3817  case 242: {
3818  yyval.stringval = TrackedPtr<std::string>::make(lexer.parsed_str_tokens_, "DELETE");
3819  ;
3820  break;
3821  }
3822  case 243: {
3823  yyval.stringval = TrackedPtr<std::string>::make(lexer.parsed_str_tokens_, "ALTER");
3824  ;
3825  break;
3826  }
3827  case 244: {
3828  yyval.stringval = TrackedPtr<std::string>::make(lexer.parsed_str_tokens_, "DROP");
3829  ;
3830  break;
3831  }
3832  case 245: {
3833  yyval.stringval = TrackedPtr<std::string>::make(lexer.parsed_str_tokens_, "VIEW");
3834  ;
3835  break;
3836  }
3837  case 246: {
3838  yyval.stringval = TrackedPtr<std::string>::make(lexer.parsed_str_tokens_, "EDIT");
3839  ;
3840  break;
3841  }
3842  case 247: {
3843  yyval.stringval = TrackedPtr<std::string>::make(lexer.parsed_str_tokens_, "ACCESS");
3844  ;
3845  break;
3846  }
3847  case 248: {
3848  yyval.stringval = TrackedPtr<std::string>::make(lexer.parsed_str_tokens_, "USAGE");
3849  ;
3850  break;
3851  }
3852  case 249: {
3853  yyval.stringval =
3854  TrackedPtr<std::string>::make(lexer.parsed_str_tokens_, "SERVER USAGE");
3855  ;
3856  break;
3857  }
3858  case 250: {
3859  yyval.stringval =
3860  TrackedPtr<std::string>::make(lexer.parsed_str_tokens_, "ALTER SERVER");
3861  ;
3862  break;
3863  }
3864  case 251: {
3865  yyval.stringval =
3866  TrackedPtr<std::string>::make(lexer.parsed_str_tokens_, "CREATE SERVER");
3867  ;
3868  break;
3869  }
3870  case 252: {
3871  yyval.stringval =
3872  TrackedPtr<std::string>::make(lexer.parsed_str_tokens_, "CREATE TABLE");
3873  ;
3874  break;
3875  }
3876  case 253: {
3877  yyval.stringval =
3878  TrackedPtr<std::string>::make(lexer.parsed_str_tokens_, "CREATE VIEW");
3879  ;
3880  break;
3881  }
3882  case 254: {
3883  yyval.stringval =
3884  TrackedPtr<std::string>::make(lexer.parsed_str_tokens_, "SELECT VIEW");
3885  ;
3886  break;
3887  }
3888  case 255: {
3889  yyval.stringval =
3890  TrackedPtr<std::string>::make(lexer.parsed_str_tokens_, "DROP VIEW");
3891  ;
3892  break;
3893  }
3894  case 256: {
3895  yyval.stringval =
3896  TrackedPtr<std::string>::make(lexer.parsed_str_tokens_, "DROP SERVER");
3897  ;
3898  break;
3899  }
3900  case 257: {
3901  yyval.stringval =
3902  TrackedPtr<std::string>::make(lexer.parsed_str_tokens_, "CREATE DASHBOARD");
3903  ;
3904  break;
3905  }
3906  case 258: {
3907  yyval.stringval =
3908  TrackedPtr<std::string>::make(lexer.parsed_str_tokens_, "EDIT DASHBOARD");
3909  ;
3910  break;
3911  }
3912  case 259: {
3913  yyval.stringval =
3914  TrackedPtr<std::string>::make(lexer.parsed_str_tokens_, "VIEW DASHBOARD");
3915  ;
3916  break;
3917  }
3918  case 260: {
3919  yyval.stringval =
3920  TrackedPtr<std::string>::make(lexer.parsed_str_tokens_, "DELETE DASHBOARD");
3921  ;
3922  break;
3923  }
3924  case 261: {
3925  yyval.stringval =
3926  TrackedPtr<std::string>::make(lexer.parsed_str_tokens_, "VIEW SQL EDITOR");
3927  ;
3928  break;
3929  }
3930  case 262: {
3931  yyval.stringval =
3932  TrackedPtr<std::string>::make(lexer.parsed_str_tokens_, "DATABASE");
3933  ;
3934  break;
3935  }
3936  case 263: {
3937  yyval.stringval = TrackedPtr<std::string>::make(lexer.parsed_str_tokens_, "TABLE");
3938  ;
3939  break;
3940  }
3941  case 264: {
3942  yyval.stringval =
3943  TrackedPtr<std::string>::make(lexer.parsed_str_tokens_, "DASHBOARD");
3944  ;
3945  break;
3946  }
3947  case 265: {
3948  yyval.stringval = TrackedPtr<std::string>::make(lexer.parsed_str_tokens_, "VIEW");
3949  ;
3950  break;
3951  }
3952  case 266: {
3953  yyval.stringval = TrackedPtr<std::string>::make(lexer.parsed_str_tokens_, "SERVER");
3954  ;
3955  break;
3956  }
3957  case 268: {
3958  yyval.stringval = TrackedPtr<std::string>::make(lexer.parsed_str_tokens_,
3959  std::to_string(yyvsp[0].intval));
3960  ;
3961  break;
3962  }
3963  case 269: {
3964  yyval.nodeval = TrackedPtr<Node>::make(
3965  lexer.parsed_node_tokens_, new ColumnRef((yyvsp[0].stringval)->release()));
3966  ;
3967  break;
3968  }
3969  case 270: {
3970  yyval.nodeval =
3971  TrackedPtr<Node>::make(lexer.parsed_node_tokens_,
3972  new ColumnRef((yyvsp[-2].stringval)->release(),
3973  (yyvsp[0].stringval)->release()));
3974  ;
3975  break;
3976  }
3977  case 271: {
3978  yyval.nodeval = TrackedPtr<Node>::make(
3979  lexer.parsed_node_tokens_,
3980  new ColumnRef((yyvsp[-2].stringval)->release(), nullptr));
3981  ;
3982  break;
3983  }
3984  case 272: {
3985  if (yyvsp[0].intval < 0)
3986  throw std::runtime_error("No negative number in type definition.");
3987  yyval.intval = yyvsp[0].intval;
3988  ;
3989  break;
3990  }
3991  case 273: {
3992  yyval.nodeval =
3993  TrackedPtr<Node>::make(lexer.parsed_node_tokens_, new SQLType(kBIGINT));
3994  ;
3995  break;
3996  }
3997  case 274: {
3998  yyval.nodeval =
3999  TrackedPtr<Node>::make(lexer.parsed_node_tokens_, new SQLType(kTEXT));
4000  ;
4001  break;
4002  }
4003  case 275: {
4004  yyval.nodeval =
4005  TrackedPtr<Node>::make(lexer.parsed_node_tokens_, new SQLType(kBOOLEAN));
4006  ;
4007  break;
4008  }
4009  case 276: {
4010  yyval.nodeval =
4011  TrackedPtr<Node>::make(lexer.parsed_node_tokens_, new SQLType(kCHAR));
4012  ;
4013  break;
4014  }
4015  case 277: {
4016  yyval.nodeval = TrackedPtr<Node>::make(lexer.parsed_node_tokens_,
4017  new SQLType(kCHAR, yyvsp[-1].intval));
4018  ;
4019  break;
4020  }
4021  case 278: {
4022  yyval.nodeval =
4023  TrackedPtr<Node>::make(lexer.parsed_node_tokens_, new SQLType(kNUMERIC));
4024  ;
4025  break;
4026  }
4027  case 279: {
4028  yyval.nodeval = TrackedPtr<Node>::make(lexer.parsed_node_tokens_,
4029  new SQLType(kNUMERIC, yyvsp[-1].intval));
4030  ;
4031  break;
4032  }
4033  case 280: {
4034  yyval.nodeval = TrackedPtr<Node>::make(
4035  lexer.parsed_node_tokens_,
4036  new SQLType(kNUMERIC, yyvsp[-3].intval, yyvsp[-1].intval, false));
4037  ;
4038  break;
4039  }
4040  case 281: {
4041  yyval.nodeval =
4042  TrackedPtr<Node>::make(lexer.parsed_node_tokens_, new SQLType(kDECIMAL));
4043  ;
4044  break;
4045  }
4046  case 282: {
4047  yyval.nodeval = TrackedPtr<Node>::make(lexer.parsed_node_tokens_,
4048  new SQLType(kDECIMAL, yyvsp[-1].intval));
4049  ;
4050  break;
4051  }
4052  case 283: {
4053  yyval.nodeval = TrackedPtr<Node>::make(
4054  lexer.parsed_node_tokens_,
4055  new SQLType(kDECIMAL, yyvsp[-3].intval, yyvsp[-1].intval, false));
4056  ;
4057  break;
4058  }
4059  case 284: {
4060  yyval.nodeval =
4061  TrackedPtr<Node>::make(lexer.parsed_node_tokens_, new SQLType(kINT));
4062  ;
4063  break;
4064  }
4065  case 285: {
4066  yyval.nodeval =
4067  TrackedPtr<Node>::make(lexer.parsed_node_tokens_, new SQLType(kTINYINT));
4068  ;
4069  break;
4070  }
4071  case 286: {
4072  yyval.nodeval =
4073  TrackedPtr<Node>::make(lexer.parsed_node_tokens_, new SQLType(kSMALLINT));
4074  ;
4075  break;
4076  }
4077  case 287: {
4078  yyval.nodeval =
4079  TrackedPtr<Node>::make(lexer.parsed_node_tokens_, new SQLType(kFLOAT));
4080  ;
4081  break;
4082  }
4083  case 288: {
4084  yyval.nodeval =
4085  TrackedPtr<Node>::make(lexer.parsed_node_tokens_, new SQLType(kFLOAT));
4086  ;
4087  break;
4088  }
4089  case 289: {
4090  yyval.nodeval =
4091  TrackedPtr<Node>::make(lexer.parsed_node_tokens_, new SQLType(kDOUBLE));
4092  ;
4093  break;
4094  }
4095  case 290: {
4096  yyval.nodeval =
4097  TrackedPtr<Node>::make(lexer.parsed_node_tokens_, new SQLType(kDOUBLE));
4098  ;
4099  break;
4100  }
4101  case 291: {
4102  yyval.nodeval =
4103  TrackedPtr<Node>::make(lexer.parsed_node_tokens_, new SQLType(kDATE));
4104  ;
4105  break;
4106  }
4107  case 292: {
4108  yyval.nodeval =
4109  TrackedPtr<Node>::make(lexer.parsed_node_tokens_, new SQLType(kTIME));
4110  ;
4111  break;
4112  }
4113  case 293: {
4114  yyval.nodeval = TrackedPtr<Node>::make(lexer.parsed_node_tokens_,
4115  new SQLType(kTIME, yyvsp[-1].intval));
4116  ;
4117  break;
4118  }
4119  case 294: {
4120  yyval.nodeval =
4121  TrackedPtr<Node>::make(lexer.parsed_node_tokens_, new SQLType(kTIMESTAMP));
4122  ;
4123  break;
4124  }
4125  case 295: {
4126  yyval.nodeval = TrackedPtr<Node>::make(lexer.parsed_node_tokens_,
4127  new SQLType(kTIMESTAMP, yyvsp[-1].intval));
4128  ;
4129  break;
4130  }
4131  case 296: {
4132  yyval.nodeval =
4133  TrackedPtr<Node>::make(lexer.parsed_node_tokens_,
4134  new SQLType(static_cast<SQLTypes>(yyvsp[0].intval),
4135  static_cast<int>(kGEOMETRY),
4136  0,
4137  false));
4138  ;
4139  break;
4140  }
4141  case 297: {
4142  yyval.nodeval = yyvsp[0].nodeval;
4143  ;
4144  break;
4145  }
4146  case 298: {
4147  yyval.nodeval = yyvsp[-2].nodeval;
4148  if (dynamic_cast<SQLType*>((yyval.nodeval)->get())->get_is_array())
4149  throw std::runtime_error("array of array not supported.");
4150  dynamic_cast<SQLType*>((yyval.nodeval)->get())->set_is_array(true);
4151  ;
4152  break;
4153  }
4154  case 299: {
4155  yyval.nodeval = yyvsp[-3].nodeval;
4156  if (dynamic_cast<SQLType*>((yyval.nodeval)->get())->get_is_array())
4157  throw std::runtime_error("array of array not supported.");
4158  dynamic_cast<SQLType*>((yyval.nodeval)->get())->set_is_array(true);
4159  dynamic_cast<SQLType*>((yyval.nodeval)->get())->set_array_size(yyvsp[-1].intval);
4160  ;
4161  break;
4162  }
4163  case 300: {
4164  yyval.intval = kPOINT;
4165  ;
4166  break;
4167  }
4168  case 301: {
4169  yyval.intval = kLINESTRING;
4170  ;
4171  break;
4172  }
4173  case 302: {
4174  yyval.intval = kPOLYGON;
4175  ;
4176  break;
4177  }
4178  case 303: {
4179  yyval.intval = kMULTIPOLYGON;
4180  ;
4181  break;
4182  }
4183  case 304: {
4184  yyval.nodeval =
4185  TrackedPtr<Node>::make(lexer.parsed_node_tokens_,
4186  new SQLType(static_cast<SQLTypes>(yyvsp[-1].intval),
4187  static_cast<int>(kGEOGRAPHY),
4188  4326,
4189  false));
4190  ;
4191  break;
4192  }
4193  case 305: {
4194  yyval.nodeval =
4195  TrackedPtr<Node>::make(lexer.parsed_node_tokens_,
4196  new SQLType(static_cast<SQLTypes>(yyvsp[-3].intval),
4197  static_cast<int>(kGEOGRAPHY),
4198  yyvsp[-1].intval,
4199  false));
4200  ;
4201  break;
4202  }
4203  case 306: {
4204  yyval.nodeval =
4205  TrackedPtr<Node>::make(lexer.parsed_node_tokens_,
4206  new SQLType(static_cast<SQLTypes>(yyvsp[-1].intval),
4207  static_cast<int>(kGEOMETRY),
4208  0,
4209  false));
4210  ;
4211  break;
4212  }
4213  case 307: {
4214  yyval.nodeval =
4215  TrackedPtr<Node>::make(lexer.parsed_node_tokens_,
4216  new SQLType(static_cast<SQLTypes>(yyvsp[-3].intval),
4217  static_cast<int>(kGEOMETRY),
4218  yyvsp[-1].intval,
4219  false));
4220  ;
4221  break;
4222  }
4223  case 308: {
4224  const auto uc_col_name =
4225  boost::to_upper_copy<std::string>(*(yyvsp[0].stringval)->get());
4226  if (reserved_keywords.find(uc_col_name) != reserved_keywords.end()) {
4227  errors_.push_back("Cannot use a reserved keyword as column name: " +
4228  *(yyvsp[0].stringval)->get());
4229  }
4230  yyval.stringval = yyvsp[0].stringval;
4231  ;
4232  break;
4233  }
4234  case 309: {
4235  yyval.stringval = yyvsp[0].stringval;
4236  ;
4237  break;
4238  }
4239  case 310: {
4240  yyval.stringval = yyvsp[0].stringval;
4241  ;
4242  break;
4243  }
4244  }
4245 
4246 #line 811 "/usr/local/mapd-deps/20210608/lib/bison.cc"
4247  /* the action file gets copied in in place of this dollarsign */
4248  yyvsp -= yylen;
4249  yyssp -= yylen;
4250 #ifdef YY_Parser_LSP_NEEDED
4251  yylsp -= yylen;
4252 #endif
4253 
4254 #if YY_Parser_DEBUG != 0
4255  if (YY_Parser_DEBUG_FLAG) {
4256  short* ssp1 = yyss - 1;
4257  fprintf(stderr, "state stack now");
4258  while (ssp1 != yyssp)
4259  fprintf(stderr, " %d", *++ssp1);
4260  fprintf(stderr, "\n");
4261  }
4262 #endif
4263 
4264  *++yyvsp = yyval;
4265 
4266 #ifdef YY_Parser_LSP_NEEDED
4267  yylsp++;
4268  if (yylen == 0) {
4269  yylsp->first_line = YY_Parser_LLOC.first_line;
4270  yylsp->first_column = YY_Parser_LLOC.first_column;
4271  yylsp->last_line = (yylsp - 1)->last_line;
4272  yylsp->last_column = (yylsp - 1)->last_column;
4273  yylsp->text = 0;
4274  } else {
4275  yylsp->last_line = (yylsp + yylen - 1)->last_line;
4276  yylsp->last_column = (yylsp + yylen - 1)->last_column;
4277  }
4278 #endif
4279 
4280  /* Now "shift" the result of the reduction.
4281  Determine what state that goes to,
4282  based on the state we popped back to
4283  and the rule number reduced by. */
4284 
4285  yyn = yyr1[yyn];
4286 
4287  yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
4288  if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
4289  yystate = yytable[yystate];
4290  else
4291  yystate = yydefgoto[yyn - YYNTBASE];
4292 
4293  YYGOTO(yynewstate);
4294 
4295  YYLABEL(yyerrlab) /* here on detecting error */
4296 
4297  if (!yyerrstatus)
4298  /* If not already recovering from an error, report this error. */
4299  {
4300  ++YY_Parser_NERRS;
4301 
4302 #ifdef YY_Parser_ERROR_VERBOSE
4303  yyn = yypact[yystate];
4304 
4305  if (yyn > YYFLAG && yyn < YYLAST) {
4306  int size = 0;
4307  char* msg;
4308  int x, count;
4309 
4310  count = 0;
4311  /* Start X at -yyn if nec to avoid negative indexes in yycheck. */
4312  for (x = (yyn < 0 ? -yyn : 0); x < (sizeof(yytname) / sizeof(char*)); x++)
4313  if (yycheck[x + yyn] == x)
4314  size += strlen(yytname[x]) + 15, count++;
4315  msg = (char*)malloc(size + 15);
4316  if (msg != 0) {
4317  strcpy(msg, "parse error");
4318 
4319  if (count < 5) {
4320  count = 0;
4321  for (x = (yyn < 0 ? -yyn : 0); x < (sizeof(yytname) / sizeof(char*)); x++)
4322  if (yycheck[x + yyn] == x) {
4323  strcat(msg, count == 0 ? ", expecting `" : " or `");
4324  strcat(msg, yytname[x]);
4325  strcat(msg, "'");
4326  count++;
4327  }
4328  }
4329  YY_Parser_ERROR(msg);
4330  free(msg);
4331  } else
4332  YY_Parser_ERROR("parse error; also virtual memory exceeded");
4333  } else
4334 #endif /* YY_Parser_ERROR_VERBOSE */
4335  YY_Parser_ERROR("parse error");
4336  }
4337 
4338  YYGOTO(yyerrlab1);
4339  YYLABEL(yyerrlab1) /* here on error raised explicitly by an action */
4340 
4341  if (yyerrstatus == 3) {
4342  /* if just tried and failed to reuse lookahead token after an error, discard it. */
4343 
4344  /* return failure if at end of input */
4345  if (YY_Parser_CHAR == YYEOF)
4346  YYABORT;
4347 
4348 #if YY_Parser_DEBUG != 0
4350  fprintf(stderr, "Discarding token %d (%s).\n", YY_Parser_CHAR, yytname[yychar1]);
4351 #endif
4352 
4353  YY_Parser_CHAR = YYEMPTY;
4354  }
4355 
4356  /* Else will try to reuse lookahead token
4357  after shifting the error token. */
4358 
4359  yyerrstatus = 3; /* Each real token shifted decrements this */
4360 
4361  YYGOTO(yyerrhandle);
4362 
4363  YYLABEL(
4364  yyerrdefault) /* current state does not do anything special for the error token. */
4365 
4366 #if 0
4367  /* This is wrong; only states that explicitly want error tokens
4368  should shift them. */
4369  yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/
4370  if (yyn) YYGOTO(yydefault);
4371 #endif
4372 
4373  YYLABEL(yyerrpop) /* pop the current state because it cannot handle the error token */
4374 
4375  if (yyssp == yyss)
4376  YYABORT;
4377  yyvsp--;
4378  yystate = *--yyssp;
4379 #ifdef YY_Parser_LSP_NEEDED
4380  yylsp--;
4381 #endif
4382 
4383 #if YY_Parser_DEBUG != 0
4384  if (YY_Parser_DEBUG_FLAG) {
4385  short* ssp1 = yyss - 1;
4386  fprintf(stderr, "Error: state stack now");
4387  while (ssp1 != yyssp)
4388  fprintf(stderr, " %d", *++ssp1);
4389  fprintf(stderr, "\n");
4390  }
4391 #endif
4392 
4393  YYLABEL(yyerrhandle)
4394 
4395  yyn = yypact[yystate];
4396  if (yyn == YYFLAG)
4397  YYGOTO(yyerrdefault);
4398 
4399  yyn += YYTERROR;
4400  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
4401  YYGOTO(yyerrdefault);
4402 
4403  yyn = yytable[yyn];
4404  if (yyn < 0) {
4405  if (yyn == YYFLAG)
4406  YYGOTO(yyerrpop);
4407  yyn = -yyn;
4408  YYGOTO(yyreduce);
4409  } else if (yyn == 0)
4410  YYGOTO(yyerrpop);
4411 
4412  if (yyn == YYFINAL)
4413  YYACCEPT;
4414 
4415 #if YY_Parser_DEBUG != 0
4417  fprintf(stderr, "Shifting error token, ");
4418 #endif
4419 
4420  *++yyvsp = YY_Parser_LVAL;
4421 #ifdef YY_Parser_LSP_NEEDED
4422  *++yylsp = YY_Parser_LLOC;
4423 #endif
4424 
4425  yystate = yyn;
4426  YYGOTO(yynewstate);
4427  /* end loop, in which YYGOTO may be used. */
4428  YYENDGOTO
4429 }
4430 
4431 /* END */
4432 
4433 /* #line 1010 "/usr/local/mapd-deps/20210608/lib/bison.cc" */
#define YY_Parser_STYPE
#define YY_Parser_LEX
#define COMMIT
static std::set< std::string > reserved_keywords
#define BETWEEN
#define DELETE
#define FOREIGN
#define PRECISION
#define PRIMARY
#define VALUES
#define YYENDGOTO
#define NOT
#define LINESTRING
#define YYACCEPT
#define INSERT
int yystacksize
#define QUOTED_IDENTIFIER
int yychar1
#define REVOKE
#define YY_Parser_MEMBERS
#define THEN
#define REFERENCES
YY_Parser_STYPE * yyvsp
#define YY_Parser_CONSTRUCTOR_INIT
#define BY
#define NOW
Definition: sqltypes.h:49
#define EMAIL
YY_Parser_STYPE yyvsa[YYINITDEPTH]
#define TEMPORARY
#define REAL
#define GEOMETRY
#define parsed_str_tokens_
#define ELSE
short * yyssp
#define DUMP
SQLQualifier
Definition: sqldefs.h:69
#define HAVING
#define CURSOR
#define DATABASE
#define SMALLINT
SQLOps
Definition: sqldefs.h:29
#define OPTIMIZE
#define EXISTS
#define END
#define ALTER
#define DROP
#define OPTION
#define DOUBLE
#define yylval
#define FOUND
#define CONTINUE
#define YY_Parser_PARSE_PARAM
#define BIGINT
YY_Parser_STYPE * yyvs
Definition: sqldefs.h:38
#define TO
#define YY_Parser_LVAL
#define VALIDATE
#define TRUNCATE
#define YYDECLARELABEL(lb)
#define DICTIONARY
#define DASHBOARD
#define CURRENT
Definition: sqldefs.h:41
int YY_Parser_PARSE_PARAM_DEF
#define YYTERROR
#define OPEN
#define IN
#define DATE
#define EDIT
#define PARAMETER
#define OFFSET
#define INTNUM
#define WHENEVER
#define VIEW
short * yyss
int yylen
#define GRANT
#define SHARED
#define ROLLBACK
#define YY_Parser_ERROR_BODY
#define FWDSTR
std::string to_string(char const *&&v)
#define CHARACTER
#define PUBLIC
#define MOD
#define NULLX
#define AMMSC
#define YYABORT
#define RESTORE
#define TEXT
#define ROLE
#define SELECTSTRING
#define DASHEDNAME
#define YYFINAL
#define EDITOR
#define ADD
#define FOR
#define MULTIPOLYGON
#define POINT
#define IF
#define YY_Parser_LLOC
static const short yypact[]
#define SHOW
static TrackedPtr< T > * make(std::vector< std::unique_ptr< TrackedPtr< T >>> &tracked_ptrs, Args &&...args)
Definition: TrackedPtr.h:70
#define FIRST
#define UNION
static TrackedListPtr< T > * make(std::vector< std::unique_ptr< TrackedListPtr< T >>> &tracked_ptrs, Args &&...args)
Definition: TrackedPtr.h:170
Classes representing a parse tree.
Definition: ParserNode.h:1707
#define ASC
#define GROUP
#define YY_Parser_CHAR
int count
#define LIMIT
YY_Parser_STYPE yyval
#define SHARD
static const short yypgoto[]
static void __yy_bcopy(from, to, count) char *from
#define YYNTBASE
#define NAME
#define YYEMPTY
#define WITH
#define TIME
#define FROM
Definition: sqldefs.h:37
#define CLUSTER
#define SQL
#define YYLABEL(lb)
#define TINYINT
static const short yyr2[]
static const short yytable[]
#define AUTHORIZATION
OUTPUT transform(INPUT const &input, FUNC const &func)
Definition: misc.h:290
#define USAGE
#define __ALLOCA_return(num)
short yyssa[YYINITDEPTH]
#define CREATE
#define YYBEGINDECLARELABEL
#define COMPARISON
#define RENAME
#define ON
#define YY_Parser_DEBUG_FLAG
static TrackedListPtr< T > * makeEmpty()
Definition: TrackedPtr.h:183
char * to
#define YYFLAG
#define DATAFRAME
#define ANY
#define DESC
#define COLUMN
#define LAST
TrackedPtr< Node > * nodeval
#define YY_Parser_ERROR
#define CASE
static TrackedPtr< T > * makeEmpty()
Definition: TrackedPtr.h:81
#define YYMAXDEPTH
#define WHERE
Definition: sqltypes.h:52
Definition: sqltypes.h:53
Definition: sqldefs.h:40
#define ARRAY
#define WHEN
Definition: sqldefs.h:69
#define YYBEGINGOTO
#define IS
#define SOME
#define SCHEMA
#define CHAR_LENGTH
#define PRIVILEGES
int yyerrstatus
#define YY_Parser_LEX_BODY
#define SERVER
TrackedPtr< std::string > * stringval
static const short yytranslate[]
#define CLOSE
#define LENGTH
#define YY_Parser_CLASS
#define YYLAST
#define SET
#define CHECK
#define __ALLOCA_alloca(size)
#define TIMESTAMP
#define ORDER
Definition: sqltypes.h:41
static const short yydefgoto[]
#define DISTINCT
#define FETCH
static const short yyr1[]
#define YYTRANSLATE(x)
#define YYGOTO(lb)
#define EQUAL
#define LIKE
#define WORK
#define PROCEDURE
#define UPDATE
#define USER
#define STRING
#define OR
#define EXTRACT
#define NUMERIC
char * t
#define ARCHIVE
#define ILIKE
#define YYLEX
#define DECIMAL
#define DATE_TRUNC
#define FIXEDNUM
#define DEFAULT
#define UNIQUE
char * f
#define GEOGRAPHY
#define YYINITDEPTH
#define DATETIME
#define POLYGON
#define CAST
Definition: sqltypes.h:45
#define COPY
static const short yycheck[]
static const short yydefact[]
#define YY_Parser_PARSE
#define AND
#define TABLE
#define FLOAT
#define OF
#define DECLARE
#define OPTIMIZED
Definition: sqldefs.h:39
YYBEGINGOTO yystate
if(yyssp >=yyss+yystacksize-1)
#define UMINUS
#define __ALLOCA_free(ptr, ref)
#define INTO
#define ALL
#define AS
#define LANGUAGE
#define SELECT
#define YYENDDECLARELABEL
TrackedListPtr< std::string > * slistval
#define YYEOF
#define BOOLEAN
#define YY_Parser_NERRS
TrackedListPtr< Node > * listval
#define INTEGER
#define ACCESS