#ifndef TABLE_INCLUDED
#define TABLE_INCLUDED
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 St, Fifth Floor, Boston, MA 02110-1301 USA */
#include "my_global.h"
#include "sql_plist.h"
#include "sql_alloc.h"
#ifndef MYSQL_CLIENT
#include "hash.h"
#include "handler.h"
#include "mysql_com.h"
#include "thr_lock.h"
#include "parse_file.h"
#include "table_id.h"
#include "mysqld.h"
class Item;
class Item_subselect;
class Item_field;
class GRANT_TABLE;
class st_select_lex_unit;
class st_select_lex;
class partition_info;
class COND_EQUAL;
class Security_context;
struct TABLE_LIST;
class Field_temporal_with_date_and_time;
struct INDEX_FIELD;
struct JOIN_CONDITION;
Used to identify NESTED_JOIN structures within a join (applicable to
structures representing outer joins that have not been simplified away).
*/
typedef ulonglong nested_join_map;
#define tmp_file_prefix "#sql"
#define tmp_file_prefix_length 4
#define TMP_TABLE_KEY_EXTRA 8
Enumerate possible types of a table from re-execution
standpoint.
TABLE_LIST class has a member of this type.
At prepared statement prepare, this member is assigned a value
as of the current state of the database. Before (re-)execution
of a prepared statement, we check that the value recorded at
prepare matches the type of the object we obtained from the
table definition cache.
@sa check_and_update_table_version()
@sa Execute_observer
@sa Prepared_statement::reprepare()
*/
enum enum_table_ref_type
{
TABLE_REF_NULL= 0,
TABLE_REF_VIEW,
TABLE_REF_BASE_TABLE,
TABLE_REF_I_S_TABLE,
TABLE_REF_TMP_TABLE
};
Enumerate possible status of a identifier name while determining
its validity
*/
enum enum_ident_name_check
{
IDENT_NAME_OK,
IDENT_NAME_WRONG,
IDENT_NAME_TOO_LONG
};
Object_creation_ctx -- interface for creation context of database objects
(views, stored routines, events, triggers). Creation context -- is a set
of attributes, that should be fixed at the creation time and then be used
each time the object is parsed or executed.
*/
class Object_creation_ctx
{
public:
Object_creation_ctx *set_n_backup(THD *thd);
void restore_env(THD *thd, Object_creation_ctx *backup_ctx);
protected:
Object_creation_ctx() {}
virtual Object_creation_ctx *create_backup_ctx(THD *thd) const = 0;
virtual void change_env(THD *thd) const = 0;
public:
virtual ~Object_creation_ctx()
{ }
};
Default_object_creation_ctx -- default implementation of
Object_creation_ctx.
*/
class Default_object_creation_ctx : public Object_creation_ctx
{
public:
const CHARSET_INFO *get_client_cs()
{
return m_client_cs;
}
const CHARSET_INFO *get_connection_cl()
{
return m_connection_cl;
}
protected:
Default_object_creation_ctx(THD *thd);
Default_object_creation_ctx(const CHARSET_INFO *client_cs,
const CHARSET_INFO *connection_cl);
protected:
virtual Object_creation_ctx *create_backup_ctx(THD *thd) const;
virtual void change_env(THD *thd) const;
protected:
client_cs stores the value of character_set_client session variable.
The only character set attribute is used.
Client character set is included into query context, because we save
query in the original character set, which is client character set. So,
in order to parse the query properly we have to switch client character
set on parsing.
*/
const CHARSET_INFO *m_client_cs;
connection_cl stores the value of collation_connection session
variable. Both character set and collation attributes are used.
Connection collation is included into query context, becase it defines
the character set and collation of text literals in internal
representation of query (item-objects).
*/
const CHARSET_INFO *m_connection_cl;
};
View_creation_ctx -- creation context of view objects.
*/
class View_creation_ctx : public Default_object_creation_ctx,
public Sql_alloc
{
public:
static View_creation_ctx *create(THD *thd);
static View_creation_ctx *create(THD *thd,
TABLE_LIST *view);
private:
View_creation_ctx(THD *thd)
: Default_object_creation_ctx(thd)
{ }
};
typedef struct st_order {
struct st_order *next;
Item **item;
Item *item_ptr;
int counter;
only if counter_used is true */
enum enum_order {
ORDER_NOT_RELEVANT,
ORDER_ASC,
ORDER_DESC
};
enum_order direction;
bool in_field_list;
bool counter_used;
Tells whether this ORDER element was referenced with an alias or with an
expression, in the query:
SELECT a AS foo GROUP BY foo: true.
SELECT a AS foo GROUP BY a: false.
*/
bool used_alias;
char *buff;
table_map used, depend_map;
} ORDER;
enum tmp_table_type
{
NO_TMP_TABLE, NON_TRANSACTIONAL_TMP_TABLE, TRANSACTIONAL_TMP_TABLE,
INTERNAL_TMP_TABLE, SYSTEM_TMP_TABLE
};
enum release_type { RELEASE_NORMAL, RELEASE_WAIT_FOR_DROP };
class Field_blob;
class Table_triggers_list;
Category of table found in the table share.
*/
enum enum_table_category
{
Unknown value.
*/
TABLE_UNKNOWN_CATEGORY=0,
Temporary table.
The table is visible only in the session.
Therefore,
- FLUSH TABLES WITH READ LOCK
- SET GLOBAL READ_ONLY = ON
do not apply to this table.
Note that LOCK TABLE t FOR READ/WRITE
can be used on temporary tables.
Temporary tables are not part of the table cache.
*/
TABLE_CATEGORY_TEMPORARY=1,
User table.
These tables do honor:
- LOCK TABLE t FOR READ/WRITE
- FLUSH TABLES WITH READ LOCK
- SET GLOBAL READ_ONLY = ON
User tables are cached in the table cache.
*/
TABLE_CATEGORY_USER=2,
System table, maintained by the server.
These tables do honor:
- LOCK TABLE t FOR READ/WRITE
- FLUSH TABLES WITH READ LOCK
- SET GLOBAL READ_ONLY = ON
Typically, writes to system tables are performed by
the server implementation, not explicitly be a user.
System tables are cached in the table cache.
*/
TABLE_CATEGORY_SYSTEM=3,
Information schema tables.
These tables are an interface provided by the system
to inspect the system metadata.
These tables do *not* honor:
- LOCK TABLE t FOR READ/WRITE
- FLUSH TABLES WITH READ LOCK
- SET GLOBAL READ_ONLY = ON
as there is no point in locking explicitly
an INFORMATION_SCHEMA table.
Nothing is directly written to information schema tables.
Note that this value is not used currently,
since information schema tables are not shared,
but implemented as session specific temporary tables.
*/
TODO: Fixing the performance issues of I_S will lead
to I_S tables in the table cache, which should use
this table type.
*/
TABLE_CATEGORY_INFORMATION=4,
Log tables.
These tables are an interface provided by the system
to inspect the system logs.
These tables do *not* honor:
- LOCK TABLE t FOR READ/WRITE
- FLUSH TABLES WITH READ LOCK
- SET GLOBAL READ_ONLY = ON
as there is no point in locking explicitly
a LOG table.
An example of LOG tables are:
- mysql.slow_log
- mysql.general_log,
which *are* updated even when there is either
a GLOBAL READ LOCK or a GLOBAL READ_ONLY in effect.
User queries do not write directly to these tables
(there are exceptions for log tables).
The server implementation perform writes.
Log tables are cached in the table cache.
*/
TABLE_CATEGORY_LOG=5,
Performance schema tables.
These tables are an interface provided by the system
to inspect the system performance data.
These tables do *not* honor:
- LOCK TABLE t FOR READ/WRITE
- FLUSH TABLES WITH READ LOCK
- SET GLOBAL READ_ONLY = ON
as there is no point in locking explicitly
a PERFORMANCE_SCHEMA table.
An example of PERFORMANCE_SCHEMA tables are:
- performance_schema.*
which *are* updated (but not using the handler interface)
even when there is either
a GLOBAL READ LOCK or a GLOBAL READ_ONLY in effect.
User queries do not write directly to these tables
(there are exceptions for SETUP_* tables).
The server implementation perform writes.
Performance tables are cached in the table cache.
*/
TABLE_CATEGORY_PERFORMANCE=6,
Replication Information Tables.
These tables are used to store replication information.
These tables do *not* honor:
- LOCK TABLE t FOR READ/WRITE
- FLUSH TABLES WITH READ LOCK
- SET GLOBAL READ_ONLY = ON
as there is no point in locking explicitly
a Replication Information table.
An example of replication tables are:
- mysql.slave_master_info
- mysql.slave_relay_log_info,
which *are* updated even when there is either
a GLOBAL READ LOCK or a GLOBAL READ_ONLY in effect.
User queries do not write directly to these tables.
Replication tables are cached in the table cache.
*/
TABLE_CATEGORY_RPL_INFO=7
};
typedef enum enum_table_category TABLE_CATEGORY;
TABLE_CATEGORY get_table_category(const LEX_STRING *db,
const LEX_STRING *name);
extern ulong refresh_version;
typedef struct st_table_field_type
{
LEX_STRING name;
LEX_STRING type;
LEX_STRING cset;
} TABLE_FIELD_TYPE;
typedef struct st_table_field_def
{
uint count;
const TABLE_FIELD_TYPE *field;
} TABLE_FIELD_DEF;
enum index_hint_type
{
INDEX_HINT_IGNORE,
INDEX_HINT_USE,
INDEX_HINT_FORCE
};
enum enum_schema_table_state
{
NOT_PROCESSED= 0,
PROCESSED_BY_CREATE_SORT_INDEX,
PROCESSED_BY_JOIN_EXEC
};
typedef struct st_foreign_key_info
{
LEX_STRING *foreign_id;
LEX_STRING *foreign_db;
LEX_STRING *foreign_table;
LEX_STRING *referenced_db;
LEX_STRING *referenced_table;
LEX_STRING *update_method;
LEX_STRING *delete_method;
LEX_STRING *referenced_key_name;
List<LEX_STRING> foreign_fields;
List<LEX_STRING> referenced_fields;
} FOREIGN_KEY_INFO;
#define MY_I_S_MAYBE_NULL 1
#define MY_I_S_UNSIGNED 2
#define SKIP_OPEN_TABLE 0
#define OPEN_FRM_ONLY 1
#define OPEN_FULL_TABLE 2
typedef struct st_field_info
{
This is used as column name.
*/
const char* field_name;
For string-type columns, this is the maximum number of
characters. Otherwise, it is the 'display-length' for the column.
*/
uint field_length;
This denotes data type for the column. For the most part, there seems to
be one entry in the enum for each SQL data type, although there seem to
be a number of additional entries in the enum.
*/
enum enum_field_types field_type;
int value;
This is used to set column attributes. By default, columns are @c NOT
@c NULL and @c SIGNED, and you can deviate from the default
by setting the appopriate flags. You can use either one of the flags
@c MY_I_S_MAYBE_NULL and @cMY_I_S_UNSIGNED or
combine them using the bitwise or operator @c |. Both flags are
defined in table.h.
*/
uint field_flags;
const char* old_name;
This should be one of @c SKIP_OPEN_TABLE,
@c OPEN_FRM_ONLY or @c OPEN_FULL_TABLE.
*/
uint open_method;
} ST_FIELD_INFO;
struct TABLE_LIST;
typedef struct st_schema_table
{
const char* table_name;
ST_FIELD_INFO *fields_info;
int idx_field1, idx_field2;
bool hidden;
uint i_s_requested_object;
} ST_SCHEMA_TABLE;
#define JOIN_TYPE_LEFT 1
#define JOIN_TYPE_RIGHT 2
enum enum_derived_type {
VIEW_ALGORITHM_UNDEFINED = 0,
VIEW_ALGORITHM_TMPTABLE,
VIEW_ALGORITHM_MERGE,
DERIVED_ALGORITHM_TMPTABLE
};
#define VIEW_SUID_INVOKER 0
#define VIEW_SUID_DEFINER 1
#define VIEW_SUID_DEFAULT 2
#define VIEW_CHECK_NONE 0
#define VIEW_CHECK_LOCAL 1
#define VIEW_CHECK_CASCADED 2
#define VIEW_CHECK_OK 0
#define VIEW_CHECK_ERROR 1
#define VIEW_CHECK_SKIP 2
#define MAX_TDC_BLOB_SIZE 65536
class select_union;
struct Field_translator
{
Item *item;
const char *name;
};
Column reference of a NATURAL/USING join. Since column references in
joins can be both from views and stored tables, may point to either a
Field (for tables), or a Field_translator (for views).
*/
class Natural_join_column: public Sql_alloc
{
public:
Field_translator *view_field;
Item_field *table_field;
TABLE_LIST *table_ref;
True if a common join column of two NATURAL/USING join operands. Notice
that when we have a hierarchy of nested NATURAL/USING joins, a column can
be common at some level of nesting but it may not be common at higher
levels of nesting. Thus this flag may change depending on at which level
we are looking at some column.
*/
bool is_common;
public:
Natural_join_column(Field_translator *field_param, TABLE_LIST *tab);
Natural_join_column(Item_field *field_param, TABLE_LIST *tab);
const char *name();
Item *create_item(THD *thd);
const char *table_name();
const char *db_name();
};
Type of table which can be open for an element of table list.
*/
enum enum_open_type
{
OT_TEMPORARY_OR_BASE= 0, OT_TEMPORARY_ONLY, OT_BASE_ONLY
};
Data dictionary API.
*/
enum frm_type_enum
{
FRMTYPE_ERROR= 0,
FRMTYPE_TABLE,
FRMTYPE_VIEW
};
class Index_hint;
class Item_exists_subselect;
Table reference in the FROM clause.
These table references can be of several types that correspond to
different SQL elements. Below we list all types of TABLE_LISTs with
the necessary conditions to determine when a TABLE_LIST instance
belongs to a certain type.
1) table (TABLE_LIST::view == NULL)
- base table
(TABLE_LIST::derived == NULL)
- subquery - TABLE_LIST::table is a temp table
(TABLE_LIST::derived != NULL)
- information schema table
(TABLE_LIST::schema_table != NULL)
NOTICE: for schema tables TABLE_LIST::field_translation may be != NULL
2) view (TABLE_LIST::view != NULL)
- merge (TABLE_LIST::effective_algorithm == VIEW_ALGORITHM_MERGE)
also (TABLE_LIST::field_translation != NULL)
- tmptable (TABLE_LIST::effective_algorithm == VIEW_ALGORITHM_TMPTABLE)
also (TABLE_LIST::field_translation == NULL)
3) nested table reference (TABLE_LIST::nested_join != NULL)
- table sequence - e.g. (t1, t2, t3)
TODO: how to distinguish from a JOIN?
- general JOIN
TODO: how to distinguish from a table sequence?
- NATURAL JOIN
(TABLE_LIST::natural_join != NULL)
- JOIN ... USING
(TABLE_LIST::join_using_fields != NULL)
- semi-join
;
*/
struct Name_resolution_context;
struct LEX;
struct TABLE_LIST
{
TABLE_LIST() {}
Prepare TABLE_LIST that consists of one table instance to use in
simple_open_and_lock_tables
*/
inline void init_one_table(const char *db_name_arg,
size_t db_length_arg,
const char *table_name_arg,
size_t table_name_length_arg,
const char *alias_arg,
enum thr_lock_type lock_type_arg)
{
memset(this, 0, sizeof(*this));
db= (char*) db_name_arg;
db_length= db_length_arg;
table_name= (char*) table_name_arg;
table_name_length= table_name_length_arg;
alias= (char*) alias_arg;
lock_type= lock_type_arg;
}
static TABLE_LIST *new_nested_join(MEM_ROOT *allocator,
const char *alias,
TABLE_LIST *embedding,
List<TABLE_LIST> *belongs_to,
class st_select_lex *select);
List of tables local to a subquery or the top-level SELECT (used by
SQL_I_List). Considers views as leaves (unlike 'next_leaf' below).
Created at parse time in st_select_lex::add_table_to_list() ->
table_list.link_in_list().
*/
TABLE_LIST *next_local;
TABLE_LIST *next_global, **prev_global;
char *db, *alias, *table_name, *schema_table_name;
char *option;
Context which should be used to resolve identifiers contained in the ON
condition of the embedding join nest.
@todo When name resolution contexts are created after parsing, we should
be able to store this in the embedding join nest instead.
*/
Name_resolution_context *context_of_embedding;
private:
Item *m_join_cond;
public:
INDEX_FIELD *index_field_head;
bool is_table_driverd;
List<JOIN_CONDITION> join_condition;
Item **join_cond_ref() { return &m_join_cond; }
Item *join_cond() const { return m_join_cond; }
Item *set_join_cond(Item *val)
{ return m_join_cond= val; }
The structure of the join condition presented in the member above
can be changed during certain optimizations. This member
contains a snapshot of AND-OR structure of the join condition
made after permanent transformations of the parse tree, and is
used to restore the join condition before every reexecution of a prepared
statement or stored procedure.
*/
Item *prep_join_cond;
Item *sj_on_expr;
(Valid only for semi-join nests) Bitmap of tables that are within the
semi-join (this is different from bitmap of all nest's children because
tables that were pulled out of the semi-join nest remain listed as
nest's children).
*/
table_map sj_inner_tables;
COND_EQUAL *cond_equal;
During parsing - left operand of NATURAL/USING join where 'this' is
the right operand. After parsing (this->natural_join == this) iff
'this' represents a NATURAL or USING join operation. Thus after
parsing 'this' is a NATURAL/USING join iff (natural_join != NULL).
*/
TABLE_LIST *natural_join;
True if 'this' represents a nested join that is a NATURAL JOIN.
For one of the operands of 'this', the member 'natural_join' points
to the other operand of 'this'.
*/
bool is_natural_join;
List<String> *join_using_fields;
Explicitly store the result columns of either a NATURAL/USING join or
an operand of such a join.
*/
List<Natural_join_column> *join_columns;
bool is_join_columns_complete;
List of nodes in a nested join tree, that should be considered as
leaves with respect to name resolution. The leaves are: views,
top-most nodes representing NATURAL/USING joins, subqueries, and
base tables. All of these TABLE_LIST instances contain a
materialized list of columns. The list is local to a subquery.
*/
TABLE_LIST *next_name_resolution_table;
List<Index_hint> *index_hints;
Table_id table_id;
select_result for derived table to pass it from table creation to table
filling procedure
*/
select_union *derived_result;
Reference from aux_tables to local list entry of main select of
multi-delete statement:
delete t1 from t2,t1 where t1.a<'B' and t2.b=t1.b;
here it will be reference of first occurrence of t1 to second (as you
can see this lists can't be merged)
*/
TABLE_LIST *correspondent_table;
@brief Normally, this field is non-null for anonymous derived tables only.
@details This field is set to non-null for
- Anonymous derived tables, In this case it points to the SELECT_LEX_UNIT
representing the derived table. E.g. for a query
@verbatim SELECT * FROM (SELECT a FROM t1) b @endverbatim
For the @c TABLE_LIST representing the derived table @c b, @c derived
points to the SELECT_LEX_UNIT representing the result of the query within
parenteses.
- Views. This is set for views with @verbatim ALGORITHM = TEMPTABLE
@endverbatim by mysql_make_view().
@note Inside views, a subquery in the @c FROM clause is not allowed.
@note Do not use this field to separate views/base tables/anonymous
derived tables. Use TABLE_LIST::is_anonymous_derived_table().
*/
st_select_lex_unit *derived;
TRUE <=> all possible keys for a derived table were collected and
could be re-used while statement re-execution.
*/
bool derived_keys_ready;
ST_SCHEMA_TABLE *schema_table;
st_select_lex *schema_select_lex;
True when the view field translation table is used to convert
schema table fields for backwards compatibility with SHOW command.
*/
bool schema_table_reformed;
st_select_lex *select_lex;
LEX *view;
Field_translator *field_translation;
Field_translator *field_translation_end;
List (based on next_local) of underlying tables of this view. I.e. it
does not include the tables of subqueries used in the view. Is set only
for merged views.
*/
TABLE_LIST *merge_underlying_list;
- 0 for base tables
- in case of the view it is the list of all (not only underlying
tables but also used in subquery ones) tables of the view.
*/
List<TABLE_LIST> *view_tables;
TABLE_LIST *belong_to_view;
The view directly referencing this table
(non-zero only for merged underlying tables of a view).
*/
TABLE_LIST *referencing_view;
TABLE_LIST *parent_l;
Security context (non-zero only for tables which belong
to view with SQL SECURITY DEFINER)
*/
Security_context *security_ctx;
This view security context (non-zero only for views with
SQL SECURITY DEFINER)
*/
Security_context *view_sctx;
List of all base tables local to a subquery including all view
tables. Unlike 'next_local', this in this list views are *not*
leaves. Created in setup_tables() -> make_leaves_list().
*/
bool allowed_show;
TABLE_LIST *next_leaf;
Item *where;
Item *check_option;
LEX_STRING select_stmt;
LEX_STRING md5;
LEX_STRING source;
LEX_STRING view_db;
LEX_STRING view_name;
LEX_STRING timestamp;
st_lex_user definer;
ulonglong file_version;
ulonglong updatable_view;
@brief The declared algorithm, if this is a view.
@details One of
- VIEW_ALGORITHM_UNDEFINED
- VIEW_ALGORITHM_TMPTABLE
- VIEW_ALGORITHM_MERGE
@to do Replace with an enum
*/
ulonglong algorithm;
ulonglong view_suid;
ulonglong with_check;
effective value of WITH CHECK OPTION (differ for temporary table
algorithm)
*/
uint8 effective_with_check;
@brief The view algorithm that is actually used, if this is a view.
@details One of
- VIEW_ALGORITHM_UNDEFINED
- VIEW_ALGORITHM_TMPTABLE
- VIEW_ALGORITHM_MERGE
@to do Replace with an enum
*/
enum_derived_type effective_algorithm;
ulonglong engine_data;
thr_lock_type lock_type;
uint outer_join;
uint shared;
size_t db_length;
size_t table_name_length;
bool updatable;
bool straight;
bool updating;
bool force_index;
bool ignore_leaves;
table_map dep_tables;
table_map on_expr_dep_tables;
struct st_nested_join *nested_join;
TABLE_LIST *embedding;
List<TABLE_LIST> *join_list;
bool cacheable_table;
bool table_in_first_from_clause;
Specifies which kind of table should be open for this element
of table list.
*/
enum enum_open_type open_type;
bool contain_auto_increment;
bool multitable_view;
bool compact_view_format;
bool where_processed;
bool check_option_processed;
enum frm_type_enum required_type;
char timestamp_buffer[20];
This TABLE_LIST object is just placeholder for prelocking, it will be
used for implicit LOCK TABLES only and won't be used in real statement.
*/
bool prelocking_placeholder;
Indicates that if TABLE_LIST object corresponds to the table/view
which requires special handling.
*/
enum
{
OPEN_NORMAL= 0,
OPEN_IF_EXISTS,
Associate a table share only if the the table exists.
Also upgrade metadata lock to exclusive if table doesn't exist.
*/
OPEN_FOR_CREATE,
OPEN_STUB
} open_strategy;
bool internal_tmp_table;
bool is_alias;
qualified name (<db_name>.<table_name>).
*/
bool is_fqtn;
View_creation_ctx *view_creation_ctx;
Attributes to save/load view creation context in/from frm-file.
Ther are required only to be able to use existing parser to load
view-definition file. As soon as the parser parsed the file, view
creation context is initialized and the attributes become redundant.
These attributes MUST NOT be used for any purposes but the parsing.
*/
LEX_STRING view_client_cs_name;
LEX_STRING view_connection_cl_name;
View definition (SELECT-statement) in the UTF-form.
*/
LEX_STRING view_body_utf8;
Indicates what triggers we need to pre-load for this TABLE_LIST
when opening an associated TABLE. This is filled after
the parsed tree is created.
*/
uint8 trg_event_map;
bool optimized_away;
uint i_s_requested_object;
bool has_db_lookup_value;
bool has_table_lookup_value;
uint table_open_method;
enum enum_schema_table_state schema_table_state;
#ifdef WITH_PARTITION_STORAGE_ENGINE
List<String> *partition_names;
#endif
inline List<JOIN_CONDITION> * get_join_condition(){
if (join_condition.elements == 0){
join_condition.empty();
}
return &join_condition;
}
bool setup_underlying(THD *thd);
void print(THD *thd, String *str, enum_query_type query_type);
void hide_view_error(THD *thd);
TABLE_LIST *first_leaf_for_name_resolution();
TABLE_LIST *last_leaf_for_name_resolution();
bool is_leaf_for_name_resolution();
inline const TABLE_LIST *top_table() const
{ return belong_to_view ? belong_to_view : this; }
inline TABLE_LIST *top_table()
{
return
const_cast<TABLE_LIST*>(const_cast<const TABLE_LIST*>(this)->top_table());
}
@returns
TRUE this is a materializable derived table/view.
FALSE otherwise.
*/
inline bool uses_materialization() const
{
return (effective_algorithm == VIEW_ALGORITHM_TMPTABLE ||
effective_algorithm == DERIVED_ALGORITHM_TMPTABLE);
}
inline bool is_view_or_derived() const
{
return (effective_algorithm != VIEW_ALGORITHM_UNDEFINED);
}
@returns true if materializable table contains one or zero rows.
Returning true implies that the table is materialized during optimization,
so it need not be optimized during execution.
*/
bool materializable_is_const() const;
void register_want_access(ulong want_access);
bool prepare_security(THD *thd);
Cleanup for re-execution in a prepared statement or a stored
procedure.
*/
void reinit_before_use(THD *thd);
Item_subselect *containing_subselect();
inline
void set_table_ref_id(enum_table_ref_type table_ref_type_arg,
ulonglong table_ref_version_arg)
{
m_table_ref_type= table_ref_type_arg;
m_table_ref_version= table_ref_version_arg;
}
@brief True if this TABLE_LIST represents an anonymous derived table,
i.e. the result of a subquery.
*/
bool is_anonymous_derived_table() const { return derived && !view; }
uint query_block_id() const;
@brief Returns the name of the database that the referenced table belongs
to.
*/
char *get_db_name() const { return view != NULL ? view_db.str : db; }
@brief Returns the name of the table that this TABLE_LIST represents.
@details The unqualified table name or view name for a table or view,
respectively.
*/
char *get_table_name() const { return view != NULL ? view_name.str : table_name; }
st_select_lex_unit *get_unit() const;
@brief Returns the outer join nest that this TABLE_LIST belongs to, if any.
@details There are two kinds of join nests, outer-join nests and semi-join
nests. This function returns non-NULL in the following cases:
@li 1. If this table/nest is embedded in a nest and this nest IS NOT a
semi-join nest. (In other words, it is an outer-join nest.)
@li 2. If this table/nest is embedded in a nest and this nest IS a
semi-join nest, but this semi-join nest is embedded in another
nest. (This other nest will be an outer-join nest, since all inner
joined nested semi-join nests have been merged in
@c simplify_joins() ).
Note: This function assumes that @c simplify_joins() has been performed.
Before that, join nests will be present for all types of join.
@return outer join nest, or NULL if none.
*/
TABLE_LIST *outer_join_nest() const
{
if (!embedding)
return NULL;
if (embedding->sj_on_expr)
return embedding->embedding;
return embedding;
}
private:
enum enum_table_ref_type m_table_ref_type;
ulonglong m_table_ref_version;
};
struct st_position;
class Item;
Iterator over the fields of a generic table reference.
*/
class Field_iterator: public Sql_alloc
{
public:
Field_iterator() {}
virtual ~Field_iterator() {}
virtual void set(TABLE_LIST *)= 0;
virtual void next()= 0;
virtual bool end_of_fields()= 0;
virtual const char *name()= 0;
virtual Item *create_item(THD *)= 0;
};
Struct st_nested_join is used to represent how tables are connected through
outer join operations and semi-join operations to form a query block.
Out of the parser, inner joins are also represented by st_nested_join
structs, but these are later flattened out by simplify_joins().
Some outer join nests are also flattened, when it can be determined that
they can be processed as inner joins instead of outer joins.
*/
typedef struct st_nested_join
{
List<TABLE_LIST> join_list;
table_map used_tables;
table_map not_null_tables;
Used for pointing out the first table in the plan being covered by this
join nest. It is used exclusively within make_outerjoin_info().
*/
struct st_join_table *first_nested;
Number of tables and outer join nests administered by this nested join
object for the sake of cost analysis. Includes direct member tables as
well as tables included through semi-join nests, but notice that semi-join
nests themselves are not counted.
*/
uint nj_total;
Used to count tables in the nested join in 2 isolated places:
1. In make_outerjoin_info().
2. check_interleaving_with_nj/backout_nj_state (these are called
by the join optimizer.
Before each use the counters are zeroed by reset_nj_counters.
*/
uint nj_counter;
Bit identifying this nested join. Only nested joins representing the
outer join structure need this, other nests have bit set to zero.
*/
nested_join_map nj_map;
Tables outside the semi-join that are used within the semi-join's
ON condition (ie. the subquery WHERE clause and optional IN equalities).
*/
table_map sj_depends_on;
Outer non-trivially correlated tables, a true subset of sj_depends_on
*/
table_map sj_corr_tables;
Query block id if this struct is generated from a subquery transform.
*/
uint query_block_id;
Lists of trivially-correlated expressions from the outer and inner tables
of the semi-join, respectively.
*/
List<Item> sj_outer_exprs, sj_inner_exprs;
} NESTED_JOIN;
typedef struct st_changed_table_list
{
struct st_changed_table_list *next;
char *key;
uint32 key_length;
} CHANGED_TABLE_LIST;
typedef struct st_open_table_list{
struct st_open_table_list *next;
char *db,*table;
uint32 in_use,locked;
} OPEN_TABLE_LIST;
static inline void tmp_restore_column_map(MY_BITMAP *bitmap,
my_bitmap_map *old)
{
bitmap->bitmap= old;
}
static inline void dbug_tmp_restore_column_map(MY_BITMAP *bitmap,
my_bitmap_map *old)
{
#ifndef DBUG_OFF
tmp_restore_column_map(bitmap, old);
#endif
}
enum_ident_name_check check_and_convert_db_name(LEX_STRING *db,
bool preserve_lettercase);
bool check_column_name(const char *name);
enum_ident_name_check check_table_name(const char *name, size_t length,
bool check_for_path_chars);
int rename_file_ext(const char * from,const char * to,const char * ext);
int set_zone(int nr,int min_zone,int max_zone);
ulong get_form_pos(File file, uchar *head, TYPELIB *save_names);
ulong make_new_entry(File file,uchar *fileinfo,TYPELIB *formnames,
const char *newname);
ulong next_io_size(ulong pos);
void append_unescaped(String *res, const char *pos, uint length);
char *fn_rext(char *name);
extern LEX_STRING PERFORMANCE_SCHEMA_DB_NAME;
extern LEX_STRING GENERAL_LOG_NAME;
extern LEX_STRING SLOW_LOG_NAME;
extern LEX_STRING INFORMATION_SCHEMA_NAME;
extern LEX_STRING MYSQL_SCHEMA_NAME;
extern LEX_STRING RLI_INFO_NAME;
extern LEX_STRING MI_INFO_NAME;
extern LEX_STRING WORKER_INFO_NAME;
inline bool is_infoschema_db(const char *name, size_t len)
{
return (INFORMATION_SCHEMA_NAME.length == len &&
!my_strcasecmp(system_charset_info,
INFORMATION_SCHEMA_NAME.str, name));
}
inline bool is_infoschema_db(const char *name)
{
return !my_strcasecmp(system_charset_info,
INFORMATION_SCHEMA_NAME.str, name);
}
TYPELIB *typelib(MEM_ROOT *mem_root, List<String> &strings);
bool is_simple_order(ORDER *order);
#endif
#endif