{

std::multimap<sqlb::IndexedColumnVector, std::shared_ptr<sqlb::UniqueConstraint>> index;

std::multimap<sqlb::StringVector, std::shared_ptr<sqlb::ForeignKeyClause>> fk;

std::vector<std::shared_ptr<sqlb::CheckConstraint>> check;

{

public:

/// Type of *this.

typedef value_type self_type;

/// Empty construction.

value_type () YY_NOEXCEPT

: yyraw_ ()

, yytypeid_ (YY_NULLPTR)

{}

/// Construct and fill.

template <typename T>

value_type (YY_RVREF (T) t)

: yytypeid_ (&typeid (T))

{

YY_ASSERT (sizeof (T) <= size);

new (yyas_<T> ()) T (YY_MOVE (t));

}

#if 201103L <= YY_CPLUSPLUS

/// Non copyable.

value_type (const self_type&) = delete;

/// Non copyable.

self_type& operator= (const self_type&) = delete;

#endif

/// Destruction, allowed only if empty.

~value_type () YY_NOEXCEPT

{

YY_ASSERT (!yytypeid_);

}

# if 201103L <= YY_CPLUSPLUS

/// Instantiate a \a T in here from \a t.

template <typename T, typename... U>

T&

emplace (U&&... u)

{

YY_ASSERT (!yytypeid_);

YY_ASSERT (sizeof (T) <= size);

yytypeid_ = & typeid (T);

return *new (yyas_<T> ()) T (std::forward <U>(u)...);

}

# else

/// Instantiate an empty \a T in here.

template <typename T>

T&

emplace ()

{

YY_ASSERT (!yytypeid_);

YY_ASSERT (sizeof (T) <= size);

yytypeid_ = & typeid (T);

return *new (yyas_<T> ()) T ();

}

/// Instantiate a \a T in here from \a t.

template <typename T>

T&

emplace (const T& t)

{

YY_ASSERT (!yytypeid_);

YY_ASSERT (sizeof (T) <= size);

yytypeid_ = & typeid (T);

return *new (yyas_<T> ()) T (t);

}

# endif

/// Instantiate an empty \a T in here.

/// Obsolete, use emplace.

template <typename T>

T&

build ()

{

return emplace<T> ();

}

/// Instantiate a \a T in here from \a t.

/// Obsolete, use emplace.

template <typename T>

T&

build (const T& t)

{

return emplace<T> (t);

}

/// Accessor to a built \a T.

template <typename T>

T&

as () YY_NOEXCEPT

{

YY_ASSERT (yytypeid_);

YY_ASSERT (*yytypeid_ == typeid (T));

YY_ASSERT (sizeof (T) <= size);

return *yyas_<T> ();

}

/// Const accessor to a built \a T (for %printer).

template <typename T>

const T&

as () const YY_NOEXCEPT

{

YY_ASSERT (yytypeid_);

YY_ASSERT (*yytypeid_ == typeid (T));

YY_ASSERT (sizeof (T) <= size);

return *yyas_<T> ();

}

/// Swap the content with \a that, of same type.

///

/// Both variants must be built beforehand, because swapping the actual

/// data requires reading it (with as()), and this is not possible on

/// unconstructed variants: it would require some dynamic testing, which

/// should not be the variant's responsibility.

/// Swapping between built and (possibly) non-built is done with

/// self_type::move ().

template <typename T>

void

swap (self_type& that) YY_NOEXCEPT

{

YY_ASSERT (yytypeid_);

YY_ASSERT (*yytypeid_ == *that.yytypeid_);

std::swap (as<T> (), that.as<T> ());

}

/// Move the content of \a that to this.

///

/// Destroys \a that.

template <typename T>

void

move (self_type& that)

{

# if 201103L <= YY_CPLUSPLUS

emplace<T> (std::move (that.as<T> ()));

# else

emplace<T> ();

swap<T> (that);

# endif

that.destroy<T> ();

}

# if 201103L <= YY_CPLUSPLUS

/// Move the content of \a that to this.

template <typename T>

void

move (self_type&& that)

{

emplace<T> (std::move (that.as<T> ()));

that.destroy<T> ();

}

#endif

/// Copy the content of \a that to this.

template <typename T>

void

copy (const self_type& that)

{

emplace<T> (that.as<T> ());

}

/// Destroy the stored \a T.

template <typename T>

void

destroy ()

{

as<T> ().~T ();

yytypeid_ = YY_NULLPTR;

}

private:

#if YY_CPLUSPLUS < 201103L

/// Non copyable.

value_type (const self_type&);

/// Non copyable.

self_type& operator= (const self_type&);

#endif

/// Accessor to raw memory as \a T.

template <typename T>

T*

yyas_ () YY_NOEXCEPT

{

void *yyp = yyraw_;

return static_cast<T*> (yyp);

}

/// Const accessor to raw memory as \a T.

template <typename T>

const T*

yyas_ () const YY_NOEXCEPT

{

const void *yyp = yyraw_;

return static_cast<const T*> (yyp);

}

/// An auxiliary type to compute the largest semantic type.

union union_type

{

// columndef_list

char dummy1[sizeof (ColumnList)];

// columnconstraint_list

// tableconstraint

// tableconstraint_list

// optional_tableconstraint_list

char dummy2[sizeof (TableConstraints)];

// optional_if_not_exists

// optional_unique

// optional_temporary

// optional_always_generated

char dummy3[sizeof (bool)];

// createindex_stmt

char dummy4[sizeof (sqlb::IndexPtr)];

// indexed_column

char dummy5[sizeof (sqlb::IndexedColumn)];

// indexed_column_list

char dummy6[sizeof (sqlb::IndexedColumnVector)];

// columnid_list

// optional_columnid_with_paren_list

char dummy7[sizeof (sqlb::StringVector)];

// createvirtualtable_stmt

// createtable_stmt

char dummy8[sizeof (sqlb::TablePtr)];

// tableoption

// tableoptions_list

// optional_tableoptions_list

char dummy9[sizeof (std::bitset<sqlb::Table::NumOptions>)];

// columnconstraint

char dummy10[sizeof (std::pair<std::shared_ptr<sqlb::PrimaryKeyConstraint>, std::shared_ptr<sqlb::ForeignKeyClause>>)];

// columndef

char dummy11[sizeof (std::shared_ptr<sqlb::Field>)];

// "ABORT"

// "ACTION"

// "ALWAYS"

// "AND"

// "AND BETWEEN"

// "AS"

// "ASC"

// "AUTOINCREMENT"

// "BETWEEN"

// "CASCADE"

// "CASE"

// "CAST"

// "CHECK"

// "COLLATE"

// "CONFLICT"

// "CONSTRAINT"

// "CREATE"

// "CURRENT_DATE"

// "CURRENT_TIME"

// "CURRENT_TIMESTAMP"

// "DEFAULT"

// "DEFERRABLE"

// "DEFERRED"

// "DELETE"

// "DESC"

// "DISTINCT"

// "ELSE"

// "END"

// "ESCAPE"

// "EXISTS"

// "FAIL"

// "FALSE"

// "FILTER"

// "FOLLOWING"

// "FOREIGN"

// "FROM"

// "GENERATED"

// "GLOB"

// "IF"

// "IGNORE"

// "IMMEDIATE"

// "IN"

// "INDEX"

// "INITIALLY"

// "INSERT"

// "IS"

// "ISNULL"

// "KEY"

// "LIKE"

// "MATCH"

// "NO"

// "NOT"

// "NOTNULL"

// "NULL"

// "ON"

// "OR"

// "OVER"

// "PARTITION"

// "PRECEDING"

// "PRIMARY"

// "RAISE"

// "RANGE"

// "REFERENCES"

// "REGEXP"

// "REPLACE"

// "RESTRICT"

// "RETURNING"

// "ROLLBACK"

// "ROWID"

// "ROWS"

// "SELECT"

// "SET"

// "STORED"

// "STRICT"

// "TABLE"

// "TEMP"

// "TEMPORARY"

// "THEN"

// "TRUE"

// "UNBOUNDED"

// "UNIQUE"

// "UPDATE"

// "USING"

// "VIRTUAL"

// "WHEN"

// "WHERE"

// "WITHOUT"

// "identifier"

// "numeric"

// "string literal"

// "quoted literal"

// "blob literal"

// "bind parameter"

// literalvalue

// id

// allowed_keywords_as_identifier

// tableid

// columnid

// signednumber

// signednumber_or_numeric

// typename_namelist

// type_name

// unary_expr

// binary_expr

// like_expr

// exprlist_expr

// function_expr

// isnull_expr

// between_expr

// in_expr

// whenthenlist_expr

// case_expr

// raise_expr

// expr

// select_stmt

// optional_sort_order

// optional_where

// tableid_with_uninteresting_schema

// optional_exprlist_with_paren

// optional_conflictclause

// optional_typename

// optional_storage_identifier

// optional_constraintname

// fk_clause_part

// fk_clause_part_list

// optional_fk_clause

char dummy12[sizeof (std::string)];

};

/// The size of the largest semantic type.

enum { size = sizeof (union_type) };

/// A buffer to store semantic values.

union

{

/// Strongest alignment constraints.

long double yyalign_me_;

/// A buffer large enough to store any of the semantic values.

char yyraw_[size];

};

/// Whether the content is built: if defined, the name of the stored type.

const std::type_info *yytypeid_;

{

syntax_error (const location_type& l, const std::string& m)

: std::runtime_error (m)

, location (l)

{}

syntax_error (const syntax_error& s)

: std::runtime_error (s.what ())

, location (s.location)

{}

~syntax_error () YY_NOEXCEPT YY_NOTHROW;

location_type location;

{

enum token_kind_type

{

TOK_YYEMPTY = -2,

TOK_EOF = 0, // "end of file"

TOK_YYerror = 256, // error

TOK_YYUNDEF = 257, // "invalid token"

TOK_LPAREN = 258, // "("

TOK_RPAREN = 259, // ")"

TOK_DOT = 260, // "."

TOK_COMMA = 261, // ","

TOK_SEMI = 262, // ";"

TOK_PLUS = 263, // "+"

TOK_MINUS = 264, // "-"

TOK_STAR = 265, // "*"

TOK_SLASH = 266, // "/"

TOK_TILDE = 267, // "~"

TOK_AMPERSAND = 268, // "&"

TOK_PERCENT = 269, // "%"

TOK_BITOR = 270, // "|"

TOK_OROP = 271, // "||"

TOK_EQUAL = 272, // "="

TOK_EQUAL2 = 273, // "=="

TOK_GREATER = 274, // ">"

TOK_GREATEREQUAL = 275, // ">="

TOK_LOWER = 276, // "<"

TOK_LOWEREQUAL = 277, // "<="

TOK_UNEQUAL = 278, // "!="

TOK_UNEQUAL2 = 279, // "<>"

TOK_BITWISELEFT = 280, // "<<"

TOK_BITWISERIGHT = 281, // ">>"

TOK_ABORT = 282, // "ABORT"

TOK_ACTION = 283, // "ACTION"

TOK_ALWAYS = 284, // "ALWAYS"

TOK_AND = 285, // "AND"

TOK_AND_BETWEEN = 286, // "AND BETWEEN"

TOK_AS = 287, // "AS"

TOK_ASC = 288, // "ASC"

TOK_AUTOINCREMENT = 289, // "AUTOINCREMENT"

TOK_BETWEEN = 290, // "BETWEEN"

TOK_CASCADE = 291, // "CASCADE"

TOK_CASE = 292, // "CASE"

TOK_CAST = 293, // "CAST"

TOK_CHECK = 294, // "CHECK"

TOK_COLLATE = 295, // "COLLATE"

TOK_CONFLICT = 296, // "CONFLICT"

TOK_CONSTRAINT = 297, // "CONSTRAINT"

TOK_CREATE = 298, // "CREATE"

TOK_CURRENT_DATE = 299, // "CURRENT_DATE"

TOK_CURRENT_TIME = 300, // "CURRENT_TIME"

TOK_CURRENT_TIMESTAMP = 301, // "CURRENT_TIMESTAMP"

TOK_DEFAULT = 302, // "DEFAULT"

TOK_DEFERRABLE = 303, // "DEFERRABLE"

TOK_DEFERRED = 304, // "DEFERRED"

TOK_DELETE = 305, // "DELETE"

TOK_DESC = 306, // "DESC"

TOK_DISTINCT = 307, // "DISTINCT"

TOK_ELSE = 308, // "ELSE"

TOK_END = 309, // "END"

TOK_ESCAPE = 310, // "ESCAPE"

TOK_EXISTS = 311, // "EXISTS"

TOK_FAIL = 312, // "FAIL"

TOK_FALSE = 313, // "FALSE"

TOK_FILTER = 314, // "FILTER"

TOK_FOLLOWING = 315, // "FOLLOWING"

TOK_FOREIGN = 316, // "FOREIGN"

TOK_FROM = 317, // "FROM"

TOK_GENERATED = 318, // "GENERATED"

TOK_GLOB = 319, // "GLOB"

TOK_IF = 320, // "IF"

TOK_IGNORE = 321, // "IGNORE"

TOK_IMMEDIATE = 322, // "IMMEDIATE"

TOK_IN = 323, // "IN"

TOK_INDEX = 324, // "INDEX"

TOK_INITIALLY = 325, // "INITIALLY"

TOK_INSERT = 326, // "INSERT"

TOK_IS = 327, // "IS"

TOK_ISNULL = 328, // "ISNULL"

TOK_KEY = 329, // "KEY"

TOK_LIKE = 330, // "LIKE"

TOK_MATCH = 331, // "MATCH"

TOK_NO = 332, // "NO"

TOK_NOT = 333, // "NOT"

TOK_NOTNULL = 334, // "NOTNULL"

TOK_NULL = 335, // "NULL"

TOK_ON = 336, // "ON"

TOK_OR = 337, // "OR"

TOK_OVER = 338, // "OVER"

TOK_PARTITION = 339, // "PARTITION"

TOK_PRECEDING = 340, // "PRECEDING"

TOK_PRIMARY = 341, // "PRIMARY"

TOK_RAISE = 342, // "RAISE"

TOK_RANGE = 343, // "RANGE"

TOK_REFERENCES = 344, // "REFERENCES"

TOK_REGEXP = 345, // "REGEXP"

TOK_REPLACE = 346, // "REPLACE"

TOK_RESTRICT = 347, // "RESTRICT"

TOK_RETURNING = 348, // "RETURNING"

TOK_ROLLBACK = 349, // "ROLLBACK"

TOK_ROWID = 350, // "ROWID"

TOK_ROWS = 351, // "ROWS"

TOK_SELECT = 352, // "SELECT"

TOK_SET = 353, // "SET"

TOK_STORED = 354, // "STORED"

TOK_STRICT = 355, // "STRICT"

TOK_TABLE = 356, // "TABLE"

TOK_TEMP = 357, // "TEMP"

TOK_TEMPORARY = 358, // "TEMPORARY"

TOK_THEN = 359, // "THEN"

TOK_TRUE = 360, // "TRUE"

TOK_UNBOUNDED = 361, // "UNBOUNDED"

TOK_UNIQUE = 362, // "UNIQUE"

TOK_UPDATE = 363, // "UPDATE"

TOK_USING = 364, // "USING"

TOK_VIRTUAL = 365, // "VIRTUAL"

TOK_WHEN = 366, // "WHEN"

TOK_WHERE = 367, // "WHERE"

TOK_WITHOUT = 368, // "WITHOUT"

TOK_IDENTIFIER = 369, // "identifier"

TOK_NUMERIC = 370, // "numeric"

TOK_STRINGLITERAL = 371, // "string literal"

TOK_QUOTEDLITERAL = 372, // "quoted literal"

TOK_BLOBLITERAL = 373, // "blob literal"

TOK_BINDPARAMETER = 374 // "bind parameter"

};

/// Backward compatibility alias (Bison 3.6).

typedef token_kind_type yytokentype;

{

enum symbol_kind_type

{

YYNTOKENS = 120, ///< Number of tokens.

S_YYEMPTY = -2,

S_YYEOF = 0, // "end of file"

S_YYerror = 1, // error

S_YYUNDEF = 2, // "invalid token"

S_LPAREN = 3, // "("

S_RPAREN = 4, // ")"

S_DOT = 5, // "."

S_COMMA = 6, // ","

S_SEMI = 7, // ";"

S_PLUS = 8, // "+"

S_MINUS = 9, // "-"

S_STAR = 10, // "*"

S_SLASH = 11, // "/"

S_TILDE = 12, // "~"

S_AMPERSAND = 13, // "&"

S_PERCENT = 14, // "%"

S_BITOR = 15, // "|"

S_OROP = 16, // "||"

S_EQUAL = 17, // "="

S_EQUAL2 = 18, // "=="

S_GREATER = 19, // ">"

S_GREATEREQUAL = 20, // ">="

S_LOWER = 21, // "<"

S_LOWEREQUAL = 22, // "<="

S_UNEQUAL = 23, // "!="

S_UNEQUAL2 = 24, // "<>"

S_BITWISELEFT = 25, // "<<"

S_BITWISERIGHT = 26, // ">>"

S_ABORT = 27, // "ABORT"

S_ACTION = 28, // "ACTION"

S_ALWAYS = 29, // "ALWAYS"

S_AND = 30, // "AND"

S_AND_BETWEEN = 31, // "AND BETWEEN"

S_AS = 32, // "AS"

S_ASC = 33, // "ASC"

S_AUTOINCREMENT = 34, // "AUTOINCREMENT"

S_BETWEEN = 35, // "BETWEEN"

S_CASCADE = 36, // "CASCADE"

S_CASE = 37, // "CASE"

S_CAST = 38, // "CAST"

S_CHECK = 39, // "CHECK"

S_COLLATE = 40, // "COLLATE"

S_CONFLICT = 41, // "CONFLICT"

S_CONSTRAINT = 42, // "CONSTRAINT"

S_CREATE = 43, // "CREATE"

S_CURRENT_DATE = 44, // "CURRENT_DATE"

S_CURRENT_TIME = 45, // "CURRENT_TIME"

S_CURRENT_TIMESTAMP = 46, // "CURRENT_TIMESTAMP"

S_DEFAULT = 47, // "DEFAULT"

S_DEFERRABLE = 48, // "DEFERRABLE"

S_DEFERRED = 49, // "DEFERRED"

S_DELETE = 50, // "DELETE"

S_DESC = 51, // "DESC"

S_DISTINCT = 52, // "DISTINCT"

S_ELSE = 53, // "ELSE"

S_END = 54, // "END"

S_ESCAPE = 55, // "ESCAPE"

S_EXISTS = 56, // "EXISTS"

S_FAIL = 57, // "FAIL"

S_FALSE = 58, // "FALSE"

S_FILTER = 59, // "FILTER"

S_FOLLOWING = 60, // "FOLLOWING"

S_FOREIGN = 61, // "FOREIGN"

S_FROM = 62, // "FROM"

S_GENERATED = 63, // "GENERATED"

S_GLOB = 64, // "GLOB"

S_IF = 65, // "IF"

S_IGNORE = 66, // "IGNORE"

S_IMMEDIATE = 67, // "IMMEDIATE"

S_IN = 68, // "IN"

S_INDEX = 69, // "INDEX"

S_INITIALLY = 70, // "INITIALLY"

S_INSERT = 71, // "INSERT"

S_IS = 72, // "IS"

S_ISNULL = 73, // "ISNULL"

S_KEY = 74, // "KEY"

S_LIKE = 75, // "LIKE"

S_MATCH = 76, // "MATCH"

S_NO = 77, // "NO"

S_NOT = 78, // "NOT"

S_NOTNULL = 79, // "NOTNULL"

S_NULL = 80, // "NULL"

S_ON = 81, // "ON"

S_OR = 82, // "OR"

S_OVER = 83, // "OVER"

S_PARTITION = 84, // "PARTITION"

S_PRECEDING = 85, // "PRECEDING"

S_PRIMARY = 86, // "PRIMARY"

S_RAISE = 87, // "RAISE"

S_RANGE = 88, // "RANGE"

S_REFERENCES = 89, // "REFERENCES"

S_REGEXP = 90, // "REGEXP"

S_REPLACE = 91, // "REPLACE"

S_RESTRICT = 92, // "RESTRICT"

S_RETURNING = 93, // "RETURNING"

S_ROLLBACK = 94, // "ROLLBACK"

S_ROWID = 95, // "ROWID"

S_ROWS = 96, // "ROWS"

S_SELECT = 97, // "SELECT"

S_SET = 98, // "SET"

S_STORED = 99, // "STORED"

S_STRICT = 100, // "STRICT"

S_TABLE = 101, // "TABLE"

S_TEMP = 102, // "TEMP"

S_TEMPORARY = 103, // "TEMPORARY"

S_THEN = 104, // "THEN"

S_TRUE = 105, // "TRUE"

S_UNBOUNDED = 106, // "UNBOUNDED"

S_UNIQUE = 107, // "UNIQUE"

S_UPDATE = 108, // "UPDATE"

S_USING = 109, // "USING"

S_VIRTUAL = 110, // "VIRTUAL"

S_WHEN = 111, // "WHEN"

S_WHERE = 112, // "WHERE"

S_WITHOUT = 113, // "WITHOUT"

S_IDENTIFIER = 114, // "identifier"

S_NUMERIC = 115, // "numeric"

S_STRINGLITERAL = 116, // "string literal"

S_QUOTEDLITERAL = 117, // "quoted literal"

S_BLOBLITERAL = 118, // "blob literal"

S_BINDPARAMETER = 119, // "bind parameter"

S_YYACCEPT = 120, // $accept

S_sql = 121, // sql

S_statement = 122, // statement

S_literalvalue = 123, // literalvalue

S_id = 124, // id

S_allowed_keywords_as_identifier = 125, // allowed_keywords_as_identifier

S_tableid = 126, // tableid

S_columnid = 127, // columnid

S_signednumber = 128, // signednumber

S_signednumber_or_numeric = 129, // signednumber_or_numeric

S_typename_namelist = 130, // typename_namelist

S_type_name = 131, // type_name

S_unary_expr = 132, // unary_expr

S_binary_expr = 133, // binary_expr

S_like_expr = 134, // like_expr

S_exprlist_expr = 135, // exprlist_expr

S_function_expr = 136, // function_expr

S_isnull_expr = 137, // isnull_expr

S_between_expr = 138, // between_expr

S_in_expr = 139, // in_expr

S_whenthenlist_expr = 140, // whenthenlist_expr

S_case_expr = 141, // case_expr

S_raise_expr = 142, // raise_expr

S_expr = 143, // expr

S_select_stmt = 144, // select_stmt

S_optional_if_not_exists = 145, // optional_if_not_exists

S_optional_sort_order = 146, // optional_sort_order

S_optional_unique = 147, // optional_unique

S_optional_where = 148, // optional_where

S_tableid_with_uninteresting_schema = 149, // tableid_with_uninteresting_schema

S_indexed_column = 150, // indexed_column

S_indexed_column_list = 151, // indexed_column_list

S_createindex_stmt = 152, // createindex_stmt

S_optional_exprlist_with_paren = 153, // optional_exprlist_with_paren

S_createvirtualtable_stmt = 154, // createvirtualtable_stmt

S_optional_temporary = 155, // optional_temporary

S_tableoption = 156, // tableoption

S_tableoptions_list = 157, // tableoptions_list

S_optional_tableoptions_list = 158, // optional_tableoptions_list

S_optional_conflictclause = 159, // optional_conflictclause

S_optional_typename = 160, // optional_typename

S_optional_storage_identifier = 161, // optional_storage_identifier

S_optional_always_generated = 162, // optional_always_generated

S_columnconstraint = 163, // columnconstraint

S_columnconstraint_list = 164, // columnconstraint_list

S_columndef = 165, // columndef

S_columndef_list = 166, // columndef_list

S_optional_constraintname = 167, // optional_constraintname

S_columnid_list = 168, // columnid_list

S_optional_columnid_with_paren_list = 169, // optional_columnid_with_paren_list

S_fk_clause_part = 170, // fk_clause_part

S_fk_clause_part_list = 171, // fk_clause_part_list

S_optional_fk_clause = 172, // optional_fk_clause

S_tableconstraint = 173, // tableconstraint

S_tableconstraint_list = 174, // tableconstraint_list

S_optional_tableconstraint_list = 175, // optional_tableconstraint_list

S_createtable_stmt = 176 // createtable_stmt

};

{

/// Alias to Base.

typedef Base super_type;

/// Default constructor.

basic_symbol () YY_NOEXCEPT

: value ()

, location ()

{}

#if 201103L <= YY_CPLUSPLUS

/// Move constructor.

basic_symbol (basic_symbol&& that)

: Base (std::move (that))

, value ()

, location (std::move (that.location))

{

switch (this->kind ())

{

case symbol_kind::S_columndef_list: // columndef_list

value.move< ColumnList > (std::move (that.value));

break;

case symbol_kind::S_columnconstraint_list: // columnconstraint_list