{

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

char dummy1[sizeof (ColumndefData)];

// tableconstraint

// tableconstraint_list

// optional_tableconstraint_list

char dummy2[sizeof (Constraints)];

// optional_if_not_exists

// optional_unique

// optional_temporary

// optional_always_generated

char dummy3[sizeof (bool)];

// columnconstraint

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

// createindex_stmt

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

// indexed_column

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

// indexed_column_list

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

// columnid_list

// optional_columnid_with_paren_list

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

// createvirtualtable_stmt

// createtable_stmt

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

// tableoption

// tableoptions_list

// optional_tableoptions_list

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

// "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"

// "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 dummy11[sizeof (std::string)];

// columndef_list

char dummy12[sizeof (std::vector<ColumndefData>)];

// columnconstraint_list

char dummy13[sizeof (std::vector<sqlb::ConstraintPtr>)];

};

/// 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_GENERATED = 317, // "GENERATED"

TOK_GLOB = 318, // "GLOB"

TOK_IF = 319, // "IF"

TOK_IGNORE = 320, // "IGNORE"

TOK_IMMEDIATE = 321, // "IMMEDIATE"

TOK_IN = 322, // "IN"

TOK_INDEX = 323, // "INDEX"

TOK_INITIALLY = 324, // "INITIALLY"

TOK_INSERT = 325, // "INSERT"

TOK_IS = 326, // "IS"

TOK_ISNULL = 327, // "ISNULL"

TOK_KEY = 328, // "KEY"

TOK_LIKE = 329, // "LIKE"

TOK_MATCH = 330, // "MATCH"

TOK_NO = 331, // "NO"

TOK_NOT = 332, // "NOT"

TOK_NOTNULL = 333, // "NOTNULL"

TOK_NULL = 334, // "NULL"

TOK_ON = 335, // "ON"

TOK_OR = 336, // "OR"

TOK_OVER = 337, // "OVER"

TOK_PARTITION = 338, // "PARTITION"

TOK_PRECEDING = 339, // "PRECEDING"

TOK_PRIMARY = 340, // "PRIMARY"

TOK_RAISE = 341, // "RAISE"

TOK_RANGE = 342, // "RANGE"

TOK_REFERENCES = 343, // "REFERENCES"

TOK_REGEXP = 344, // "REGEXP"

TOK_REPLACE = 345, // "REPLACE"

TOK_RESTRICT = 346, // "RESTRICT"

TOK_RETURNING = 347, // "RETURNING"

TOK_ROLLBACK = 348, // "ROLLBACK"

TOK_ROWID = 349, // "ROWID"

TOK_ROWS = 350, // "ROWS"

TOK_SELECT = 351, // "SELECT"

TOK_SET = 352, // "SET"

TOK_STORED = 353, // "STORED"

TOK_STRICT = 354, // "STRICT"

TOK_TABLE = 355, // "TABLE"

TOK_TEMP = 356, // "TEMP"

TOK_TEMPORARY = 357, // "TEMPORARY"

TOK_THEN = 358, // "THEN"

TOK_TRUE = 359, // "TRUE"

TOK_UNBOUNDED = 360, // "UNBOUNDED"

TOK_UNIQUE = 361, // "UNIQUE"

TOK_UPDATE = 362, // "UPDATE"

TOK_USING = 363, // "USING"

TOK_VIRTUAL = 364, // "VIRTUAL"

TOK_WHEN = 365, // "WHEN"

TOK_WHERE = 366, // "WHERE"

TOK_WITHOUT = 367, // "WITHOUT"

TOK_IDENTIFIER = 368, // "identifier"

TOK_NUMERIC = 369, // "numeric"

TOK_STRINGLITERAL = 370, // "string literal"

TOK_QUOTEDLITERAL = 371, // "quoted literal"

TOK_BLOBLITERAL = 372, // "blob literal"

TOK_BINDPARAMETER = 373 // "bind parameter"

};

/// Backward compatibility alias (Bison 3.6).

typedef token_kind_type yytokentype;

{

enum symbol_kind_type

{

YYNTOKENS = 119, ///< 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_GENERATED = 62, // "GENERATED"

S_GLOB = 63, // "GLOB"

S_IF = 64, // "IF"

S_IGNORE = 65, // "IGNORE"

S_IMMEDIATE = 66, // "IMMEDIATE"

S_IN = 67, // "IN"

S_INDEX = 68, // "INDEX"

S_INITIALLY = 69, // "INITIALLY"

S_INSERT = 70, // "INSERT"

S_IS = 71, // "IS"

S_ISNULL = 72, // "ISNULL"

S_KEY = 73, // "KEY"

S_LIKE = 74, // "LIKE"

S_MATCH = 75, // "MATCH"

S_NO = 76, // "NO"

S_NOT = 77, // "NOT"

S_NOTNULL = 78, // "NOTNULL"

S_NULL = 79, // "NULL"

S_ON = 80, // "ON"

S_OR = 81, // "OR"

S_OVER = 82, // "OVER"

S_PARTITION = 83, // "PARTITION"

S_PRECEDING = 84, // "PRECEDING"

S_PRIMARY = 85, // "PRIMARY"

S_RAISE = 86, // "RAISE"

S_RANGE = 87, // "RANGE"

S_REFERENCES = 88, // "REFERENCES"

S_REGEXP = 89, // "REGEXP"

S_REPLACE = 90, // "REPLACE"

S_RESTRICT = 91, // "RESTRICT"

S_RETURNING = 92, // "RETURNING"

S_ROLLBACK = 93, // "ROLLBACK"

S_ROWID = 94, // "ROWID"

S_ROWS = 95, // "ROWS"

S_SELECT = 96, // "SELECT"

S_SET = 97, // "SET"

S_STORED = 98, // "STORED"

S_STRICT = 99, // "STRICT"

S_TABLE = 100, // "TABLE"

S_TEMP = 101, // "TEMP"

S_TEMPORARY = 102, // "TEMPORARY"

S_THEN = 103, // "THEN"

S_TRUE = 104, // "TRUE"

S_UNBOUNDED = 105, // "UNBOUNDED"

S_UNIQUE = 106, // "UNIQUE"

S_UPDATE = 107, // "UPDATE"

S_USING = 108, // "USING"

S_VIRTUAL = 109, // "VIRTUAL"

S_WHEN = 110, // "WHEN"

S_WHERE = 111, // "WHERE"

S_WITHOUT = 112, // "WITHOUT"

S_IDENTIFIER = 113, // "identifier"

S_NUMERIC = 114, // "numeric"

S_STRINGLITERAL = 115, // "string literal"

S_QUOTEDLITERAL = 116, // "quoted literal"

S_BLOBLITERAL = 117, // "blob literal"

S_BINDPARAMETER = 118, // "bind parameter"

S_YYACCEPT = 119, // $accept

S_sql = 120, // sql

S_statement = 121, // statement

S_literalvalue = 122, // literalvalue

S_id = 123, // id

S_allowed_keywords_as_identifier = 124, // allowed_keywords_as_identifier

S_tableid = 125, // tableid

S_columnid = 126, // columnid

S_signednumber = 127, // signednumber

S_signednumber_or_numeric = 128, // signednumber_or_numeric

S_typename_namelist = 129, // typename_namelist

S_type_name = 130, // type_name

S_unary_expr = 131, // unary_expr

S_binary_expr = 132, // binary_expr

S_like_expr = 133, // like_expr

S_exprlist_expr = 134, // exprlist_expr

S_function_expr = 135, // function_expr

S_isnull_expr = 136, // isnull_expr

S_between_expr = 137, // between_expr

S_in_expr = 138, // in_expr

S_whenthenlist_expr = 139, // whenthenlist_expr

S_case_expr = 140, // case_expr

S_raise_expr = 141, // raise_expr

S_expr = 142, // expr

S_select_stmt = 143, // select_stmt

S_optional_if_not_exists = 144, // optional_if_not_exists

S_optional_sort_order = 145, // optional_sort_order

S_optional_unique = 146, // optional_unique

S_optional_where = 147, // optional_where

S_tableid_with_uninteresting_schema = 148, // tableid_with_uninteresting_schema

S_indexed_column = 149, // indexed_column

S_indexed_column_list = 150, // indexed_column_list

S_createindex_stmt = 151, // createindex_stmt

S_optional_exprlist_with_paren = 152, // optional_exprlist_with_paren

S_createvirtualtable_stmt = 153, // createvirtualtable_stmt

S_optional_temporary = 154, // optional_temporary

S_tableoption = 155, // tableoption

S_tableoptions_list = 156, // tableoptions_list

S_optional_tableoptions_list = 157, // optional_tableoptions_list

S_optional_conflictclause = 158, // optional_conflictclause

S_optional_typename = 159, // optional_typename

S_optional_storage_identifier = 160, // optional_storage_identifier

S_optional_always_generated = 161, // optional_always_generated

S_columnconstraint = 162, // columnconstraint

S_columnconstraint_list = 163, // columnconstraint_list

S_columndef = 164, // columndef

S_columndef_list = 165, // columndef_list

S_optional_constraintname = 166, // optional_constraintname

S_columnid_list = 167, // columnid_list

S_optional_columnid_with_paren_list = 168, // optional_columnid_with_paren_list

S_fk_clause_part = 169, // fk_clause_part

S_fk_clause_part_list = 170, // fk_clause_part_list

S_optional_fk_clause = 171, // optional_fk_clause

S_tableconstraint = 172, // tableconstraint

S_tableconstraint_list = 173, // tableconstraint_list

S_optional_tableconstraint_list = 174, // optional_tableconstraint_list

S_createtable_stmt = 175 // 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: // columndef

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

break;

case symbol_kind::S_tableconstraint: // tableconstraint