YugabyteDB (2.13.1.0-b60, 21121d69985fbf76aa6958d8f04a9bfa936293b5)

// A Bison parser, made by GNU Bison 3.4.1.

// Skeleton implementation for Bison LALR(1) parsers in C++

// Copyright (C) 2002-2015, 2018-2019 Free Software Foundation, Inc.

// This program is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

// This program is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

// As a special exception, you may create a larger work that contains

// part or all of the Bison parser skeleton and distribute that work

// under terms of your choice, so long as that work isn't itself a

// parser generator using the skeleton or a modified version thereof

// as a parser skeleton.  Alternatively, if you modify or redistribute

// the parser skeleton itself, you may (at your option) remove this

// special exception, which will cause the skeleton and the resulting

// Bison output files to be licensed under the GNU General Public

// License without this special exception.

// This special exception was added by the Free Software Foundation in

// version 2.2 of Bison.

// Undocumented macros, especially those whose name start with YY_,

// are private implementation details.  Do not rely on them.

// First part of user prologue.

#line 1 "parser_gram.y"

//--------------------------------------------------------------------------------------------------

// Portions Copyright (c) YugaByte, Inc.

// Portions Copyright (c) 1996-2015, PostgreSQL Global Development Group

// Portions Copyright (c) 1994, Regents of the University of California

//

// POSTGRESQL BISON rules/actions

//

// NOTES

//    CAPITALS are used to represent terminal symbols.

//    non-capitals are used to represent non-terminals.

//

//    In general, nothing in this file should initiate database accesses

//    nor depend on changeable state (such as SET variables).  If you do

//    database accesses, your code will fail when we have aborted the

//    current transaction and are just parsing commands to find the next

//    ROLLBACK or COMMIT.  If you make use of SET variables, then you

//    will do the wrong thing in multi-query strings like this:

//      SET SQL_inheritance TO off; SELECT * FROM foo;

//    because the entire string is parsed by gram.y before the SET gets

//    executed.  Anything that depends on the database or changeable state

//    should be handled during parse analysis so that it happens at the

//    right time not the wrong time.  The handling of SQL_inheritance is

//    a good example.

//--------------------------------------------------------------------------------------------------

#line 67 "/Users/deen/code/yugabyte-db/build/debugcov-clang-dynamic-arm64-ninja/src/yb/yql/cql/ql/parser/parser_gram.y.cc"

#include "parser_gram.y.final.hh"

// Unqualified %code blocks.

#line 178 "parser_gram.y"

#include <stdio.h>

#include <string.h>

#include <gflags/gflags.h>

#include "yb/yql/cql/ql/parser/parser.h"

#include "yb/yql/cql/ql/parser/scanner_util.h"

#include "yb/util/stol_utils.h"

using namespace std;

using namespace yb::ql;

#undef yylex

#define yylex parser_->Scan

#define PTREE_MEM parser_->PTreeMem()

#define PTREE_LOC(loc) Location::MakeShared(PTREE_MEM, loc)

#define MAKE_NODE(loc, node, ...) node::MakeShared(PTREE_MEM, PTREE_LOC(loc), ##__VA_ARGS__)

// This allows nested MAKE_NODE macros since it doesn't have ##__VA_ARGS__ and requires atleast

// one variable argument.

#define NESTED_MAKE_NODE(loc, node, ...)  MAKE_NODE(loc, node, __VA_ARGS__)

#define PARSER_ERROR(loc, code) parser_->Error(loc, ErrorCode:##:code)

#define PARSER_ERROR_MSG(loc, code, msg) parser_->Error(loc, msg, ErrorCode:##:code)

#define PARSER_INVALID(loc) parser_->Error(loc, ErrorCode::SQL_STATEMENT_INVALID)

#define PARSER_UNSUPPORTED(loc) parser_->Error(loc, ErrorCode::FEATURE_NOT_SUPPORTED)

#define PARSER_NOCODE(loc) parser_->Error(loc, ErrorCode::FEATURE_NOT_YET_IMPLEMENTED)

#define PARSER_CQL_INVALID(loc) parser_->Error(loc, ErrorCode::CQL_STATEMENT_INVALID)

#define PARSER_CQL_INVALID_MSG(loc, msg) parser_->Error(loc, msg, ErrorCode::CQL_STATEMENT_INVALID)

#line 108 "/Users/deen/code/yugabyte-db/build/debugcov-clang-dynamic-arm64-ninja/src/yb/yql/cql/ql/parser/parser_gram.y.cc"

#ifndef YY_

# if defined YYENABLE_NLS && YYENABLE_NLS

#  if ENABLE_NLS

#   include <libintl.h> // FIXME: INFRINGES ON USER NAME SPACE.

#   define YY_(msgid) dgettext ("bison-runtime", msgid)

#  endif

# endif

# ifndef YY_

#  define YY_(msgid) msgid

# endif

#endif

// Whether we are compiled with exception support.

#ifndef YY_EXCEPTIONS

# if defined __GNUC__ && !defined __EXCEPTIONS

#  define YY_EXCEPTIONS 0

# else

#  define YY_EXCEPTIONS 1

# endif

#endif

#define YYRHSLOC(Rhs, K) ((Rhs)[K].location)

/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].

   If N is 0, then set CURRENT to the empty location which ends

   the previous symbol: RHS[0] (always defined).  */

# ifndef YYLLOC_DEFAULT

#  define YYLLOC_DEFAULT(Current, Rhs, N)                               \

    do                                                                  \

      if (N)                                                            \

        {                                                               \

          (Current).begin  = YYRHSLOC (Rhs, 1).begin;                   \

          (Current).end    = YYRHSLOC (Rhs, N).end;                     \

        }                                                               \

      else                                                              \

        {                                                               \

          (Current).begin = (Current).end = YYRHSLOC (Rhs, 0).end;      \

        }                                                               \

    while (false)

# endif

// Suppress unused-variable warnings by "using" E.

#define YYUSE(E) ((void) (E))

// Enable debugging if requested.

#if YYDEBUG

// A pseudo ostream that takes yydebug_ into account.

# define YYCDEBUG if (yydebug_) 
(*yycdebug_)0

# define YY_SYMBOL_PRINT(Title, Symbol)         \

  do {                                          \

    if (yydebug_)                               \

    {                                           \

      *yycdebug_ << Title << ' ';               \

      yy_print_ (*yycdebug_, Symbol);           \

      *yycdebug_ << '\n';                       \

    }                                           \

  } while (false)

# define YY_REDUCE_PRINT(Rule)          \

  do {                                  \

    if (yydebug_)                       \

      
yy_reduce_print_ (Rule)0
;          \

  } while (false)

# define YY_STACK_PRINT()               \

  do {                                  \

    if (yydebug_)                       \

      
yystack_print_ ()0
;                \

  } while (false)

#else // !YYDEBUG

# define YYCDEBUG if (false) std::cerr

# define YY_SYMBOL_PRINT(Title, Symbol)  YYUSE (Symbol)

# define YY_REDUCE_PRINT(Rule)           static_cast<void> (0)

# define YY_STACK_PRINT()                static_cast<void> (0)

#endif // !YYDEBUG

#define yyerrok         (yyerrstatus_ = 0)

#define yyclearin       (yyla.clear ())

#define YYACCEPT        goto yyacceptlab

#define YYABORT         goto yyabortlab

#define YYERROR         goto yyerrorlab

#define YYRECOVERING()  (!!yyerrstatus_)

#line 52 "parser_gram.y"

namespace yb { namespace ql {

#line 203 "/Users/deen/code/yugabyte-db/build/debugcov-clang-dynamic-arm64-ninja/src/yb/yql/cql/ql/parser/parser_gram.y.cc"

  /* Return YYSTR after stripping away unnecessary quotes and

     backslashes, so that it's suitable for yyerror.  The heuristic is

     that double-quoting is unnecessary unless the string contains an

     apostrophe, a comma, or backslash (other than backslash-backslash).

     YYSTR is taken from yytname.  */

  std::string

  GramProcessor::yytnamerr_ (const char *yystr)

  {

    if (*yystr == '"')

      {

        std::string yyr;

        char const *yyp = yystr;

        for (;;)

          switch (*++yyp)

            {

            case '\'':

            case ',':

              goto do_not_strip_quotes;

            case '\\':

              if (*++yyp != '\\')

                goto do_not_strip_quotes;

              else

                goto append;

            append:

            default:

              yyr += *yyp;

              break;

            case '"':

              return yyr;

            }

      do_not_strip_quotes: ;

      }

    return yystr;

  }

  /// Build a parser object.

  GramProcessor::GramProcessor (Parser *parser__yyarg)

    :

#if YYDEBUG

      yydebug_ (false),

      yycdebug_ (&std::cerr),

#endif

      parser_ (parser__yyarg)

  {}

  GramProcessor::~GramProcessor ()

  {}

  GramProcessor::syntax_error::~syntax_error () YY_NOEXCEPT YY_NOTHROW

  {}

  /*---------------.

  | Symbol types.  |

  `---------------*/

  // by_state.

  GramProcessor::by_state::by_state () YY_NOEXCEPT

    : state (empty_state)

  {}

  GramProcessor::by_state::by_state (const by_state& that) YY_NOEXCEPT

    : state (that.state)

  {}

  void

  GramProcessor::by_state::clear () YY_NOEXCEPT

  {

    state = empty_state;

  }

  void

  GramProcessor::by_state::move (by_state& that)

  {

    state = that.state;

    that.clear ();

  }

  GramProcessor::by_state::by_state (state_type s) YY_NOEXCEPT

    : state (s)

  {}

  GramProcessor::symbol_number_type

  GramProcessor::by_state::type_get () const YY_NOEXCEPT

  {

    if (state == empty_state)

      return empty_symbol;

    else

      return yystos_[state];

  }

  GramProcessor::stack_symbol_type::stack_symbol_type ()

  {}

  GramProcessor::stack_symbol_type::stack_symbol_type (YY_RVREF (stack_symbol_type) that)

    : super_type (YY_MOVE (that.state), YY_MOVE (that.location))

  {

    switch (that.type_get ())

    {

      case 3: // ABORT_P

      case 4: // ABSOLUTE_P

      case 5: // ACCESS

      case 6: // ACTION

      case 7: // ADD_P

      case 8: // ADMIN

      case 9: // AFTER

      case 10: // AGGREGATE

      case 11: // ALL

      case 12: // ALLOW

      case 13: // ALSO

      case 14: // ALTER

      case 15: // ALWAYS

      case 16: // ANALYSE

      case 17: // ANALYZE

      case 18: // AND

      case 19: // ANY

      case 20: // ARRAY

      case 21: // AS

      case 22: // ASC

      case 23: // ASSERTION

      case 24: // ASSIGNMENT

      case 25: // ASYMMETRIC

      case 26: // AT

      case 27: // ATTRIBUTE

      case 28: // AUTHORIZATION

      case 29: // AUTHORIZE

      case 30: // BACKWARD

      case 31: // BEFORE

      case 32: // BEGIN_P

      case 33: // BETWEEN

      case 34: // BIGINT

      case 35: // BINARY

      case 36: // BIT

      case 37: // BLOB

      case 38: // BOOLEAN_P

      case 39: // BOTH

      case 40: // BY

      case 41: // CACHE

      case 42: // CALLED

      case 43: // CASCADE

      case 44: // CASCADED

      case 45: // CASE

      case 46: // CAST

      case 47: // CATALOG_P

      case 48: // CHAIN

      case 49: // CHAR_P

      case 50: // CHARACTER

      case 51: // CHARACTERISTICS

      case 52: // CHECK

      case 53: // CHECKPOINT

      case 54: // CLASS

      case 55: // CLOSE

      case 56: // CLUSTER

      case 57: // CLUSTERING

      case 58: // COALESCE

      case 59: // COLLATE

      case 60: // COLLATION

      case 61: // COLUMN

      case 62: // COMMENT

      case 63: // COMMENTS

      case 64: // COMMIT

      case 65: // COMMITTED

      case 66: // COMPACT

      case 67: // CONCURRENTLY

      case 68: // CONFIGURATION

      case 69: // CONFLICT

      case 70: // CONNECTION

      case 71: // CONSTRAINT

      case 72: // CONSTRAINTS

      case 73: // CONTENT_P

      case 74: // CONTINUE_P

      case 75: // CONVERSION_P

      case 76: // COPY

      case 77: // COST

      case 78: // COUNTER

      case 79: // COVERING

      case 80: // CREATE

      case 81: // CROSS

      case 82: // CSV

      case 83: // CUBE

      case 84: // CURRENT_P

      case 85: // CURRENT_CATALOG

      case 86: // CURRENT_DATE

      case 87: // CURRENT_ROLE

      case 88: // CURRENT_SCHEMA

      case 89: // CURRENT_TIME

      case 90: // CURRENT_TIMESTAMP

      case 91: // CURRENT_USER

      case 92: // CURSOR

      case 93: // CYCLE

      case 94: // DATA_P

      case 95: // DATE

      case 96: // DATABASE

      case 97: // DAY_P

      case 98: // DEALLOCATE

      case 99: // DEC

      case 100: // DECIMAL_P

      case 101: // DECLARE

      case 102: // DEFAULT

      case 103: // DEFAULTS

      case 104: // DEFERRABLE

      case 105: // DEFERRED

      case 106: // DEFINER

      case 107: // DELETE_P

      case 108: // DELIMITER

      case 109: // DELIMITERS

      case 110: // DESC

      case 111: // DESCRIBE

      case 112: // DICTIONARY

      case 113: // DISABLE_P

      case 114: // DISCARD

      case 115: // DISTINCT

      case 116: // DO

      case 117: // DOCUMENT_P

      case 118: // DOMAIN_P

      case 119: // DOUBLE_P

      case 120: // DROP

      case 121: // EACH

      case 122: // ELSE

      case 123: // ENABLE_P

      case 124: // ENCODING

      case 125: // ENCRYPTED

      case 126: // END_P

      case 127: // ENUM_P

      case 128: // ERROR

      case 129: // ESCAPE

      case 130: // EVENT

      case 131: // EXCEPT

      case 132: // EXCLUDE

      case 133: // EXCLUDING

      case 134: // EXCLUSIVE

      case 135: // EXECUTE

      case 136: // EXISTS

      case 137: // EXPLAIN

      case 138: // EXTENSION

      case 139: // EXTERNAL

      case 140: // EXTRACT

      case 141: // FALSE_P

      case 142: // FAMILY

      case 143: // FETCH

      case 144: // FILTER

      case 145: // FILTERING

      case 146: // FIRST_P

      case 147: // FLOAT_P

      case 148: // FOLLOWING

      case 149: // FOR

      case 150: // FORCE

      case 151: // FOREIGN

      case 152: // FORWARD

      case 153: // FREEZE

      case 154: // FROM

      case 155: // FROZEN

      case 156: // FULL

      case 157: // FUNCTION

      case 158: // FUNCTIONS

      case 159: // GLOBAL

      case 160: // GRANT

      case 161: // GRANTED

      case 162: // GREATEST

      case 163: // GROUP_P

      case 164: // GROUPING

      case 165: // HANDLER

      case 166: // HAVING

      case 167: // HEADER_P

      case 168: // HOLD

      case 169: // HOUR_P

      case 170: // IDENTITY_P

      case 171: // IF_P

      case 172: // ILIKE

      case 173: // IMMEDIATE

      case 174: // IMMUTABLE

      case 175: // IMPLICIT_P

      case 176: // IMPORT_P

      case 177: // IN_P

      case 178: // INCLUDE

      case 179: // INCLUDING

      case 180: // INCREMENT

      case 181: // INDEX

      case 182: // INDEXES

      case 183: // INET

      case 184: // INFINITY

      case 185: // INHERIT

      case 186: // INHERITS

      case 187: // INITIALLY

      case 188: // INLINE_P

      case 189: // INNER_P

      case 190: // INOUT

      case 191: // INPUT_P

      case 192: // INSENSITIVE

      case 193: // INSERT

      case 194: // INSTEAD

      case 195: // INT_P

      case 196: // INTEGER

      case 197: // INTERSECT

      case 198: // INTERVAL

      case 199: // INTO

      case 200: // INVOKER

      case 201: // IS

      case 202: // ISNULL

      case 203: // ISOLATION

      case 204: // JOIN

      case 205: // JSON

      case 206: // JSONB

      case 207: // KEY

      case 208: // KEYSPACE

      case 209: // KEYSPACES

      case 210: // LABEL

      case 211: // LANGUAGE

      case 212: // LARGE_P

      case 213: // LAST_P

      case 214: // LATERAL_P

      case 215: // LEADING

      case 216: // LEAKPROOF

      case 217: // LEAST

      case 218: // LEFT

      case 219: // LEVEL

      case 220: // LIKE

      case 221: // LIMIT

      case 222: // LIST

      case 223: // LISTEN

      case 224: // LOAD

      case 225: // LOCAL

      case 226: // LOCALTIME

      case 227: // LOCALTIMESTAMP

      case 228: // LOCATION

      case 229: // LOCK_P

      case 230: // LOCKED

      case 231: // LOGGED

      case 232: // LOGIN

      case 233: // MAP

      case 234: // MAPPING

      case 235: // MATCH

      case 236: // MATERIALIZED

      case 237: // MAXVALUE

      case 238: // MINUTE_P

      case 239: // MINVALUE

      case 240: // MODE

      case 241: // MODIFY

      case 242: // MONTH_P

      case 243: // MOVE

      case 244: // NAME_P

      case 245: // NAMES

      case 246: // NAN

      case 247: // NATIONAL

      case 248: // NATURAL

      case 249: // NCHAR

      case 250: // NEXT

      case 251: // NO

      case 252: // NONE

      case 253: // NOT

      case 254: // NOTHING

      case 255: // NOTIFY

      case 256: // NOTNULL

      case 257: // NOWAIT

      case 258: // NULL_P

      case 259: // NULLIF

      case 260: // NULLS_P

      case 261: // NUMERIC

      case 262: // OBJECT_P

      case 263: // OF

      case 264: // OFF

      case 265: // OFFSET

      case 266: // OIDS

      case 267: // ON

      case 268: // ONLY

      case 269: // OPERATOR

      case 270: // OPTION

      case 271: // OPTIONS

      case 272: // OR

      case 273: // ORDER

      case 274: // ORDINALITY

      case 275: // OUT_P

      case 276: // OUTER_P

      case 277: // OVER

      case 278: // OVERLAPS

      case 279: // OVERLAY

      case 280: // OWNED

      case 281: // OWNER

      case 282: // PARSER

      case 283: // PARTIAL

      case 284: // PARTITION

      case 285: // PASSING

      case 286: // PASSWORD

      case 287: // PERMISSION

      case 288: // PERMISSIONS

      case 289: // PLACING

      case 290: // PLANS

      case 291: // POLICY

      case 292: // POSITION

      case 293: // PRECEDING

      case 294: // PRECISION

      case 295: // PRESERVE

      case 296: // PREPARE

      case 297: // PREPARED

      case 298: // PRIMARY

      case 299: // PRIOR

      case 300: // PRIVILEGES

      case 301: // PROCEDURAL

      case 302: // PROCEDURE

      case 303: // PROGRAM

      case 304: // QUOTE

      case 305: // RANGE

      case 306: // READ

      case 307: // REAL

      case 308: // REASSIGN

      case 309: // RECHECK

      case 310: // RECURSIVE

      case 311: // REF

      case 312: // REFRESH

      case 313: // REINDEX

      case 314: // RELATIVE_P

      case 315: // RELEASE

      case 316: // RENAME

      case 317: // REPEATABLE

      case 318: // REPLACE

      case 319: // REPLICA

      case 320: // RESET

      case 321: // RESTART

      case 322: // RESTRICT

      case 323: // RETURNING

      case 324: // RETURNS

      case 325: // REVOKE

      case 326: // RIGHT

      case 327: // ROLE

      case 328: // ROLES

      case 329: // ROLLBACK

      case 330: // ROLLUP

      case 331: // ROW

      case 332: // ROWS

      case 333: // RULE

      case 334: // SAVEPOINT

      case 335: // SCHEMA

      case 336: // SCHEME

      case 337: // SCROLL

      case 338: // SEARCH

      case 339: // SECOND_P

      case 340: // SECURITY

      case 341: // SELECT

      case 342: // SEQUENCE

      case 343: // SEQUENCES

      case 344: // SERIALIZABLE

      case 345: // SERVER

      case 346: // SESSION

      case 347: // SESSION_USER

      case 348: // SET

      case 349: // SETS

      case 350: // SETOF

      case 351: // SHARE

      case 352: // SHOW

      case 353: // SIMILAR

      case 354: // SIMPLE

      case 355: // SKIP

      case 356: // SMALLINT

      case 357: // SNAPSHOT

      case 358: // SOME

      case 359: // SQL_P

      case 360: // STABLE

      case 361: // STANDALONE_P

      case 362: // START

      case 363: // STATEMENT

      case 364: // STATIC

      case 365: // STATISTICS

      case 366: // STATUS

      case 367: // STDIN

      case 368: // STDOUT

      case 369: // STORAGE

      case 370: // STRICT_P

      case 371: // STRIP_P

      case 372: // SUBSTRING

      case 373: // SUPERUSER

      case 374: // SYMMETRIC

      case 375: // SYSID

      case 376: // SYSTEM_P

      case 377: // TABLE

      case 378: // TABLES

      case 379: // TABLESAMPLE

      case 380: // TABLESPACE

      case 381: // TEMP

      case 382: // TEMPLATE

      case 383: // TEMPORARY

      case 384: // TEXT_P

      case 385: // THEN

      case 386: // TIME

      case 387: // TIMESTAMP

      case 388: // TIMEUUID

      case 389: // TINYINT

      case 390: // TO

      case 391: // TOKEN

      case 392: // TRAILING

      case 393: // TRANSACTION

      case 394: // TRANSFORM

      case 395: // TREAT

      case 396: // TRIGGER

      case 397: // TRIM

      case 398: // TRUE_P

      case 399: // TRUNCATE

      case 400: // TRUSTED

      case 401: // TTL

      case 402: // TUPLE

      case 403: // TYPE_P

      case 404: // TYPES_P

      case 405: // PARTITION_HASH

      case 406: // UNBOUNDED

      case 407: // UNCOMMITTED

      case 408: // UNENCRYPTED

      case 409: // UNION

      case 410: // UNIQUE

      case 411: // UNKNOWN

      case 412: // UNLISTEN

      case 413: // UNLOGGED

      case 414: // UNSET

      case 415: // UNTIL

      case 416: // UPDATE

      case 417: // USE

      case 418: // USER

      case 419: // USING

      case 420: // UUID

      case 421: // VACUUM

      case 422: // VALID

      case 423: // VALIDATE

      case 424: // VALIDATOR

      case 425: // VALUE_P

      case 426: // VALUES

      case 427: // VARCHAR

      case 428: // VARIADIC

      case 429: // VARINT

      case 430: // VARYING

      case 431: // VERBOSE

      case 432: // VERSION_P

      case 433: // VIEW

      case 434: // VIEWS

      case 435: // VOLATILE

      case 436: // WHEN

      case 437: // WHERE

      case 438: // WHITESPACE_P

      case 439: // WINDOW

      case 440: // WITH

      case 441: // WITHIN

      case 442: // WITHOUT

      case 443: // WORK

      case 444: // WRAPPER

      case 445: // WRITE

      case 446: // XML_P

      case 447: // XMLATTRIBUTES

      case 448: // XMLCONCAT

      case 449: // XMLELEMENT

      case 450: // XMLEXISTS

      case 451: // XMLFOREST

      case 452: // XMLPARSE

      case 453: // XMLPI

      case 454: // XMLROOT

      case 455: // XMLSERIALIZE

      case 456: // YEAR_P

      case 457: // YES_P

      case 458: // ZONE

      case 729: // all_Op

      case 730: // MathOp

      case 739: // extract_arg

      case 815: // unreserved_keyword

      case 816: // col_name_keyword

      case 817: // type_func_name_keyword

      case 818: // reserved_keyword

      case 844: // iso_level

      case 845: // opt_boolean_or_string

      case 847: // opt_encoding

      case 953: // RowSecurityDefaultForCmd

      case 954: // row_security_cmd

        value.YY_MOVE_OR_COPY< KeywordType > (YY_MOVE (that.value));

        break;

      case 655: // set_clause

      case 656: // single_set_clause

        value.YY_MOVE_OR_COPY< PAssign > (YY_MOVE (that.value));

        break;

      case 654: // set_clause_list

        value.YY_MOVE_OR_COPY< PAssignListNode > (YY_MOVE (that.value));

        break;

      case 538: // opt_no_inherit

      case 601: // opt_json_clause_default_null

      case 605: // all_or_distinct

      case 615: // opt_allow_filtering

      case 640: // opt_returns_clause

      case 686: // opt_else_clause

      case 687: // opt_ordinality

      case 711: // xml_whitespace_option

      case 808: // opt_varying

      case 812: // opt_timezone

      case 825: // boolean

      case 857: // constraints_set_mode

      case 873: // copy_from

      case 874: // opt_program

      case 890: // opt_with_data

      case 903: // opt_trusted

      case 959: // TriggerForSpec

      case 961: // TriggerForType

      case 988: // opt_if_not_exists

      case 992: // opt_default

      case 995: // opt_recheck

      case 1005: // opt_restart_seqs

      case 1028: // opt_grant_grant_option

      case 1038: // opt_deferred

      case 1039: // opt_unique

      case 1040: // opt_concurrently

      case 1052: // opt_or_replace

      case 1088: // opt_if_exists

      case 1109: // opt_instead

      case 1147: // opt_verbose

      case 1148: // opt_full

      case 1149: // opt_freeze

      case 1162: // opt_nowait

        value.YY_MOVE_OR_COPY< PBool > (YY_MOVE (that.value));

        break;

      case 468: // CCONST

      case 974: // enable_trigger

        value.YY_MOVE_OR_COPY< PChar > (YY_MOVE (that.value));

        break;

      case 803: // Character

      case 804: // ConstCharacter

      case 805: // CharacterWithLength

      case 806: // CharacterWithoutLength

      case 807: // character

        value.YY_MOVE_OR_COPY< PCharBaseType > (YY_MOVE (that.value));

        break;

      case 594: // SelectStmt

      case 595: // select_with_parens

      case 596: // select_no_parens

      case 597: // select_clause

        value.YY_MOVE_OR_COPY< PCollection > (YY_MOVE (that.value));

        break;

      case 768: // map_elems

      case 769: // map_expr

      case 770: // set_elems

      case 771: // set_expr

      case 772: // list_elems

      case 773: // list_expr

      case 774: // tuple_elems

      case 775: // tuple_expr

        value.YY_MOVE_OR_COPY< PCollectionExpr > (YY_MOVE (that.value));

        break;

      case 646: // opt_using_ttl_timestamp_clause

      case 647: // using_ttl_timestamp_clause

      case 648: // recursive_ttl_timestamp_clause

        value.YY_MOVE_OR_COPY< PDmlUsingClause > (YY_MOVE (that.value));

        break;

      case 649: // ttl_timestamp_clause

        value.YY_MOVE_OR_COPY< PDmlUsingClauseElement > (YY_MOVE (that.value));

        break;

      case 666: // write_dml_property_map_list_element

        value.YY_MOVE_OR_COPY< PDmlWriteProperty > (YY_MOVE (that.value));

        break;

      case 661: // opt_write_dml_properties

      case 662: // write_dml_properties

      case 663: // write_dml_property

        value.YY_MOVE_OR_COPY< PDmlWritePropertyListNode > (YY_MOVE (that.value));

        break;

      case 664: // write_dml_property_map

      case 665: // write_dml_property_map_list

        value.YY_MOVE_OR_COPY< PDmlWritePropertyMap > (YY_MOVE (that.value));

        break;

      case 614: // target_el