mirror of
https://github.com/MariaDB/server.git
synced 2025-01-31 02:51:44 +01:00
094de71742
que_eval_sql(): Remove the parameter lock_dict. The only caller with lock_dict=true was dict_stats_exec_sql(), which will now explicitly invoke dict_sys.lock() and dict_sys.unlock() by itself. row_import_cleanup(): Do not unnecessarily lock the dictionary. Concurrent access to the table during ALTER TABLE...IMPORT TABLESPACE is prevented by MDL and the fact that there cannot exist any undo log or change buffer records that would refer to the table or tablespace. row_import_for_mysql(): Do not unnecessarily lock the dictionary while accessing fil_system. Thanks to MDL_EXCLUSIVE that was acquired by the SQL layer, only one IMPORT may be in effect for the table name. row_quiesce_set_state(): Do not unnecessarily lock the dictionary. The dict_table_t::quiesce state is documented to be protected by all index latches, which we are acquiring. dict_table_close(): Introduce a simpler variant with fewer parameters. dict_table_close(): Reduce the amount of calls. We can simply invoke dict_table_t::release() on startup or in DDL operations, or when the table is inaccessible. In none of these cases, there is no need to invalidate the InnoDB persistent statistics. pars_info_t::graph_owns_us: Remove (unused). pars_info_free(): Define inline. fts_delete(), trx_t::evict_table(), row_prebuilt_free(), row_rename_table_for_mysql(): Simplify. row_mysql_lock_data_dictionary(): Remove some references; use dict_sys.lock() and dict_sys.unlock() instead. row_mysql_lock_table(): Remove. Use lock_table_for_trx() instead. ha_innobase::check_if_supported_inplace_alter(), row_create_table_for_mysql(): Simply assert dict_sys.sys_tables_exist(). In commit49e2c8f0a6
and commit1bd681c8b3
srv_start() actually guarantees that the system tables will exist, or the server is in read-only mode, or startup will fail. Reviewed by: Thirunarayanan Balathandayuthapani
695 lines
24 KiB
C
695 lines
24 KiB
C
/*****************************************************************************
|
|
|
|
Copyright (c) 1996, 2016, Oracle and/or its affiliates. All Rights Reserved.
|
|
Copyright (c) 2017, 2021, MariaDB Corporation.
|
|
|
|
This program is free software; you can redistribute it and/or modify it under
|
|
the terms of the GNU General Public License as published by the Free Software
|
|
Foundation; version 2 of the License.
|
|
|
|
This program is distributed in the hope that it will be useful, but WITHOUT
|
|
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
|
|
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License along with
|
|
this program; if not, write to the Free Software Foundation, Inc.,
|
|
51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA
|
|
|
|
*****************************************************************************/
|
|
|
|
/**************************************************//**
|
|
@file include/pars0pars.h
|
|
SQL parser
|
|
|
|
Created 11/19/1996 Heikki Tuuri
|
|
*******************************************************/
|
|
|
|
#ifndef pars0pars_h
|
|
#define pars0pars_h
|
|
|
|
#include "que0types.h"
|
|
#include "pars0types.h"
|
|
#include "row0types.h"
|
|
#include "trx0types.h"
|
|
#include "ut0vec.h"
|
|
#include "row0mysql.h"
|
|
|
|
/** Type of the user functions. The first argument is always InnoDB-supplied
|
|
and varies in type, while 'user_arg' is a user-supplied argument. The
|
|
meaning of the return type also varies. See the individual use cases, e.g.
|
|
the FETCH statement, for details on them. */
|
|
typedef ibool (*pars_user_func_cb_t)(void* arg, void* user_arg);
|
|
|
|
/** If the following is set TRUE, the parser will emit debugging
|
|
information */
|
|
extern int yydebug;
|
|
|
|
/* Global variable used while parsing a single procedure or query : the code is
|
|
NOT re-entrant */
|
|
extern sym_tab_t* pars_sym_tab_global;
|
|
|
|
extern pars_res_word_t pars_to_binary_token;
|
|
extern pars_res_word_t pars_substr_token;
|
|
extern pars_res_word_t pars_concat_token;
|
|
extern pars_res_word_t pars_length_token;
|
|
extern pars_res_word_t pars_instr_token;
|
|
extern pars_res_word_t pars_count_token;
|
|
extern pars_res_word_t pars_int_token;
|
|
extern pars_res_word_t pars_bigint_token;
|
|
extern pars_res_word_t pars_char_token;
|
|
extern pars_res_word_t pars_update_token;
|
|
extern pars_res_word_t pars_asc_token;
|
|
extern pars_res_word_t pars_desc_token;
|
|
extern pars_res_word_t pars_open_token;
|
|
extern pars_res_word_t pars_close_token;
|
|
extern pars_res_word_t pars_share_token;
|
|
extern pars_res_word_t pars_unique_token;
|
|
extern pars_res_word_t pars_clustered_token;
|
|
|
|
extern ulint pars_star_denoter;
|
|
|
|
/* Procedure parameter types */
|
|
#define PARS_INPUT 0
|
|
#define PARS_OUTPUT 1
|
|
#define PARS_NOT_PARAM 2
|
|
|
|
int
|
|
yyparse(void);
|
|
|
|
/*************************************************************//**
|
|
Parses an SQL string returning the query graph.
|
|
@return own: the query graph */
|
|
que_t*
|
|
pars_sql(
|
|
/*=====*/
|
|
pars_info_t* info, /*!< in: extra information, or NULL */
|
|
const char* str); /*!< in: SQL string */
|
|
/*************************************************************//**
|
|
Retrieves characters to the lexical analyzer.
|
|
@return number of characters copied or 0 on EOF */
|
|
int
|
|
pars_get_lex_chars(
|
|
/*===============*/
|
|
char* buf, /*!< in/out: buffer where to copy */
|
|
size_t max_size); /*!< in: maximum number of characters which fit
|
|
in the buffer */
|
|
/*************************************************************//**
|
|
Called by yyparse on error. */
|
|
void
|
|
yyerror(
|
|
/*====*/
|
|
const char* s); /*!< in: error message string */
|
|
/*********************************************************************//**
|
|
Parses a variable declaration.
|
|
@return own: symbol table node of type SYM_VAR */
|
|
sym_node_t*
|
|
pars_variable_declaration(
|
|
/*======================*/
|
|
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 */
|
|
/*********************************************************************//**
|
|
Parses a function expression.
|
|
@return own: function node in a query tree */
|
|
func_node_t*
|
|
pars_func(
|
|
/*======*/
|
|
que_node_t* res_word,/*!< in: function name reserved word */
|
|
que_node_t* arg); /*!< in: first argument in the argument list */
|
|
/*************************************************************************
|
|
Rebind a LIKE search string. NOTE: We ignore any '%' characters embedded
|
|
within the search string.
|
|
@return own: function node in a query tree */
|
|
int
|
|
pars_like_rebind(
|
|
/*=============*/
|
|
sym_node_t* node, /* in: The search string node.*/
|
|
const byte* ptr, /* in: literal to (re) bind */
|
|
ulint len); /* in: length of literal to (re) bind*/
|
|
/*********************************************************************//**
|
|
Parses an operator expression.
|
|
@return own: function node in a query tree */
|
|
func_node_t*
|
|
pars_op(
|
|
/*====*/
|
|
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 */
|
|
/*********************************************************************//**
|
|
Parses an ORDER BY clause. Order by a single column only is supported.
|
|
@return own: order-by node in a query tree */
|
|
order_node_t*
|
|
pars_order_by(
|
|
/*==========*/
|
|
sym_node_t* column, /*!< in: column name */
|
|
pars_res_word_t* asc); /*!< in: &pars_asc_token or pars_desc_token */
|
|
/*********************************************************************//**
|
|
Parses a select list; creates a query graph node for the whole SELECT
|
|
statement.
|
|
@return own: select node in a query tree */
|
|
sel_node_t*
|
|
pars_select_list(
|
|
/*=============*/
|
|
que_node_t* select_list, /*!< in: select list */
|
|
sym_node_t* into_list); /*!< in: variables list or NULL */
|
|
/*********************************************************************//**
|
|
Parses a cursor declaration.
|
|
@return sym_node */
|
|
que_node_t*
|
|
pars_cursor_declaration(
|
|
/*====================*/
|
|
sym_node_t* sym_node, /*!< in: cursor id node in the symbol
|
|
table */
|
|
sel_node_t* select_node); /*!< in: select node */
|
|
/*********************************************************************//**
|
|
Parses a function declaration.
|
|
@return sym_node */
|
|
que_node_t*
|
|
pars_function_declaration(
|
|
/*======================*/
|
|
sym_node_t* sym_node); /*!< in: function id node in the symbol
|
|
table */
|
|
/*********************************************************************//**
|
|
Parses a select statement.
|
|
@return own: select node in a query tree */
|
|
sel_node_t*
|
|
pars_select_statement(
|
|
/*==================*/
|
|
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 */
|
|
/*********************************************************************//**
|
|
Parses a column assignment in an update.
|
|
@return column assignment node */
|
|
col_assign_node_t*
|
|
pars_column_assignment(
|
|
/*===================*/
|
|
sym_node_t* column, /*!< in: column to assign */
|
|
que_node_t* exp); /*!< in: value to assign */
|
|
/*********************************************************************//**
|
|
Parses a delete or update statement start.
|
|
@return own: update node in a query tree */
|
|
upd_node_t*
|
|
pars_update_statement_start(
|
|
/*========================*/
|
|
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 */
|
|
/*********************************************************************//**
|
|
Parses an update or delete statement.
|
|
@return own: update node in a query tree */
|
|
upd_node_t*
|
|
pars_update_statement(
|
|
/*==================*/
|
|
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 */
|
|
/*********************************************************************//**
|
|
Parses an insert statement.
|
|
@return own: update node in a query tree */
|
|
ins_node_t*
|
|
pars_insert_statement(
|
|
/*==================*/
|
|
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 */
|
|
/*********************************************************************//**
|
|
Parses an elsif element.
|
|
@return elsif node */
|
|
elsif_node_t*
|
|
pars_elsif_element(
|
|
/*===============*/
|
|
que_node_t* cond, /*!< in: if-condition */
|
|
que_node_t* stat_list); /*!< in: statement list */
|
|
/*********************************************************************//**
|
|
Parses an if-statement.
|
|
@return if-statement node */
|
|
if_node_t*
|
|
pars_if_statement(
|
|
/*==============*/
|
|
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 */
|
|
/*********************************************************************//**
|
|
Parses a for-loop-statement.
|
|
@return for-statement node */
|
|
for_node_t*
|
|
pars_for_statement(
|
|
/*===============*/
|
|
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 */
|
|
/*********************************************************************//**
|
|
Parses a while-statement.
|
|
@return while-statement node */
|
|
while_node_t*
|
|
pars_while_statement(
|
|
/*=================*/
|
|
que_node_t* cond, /*!< in: while-condition */
|
|
que_node_t* stat_list); /*!< in: statement list */
|
|
/*********************************************************************//**
|
|
Parses an exit statement.
|
|
@return exit statement node */
|
|
exit_node_t*
|
|
pars_exit_statement(void);
|
|
/*=====================*/
|
|
/*********************************************************************//**
|
|
Parses a return-statement.
|
|
@return return-statement node */
|
|
return_node_t*
|
|
pars_return_statement(void);
|
|
/*=======================*/
|
|
/*********************************************************************//**
|
|
Parses a procedure call.
|
|
@return function node */
|
|
func_node_t*
|
|
pars_procedure_call(
|
|
/*================*/
|
|
que_node_t* res_word,/*!< in: procedure name reserved word */
|
|
que_node_t* args); /*!< in: argument list */
|
|
/*********************************************************************//**
|
|
Parses an assignment statement.
|
|
@return assignment statement node */
|
|
assign_node_t*
|
|
pars_assignment_statement(
|
|
/*======================*/
|
|
sym_node_t* var, /*!< in: variable to assign */
|
|
que_node_t* val); /*!< in: value to assign */
|
|
/*********************************************************************//**
|
|
Parses a fetch statement. into_list or user_func (but not both) must be
|
|
non-NULL.
|
|
@return fetch statement node */
|
|
fetch_node_t*
|
|
pars_fetch_statement(
|
|
/*=================*/
|
|
sym_node_t* cursor, /*!< in: cursor node */
|
|
sym_node_t* into_list, /*!< in: variables to set, or NULL */
|
|
sym_node_t* user_func); /*!< in: user function name, or NULL */
|
|
/*********************************************************************//**
|
|
Parses an open or close cursor statement.
|
|
@return fetch statement node */
|
|
open_node_t*
|
|
pars_open_statement(
|
|
/*================*/
|
|
ulint type, /*!< in: ROW_SEL_OPEN_CURSOR
|
|
or ROW_SEL_CLOSE_CURSOR */
|
|
sym_node_t* cursor); /*!< in: cursor node */
|
|
/*********************************************************************//**
|
|
Parses a row_printf-statement.
|
|
@return row_printf-statement node */
|
|
row_printf_node_t*
|
|
pars_row_printf_statement(
|
|
/*======================*/
|
|
sel_node_t* sel_node); /*!< in: select node */
|
|
/*********************************************************************//**
|
|
Parses a commit statement.
|
|
@return own: commit node struct */
|
|
commit_node_t*
|
|
pars_commit_statement(void);
|
|
/*=======================*/
|
|
/*********************************************************************//**
|
|
Parses a rollback statement.
|
|
@return own: rollback node struct */
|
|
roll_node_t*
|
|
pars_rollback_statement(void);
|
|
/*=========================*/
|
|
/*********************************************************************//**
|
|
Parses a column definition at a table creation.
|
|
@return column sym table node */
|
|
sym_node_t*
|
|
pars_column_def(
|
|
/*============*/
|
|
sym_node_t* sym_node, /*!< in: column node in the
|
|
symbol table */
|
|
pars_res_word_t* type, /*!< in: data type */
|
|
sym_node_t* len, /*!< in: length of column, or
|
|
NULL */
|
|
void* is_not_null); /*!< in: if not NULL, column
|
|
is of type NOT NULL. */
|
|
/*********************************************************************//**
|
|
Parses a table creation operation.
|
|
@return table create subgraph */
|
|
tab_node_t*
|
|
pars_create_table(
|
|
/*==============*/
|
|
sym_node_t* table_sym, /*!< in: table name node in the symbol
|
|
table */
|
|
sym_node_t* column_defs); /*!< in: list of column names */
|
|
/*********************************************************************//**
|
|
Parses an index creation operation.
|
|
@return index create subgraph */
|
|
ind_node_t*
|
|
pars_create_index(
|
|
/*==============*/
|
|
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 */
|
|
/*********************************************************************//**
|
|
Parses a procedure definition.
|
|
@return query fork node */
|
|
que_fork_t*
|
|
pars_procedure_definition(
|
|
/*======================*/
|
|
sym_node_t* sym_node, /*!< in: procedure id node in the symbol
|
|
table */
|
|
que_node_t* stat_list); /*!< in: statement list */
|
|
|
|
/** Completes a query graph by adding query thread and fork nodes
|
|
above it and prepares the graph for running.
|
|
@param[in] node root node for an incomplete query
|
|
graph, or NULL for dummy graph
|
|
@param[in] trx transaction handle
|
|
@param[in] heap memory heap from which allocated
|
|
@param[in] prebuilt row prebuilt structure
|
|
@return query thread node to run */
|
|
que_thr_t*
|
|
pars_complete_graph_for_exec(
|
|
que_node_t* node,
|
|
trx_t* trx,
|
|
mem_heap_t* heap,
|
|
row_prebuilt_t* prebuilt)
|
|
MY_ATTRIBUTE((nonnull(2,3), warn_unused_result));
|
|
|
|
/****************************************************************//**
|
|
Create parser info struct.
|
|
@return own: info struct */
|
|
pars_info_t*
|
|
pars_info_create(void);
|
|
/*==================*/
|
|
|
|
/****************************************************************//**
|
|
Add bound literal. */
|
|
void
|
|
pars_info_add_literal(
|
|
/*==================*/
|
|
pars_info_t* info, /*!< in: info struct */
|
|
const char* name, /*!< in: name */
|
|
const void* address, /*!< in: address */
|
|
ulint length, /*!< in: length of data */
|
|
ulint type, /*!< in: type, e.g. DATA_FIXBINARY */
|
|
ulint prtype); /*!< in: precise type, e.g.
|
|
DATA_UNSIGNED */
|
|
|
|
/****************************************************************//**
|
|
Equivalent to pars_info_add_literal(info, name, str, strlen(str),
|
|
DATA_VARCHAR, DATA_ENGLISH). */
|
|
void
|
|
pars_info_add_str_literal(
|
|
/*======================*/
|
|
pars_info_t* info, /*!< in: info struct */
|
|
const char* name, /*!< in: name */
|
|
const char* str); /*!< in: string */
|
|
/********************************************************************
|
|
If the literal value already exists then it rebinds otherwise it
|
|
creates a new entry.*/
|
|
void
|
|
pars_info_bind_literal(
|
|
/*===================*/
|
|
pars_info_t* info, /* in: info struct */
|
|
const char* name, /* in: name */
|
|
const void* address, /* in: address */
|
|
ulint length, /* in: length of data */
|
|
ulint type, /* in: type, e.g. DATA_FIXBINARY */
|
|
ulint prtype); /* in: precise type, e.g. */
|
|
/********************************************************************
|
|
If the literal value already exists then it rebinds otherwise it
|
|
creates a new entry.*/
|
|
void
|
|
pars_info_bind_varchar_literal(
|
|
/*===========================*/
|
|
pars_info_t* info, /*!< in: info struct */
|
|
const char* name, /*!< in: name */
|
|
const byte* str, /*!< in: string */
|
|
ulint str_len); /*!< in: string length */
|
|
/****************************************************************//**
|
|
Equivalent to:
|
|
|
|
char buf[4];
|
|
mach_write_to_4(buf, val);
|
|
pars_info_add_literal(info, name, buf, 4, DATA_INT, 0);
|
|
|
|
except that the buffer is dynamically allocated from the info struct's
|
|
heap. */
|
|
void
|
|
pars_info_bind_int4_literal(
|
|
/*=======================*/
|
|
pars_info_t* info, /*!< in: info struct */
|
|
const char* name, /*!< in: name */
|
|
const ib_uint32_t* val); /*!< in: value */
|
|
/********************************************************************
|
|
If the literal value already exists then it rebinds otherwise it
|
|
creates a new entry. */
|
|
void
|
|
pars_info_bind_int8_literal(
|
|
/*=======================*/
|
|
pars_info_t* info, /*!< in: info struct */
|
|
const char* name, /*!< in: name */
|
|
const ib_uint64_t* val); /*!< in: value */
|
|
/****************************************************************//**
|
|
Add user function. */
|
|
void
|
|
pars_info_bind_function(
|
|
/*===================*/
|
|
pars_info_t* info, /*!< in: info struct */
|
|
const char* name, /*!< in: function name */
|
|
pars_user_func_cb_t func, /*!< in: function address */
|
|
void* arg); /*!< in: user-supplied argument */
|
|
/****************************************************************//**
|
|
Add bound id. */
|
|
void
|
|
pars_info_bind_id(
|
|
/*=============*/
|
|
pars_info_t* info, /*!< in: info struct */
|
|
const char* name, /*!< in: name */
|
|
const char* id); /*!< in: id */
|
|
/****************************************************************//**
|
|
Equivalent to:
|
|
|
|
char buf[4];
|
|
mach_write_to_4(buf, val);
|
|
pars_info_add_literal(info, name, buf, 4, DATA_INT, 0);
|
|
|
|
except that the buffer is dynamically allocated from the info struct's
|
|
heap. */
|
|
void
|
|
pars_info_add_int4_literal(
|
|
/*=======================*/
|
|
pars_info_t* info, /*!< in: info struct */
|
|
const char* name, /*!< in: name */
|
|
ulint val); /*!< in: value */
|
|
|
|
/****************************************************************//**
|
|
Equivalent to:
|
|
|
|
char buf[8];
|
|
mach_write_to_8(buf, val);
|
|
pars_info_add_literal(info, name, buf, 8, DATA_FIXBINARY, 0);
|
|
|
|
except that the buffer is dynamically allocated from the info struct's
|
|
heap. */
|
|
void
|
|
pars_info_add_ull_literal(
|
|
/*======================*/
|
|
pars_info_t* info, /*!< in: info struct */
|
|
const char* name, /*!< in: name */
|
|
ib_uint64_t val); /*!< in: value */
|
|
|
|
/****************************************************************//**
|
|
If the literal value already exists then it rebinds otherwise it
|
|
creates a new entry. */
|
|
void
|
|
pars_info_bind_ull_literal(
|
|
/*=======================*/
|
|
pars_info_t* info, /*!< in: info struct */
|
|
const char* name, /*!< in: name */
|
|
const ib_uint64_t* val) /*!< in: value */
|
|
MY_ATTRIBUTE((nonnull));
|
|
|
|
/****************************************************************//**
|
|
Get bound literal with the given name.
|
|
@return bound literal, or NULL if not found */
|
|
pars_bound_lit_t*
|
|
pars_info_get_bound_lit(
|
|
/*====================*/
|
|
pars_info_t* info, /*!< in: info struct */
|
|
const char* name); /*!< in: bound literal name to find */
|
|
|
|
/****************************************************************//**
|
|
Get bound id with the given name.
|
|
@return bound id, or NULL if not found */
|
|
pars_bound_id_t*
|
|
pars_info_get_bound_id(
|
|
/*===================*/
|
|
pars_info_t* info, /*!< in: info struct */
|
|
const char* name); /*!< in: bound id name to find */
|
|
|
|
/******************************************************************//**
|
|
Release any resources used by the lexer. */
|
|
void
|
|
pars_lexer_close(void);
|
|
/*==================*/
|
|
|
|
/** Extra information supplied for pars_sql(). */
|
|
struct pars_info_t {
|
|
mem_heap_t* heap; /*!< our own memory heap */
|
|
|
|
ib_vector_t* funcs; /*!< user functions, or NUll
|
|
(pars_user_func_t*) */
|
|
ib_vector_t* bound_lits; /*!< bound literals, or NULL
|
|
(pars_bound_lit_t*) */
|
|
ib_vector_t* bound_ids; /*!< bound ids, or NULL
|
|
(pars_bound_id_t*) */
|
|
};
|
|
|
|
inline void pars_info_free(pars_info_t *info) { mem_heap_free(info->heap); }
|
|
|
|
/** User-supplied function and argument. */
|
|
struct pars_user_func_t {
|
|
const char* name; /*!< function name */
|
|
pars_user_func_cb_t func; /*!< function address */
|
|
void* arg; /*!< user-supplied argument */
|
|
};
|
|
|
|
/** Bound literal. */
|
|
struct pars_bound_lit_t {
|
|
const char* name; /*!< name */
|
|
const void* address; /*!< address */
|
|
ulint length; /*!< length of data */
|
|
ulint type; /*!< type, e.g. DATA_FIXBINARY */
|
|
ulint prtype; /*!< precise type, e.g. DATA_UNSIGNED */
|
|
sym_node_t* node; /*!< symbol node */
|
|
};
|
|
|
|
/** Bound identifier. */
|
|
struct pars_bound_id_t {
|
|
const char* name; /*!< name */
|
|
const char* id; /*!< identifier */
|
|
};
|
|
|
|
/** Struct used to denote a reserved word in a parsing tree */
|
|
struct pars_res_word_t{
|
|
int code; /*!< the token code for the reserved word from
|
|
pars0grm.h */
|
|
};
|
|
|
|
/** A predefined function or operator node in a parsing tree; this construct
|
|
is also used for some non-functions like the assignment ':=' */
|
|
struct func_node_t{
|
|
que_common_t common; /*!< type: QUE_NODE_FUNC */
|
|
int func; /*!< token code of the function name */
|
|
ulint fclass; /*!< class of the function */
|
|
que_node_t* args; /*!< argument(s) of the function */
|
|
UT_LIST_NODE_T(func_node_t) cond_list;
|
|
/*!< list of comparison conditions; defined
|
|
only for comparison operator nodes except,
|
|
presently, for OPT_SCROLL_TYPE ones */
|
|
UT_LIST_NODE_T(func_node_t) func_node_list;
|
|
/*!< list of function nodes in a parsed
|
|
query graph */
|
|
};
|
|
|
|
/** An order-by node in a select */
|
|
struct order_node_t{
|
|
que_common_t common; /*!< type: QUE_NODE_ORDER */
|
|
sym_node_t* column; /*!< order-by column */
|
|
ibool asc; /*!< TRUE if ascending, FALSE if descending */
|
|
};
|
|
|
|
/** Procedure definition node */
|
|
struct proc_node_t{
|
|
que_common_t common; /*!< type: QUE_NODE_PROC */
|
|
sym_node_t* proc_id; /*!< procedure name symbol in the symbol
|
|
table of this same procedure */
|
|
que_node_t* stat_list; /*!< statement list */
|
|
sym_tab_t* sym_tab; /*!< symbol table of this procedure */
|
|
};
|
|
|
|
/** elsif-element node */
|
|
struct elsif_node_t{
|
|
que_common_t common; /*!< type: QUE_NODE_ELSIF */
|
|
que_node_t* cond; /*!< if condition */
|
|
que_node_t* stat_list; /*!< statement list */
|
|
};
|
|
|
|
/** if-statement node */
|
|
struct if_node_t{
|
|
que_common_t common; /*!< type: QUE_NODE_IF */
|
|
que_node_t* cond; /*!< if condition */
|
|
que_node_t* stat_list; /*!< statement list */
|
|
que_node_t* else_part; /*!< else-part statement list */
|
|
elsif_node_t* elsif_list; /*!< elsif element list */
|
|
};
|
|
|
|
/** while-statement node */
|
|
struct while_node_t{
|
|
que_common_t common; /*!< type: QUE_NODE_WHILE */
|
|
que_node_t* cond; /*!< while condition */
|
|
que_node_t* stat_list; /*!< statement list */
|
|
};
|
|
|
|
/** for-loop-statement node */
|
|
struct for_node_t{
|
|
que_common_t common; /*!< type: QUE_NODE_FOR */
|
|
sym_node_t* loop_var; /*!< loop variable: this is the
|
|
dereferenced symbol from the
|
|
variable declarations, not the
|
|
symbol occurrence in the for loop
|
|
definition */
|
|
que_node_t* loop_start_limit;/*!< initial value of loop variable */
|
|
que_node_t* loop_end_limit; /*!< end value of loop variable */
|
|
lint loop_end_value; /*!< evaluated value for the end value:
|
|
it is calculated only when the loop
|
|
is entered, and will not change within
|
|
the loop */
|
|
que_node_t* stat_list; /*!< statement list */
|
|
};
|
|
|
|
/** exit statement node */
|
|
struct exit_node_t{
|
|
que_common_t common; /*!< type: QUE_NODE_EXIT */
|
|
};
|
|
|
|
/** return-statement node */
|
|
struct return_node_t{
|
|
que_common_t common; /*!< type: QUE_NODE_RETURN */
|
|
};
|
|
|
|
/** Assignment statement node */
|
|
struct assign_node_t{
|
|
que_common_t common; /*!< type: QUE_NODE_ASSIGNMENT */
|
|
sym_node_t* var; /*!< variable to set */
|
|
que_node_t* val; /*!< value to assign */
|
|
};
|
|
|
|
/** Column assignment node */
|
|
struct col_assign_node_t{
|
|
que_common_t common; /*!< type: QUE_NODE_COL_ASSIGN */
|
|
sym_node_t* col; /*!< column to set */
|
|
que_node_t* val; /*!< value to assign */
|
|
};
|
|
|
|
/** Classes of functions */
|
|
/* @{ */
|
|
#define PARS_FUNC_ARITH 1 /*!< +, -, *, / */
|
|
#define PARS_FUNC_LOGICAL 2 /*!< AND, OR, NOT */
|
|
#define PARS_FUNC_CMP 3 /*!< comparison operators */
|
|
#define PARS_FUNC_PREDEFINED 4 /*!< TO_NUMBER, SUBSTR, ... */
|
|
#define PARS_FUNC_AGGREGATE 5 /*!< COUNT */
|
|
#define PARS_FUNC_OTHER 6 /*!< these are not real functions,
|
|
e.g., := */
|
|
/* @} */
|
|
|
|
#endif
|