#include "sql/sql_lex.h"

#include <algorithm> // find_if, iter_swap, reverse

#include <climits>

#include <cstdlib>

#include <initializer_list>

#include "field_types.h"

#include "m_string.h"

#include "my_alloc.h"

#include "my_dbug.h"

#include "mysql/mysql_lex_string.h"

#include "mysql/service_mysql_alloc.h"

#include "mysql/strings/collations.h"

#include "mysql/strings/m_ctype.h"

#include "mysql_version.h" // MYSQL_VERSION_ID

#include "mysqld_error.h"

#include "prealloced_array.h" // Prealloced_array

#include "sql/current_thd.h"

#include "sql/derror.h"

#include "sql/item_func.h"

#include "sql/item_subselect.h"

#include "sql/lex_symbol.h"

#include "sql/lexer_yystype.h"

#include "sql/mysqld.h" // table_alias_charset

#include "sql/nested_join.h"

#include "sql/opt_hints.h"

#include "sql/parse_location.h"

#include "sql/parse_tree_nodes.h" // PT_with_clause

#include "sql/protocol.h"

#include "sql/select_lex_visitor.h"

#include "sql/sp_head.h" // sp_head

#include "sql/sql_admin.h"

#include "sql/sql_base.h"

#include "sql/sql_class.h" // THD

#include "sql/sql_cmd.h"

#include "sql/sql_digest_stream.h"

#include "sql/sql_error.h"

#include "sql/sql_insert.h" // Sql_cmd_insert_base

#include "sql/sql_lex_hash.h"

#include "sql/sql_lex_hints.h"

#include "sql/sql_optimizer.h" // JOIN

#include "sql/sql_parse.h" // add_to_list

#include "sql/sql_plugin.h" // plugin_unlock_list

#include "sql/sql_profile.h"

#include "sql/sql_show.h" // append_identifier

#include "sql/sql_table.h" // primary_key_name

#include "sql/sql_yacc.h"

#include "sql/system_variables.h"

#include "sql/table_function.h"

#include "sql/window.h"

#include "sql_update.h" // Sql_cmd_update

#include "string_with_len.h"

#include "template_utils.h"

class PT_hint_list;

extern int my_hint_parser_parse(THD *thd, Hint_scanner *scanner,

PT_hint_list **ret);

static int lex_one_token(Lexer_yystype *yylval, THD *thd);

const LEX_STRING null_lex_str = {nullptr, 0};

const int

Query_tables_list::binlog_stmt_unsafe_errcode[BINLOG_STMT_UNSAFE_COUNT] = {

ER_BINLOG_UNSAFE_LIMIT,

ER_BINLOG_UNSAFE_SYSTEM_TABLE,

ER_BINLOG_UNSAFE_AUTOINC_COLUMNS,

ER_BINLOG_UNSAFE_UDF,

ER_BINLOG_UNSAFE_SYSTEM_VARIABLE,

ER_BINLOG_UNSAFE_SYSTEM_FUNCTION,

ER_BINLOG_UNSAFE_NONTRANS_AFTER_TRANS,

ER_BINLOG_UNSAFE_MULTIPLE_ENGINES_AND_SELF_LOGGING_ENGINE,

ER_BINLOG_UNSAFE_MIXED_STATEMENT,

ER_BINLOG_UNSAFE_INSERT_IGNORE_SELECT,

ER_BINLOG_UNSAFE_INSERT_SELECT_UPDATE,

ER_BINLOG_UNSAFE_WRITE_AUTOINC_SELECT,

ER_BINLOG_UNSAFE_REPLACE_SELECT,

ER_BINLOG_UNSAFE_CREATE_IGNORE_SELECT,

ER_BINLOG_UNSAFE_CREATE_REPLACE_SELECT,

ER_BINLOG_UNSAFE_CREATE_SELECT_AUTOINC,

ER_BINLOG_UNSAFE_UPDATE_IGNORE,

ER_BINLOG_UNSAFE_INSERT_TWO_KEYS,

ER_BINLOG_UNSAFE_AUTOINC_NOT_FIRST,

ER_BINLOG_UNSAFE_FULLTEXT_PLUGIN,

ER_BINLOG_UNSAFE_SKIP_LOCKED,

ER_BINLOG_UNSAFE_NOWAIT,

ER_BINLOG_UNSAFE_XA,

ER_BINLOG_UNSAFE_DEFAULT_EXPRESSION_IN_SUBSTATEMENT,

ER_BINLOG_UNSAFE_ACL_TABLE_READ_IN_DML_DDL,

ER_CREATE_SELECT_WITH_GIPK_DISALLOWED_IN_SBR};

const char *index_hint_type_name[] = {"IGNORE INDEX", "USE INDEX",

"FORCE INDEX"};

Prepare_error_tracker::~Prepare_error_tracker() {

if (unlikely(thd->is_error())) thd->lex->mark_broken();

}

const char *Query_block::type_str[static_cast<int>(

enum_explain_type::EXPLAIN_total)] = {"NONE", "PRIMARY",

"SIMPLE", "DERIVED",

"SUBQUERY", "UNION",

"INTERSECT", "EXCEPT",

"UNION RESULT", "INTERSECT RESULT",

"EXCEPT RESULT", "RESULT" /*unary*/,

"MATERIALIZED"};

Table_ident::Table_ident(Protocol *protocol, const LEX_CSTRING &db_arg,

}

void lex_free() { // Call this when daemon ends

DBUG_TRACE;

}

void st_parsing_options::reset() {

allows_variable = true;

allows_select_into = true;

}

void struct_slave_connection::reset() {

}

bool Lex_input_stream::init(THD *thd, const char *buff, size_t length) {

}

void Lex_input_stream::reset(const char *buffer, size_t length) {

}

void Lex_input_stream::body_utf8_start(THD *thd, const char *begin_ptr) {

}

void Lex_input_stream::body_utf8_append(const char *ptr, const char *end_ptr) {

}

void Lex_input_stream::body_utf8_append(const char *ptr) {

body_utf8_append(ptr, ptr);

}

void Lex_input_stream::body_utf8_append_literal(THD *thd, const LEX_STRING *txt,

}

void Lex_input_stream::add_digest_token(uint token, Lexer_yystype *yylval) {

}

void Lex_input_stream::reduce_digest_token(uint token_left, uint token_right) {

}

void LEX::assert_ok_set_current_query_block() {

}

LEX::~LEX() {

destroy_query_tables_list();

plugin_unlock_list(nullptr, plugins.begin(), plugins.size());

unit = nullptr; // Created in mem_root - no destructor

query_block = nullptr;

m_current_query_block = nullptr;

}

void LEX::reset() {

}

bool lex_start(THD *thd) {

}

void lex_end(LEX *lex) {

}

void LEX::release_plugins() {

}

void LEX::clear_execution() {

}

Query_block *LEX::new_empty_query_block() {

Query_block *select =

new (thd->mem_root) Query_block(thd->mem_root, nullptr, nullptr);

if (select == nullptr) return nullptr; /* purecov: inspected */

select->parent_lex = this;

return select;

}

Query_expression *LEX::create_query_expr_and_block(

THD *thd, Query_block *current_query_block, Item *where, Item *having,

enum_parsing_context ctx) {

if (current_query_block != nullptr &&

current_query_block->nest_level >= MAX_SELECT_NESTING) {

my_error(ER_TOO_HIGH_LEVEL_OF_NESTING_FOR_SELECT, MYF(0));

return nullptr;

}

auto *const new_expression = new (thd->mem_root) Query_expression(ctx);

if (new_expression == nullptr) return nullptr;

auto *const new_query_block =

new (thd->mem_root) Query_block(thd->mem_root, where, having);

if (new_query_block == nullptr) return nullptr;

// Link the new query expression below the current query block, if any

if (current_query_block != nullptr)

new_expression->include_down(this, current_query_block);

new_query_block->include_down(this, new_expression);

new_query_block->parent_lex = this;

new_query_block->include_in_global(&this->all_query_blocks_list);

// Set root query_term a priori. It is usually set later by

// Parse_context::finalize_query_expression. This is necessary since it

// doesn't always happen during server bootstrap of the dictionary, e.g. in

// View_metadata_updater_context which creates a top level query whose

// Query_expression/Query_block is not parsed/contextualized, so we never

// call finalize_query_expression in the usual way, after contextualization

// of PT_query_expression.

new_expression->set_query_term(new_query_block);

return new_expression;

}

Query_block *LEX::new_query(Query_block *curr_query_block) {

DBUG_TRACE;

Name_resolution_context *outer_context = current_context();

const enum_parsing_context parsing_place =

curr_query_block != nullptr ? curr_query_block->parsing_place : CTX_NONE;

Query_expression *const new_query_expression = create_query_expr_and_block(

thd, curr_query_block, nullptr, nullptr, parsing_place);

if (new_query_expression == nullptr) return nullptr;

Query_block *const new_query_block =

new_query_expression->first_query_block();

if (new_query_block->set_context(nullptr)) return nullptr;

/*

if (parsing_place == CTX_NONE) // Outer-most query block

{

} else if (parsing_place == CTX_INSERT_UPDATE &&

curr_query_block->master_query_expression()->is_set_operation()) {

/*

assert(new_query_block->context.outer_context == nullptr);

} else {

new_query_block->context.outer_context = outer_context;

}

/*

new_query_block->context.resolve_in_select_list = true;

DBUG_PRINT("outer_field", ("ctx %p <-> SL# %d", &new_query_block->context,

new_query_block->select_number));

return new_query_block;

}

Query_block *LEX::new_set_operation_query(Query_block *curr_query_block) {

DBUG_TRACE;

assert(unit != nullptr && query_block != nullptr);

// Is this the outer-most query expression?

bool const outer_most = curr_query_block->master_query_expression() == unit;

/*

if (outer_most && result) {

my_error(ER_MISPLACED_INTO, MYF(0));

return nullptr;

}

Query_block *const select = new_empty_query_block();

if (!select) return nullptr; /* purecov: inspected */

select->include_neighbour(this, curr_query_block);

Query_expression *const sel_query_expression =

select->master_query_expression();

if (select->set_context(

sel_query_expression->first_query_block()->context.outer_context))

return nullptr; /* purecov: inspected */

select->include_in_global(&all_query_blocks_list);

/*

select->context.resolve_in_select_list = true;

return select;

}

Query_block *Query_expression::create_post_processing_block(

Query_term_set_op *term) {

Query_block *first_qb = first_query_block();

DBUG_TRACE;

Query_block *const qb = first_qb->parent_lex->new_empty_query_block();

if (qb == nullptr) return nullptr; /* purecov: inspected */

qb->include_standalone(this);

qb->select_number = INT_MAX;

qb->linkage = GLOBAL_OPTIONS_TYPE;

qb->select_limit = nullptr;

qb->set_context(first_qb->context.outer_context);

/* allow item list resolving in fake select for ORDER BY */

qb->context.resolve_in_select_list = true;

qb->no_table_names_allowed =

!term->is_unary() || first_qb->is_ordered() || first_qb->has_limit();

first_qb->parent_lex->pop_context();

return qb;

}

bool Query_expression::is_leaf_block(Query_block *qb) {

}

bool LEX::new_top_level_query() {

}

void LEX::new_static_query(Query_expression *sel_query_expression,

}

bool LEX::check_preparation_invalid(THD *thd_arg) {

}

Yacc_state::~Yacc_state() {

if (yacc_yyss) {

my_free(yacc_yyss);

my_free(yacc_yyvs);

my_free(yacc_yyls);

}

}

static bool consume_optimizer_hints(Lex_input_stream *lip) {

}

static int find_keyword(Lex_input_stream *lip, uint len, bool function) {

}

bool is_keyword(const char *name, size_t len) {

assert(len != 0);

return Lex_hash::sql_keywords.get_hash_symbol(name, len) != nullptr;

}

bool is_lex_native_function(const LEX_STRING *name) {

}

static LEX_STRING get_token(Lex_input_stream *lip, uint skip, uint length) {

}

static LEX_STRING get_quoted_token(Lex_input_stream *lip, uint skip,