mirror of
https://github.com/MariaDB/server.git
synced 2025-10-30 10:26:12 +01:00
243 lines
8.5 KiB
C
243 lines
8.5 KiB
C
/*****************************************************************************
|
|
|
|
Copyright (c) 1997, 2016, Oracle and/or its affiliates. All Rights Reserved.
|
|
Copyright (c) 2017, 2019, 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/pars0sym.h
|
|
SQL parser symbol table
|
|
|
|
Created 12/15/1997 Heikki Tuuri
|
|
*******************************************************/
|
|
|
|
#ifndef pars0sym_h
|
|
#define pars0sym_h
|
|
|
|
#include "que0types.h"
|
|
#include "pars0types.h"
|
|
#include "row0types.h"
|
|
|
|
/******************************************************************//**
|
|
Creates a symbol table for a single stored procedure or query.
|
|
@return own: symbol table */
|
|
sym_tab_t*
|
|
sym_tab_create(
|
|
/*===========*/
|
|
mem_heap_t* heap); /*!< in: memory heap where to create */
|
|
/******************************************************************//**
|
|
Frees the memory allocated dynamically AFTER parsing phase for variables
|
|
etc. in the symbol table. Does not free the mem heap where the table was
|
|
originally created. Frees also SQL explicit cursor definitions. */
|
|
void
|
|
sym_tab_free_private(
|
|
/*=================*/
|
|
sym_tab_t* sym_tab); /*!< in, own: symbol table */
|
|
/******************************************************************//**
|
|
Adds an integer literal to a symbol table.
|
|
@return symbol table node */
|
|
sym_node_t*
|
|
sym_tab_add_int_lit(
|
|
/*================*/
|
|
sym_tab_t* sym_tab, /*!< in: symbol table */
|
|
ulint val); /*!< in: integer value */
|
|
/******************************************************************//**
|
|
Adds an string literal to a symbol table.
|
|
@return symbol table node */
|
|
sym_node_t*
|
|
sym_tab_add_str_lit(
|
|
/*================*/
|
|
sym_tab_t* sym_tab, /*!< in: symbol table */
|
|
const byte* str, /*!< in: string with no quotes around
|
|
it */
|
|
ulint len); /*!< in: string length */
|
|
/******************************************************************//**
|
|
Add a bound literal to a symbol table.
|
|
@return symbol table node */
|
|
sym_node_t*
|
|
sym_tab_add_bound_lit(
|
|
/*==================*/
|
|
sym_tab_t* sym_tab, /*!< in: symbol table */
|
|
const char* name, /*!< in: name of bound literal */
|
|
ulint* lit_type); /*!< out: type of literal (PARS_*_LIT) */
|
|
/**********************************************************************
|
|
Rebind literal to a node in the symbol table. */
|
|
sym_node_t*
|
|
sym_tab_rebind_lit(
|
|
/*===============*/
|
|
/* out: symbol table node */
|
|
sym_node_t* node, /* in: node that is bound to literal*/
|
|
const void* address, /* in: pointer to data */
|
|
ulint length); /* in: length of data */
|
|
/******************************************************************//**
|
|
Adds an SQL null literal to a symbol table.
|
|
@return symbol table node */
|
|
sym_node_t*
|
|
sym_tab_add_null_lit(
|
|
/*=================*/
|
|
sym_tab_t* sym_tab); /*!< in: symbol table */
|
|
/******************************************************************//**
|
|
Adds an identifier to a symbol table.
|
|
@return symbol table node */
|
|
sym_node_t*
|
|
sym_tab_add_id(
|
|
/*===========*/
|
|
sym_tab_t* sym_tab, /*!< in: symbol table */
|
|
byte* name, /*!< in: identifier name */
|
|
ulint len); /*!< in: identifier length */
|
|
|
|
/******************************************************************//**
|
|
Add a bound identifier to a symbol table.
|
|
@return symbol table node */
|
|
sym_node_t*
|
|
sym_tab_add_bound_id(
|
|
/*===========*/
|
|
sym_tab_t* sym_tab, /*!< in: symbol table */
|
|
const char* name); /*!< in: name of bound id */
|
|
|
|
/** Index of sym_node_t::field_nos corresponding to the clustered index */
|
|
#define SYM_CLUST_FIELD_NO 0
|
|
/** Index of sym_node_t::field_nos corresponding to a secondary index */
|
|
#define SYM_SEC_FIELD_NO 1
|
|
|
|
/** Types of a symbol table node */
|
|
enum sym_tab_entry {
|
|
SYM_UNSET, /*!< Unset entry. */
|
|
SYM_VAR = 91, /*!< declared parameter or local
|
|
variable of a procedure */
|
|
SYM_IMPLICIT_VAR, /*!< storage for a intermediate result
|
|
of a calculation */
|
|
SYM_LIT, /*!< literal */
|
|
SYM_TABLE_REF_COUNTED, /*!< database table name, ref counted. Must
|
|
be closed explicitly. */
|
|
SYM_TABLE, /*!< database table name */
|
|
SYM_COLUMN, /*!< database table name */
|
|
SYM_CURSOR, /*!< named cursor */
|
|
SYM_PROCEDURE_NAME, /*!< stored procedure name */
|
|
SYM_INDEX, /*!< database index name */
|
|
SYM_FUNCTION /*!< user function name */
|
|
};
|
|
|
|
/** Symbol table node */
|
|
struct sym_node_t{
|
|
que_common_t common; /*!< node type:
|
|
QUE_NODE_SYMBOL */
|
|
/* NOTE: if the data field in 'common.val' is not NULL and the symbol
|
|
table node is not for a temporary column, the memory for the value has
|
|
been allocated from dynamic memory and it should be freed when the
|
|
symbol table is discarded */
|
|
|
|
/* 'alias' and 'indirection' are almost the same, but not quite.
|
|
'alias' always points to the primary instance of the variable, while
|
|
'indirection' does the same only if we should use the primary
|
|
instance's values for the node's data. This is usually the case, but
|
|
when initializing a cursor (e.g., "DECLARE CURSOR c IS SELECT * FROM
|
|
t WHERE id = x;"), we copy the values from the primary instance to
|
|
the cursor's instance so that they are fixed for the duration of the
|
|
cursor, and set 'indirection' to NULL. If we did not, the value of
|
|
'x' could change between fetches and things would break horribly.
|
|
|
|
TODO: It would be cleaner to make 'indirection' a boolean field and
|
|
always use 'alias' to refer to the primary node. */
|
|
|
|
sym_node_t* indirection; /*!< pointer to
|
|
another symbol table
|
|
node which contains
|
|
the value for this
|
|
node, NULL otherwise */
|
|
sym_node_t* alias; /*!< pointer to
|
|
another symbol table
|
|
node for which this
|
|
node is an alias,
|
|
NULL otherwise */
|
|
UT_LIST_NODE_T(sym_node_t) col_var_list; /*!< list of table
|
|
columns or a list of
|
|
input variables for an
|
|
explicit cursor */
|
|
ibool copy_val; /*!< TRUE if a column
|
|
and its value should
|
|
be copied to dynamic
|
|
memory when fetched */
|
|
ulint field_nos[2]; /*!< if a column, in
|
|
the position
|
|
SYM_CLUST_FIELD_NO is
|
|
the field number in the
|
|
clustered index; in
|
|
the position
|
|
SYM_SEC_FIELD_NO
|
|
the field number in the
|
|
non-clustered index to
|
|
use first; if not found
|
|
from the index, then
|
|
ULINT_UNDEFINED */
|
|
ibool resolved; /*!< TRUE if the
|
|
meaning of a variable
|
|
or a column has been
|
|
resolved; for literals
|
|
this is always TRUE */
|
|
enum sym_tab_entry token_type; /*!< type of the
|
|
parsed token */
|
|
const char* name; /*!< name of an id */
|
|
ulint name_len; /*!< id name length */
|
|
dict_table_t* table; /*!< table definition
|
|
if a table id or a
|
|
column id */
|
|
ulint col_no; /*!< column number if a
|
|
column */
|
|
sel_buf_t* prefetch_buf; /*!< NULL, or a buffer
|
|
for cached column
|
|
values for prefetched
|
|
rows */
|
|
sel_node_t* cursor_def; /*!< cursor definition
|
|
select node if a
|
|
named cursor */
|
|
ulint param_type; /*!< PARS_INPUT,
|
|
PARS_OUTPUT, or
|
|
PARS_NOT_PARAM if not a
|
|
procedure parameter */
|
|
sym_tab_t* sym_table; /*!< back pointer to
|
|
the symbol table */
|
|
UT_LIST_NODE_T(sym_node_t) sym_list; /*!< list of symbol
|
|
nodes */
|
|
sym_node_t* like_node; /* LIKE operator node*/
|
|
};
|
|
|
|
/** Symbol table */
|
|
struct sym_tab_t{
|
|
que_t* query_graph;
|
|
/*!< query graph generated by the
|
|
parser */
|
|
const char* sql_string;
|
|
/*!< SQL string to parse */
|
|
size_t string_len;
|
|
/*!< SQL string length */
|
|
size_t next_char_pos;
|
|
/*!< position of the next character in
|
|
sql_string to give to the lexical
|
|
analyzer */
|
|
pars_info_t* info; /*!< extra information, or NULL */
|
|
sym_node_list_t sym_list;
|
|
/*!< list of symbol nodes in the symbol
|
|
table */
|
|
UT_LIST_BASE_NODE_T(func_node_t)
|
|
func_node_list;
|
|
/*!< list of function nodes in the
|
|
parsed query graph */
|
|
mem_heap_t* heap; /*!< memory heap from which we can
|
|
allocate space */
|
|
};
|
|
|
|
#endif
|