mirror/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-01-19 13:32:33 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
mariadb/innobase/pars/pars0pars.c
jani@hynda.mysql.fi d0e8306203 Added xml patch to mysqldump. 
Made innodb to compile more cleanly with debugging options
enabled. Fixed a few bugs and found a few possible bugs, which
I hope Heikki will check. Comments needs to be fixed too. Some
while() functions should be changed to do ... until for documenting
purposes, because some of them must and will be processed at least
once, or a variable would be used uninitialized.

Regards,
Jani
2001-11-05 23:48:03 +02:00

2035 lines
49 KiB
C
Raw Blame History

/******************************************************
SQL parser
(c) 1996 Innobase Oy
Created 11/19/1996 Heikki Tuuri
*******************************************************/
/* Historical note: Innobase executed its first SQL string (CREATE TABLE)
on 1/27/1998 */
#include "pars0pars.h"
#ifdef UNIV_NONINL
#include "pars0pars.ic"
#endif
#include "row0sel.h"
#include "row0ins.h"
#include "row0upd.h"
#include "dict0dict.h"
#include "dict0mem.h"
#include "dict0crea.h"
#include "que0que.h"
#include "pars0grm.h"
#include "pars0opt.h"
#include "data0data.h"
#include "data0type.h"
#include "trx0trx.h"
#include "trx0roll.h"
#include "lock0lock.h"
#include "odbc0odbc.h"
#include "eval0eval.h"
/* If the following is set TRUE, the lexer will print the SQL string
as it tokenizes it */
ibool pars_print_lexed = FALSE;
/* Global variable used while parsing a single procedure or query : the code is
NOT re-entrant */
sym_tab_t* pars_sym_tab_global;
/* Global variables used to denote certain reserved words, used in
constructing the parsing tree */
pars_res_word_t pars_to_char_token = {PARS_TO_CHAR_TOKEN};
pars_res_word_t pars_to_number_token = {PARS_TO_NUMBER_TOKEN};
pars_res_word_t pars_to_binary_token = {PARS_TO_BINARY_TOKEN};
pars_res_word_t pars_binary_to_number_token = {PARS_BINARY_TO_NUMBER_TOKEN};
pars_res_word_t pars_substr_token = {PARS_SUBSTR_TOKEN};
pars_res_word_t pars_replstr_token = {PARS_REPLSTR_TOKEN};
pars_res_word_t pars_concat_token = {PARS_CONCAT_TOKEN};
pars_res_word_t pars_instr_token = {PARS_INSTR_TOKEN};
pars_res_word_t pars_length_token = {PARS_LENGTH_TOKEN};
pars_res_word_t pars_sysdate_token = {PARS_SYSDATE_TOKEN};
pars_res_word_t pars_printf_token = {PARS_PRINTF_TOKEN};
pars_res_word_t pars_assert_token = {PARS_ASSERT_TOKEN};
pars_res_word_t pars_rnd_token = {PARS_RND_TOKEN};
pars_res_word_t pars_rnd_str_token = {PARS_RND_STR_TOKEN};
pars_res_word_t pars_count_token = {PARS_COUNT_TOKEN};
pars_res_word_t pars_sum_token = {PARS_SUM_TOKEN};
pars_res_word_t pars_distinct_token = {PARS_DISTINCT_TOKEN};
pars_res_word_t pars_int_token = {PARS_INT_TOKEN};
pars_res_word_t pars_char_token = {PARS_CHAR_TOKEN};
pars_res_word_t pars_float_token = {PARS_FLOAT_TOKEN};
pars_res_word_t pars_update_token = {PARS_UPDATE_TOKEN};
pars_res_word_t pars_asc_token = {PARS_ASC_TOKEN};
pars_res_word_t pars_desc_token = {PARS_DESC_TOKEN};
pars_res_word_t pars_open_token = {PARS_OPEN_TOKEN};
pars_res_word_t pars_close_token = {PARS_CLOSE_TOKEN};
pars_res_word_t pars_consistent_token = {PARS_CONSISTENT_TOKEN};
pars_res_word_t pars_unique_token = {PARS_UNIQUE_TOKEN};
pars_res_word_t pars_clustered_token = {PARS_CLUSTERED_TOKEN};
/* Global variable used to denote the '*' in SELECT * FROM.. */
#define PARS_STAR_DENOTER 12345678
ulint pars_star_denoter = PARS_STAR_DENOTER;
/*************************************************************************
Determines the class of a function code. */
static
ulint
pars_func_get_class(
/*================*/
/* out: function class: PARS_FUNC_ARITH, ... */
int func) /* in: function code: '=', PARS_GE_TOKEN, ... */
{
if ((func == '+') || (func == '-') || (func == '*') || (func == '/')) {
return(PARS_FUNC_ARITH);
} else if ((func == '=') || (func == '<') || (func == '>')
|| (func == PARS_GE_TOKEN) || (func == PARS_LE_TOKEN)
|| (func == PARS_NE_TOKEN)) {
return(PARS_FUNC_CMP);
} else if ((func == PARS_AND_TOKEN) || (func == PARS_OR_TOKEN)
|| (func == PARS_NOT_TOKEN)) {
return(PARS_FUNC_LOGICAL);
} else if ((func == PARS_COUNT_TOKEN) || (func == PARS_SUM_TOKEN)) {
return(PARS_FUNC_AGGREGATE);
} else if ((func == PARS_TO_CHAR_TOKEN)
|| (func == PARS_TO_NUMBER_TOKEN)
|| (func == PARS_TO_BINARY_TOKEN)
|| (func == PARS_BINARY_TO_NUMBER_TOKEN)
|| (func == PARS_SUBSTR_TOKEN)
|| (func == PARS_CONCAT_TOKEN)
|| (func == PARS_LENGTH_TOKEN)
|| (func == PARS_INSTR_TOKEN)
|| (func == PARS_SYSDATE_TOKEN)
|| (func == PARS_NOTFOUND_TOKEN)
|| (func == PARS_PRINTF_TOKEN)
|| (func == PARS_ASSERT_TOKEN)
|| (func == PARS_RND_TOKEN)
|| (func == PARS_RND_STR_TOKEN)
|| (func == PARS_REPLSTR_TOKEN)) {
return(PARS_FUNC_PREDEFINED);
} else {
return(PARS_FUNC_OTHER);
}
}
/*************************************************************************
Parses an operator or predefined function expression. */
static
func_node_t*
pars_func_low(
/*==========*/
/* out, own: function node in a query tree */
int func, /* in: function token code */
que_node_t* arg) /* in: first argument in the argument list */
{
func_node_t* node;
node = mem_heap_alloc(pars_sym_tab_global->heap, sizeof(func_node_t));
node->common.type = QUE_NODE_FUNC;
dfield_set_data(&(node->common.val), NULL, 0);
node->common.val_buf_size = 0;
node->func = func;
node->class = pars_func_get_class(func);
node->args = arg;
UT_LIST_ADD_LAST(func_node_list, pars_sym_tab_global->func_node_list,
node);
return(node);
}
/*************************************************************************
Parses a function expression. */
func_node_t*
pars_func(
/*======*/
/* out, own: function node in a query tree */
que_node_t* res_word,/* in: function name reserved word */
que_node_t* arg) /* in: first argument in the argument list */
{
return(pars_func_low(((pars_res_word_t*)res_word)->code, arg));
}
/*************************************************************************
Parses an operator expression. */
func_node_t*
pars_op(
/*====*/
/* out, own: function node in a query tree */
int func, /* in: operator token code */
que_node_t* arg1, /* in: first argument */
que_node_t* arg2) /* in: second argument or NULL for an unary
operator */
{
que_node_list_add_last(NULL, arg1);
if (arg2) {
que_node_list_add_last(arg1, arg2);
}
return(pars_func_low(func, arg1));
}
/*************************************************************************
Parses an ORDER BY clause. Order by a single column only is supported. */
order_node_t*
pars_order_by(
/*==========*/
/* out, own: order-by node in a query tree */
sym_node_t* column, /* in: column name */
pars_res_word_t* asc) /* in: &pars_asc_token or pars_desc_token */
{
order_node_t* node;
node = mem_heap_alloc(pars_sym_tab_global->heap, sizeof(order_node_t));
node->common.type = QUE_NODE_ORDER;
node->column = column;
if (asc == &pars_asc_token) {
node->asc = TRUE;
} else {
ut_a(asc == &pars_desc_token);
node->asc = FALSE;
}
return(node);
}
/*************************************************************************
Resolves the data type of a function in an expression. The argument data
types must already be resolved. */
static
void
pars_resolve_func_data_type(
/*========================*/
func_node_t* node) /* in: function node */
{
que_node_t* arg;
ulint func;
ut_a(que_node_get_type(node) == QUE_NODE_FUNC);
arg = node->args;
func = node->func;
if ((func == PARS_SUM_TOKEN)
|| (func == '+') || (func == '-') || (func == '*')
|| (func == '/') || (func == '+')) {
/* Inherit the data type from the first argument (which must
not be the SQL null literal whose type is DATA_ERROR) */
ut_a(dtype_get_mtype(que_node_get_data_type(arg))
!= DATA_ERROR);
dtype_copy(que_node_get_data_type(node),
que_node_get_data_type(arg));
ut_a(dtype_get_mtype(que_node_get_data_type(node)) == DATA_INT);
} else if (func == PARS_COUNT_TOKEN) {
ut_a(arg);
dtype_set(que_node_get_data_type(node), DATA_INT, 0, 4, 0);
} else if (func == PARS_TO_CHAR_TOKEN) {
ut_a(dtype_get_mtype(que_node_get_data_type(arg)) == DATA_INT);
dtype_set(que_node_get_data_type(node), DATA_VARCHAR,
DATA_ENGLISH, 0, 0);
} else if (func == PARS_TO_BINARY_TOKEN) {
ut_a(dtype_get_mtype(que_node_get_data_type(arg)) == DATA_INT);
dtype_set(que_node_get_data_type(node), DATA_VARCHAR,
DATA_ENGLISH, 0, 0);
} else if (func == PARS_TO_NUMBER_TOKEN) {
ut_a(dtype_get_mtype(que_node_get_data_type(arg))
== DATA_VARCHAR);
dtype_set(que_node_get_data_type(node), DATA_INT, 0, 4, 0);
} else if (func == PARS_BINARY_TO_NUMBER_TOKEN) {
ut_a(dtype_get_mtype(que_node_get_data_type(arg))
== DATA_VARCHAR);
dtype_set(que_node_get_data_type(node), DATA_INT, 0, 4, 0);
} else if (func == PARS_LENGTH_TOKEN) {
ut_a(dtype_get_mtype(que_node_get_data_type(arg))
== DATA_VARCHAR);
dtype_set(que_node_get_data_type(node), DATA_INT, 0, 4, 0);
} else if (func == PARS_INSTR_TOKEN) {
ut_a(dtype_get_mtype(que_node_get_data_type(arg))
== DATA_VARCHAR);
dtype_set(que_node_get_data_type(node), DATA_INT, 0, 4, 0);
} else if (func == PARS_SYSDATE_TOKEN) {
ut_a(arg == NULL);
dtype_set(que_node_get_data_type(node), DATA_INT, 0, 4, 0);
} else if ((func == PARS_SUBSTR_TOKEN)
|| (func == PARS_CONCAT_TOKEN)) {
ut_a(dtype_get_mtype(que_node_get_data_type(arg))
== DATA_VARCHAR);
dtype_set(que_node_get_data_type(node), DATA_VARCHAR,
DATA_ENGLISH, 0, 0);
} else if ((func == '>') || (func == '<') || (func == '=')
|| (func == PARS_GE_TOKEN)
|| (func == PARS_LE_TOKEN)
|| (func == PARS_NE_TOKEN)
|| (func == PARS_AND_TOKEN)
|| (func == PARS_OR_TOKEN)
|| (func == PARS_NOT_TOKEN)
|| (func == PARS_NOTFOUND_TOKEN)) {
/* We currently have no iboolean type: use integer type */
dtype_set(que_node_get_data_type(node), DATA_INT, 0, 4, 0);
} else if (func == PARS_RND_TOKEN) {
ut_a(dtype_get_mtype(que_node_get_data_type(arg)) == DATA_INT);
dtype_set(que_node_get_data_type(node), DATA_INT, 0, 4, 0);
} else if (func == PARS_RND_STR_TOKEN) {
ut_a(dtype_get_mtype(que_node_get_data_type(arg)) == DATA_INT);
dtype_set(que_node_get_data_type(node), DATA_VARCHAR,
DATA_ENGLISH, 0, 0);
} else {
ut_error;
}
}
/*************************************************************************
Resolves the meaning of variables in an expression and the data types of
functions. It is an error if some identifier cannot be resolved here. */
static
void
pars_resolve_exp_variables_and_types(
/*=================================*/
sel_node_t* select_node, /* in: select node or NULL; if
this is not NULL then the variable
sym nodes are added to the
copy_variables list of select_node */
que_node_t* exp_node) /* in: expression */
{
func_node_t* func_node;
que_node_t* arg;
sym_node_t* sym_node;
sym_node_t* node;
ut_a(exp_node);
if (que_node_get_type(exp_node) == QUE_NODE_FUNC) {
func_node = exp_node;
arg = func_node->args;
while (arg) {
pars_resolve_exp_variables_and_types(select_node, arg);
arg = que_node_get_next(arg);
}
pars_resolve_func_data_type(func_node);
return;
}
ut_a(que_node_get_type(exp_node) == QUE_NODE_SYMBOL);
sym_node = exp_node;
if (sym_node->resolved) {
return;
}
/* Not resolved yet: look in the symbol table for a variable
or a cursor with the same name */
node = UT_LIST_GET_FIRST(pars_sym_tab_global->sym_list);
while (node) {
if (node->resolved
&& ((node->token_type == SYM_VAR)
|| (node->token_type == SYM_CURSOR))
&& node->name
&& (sym_node->name_len == node->name_len)
&& (ut_memcmp(sym_node->name, node->name,
node->name_len) == 0)) {
/* Found a variable or a cursor declared with
the same name */
break;
}
node = UT_LIST_GET_NEXT(sym_list, node);
}
if (!node) {
printf("PARSER ERROR: Unresolved identifier %s\n",
sym_node->name);
}
ut_a(node);
sym_node->resolved = TRUE;
sym_node->token_type = SYM_IMPLICIT_VAR;
sym_node->alias = node;
sym_node->indirection = node;
if (select_node) {
UT_LIST_ADD_LAST(col_var_list, select_node->copy_variables,
sym_node);
}
dfield_set_type(que_node_get_val(sym_node),
que_node_get_data_type(node));
}
/*************************************************************************
Resolves the meaning of variables in an expression list. It is an error if
some identifier cannot be resolved here. Resolves also the data types of
functions. */
static
void
pars_resolve_exp_list_variables_and_types(
/*======================================*/
sel_node_t* select_node, /* in: select node or NULL */
que_node_t* exp_node) /* in: expression list first node, or
NULL */
{
while (exp_node) {
pars_resolve_exp_variables_and_types(select_node, exp_node);
exp_node = que_node_get_next(exp_node);
}
}
/*************************************************************************
Resolves the columns in an expression. */
static
void
pars_resolve_exp_columns(
/*=====================*/
sym_node_t* table_node, /* in: first node in a table list */
que_node_t* exp_node) /* in: expression */
{
func_node_t* func_node;
que_node_t* arg;
sym_node_t* sym_node;
dict_table_t* table;
sym_node_t* t_node;
dict_col_t* col;
ulint n_cols;
ulint i;
ut_a(exp_node);
if (que_node_get_type(exp_node) == QUE_NODE_FUNC) {
func_node = exp_node;
arg = func_node->args;
while (arg) {
pars_resolve_exp_columns(table_node, arg);
arg = que_node_get_next(arg);
}
return;
}
ut_a(que_node_get_type(exp_node) == QUE_NODE_SYMBOL);
sym_node = exp_node;
if (sym_node->resolved) {
return;
}
/* Not resolved yet: look in the table list for a column with the
same name */
t_node = table_node;
while (t_node) {
table = t_node->table;
n_cols = dict_table_get_n_user_cols(table);
for (i = 0; i < n_cols; i++) {
col = dict_table_get_nth_col(table, i);
if ((sym_node->name_len == ut_strlen(col->name))
&& (0 == ut_memcmp(sym_node->name, col->name,
sym_node->name_len))) {
/* Found */
sym_node->resolved = TRUE;
sym_node->token_type = SYM_COLUMN;
sym_node->table = table;
sym_node->col_no = i;
sym_node->prefetch_buf = NULL;
dfield_set_type(&(sym_node->common.val),
dict_col_get_type(col));
return;
}
}
t_node = que_node_get_next(t_node);
}
}
/*************************************************************************
Resolves the meaning of columns in an expression list. */
static
void
pars_resolve_exp_list_columns(
/*==========================*/
sym_node_t* table_node, /* in: first node in a table list */
que_node_t* exp_node) /* in: expression list first node, or
NULL */
{
while (exp_node) {
pars_resolve_exp_columns(table_node, exp_node);
exp_node = que_node_get_next(exp_node);
}
}
/*************************************************************************
Retrieves the stored procedure definition for a procedure name. */
static
void
pars_retrieve_procedure_def(
/*========================*/
sym_node_t* sym_node) /* in: procedure name node */
{
ut_a(sym_node);
ut_a(que_node_get_type(sym_node) == QUE_NODE_SYMBOL);
sym_node->resolved = TRUE;
sym_node->token_type = SYM_PROCEDURE_NAME;
sym_node->procedure_def = dict_procedure_get((char*)sym_node->name,
NULL);
ut_a(sym_node->procedure_def);
}
/*************************************************************************
Retrieves the table definition for a table name id. */
static
void
pars_retrieve_table_def(
/*====================*/
sym_node_t* sym_node) /* in: table node */
{
char* table_name;
ut_a(sym_node);
ut_a(que_node_get_type(sym_node) == QUE_NODE_SYMBOL);
sym_node->resolved = TRUE;
sym_node->token_type = SYM_TABLE;
table_name = (char*) sym_node->name;
sym_node->table = dict_table_get_low(table_name);
ut_a(sym_node->table);
}
/*************************************************************************
Retrieves the table definitions for a list of table name ids. */
static
ulint
pars_retrieve_table_list_defs(
/*==========================*/
/* out: number of tables */
sym_node_t* sym_node) /* in: first table node in list */
{
ulint count = 0;
if (sym_node == NULL) {
return(count);
}
while (sym_node) {
pars_retrieve_table_def(sym_node);
count++;
sym_node = que_node_get_next(sym_node);
}
return(count);
}
/*************************************************************************
Adds all columns to the select list if the query is SELECT * FROM ... */
static
void
pars_select_all_columns(
/*====================*/
sel_node_t* select_node) /* in: select node already containing
the table list */
{
sym_node_t* col_node;
sym_node_t* table_node;
dict_table_t* table;
dict_col_t* col;
ulint i;
select_node->select_list = NULL;
table_node = select_node->table_list;
while (table_node) {
table = table_node->table;
for (i = 0; i < dict_table_get_n_user_cols(table); i++) {
col = dict_table_get_nth_col(table, i);
col_node = sym_tab_add_id(pars_sym_tab_global,
(byte*)col->name,
ut_strlen(col->name));
select_node->select_list
= que_node_list_add_last(
select_node->select_list,
col_node);
}
table_node = que_node_get_next(table_node);
}
}
/*************************************************************************
Parses a select list; creates a query graph node for the whole SELECT
statement. */
sel_node_t*
pars_select_list(
/*=============*/
/* out, own: select node in a query
tree */
que_node_t* select_list, /* in: select list */
sym_node_t* into_list) /* in: variables list or NULL */
{
sel_node_t* node;
node = sel_node_create(pars_sym_tab_global->heap);
node->select_list = select_list;
node->into_list = into_list;
pars_resolve_exp_list_variables_and_types(NULL, into_list);
return(node);
}
/*************************************************************************
Checks if the query is an aggregate query, in which case the selct list must
contain only aggregate function items. */
static
void
pars_check_aggregate(
/*=================*/
sel_node_t* select_node) /* in: select node already containing
the select list */
{
que_node_t* exp_node;
func_node_t* func_node;
ulint n_nodes = 0;
ulint n_aggregate_nodes = 0;
exp_node = select_node->select_list;
while (exp_node) {
n_nodes++;
if (que_node_get_type(exp_node) == QUE_NODE_FUNC) {
func_node = exp_node;
if (func_node->class == PARS_FUNC_AGGREGATE) {
n_aggregate_nodes++;
}
}
exp_node = que_node_get_next(exp_node);
}
if (n_aggregate_nodes > 0) {
ut_a(n_nodes == n_aggregate_nodes);
select_node->is_aggregate = TRUE;
} else {
select_node->is_aggregate = FALSE;
}
}
/*************************************************************************
Parses a select statement. */
sel_node_t*
pars_select_statement(
/*==================*/
/* out, own: select node in a query
tree */
sel_node_t* select_node, /* in: select node already containing
the select list */
sym_node_t* table_list, /* in: table list */
que_node_t* search_cond, /* in: search condition or NULL */
pars_res_word_t* for_update, /* in: NULL or &pars_update_token */
pars_res_word_t* consistent_read,/* in: NULL or
&pars_consistent_token */
order_node_t* order_by) /* in: NULL or an order-by node */
{
select_node->state = SEL_NODE_OPEN;
select_node->table_list = table_list;
select_node->n_tables = pars_retrieve_table_list_defs(table_list);
if (select_node->select_list == &pars_star_denoter) {
/* SELECT * FROM ... */
pars_select_all_columns(select_node);
}
if (select_node->into_list) {
ut_a(que_node_list_get_len(select_node->into_list)
== que_node_list_get_len(select_node->select_list));
}
UT_LIST_INIT(select_node->copy_variables);
pars_resolve_exp_list_columns(table_list, select_node->select_list);
pars_resolve_exp_list_variables_and_types(select_node,
select_node->select_list);
pars_check_aggregate(select_node);
select_node->search_cond = search_cond;
if (search_cond) {
pars_resolve_exp_columns(table_list, search_cond);
pars_resolve_exp_variables_and_types(select_node, search_cond);
}
if (for_update) {
ut_a(!consistent_read);
select_node->set_x_locks = TRUE;
select_node->row_lock_mode = LOCK_X;
} else {
select_node->set_x_locks = FALSE;
select_node->row_lock_mode = LOCK_S;
}
if (consistent_read) {
select_node->consistent_read = TRUE;
} else {
select_node->consistent_read = FALSE;
select_node->read_view = NULL;
}
select_node->order_by = order_by;
if (order_by) {
pars_resolve_exp_columns(table_list, order_by->column);
}
/* The final value of the following fields depend on the environment
where the select statement appears: */
select_node->can_get_updated = FALSE;
select_node->explicit_cursor = NULL;
opt_search_plan(select_node);
return(select_node);
}
/*************************************************************************
Parses a cursor declaration. */
que_node_t*
pars_cursor_declaration(
/*====================*/
/* out: sym_node */
sym_node_t* sym_node, /* in: cursor id node in the symbol
table */
sel_node_t* select_node) /* in: select node */
{
sym_node->resolved = TRUE;
sym_node->token_type = SYM_CURSOR;
sym_node->cursor_def = select_node;
select_node->state = SEL_NODE_CLOSED;
select_node->explicit_cursor = sym_node;
return(sym_node);
}
/*************************************************************************
Parses a delete or update statement start. */
upd_node_t*
pars_update_statement_start(
/*========================*/
/* out, own: update node in a query
tree */
ibool is_delete, /* in: TRUE if delete */
sym_node_t* table_sym, /* in: table name node */
col_assign_node_t* col_assign_list)/* in: column assignment list, NULL
if delete */
{
upd_node_t* node;
node = upd_node_create(pars_sym_tab_global->heap);
node->is_delete = is_delete;
node->table_sym = table_sym;
node->col_assign_list = col_assign_list;
return(node);
}
/*************************************************************************
Parses a column assignment in an update. */
col_assign_node_t*
pars_column_assignment(
/*===================*/
/* out: column assignment node */
sym_node_t* column, /* in: column to assign */
que_node_t* exp) /* in: value to assign */
{
col_assign_node_t* node;
node = mem_heap_alloc(pars_sym_tab_global->heap,
sizeof(col_assign_node_t));
node->common.type = QUE_NODE_COL_ASSIGNMENT;
node->col = column;
node->val = exp;
return(node);
}
/*************************************************************************
Processes an update node assignment list. */
static
void
pars_process_assign_list(
/*=====================*/
upd_node_t* node) /* in: update node */
{
col_assign_node_t* col_assign_list;
sym_node_t* table_sym;
col_assign_node_t* assign_node;
upd_field_t* upd_field;
dict_index_t* clust_index;
sym_node_t* col_sym;
ulint changes_ord_field;
ulint changes_field_size;
ulint n_assigns;
ulint i;
table_sym = node->table_sym;
col_assign_list = node->col_assign_list;
clust_index = dict_table_get_first_index(node->table);
assign_node = col_assign_list;
n_assigns = 0;
while (assign_node) {
pars_resolve_exp_columns(table_sym, assign_node->col);
pars_resolve_exp_columns(table_sym, assign_node->val);
pars_resolve_exp_variables_and_types(NULL, assign_node->val);
/* ut_a(dtype_get_mtype(dfield_get_type(
que_node_get_val(assign_node->col)))
== dtype_get_mtype(dfield_get_type(
que_node_get_val(assign_node->val)))); */
/* Add to the update node all the columns found in assignment
values as columns to copy: therefore, TRUE */
opt_find_all_cols(TRUE, clust_index, &(node->columns), NULL,
assign_node->val);
n_assigns++;
assign_node = que_node_get_next(assign_node);
}
node->update = upd_create(n_assigns, pars_sym_tab_global->heap);
assign_node = col_assign_list;
changes_field_size = UPD_NODE_NO_SIZE_CHANGE;
for (i = 0; i < n_assigns; i++) {
upd_field = upd_get_nth_field(node->update, i);
col_sym = assign_node->col;
upd_field_set_field_no(upd_field,
dict_index_get_nth_col_pos(clust_index,
col_sym->col_no),
clust_index);
upd_field->exp = assign_node->val;
if (!dtype_is_fixed_size(
dict_index_get_nth_type(clust_index,
upd_field->field_no))) {
changes_field_size = 0;
}
assign_node = que_node_get_next(assign_node);
}
/* Find out if the update can modify an ordering field in any index */
changes_ord_field = UPD_NODE_NO_ORD_CHANGE;
if (row_upd_changes_some_index_ord_field_binary(node->table,
node->update)) {
changes_ord_field = 0;
}
node->cmpl_info = changes_ord_field | changes_field_size;
}
/*************************************************************************
Parses an update or delete statement. */
upd_node_t*
pars_update_statement(
/*==================*/
/* out, own: update node in a query
tree */
upd_node_t* node, /* in: update node */
sym_node_t* cursor_sym, /* in: pointer to a cursor entry in
the symbol table or NULL */
que_node_t* search_cond) /* in: search condition or NULL */
{
sym_node_t* table_sym;
sel_node_t* sel_node;
plan_t* plan;
table_sym = node->table_sym;
pars_retrieve_table_def(table_sym);
node->table = table_sym->table;
UT_LIST_INIT(node->columns);
/* Make the single table node into a list of table nodes of length 1 */
que_node_list_add_last(NULL, table_sym);
if (cursor_sym) {
pars_resolve_exp_variables_and_types(NULL, cursor_sym);
sel_node = cursor_sym->alias->cursor_def;
node->searched_update = FALSE;
} else {
sel_node = pars_select_list(NULL, NULL);
pars_select_statement(sel_node, table_sym, search_cond, NULL,
NULL, NULL);
node->searched_update = TRUE;
sel_node->common.parent = node;
}
node->select = sel_node;
ut_a(!node->is_delete || (node->col_assign_list == NULL));
ut_a(node->is_delete || (node->col_assign_list != NULL));
if (node->is_delete) {
node->cmpl_info = 0;
} else {
pars_process_assign_list(node);
}
if (node->searched_update) {
node->has_clust_rec_x_lock = TRUE;
sel_node->set_x_locks = TRUE;
sel_node->row_lock_mode = LOCK_X;
} else {
node->has_clust_rec_x_lock = sel_node->set_x_locks;
}
ut_a(sel_node->n_tables == 1);
ut_a(sel_node->consistent_read == FALSE);
ut_a(sel_node->order_by == NULL);
ut_a(sel_node->is_aggregate == FALSE);
sel_node->can_get_updated = TRUE;
node->state = UPD_NODE_UPDATE_CLUSTERED;
plan = sel_node_get_nth_plan(sel_node, 0);
plan->no_prefetch = TRUE;
if (!((plan->index)->type & DICT_CLUSTERED)) {
plan->must_get_clust = TRUE;
node->pcur = &(plan->clust_pcur);
} else {
node->pcur = &(plan->pcur);
}
if (!node->is_delete && node->searched_update
&& (node->cmpl_info & UPD_NODE_NO_SIZE_CHANGE)
&& (node->cmpl_info & UPD_NODE_NO_ORD_CHANGE)) {
/* The select node can perform the update in-place */
ut_a(plan->asc);
node->select_will_do_update = TRUE;
sel_node->select_will_do_update = TRUE;
sel_node->latch_mode = BTR_MODIFY_LEAF;
}
return(node);
}
/*************************************************************************
Parses an insert statement. */
ins_node_t*
pars_insert_statement(
/*==================*/
/* out, own: update node in a query
tree */
sym_node_t* table_sym, /* in: table name node */
que_node_t* values_list, /* in: value expression list or NULL */
sel_node_t* select) /* in: select condition or NULL */
{
ins_node_t* node;
dtuple_t* row;
ulint ins_type;
ut_a(values_list || select);
ut_a(!values_list || !select);
if (values_list) {
ins_type = INS_VALUES;
} else {
ins_type = INS_SEARCHED;
}
pars_retrieve_table_def(table_sym);
node = ins_node_create(ins_type, table_sym->table,
pars_sym_tab_global->heap);
row = dtuple_create(pars_sym_tab_global->heap,
dict_table_get_n_cols(node->table));
dict_table_copy_types(row, table_sym->table);
ins_node_set_new_row(node, row);
node->select = select;
if (select) {
select->common.parent = node;
ut_a(que_node_list_get_len(select->select_list)
== dict_table_get_n_user_cols(table_sym->table));
}
node->values_list = values_list;
if (node->values_list) {
pars_resolve_exp_list_variables_and_types(NULL, values_list);
ut_a(que_node_list_get_len(values_list)
== dict_table_get_n_user_cols(table_sym->table));
}
return(node);
}
/*************************************************************************
Set the type of a dfield. */
static
void
pars_set_dfield_type(
/*=================*/
dfield_t* dfield, /* in: dfield */
pars_res_word_t* type) /* in: pointer to a type token */
{
if (type == &pars_int_token) {
dtype_set(dfield_get_type(dfield), DATA_INT, 0, 4, 0);
} else if (type == &pars_char_token) {
dtype_set(dfield_get_type(dfield), DATA_VARCHAR,
DATA_ENGLISH, 0, 0);
} else {
ut_error;
}
}
/*************************************************************************
Parses a variable declaration. */
sym_node_t*
pars_variable_declaration(
/*======================*/
/* out, own: symbol table node of type
SYM_VAR */
sym_node_t* node, /* in: symbol table node allocated for the
id of the variable */
pars_res_word_t* type) /* in: pointer to a type token */
{
node->resolved = TRUE;
node->token_type = SYM_VAR;
node->param_type = PARS_NOT_PARAM;
pars_set_dfield_type(que_node_get_val(node), type);
return(node);
}
/*************************************************************************
Parses a procedure parameter declaration. */
sym_node_t*
pars_parameter_declaration(
/*=======================*/
/* out, own: symbol table node of type
SYM_VAR */
sym_node_t* node, /* in: symbol table node allocated for the
id of the parameter */
ulint param_type,
/* in: PARS_INPUT or PARS_OUTPUT */
pars_res_word_t* type) /* in: pointer to a type token */
{
ut_a((param_type == PARS_INPUT) || (param_type == PARS_OUTPUT));
pars_variable_declaration(node, type);
node->param_type = param_type;
return(node);
}
/*************************************************************************
Sets the parent field in a query node list. */
static
void
pars_set_parent_in_list(
/*====================*/
que_node_t* node_list, /* in: first node in a list */
que_node_t* parent) /* in: parent value to set in all
nodes of the list */
{
que_common_t* common;
common = node_list;
while (common) {
common->parent = parent;
common = que_node_get_next(common);
}
}
/*************************************************************************
Parses an elsif element. */
elsif_node_t*
pars_elsif_element(
/*===============*/
/* out: elsif node */
que_node_t* cond, /* in: if-condition */
que_node_t* stat_list) /* in: statement list */
{
elsif_node_t* node;
node = mem_heap_alloc(pars_sym_tab_global->heap, sizeof(elsif_node_t));
node->common.type = QUE_NODE_ELSIF;
node->cond = cond;
pars_resolve_exp_variables_and_types(NULL, cond);
node->stat_list = stat_list;
return(node);
}
/*************************************************************************
Parses an if-statement. */
if_node_t*
pars_if_statement(
/*==============*/
/* out: if-statement node */
que_node_t* cond, /* in: if-condition */
que_node_t* stat_list, /* in: statement list */
que_node_t* else_part) /* in: else-part statement list
or elsif element list */
{
if_node_t* node;
elsif_node_t* elsif_node;
node = mem_heap_alloc(pars_sym_tab_global->heap, sizeof(if_node_t));
node->common.type = QUE_NODE_IF;
node->cond = cond;
pars_resolve_exp_variables_and_types(NULL, cond);
node->stat_list = stat_list;
if (else_part && (que_node_get_type(else_part) == QUE_NODE_ELSIF)) {
/* There is a list of elsif conditions */
node->else_part = NULL;
node->elsif_list = else_part;
elsif_node = else_part;
while (elsif_node) {
pars_set_parent_in_list(elsif_node->stat_list, node);
elsif_node = que_node_get_next(elsif_node);
}
} else {
node->else_part = else_part;
node->elsif_list = NULL;
pars_set_parent_in_list(else_part, node);
}
pars_set_parent_in_list(stat_list, node);
return(node);
}
/*************************************************************************
Parses a while-statement. */
while_node_t*
pars_while_statement(
/*=================*/
/* out: while-statement node */
que_node_t* cond, /* in: while-condition */
que_node_t* stat_list) /* in: statement list */
{
while_node_t* node;
node = mem_heap_alloc(pars_sym_tab_global->heap, sizeof(while_node_t));
node->common.type = QUE_NODE_WHILE;
node->cond = cond;
pars_resolve_exp_variables_and_types(NULL, cond);
node->stat_list = stat_list;
pars_set_parent_in_list(stat_list, node);
return(node);
}
/*************************************************************************
Parses a for-loop-statement. */
for_node_t*
pars_for_statement(
/*===============*/
/* out: for-statement node */
sym_node_t* loop_var, /* in: loop variable */
que_node_t* loop_start_limit,/* in: loop start expression */
que_node_t* loop_end_limit, /* in: loop end expression */
que_node_t* stat_list) /* in: statement list */
{
for_node_t* node;
node = mem_heap_alloc(pars_sym_tab_global->heap, sizeof(for_node_t));
node->common.type = QUE_NODE_FOR;
pars_resolve_exp_variables_and_types(NULL, loop_var);
pars_resolve_exp_variables_and_types(NULL, loop_start_limit);
pars_resolve_exp_variables_and_types(NULL, loop_end_limit);
node->loop_var = loop_var->indirection;
ut_a(loop_var->indirection);
node->loop_start_limit = loop_start_limit;
node->loop_end_limit = loop_end_limit;
node->stat_list = stat_list;
pars_set_parent_in_list(stat_list, node);
return(node);
}
/*************************************************************************
Parses a return-statement. */
return_node_t*
pars_return_statement(void)
/*=======================*/
/* out: return-statement node */
{
return_node_t* node;
node = mem_heap_alloc(pars_sym_tab_global->heap,
sizeof(return_node_t));
node->common.type = QUE_NODE_RETURN;
return(node);
}
/*************************************************************************
Parses an assignment statement. */
assign_node_t*
pars_assignment_statement(
/*======================*/
/* out: assignment statement node */
sym_node_t* var, /* in: variable to assign */
que_node_t* val) /* in: value to assign */
{
assign_node_t* node;
node = mem_heap_alloc(pars_sym_tab_global->heap,
sizeof(assign_node_t));
node->common.type = QUE_NODE_ASSIGNMENT;
node->var = var;
node->val = val;
pars_resolve_exp_variables_and_types(NULL, var);
pars_resolve_exp_variables_and_types(NULL, val);
ut_a(dtype_get_mtype(dfield_get_type(que_node_get_val(var)))
== dtype_get_mtype(dfield_get_type(que_node_get_val(val))));
return(node);
}
/*************************************************************************
Parses a procedure call. */
func_node_t*
pars_procedure_call(
/*================*/
/* out: function node */
que_node_t* res_word,/* in: procedure name reserved word */
que_node_t* args) /* in: argument list */
{
func_node_t* node;
node = pars_func(res_word, args);
pars_resolve_exp_list_variables_and_types(NULL, args);
return(node);
}
/*************************************************************************
Parses a fetch statement. */
fetch_node_t*
pars_fetch_statement(
/*=================*/
/* out: fetch statement node */
sym_node_t* cursor, /* in: cursor node */
sym_node_t* into_list) /* in: variables to set */
{
sym_node_t* cursor_decl;
fetch_node_t* node;
node = mem_heap_alloc(pars_sym_tab_global->heap, sizeof(fetch_node_t));
node->common.type = QUE_NODE_FETCH;
pars_resolve_exp_variables_and_types(NULL, cursor);
pars_resolve_exp_list_variables_and_types(NULL, into_list);
node->into_list = into_list;
cursor_decl = cursor->alias;
ut_a(cursor_decl->token_type == SYM_CURSOR);
node->cursor_def = cursor_decl->cursor_def;
ut_a(que_node_list_get_len(into_list)
== que_node_list_get_len(node->cursor_def->select_list));
return(node);
}
/*************************************************************************
Parses an open or close cursor statement. */
open_node_t*
pars_open_statement(
/*================*/
/* out: fetch statement node */
ulint type, /* in: ROW_SEL_OPEN_CURSOR
or ROW_SEL_CLOSE_CURSOR */
sym_node_t* cursor) /* in: cursor node */
{
sym_node_t* cursor_decl;
open_node_t* node;
node = mem_heap_alloc(pars_sym_tab_global->heap, sizeof(open_node_t));
node->common.type = QUE_NODE_OPEN;
pars_resolve_exp_variables_and_types(NULL, cursor);
cursor_decl = cursor->alias;
ut_a(cursor_decl->token_type == SYM_CURSOR);
node->op_type = type;
node->cursor_def = cursor_decl->cursor_def;
return(node);
}
/*************************************************************************
Parses a row_printf-statement. */
row_printf_node_t*
pars_row_printf_statement(
/*======================*/
/* out: row_printf-statement node */
sel_node_t* sel_node) /* in: select node */
{
row_printf_node_t* node;
node = mem_heap_alloc(pars_sym_tab_global->heap,
sizeof(row_printf_node_t));
node->common.type = QUE_NODE_ROW_PRINTF;
node->sel_node = sel_node;
sel_node->common.parent = node;
return(node);
}
/*************************************************************************
Parses a commit statement. */
commit_node_t*
pars_commit_statement(void)
/*=======================*/
{
return(commit_node_create(pars_sym_tab_global->heap));
}
/*************************************************************************
Parses a rollback statement. */
roll_node_t*
pars_rollback_statement(void)
/*=========================*/
{
return(roll_node_create(pars_sym_tab_global->heap));
}
/*************************************************************************
Parses a column definition at a table creation. */
sym_node_t*
pars_column_def(
/*============*/
/* out: column sym table node */
sym_node_t* sym_node, /* in: column node in the symbol
table */
pars_res_word_t* type) /* in: data type */
{
pars_set_dfield_type(que_node_get_val(sym_node), type);
return(sym_node);
}
/*************************************************************************
Parses a table creation operation. */
tab_node_t*
pars_create_table(
/*==============*/
/* out: table create subgraph */
sym_node_t* table_sym, /* in: table name node in the symbol
table */
sym_node_t* column_defs, /* in: list of column names */
void* not_fit_in_memory)/* in: a non-NULL pointer means that
this is a table which in simulations
should be simulated as not fitting
in memory; thread is put to sleep
to simulate disk accesses; NOTE that
this flag is not stored to the data
dictionary on disk, and the database
will forget about non-NULL value if
it has to reload the table definition
from disk */
{
dict_table_t* table;
sym_node_t* column;
tab_node_t* node;
dtype_t* dtype;
ulint n_cols;
n_cols = que_node_list_get_len(column_defs);
table = dict_mem_table_create(table_sym->name, 0, n_cols);
if (not_fit_in_memory != NULL) {
table->does_not_fit_in_memory = TRUE;
}
column = column_defs;
while (column) {
dtype = dfield_get_type(que_node_get_val(column));
dict_mem_table_add_col(table, column->name, dtype->mtype,
dtype->prtype, dtype->len,
dtype->prec);
column->resolved = TRUE;
column->token_type = SYM_COLUMN;
column = que_node_get_next(column);
}
node = tab_create_graph_create(table, pars_sym_tab_global->heap);
table_sym->resolved = TRUE;
table_sym->token_type = SYM_TABLE;
return(node);
}
/*************************************************************************
Parses an index creation operation. */
ind_node_t*
pars_create_index(
/*==============*/
/* out: index create subgraph */
pars_res_word_t* unique_def, /* in: not NULL if a unique index */
pars_res_word_t* clustered_def, /* in: not NULL if a clustered index */
sym_node_t* index_sym, /* in: index name node in the symbol
table */
sym_node_t* table_sym, /* in: table name node in the symbol
table */
sym_node_t* column_list) /* in: list of column names */
{
dict_index_t* index;
sym_node_t* column;
ind_node_t* node;
ulint n_fields;
ulint ind_type;
n_fields = que_node_list_get_len(column_list);
ind_type = 0;
if (unique_def) {
ind_type = ind_type | DICT_UNIQUE;
}
if (clustered_def) {
ind_type = ind_type | DICT_CLUSTERED;
}
index = dict_mem_index_create(table_sym->name, index_sym->name, 0,
ind_type, n_fields);
column = column_list;
while (column) {
dict_mem_index_add_field(index, column->name, 0);
column->resolved = TRUE;
column->token_type = SYM_COLUMN;
column = que_node_get_next(column);
}
node = ind_create_graph_create(index, pars_sym_tab_global->heap);
table_sym->resolved = TRUE;
table_sym->token_type = SYM_TABLE;
index_sym->resolved = TRUE;
index_sym->token_type = SYM_TABLE;
return(node);
}
/*************************************************************************
Parses a procedure definition. */
que_fork_t*
pars_procedure_definition(
/*======================*/
/* out: query fork node */
sym_node_t* sym_node, /* in: procedure id node in the symbol
table */
sym_node_t* param_list, /* in: parameter declaration list */
que_node_t* stat_list) /* in: statement list */
{
proc_node_t* node;
que_fork_t* fork;
que_thr_t* thr;
mem_heap_t* heap;
heap = pars_sym_tab_global->heap;
fork = que_fork_create(NULL, NULL, QUE_FORK_PROCEDURE, heap);
fork->trx = NULL;
thr = que_thr_create(fork, heap);
node = mem_heap_alloc(heap, sizeof(proc_node_t));
node->common.type = QUE_NODE_PROC;
node->common.parent = thr;
sym_node->token_type = SYM_PROCEDURE_NAME;
sym_node->resolved = TRUE;
node->proc_id = sym_node;
node->param_list = param_list;
node->stat_list = stat_list;
pars_set_parent_in_list(stat_list, node);
node->sym_tab = pars_sym_tab_global;
thr->child = node;
pars_sym_tab_global->query_graph = fork;
return(fork);
}
/*****************************************************************
Parses a stored procedure call, when this is not within another stored
procedure, that is, the client issues a procedure call directly. */
que_fork_t*
pars_stored_procedure_call(
/*=======================*/
/* out: query graph */
sym_node_t* sym_node) /* in: stored procedure name */
{
call_node_t* node;
que_fork_t* fork;
que_thr_t* thr;
mem_heap_t* heap;
heap = pars_sym_tab_global->heap;
fork = que_fork_create(NULL, NULL, QUE_FORK_PROCEDURE_CALL, heap);
fork->trx = NULL;
thr = que_thr_create(fork, heap);
node = mem_heap_alloc(heap, sizeof(call_node_t));
thr->child = node;
node->common.type = QUE_NODE_CALL;
node->common.parent = thr;
sym_node->token_type = SYM_PROCEDURE_NAME;
pars_retrieve_procedure_def(sym_node);
node->procedure_def = sym_node->procedure_def;
node->proc_name = sym_node;
node->sym_tab = pars_sym_tab_global;
pars_sym_tab_global->query_graph = fork;
return(fork);
}
/*****************************************************************
Writes info about query parameter markers (denoted with '?' in ODBC) into a
buffer. */
ulint
pars_write_query_param_info(
/*========================*/
/* out: number of bytes used for info in buf */
byte* buf, /* in: buffer which must be big enough */
que_fork_t* graph) /* in: parsed query graph */
{
que_thr_t* thr;
call_node_t* call_node;
dict_proc_t* procedure_def;
que_t* stored_graph;
proc_node_t* proc_node;
sym_node_t* param;
ulint n_params;
ibool is_input;
/* We currently support parameter markers only in stored procedure
calls, and there ALL procedure parameters must be marked with '?':
no literal values are allowed */
thr = UT_LIST_GET_FIRST(graph->thrs);
n_params = 0;
if (que_node_get_type(thr->child) == QUE_NODE_CALL) {
call_node = thr->child;
procedure_def = call_node->procedure_def;
stored_graph = dict_procedure_reserve_parsed_copy(
procedure_def);
proc_node = que_fork_get_child(stored_graph);
param = proc_node->param_list;
while (param) {
if (param->param_type == PARS_INPUT) {
is_input = TRUE;
} else {
is_input = FALSE;
}
mach_write_to_1(buf + 4 + n_params, is_input);
n_params++;
param = que_node_get_next(param);
}
dict_procedure_release_parsed_copy(stored_graph);
}
mach_write_to_4(buf, n_params);
return(4 + n_params);
}
/*****************************************************************
Reads stored procedure input parameter values from a buffer. */
void
pars_proc_read_input_params_from_buf(
/*=================================*/
que_t* graph, /* in: query graph which contains a stored procedure */
byte* buf) /* in: buffer */
{
que_thr_t* thr;
proc_node_t* proc_node;
sym_node_t* param;
byte* ptr;
ulint len;
lint odbc_len;
ut_ad(graph->fork_type == QUE_FORK_PROCEDURE);
thr = UT_LIST_GET_FIRST(graph->thrs);
proc_node = thr->child;
ptr = buf;
param = proc_node->param_list;
while (param) {
if (param->param_type == PARS_INPUT) {
odbc_len = (lint)mach_read_from_4(ptr);
ptr += 4;
if (odbc_len == SQL_NULL_DATA) {
len = UNIV_SQL_NULL;
} else {
len = (ulint)odbc_len;
}
eval_node_copy_and_alloc_val(param, ptr, len);
if (len != UNIV_SQL_NULL) {
ptr += len;
}
}
param = que_node_get_next(param);
}
ut_ad(ptr - buf < ODBC_DATAGRAM_SIZE);
}
/*****************************************************************
Writes stored procedure output parameter values to a buffer. */
ulint
pars_proc_write_output_params_to_buf(
/*=================================*/
/* out: bytes used in buf */
byte* buf, /* in: buffer which must be big enough */
que_t* graph) /* in: query graph which contains a stored procedure */
{
que_thr_t* thr;
proc_node_t* proc_node;
sym_node_t* param;
dfield_t* dfield;
byte* ptr;
ulint len;
lint odbc_len;
ut_ad(graph->fork_type == QUE_FORK_PROCEDURE);
thr = UT_LIST_GET_FIRST(graph->thrs);
proc_node = thr->child;
ptr = buf;
param = proc_node->param_list;
while (param) {
if (param->param_type == PARS_OUTPUT) {
dfield = que_node_get_val(param);
len = dfield_get_len(dfield);
if (len == UNIV_SQL_NULL) {
odbc_len = SQL_NULL_DATA;
} else {
odbc_len = (lint)len;
}
mach_write_to_4(ptr, (ulint)odbc_len);
ptr += 4;
if (len != UNIV_SQL_NULL) {
ut_memcpy(ptr, dfield_get_data(dfield), len);
ptr += len;
}
}
param = que_node_get_next(param);
}
ut_ad(ptr - buf < ODBC_DATAGRAM_SIZE);
return((ulint)(ptr - buf));
}
/*****************************************************************
Retrieves characters to the lexical analyzer. */
void
pars_get_lex_chars(
/*===============*/
char* buf, /* in/out: buffer where to copy */
int* result, /* out: number of characters copied or EOF */
int max_size) /* in: maximum number of characters which fit
in the buffer */
{
int len;
char print_buf[16];
len = pars_sym_tab_global->string_len
- pars_sym_tab_global->next_char_pos;
if (len == 0) {
#ifdef YYDEBUG
/* printf("SQL string ends\n"); */
#endif
*result = 0;
return;
}
if (len > max_size) {
len = max_size;
}
if (pars_print_lexed) {
if (len >= 5) {
len = 5;
}
ut_memcpy(print_buf, pars_sym_tab_global->sql_string +
pars_sym_tab_global->next_char_pos, len);
print_buf[len] = '\0';
printf("%s", print_buf);
}
ut_memcpy(buf, pars_sym_tab_global->sql_string +
pars_sym_tab_global->next_char_pos, len);
*result = len;
pars_sym_tab_global->next_char_pos += len;
}
/*****************************************************************
Instructs the lexical analyzer to stop when it receives the EOF integer. */
int
yywrap(void)
/*========*/
/* out: returns TRUE */
{
return(1);
}
/*****************************************************************
Called by yyparse on error. */
void
yyerror(
/*====*/
char* s __attribute__((unused))) /* in: error message string */
{
ut_ad(s);
printf("PARSER ERROR: Syntax error in SQL string\n");
ut_error;
}
/*****************************************************************
Parses an SQL string returning the query graph. */
que_t*
pars_sql(
/*=====*/
/* out, own: the query graph */
char* str) /* in: SQL string */
{
sym_node_t* sym_node;
mem_heap_t* heap;
que_t* graph;
ulint len;
char* buf;
ut_ad(str);
heap = mem_heap_create(256);
/* Currently, the parser is not reentrant: */
ut_ad(mutex_own(&(dict_sys->mutex)));
pars_sym_tab_global = sym_tab_create(heap);
len = ut_strlen(str);
buf = mem_heap_alloc(heap, len + 1);
ut_memcpy(buf, str, len + 1);
pars_sym_tab_global->sql_string = buf;
pars_sym_tab_global->string_len = len;
pars_sym_tab_global->next_char_pos = 0;
yyparse();
sym_node = UT_LIST_GET_FIRST(pars_sym_tab_global->sym_list);
while (sym_node) {
ut_a(sym_node->resolved);
sym_node = UT_LIST_GET_NEXT(sym_list, sym_node);
}
graph = pars_sym_tab_global->query_graph;
graph->sym_tab = pars_sym_tab_global;
/* printf("SQL graph size %lu\n", mem_heap_get_size(heap)); */
return(graph);
}
/**********************************************************************
Completes a query graph by adding query thread and fork nodes
above it and prepares the graph for running. The fork created is of
type QUE_FORK_MYSQL_INTERFACE. */
que_thr_t*
pars_complete_graph_for_exec(
/*=========================*/
/* out: query thread node to run */
que_node_t* node, /* in: root node for an incomplete
query graph */
trx_t* trx, /* in: transaction handle */
mem_heap_t* heap) /* in: memory heap from which allocated */
{
que_fork_t* fork;
que_thr_t* thr;
fork = que_fork_create(NULL, NULL, QUE_FORK_MYSQL_INTERFACE, heap);
fork->trx = trx;
thr = que_thr_create(fork, heap);
thr->child = node;
que_node_set_parent(node, thr);
trx->graph = NULL;
return(thr);
}
Reference in a new issue View git blame Copy permalink