diff options
Diffstat (limited to 'sql/table.h')
| -rw-r--r-- | sql/table.h | 3397 |
1 files changed, 3397 insertions, 0 deletions
diff --git a/sql/table.h b/sql/table.h new file mode 100644 index 00000000..d063a3f2 --- /dev/null +++ b/sql/table.h @@ -0,0 +1,3397 @@ +#ifndef TABLE_INCLUDED +#define TABLE_INCLUDED +/* Copyright (c) 2000, 2017, Oracle and/or its affiliates. + Copyright (c) 2009, 2020, MariaDB + + 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-1335 USA */ + +#include "sql_plist.h" +#include "sql_list.h" /* Sql_alloc */ +#include "mdl.h" +#include "datadict.h" +#include "sql_string.h" /* String */ +#include "lex_string.h" + +#ifndef MYSQL_CLIENT + +#include "my_cpu.h" /* LF_BACKOFF() */ +#include "hash.h" /* HASH */ +#include "handler.h" /* row_type, ha_choice, handler */ +#include "mysql_com.h" /* enum_field_types */ +#include "thr_lock.h" /* thr_lock_type */ +#include "filesort_utils.h" +#include "parse_file.h" +#include "sql_i_s.h" +#include "sql_type.h" /* vers_kind_t */ +#include "privilege.h" /* privilege_t */ + +/* Structs that defines the TABLE */ + +class Item; /* Needed by ORDER */ +typedef Item (*Item_ptr); +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 ACL_internal_schema_access; +class ACL_internal_table_access; +class Field; +class Table_statistics; +class With_element; +struct TDC_element; +class Virtual_column_info; +class Table_triggers_list; +class TMP_TABLE_PARAM; +class SEQUENCE; +class Range_rowid_filter_cost_info; +class derived_handler; +class Pushdown_derived; +struct Name_resolution_context; + +/* + Used to identify NESTED_JOIN structures within a join (applicable only to + structures that have not been simplified away and embed more the one + element) +*/ +typedef ulonglong nested_join_map; + + +#define tmp_file_prefix "#sql" /**< Prefix for tmp tables */ +#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 +{ + /** Initial value set by the parser */ + TABLE_REF_NULL= 0, + TABLE_REF_VIEW, + TABLE_REF_BASE_TABLE, + TABLE_REF_I_S_TABLE, + TABLE_REF_TMP_TABLE +}; + + +/*************************************************************************/ + +/** + 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: + CHARSET_INFO *get_client_cs() + { + return m_client_cs; + } + + CHARSET_INFO *get_connection_cl() + { + return m_connection_cl; + } + +protected: + Default_object_creation_ctx(THD *thd); + + Default_object_creation_ctx(CHARSET_INFO *client_cs, + 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. + */ + 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). + */ + CHARSET_INFO *m_connection_cl; +}; + +class Query_arena; + +/*************************************************************************/ + +/** + 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) + { } +}; + +/*************************************************************************/ + +/* Order clause list element */ + +typedef int (*fast_field_copier)(Field *to, Field *from); + + +typedef struct st_order { + struct st_order *next; + Item **item; /* Point at item in select fields */ + Item *item_ptr; /* Storage for initial item */ + /* + Reference to the function we are trying to optimize copy to + a temporary table + */ + fast_field_copier fast_field_copier_func; + /* Field for which above optimizer function setup */ + Field *fast_field_copier_setup; + int counter; /* position in SELECT list, correct + only if counter_used is true*/ + enum enum_order { + ORDER_NOT_RELEVANT, + ORDER_ASC, + ORDER_DESC + }; + + enum_order direction; /* Requested direction of ordering */ + bool in_field_list; /* true if in select field list */ + bool counter_used; /* parameter was counter of columns */ + Field *field; /* If tmp-table group */ + char *buff; /* If tmp-table group */ + table_map used; /* NOTE: the below is only set to 0 but is still used by eq_ref_table */ + table_map depend_map; +} ORDER; + +/** + State information for internal tables grants. + This structure is part of the TABLE_LIST, and is updated + during the ACL check process. + @sa GRANT_INFO +*/ +struct st_grant_internal_info +{ + /** True if the internal lookup by schema name was done. */ + bool m_schema_lookup_done; + /** Cached internal schema access. */ + const ACL_internal_schema_access *m_schema_access; + /** True if the internal lookup by table name was done. */ + bool m_table_lookup_done; + /** Cached internal table access. */ + const ACL_internal_table_access *m_table_access; +}; +typedef struct st_grant_internal_info GRANT_INTERNAL_INFO; + +/** + @brief The current state of the privilege checking process for the current + user, SQL statement and SQL object. + + @details The privilege checking process is divided into phases depending on + the level of the privilege to be checked and the type of object to be + accessed. Due to the mentioned scattering of privilege checking + functionality, it is necessary to keep track of the state of the + process. This information is stored in privilege, want_privilege, and + orig_want_privilege. + + A GRANT_INFO also serves as a cache of the privilege hash tables. Relevant + members are grant_table and version. + */ +typedef struct st_grant_info +{ + /** + @brief A copy of the privilege information regarding the current host, + database, object and user. + + @details The version of this copy is found in GRANT_INFO::version. + */ + GRANT_TABLE *grant_table_user; + GRANT_TABLE *grant_table_role; + /** + @brief Used for cache invalidation when caching privilege information. + + @details The privilege information is stored on disk, with dedicated + caches residing in memory: table-level and column-level privileges, + respectively, have their own dedicated caches. + + The GRANT_INFO works as a level 1 cache with this member updated to the + current value of the global variable @c grant_version (@c static variable + in sql_acl.cc). It is updated Whenever the GRANT_INFO is refreshed from + the level 2 cache. The level 2 cache is the @c column_priv_hash structure + (@c static variable in sql_acl.cc) + + @see grant_version + */ + uint version; + /** + @brief The set of privileges that the current user has fulfilled for a + certain host, database, and object. + + @details This field is continually updated throughout the access checking + process. In each step the "wanted privilege" is checked against the + fulfilled privileges. When/if the intersection of these sets is empty, + access is granted. + + The set is implemented as a bitmap, with the bits defined in sql_acl.h. + */ + privilege_t privilege; + /** + @brief the set of privileges that the current user needs to fulfil in + order to carry out the requested operation. + */ + privilege_t want_privilege; + /** + Stores the requested access acl of top level tables list. Is used to + check access rights to the underlying tables of a view. + */ + privilege_t orig_want_privilege; + /** The grant state for internal tables. */ + GRANT_INTERNAL_INFO m_internal; + + st_grant_info() + :privilege(NO_ACL), + want_privilege(NO_ACL), + orig_want_privilege(NO_ACL) + { } +} GRANT_INFO; + +enum tmp_table_type +{ + NO_TMP_TABLE= 0, NON_TRANSACTIONAL_TMP_TABLE, TRANSACTIONAL_TMP_TABLE, + INTERNAL_TMP_TABLE, SYSTEM_TMP_TABLE +}; +enum release_type { RELEASE_NORMAL, RELEASE_WAIT_FOR_DROP }; + + +enum vcol_init_mode +{ + VCOL_INIT_DEPENDENCY_FAILURE_IS_WARNING= 1, + VCOL_INIT_DEPENDENCY_FAILURE_IS_ERROR= 2 + /* + There may be new flags here. + e.g. to automatically remove sql_mode dependency: + GENERATED ALWAYS AS (char_col) -> + GENERATED ALWAYS AS (RTRIM(char_col)) + */ +}; + + +enum enum_vcol_update_mode +{ + VCOL_UPDATE_FOR_READ= 0, + VCOL_UPDATE_FOR_WRITE, + VCOL_UPDATE_FOR_DELETE, + VCOL_UPDATE_INDEXED, + VCOL_UPDATE_INDEXED_FOR_UPDATE, + VCOL_UPDATE_FOR_REPLACE +}; + +/* Field visibility enums */ + +enum field_visibility_t { + VISIBLE= 0, + INVISIBLE_USER, + /* automatically added by the server. Can be queried explicitly + in SELECT, otherwise invisible from anything" */ + INVISIBLE_SYSTEM, + INVISIBLE_FULL +}; + +#define INVISIBLE_MAX_BITS 3 +#define HA_HASH_FIELD_LENGTH 8 +#define HA_HASH_KEY_LENGTH_WITHOUT_NULL 8 +#define HA_HASH_KEY_LENGTH_WITH_NULL 9 + + +int fields_in_hash_keyinfo(KEY *keyinfo); + +void setup_keyinfo_hash(KEY *key_info); + +void re_setup_keyinfo_hash(KEY *key_info); + +/** + 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, + + /** + 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=4, + + /* + Types below are read only tables, not affected by FLUSH TABLES or + MDL locks. + */ + /** + 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=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 +}; + +typedef enum enum_table_category TABLE_CATEGORY; + +TABLE_CATEGORY get_table_category(const LEX_CSTRING *db, + const LEX_CSTRING *name); + + +typedef struct st_table_field_type +{ + LEX_CSTRING name; + LEX_CSTRING type; + LEX_CSTRING cset; +} TABLE_FIELD_TYPE; + + +typedef struct st_table_field_def +{ + uint count; + const TABLE_FIELD_TYPE *field; + uint primary_key_parts; + const uint *primary_key_columns; +} TABLE_FIELD_DEF; + + +class Table_check_intact +{ +protected: + bool has_keys; + virtual void report_error(uint code, const char *fmt, ...)= 0; + +public: + Table_check_intact(bool keys= false) : has_keys(keys) {} + virtual ~Table_check_intact() {} + + /** Checks whether a table is intact. */ + bool check(TABLE *table, const TABLE_FIELD_DEF *table_def); +}; + + +/* + If the table isn't valid, report the error to the server log only. +*/ +class Table_check_intact_log_error : public Table_check_intact +{ +protected: + void report_error(uint, const char *fmt, ...); +public: + Table_check_intact_log_error() : Table_check_intact(true) {} +}; + + +/** + Class representing the fact that some thread waits for table + share to be flushed. Is used to represent information about + such waits in MDL deadlock detector. +*/ + +class Wait_for_flush : public MDL_wait_for_subgraph +{ + MDL_context *m_ctx; + TABLE_SHARE *m_share; + uint m_deadlock_weight; +public: + Wait_for_flush(MDL_context *ctx_arg, TABLE_SHARE *share_arg, + uint deadlock_weight_arg) + : m_ctx(ctx_arg), m_share(share_arg), + m_deadlock_weight(deadlock_weight_arg) + {} + + MDL_context *get_ctx() const { return m_ctx; } + + virtual bool accept_visitor(MDL_wait_for_graph_visitor *dvisitor); + + virtual uint get_deadlock_weight() const; + + /** + Pointers for participating in the list of waiters for table share. + */ + Wait_for_flush *next_in_share; + Wait_for_flush **prev_in_share; +}; + + +typedef I_P_List <Wait_for_flush, + I_P_List_adapter<Wait_for_flush, + &Wait_for_flush::next_in_share, + &Wait_for_flush::prev_in_share> > + Wait_for_flush_list; + + +enum open_frm_error { + OPEN_FRM_OK = 0, + OPEN_FRM_OPEN_ERROR, + OPEN_FRM_READ_ERROR, + OPEN_FRM_CORRUPTED, + OPEN_FRM_DISCOVER, + OPEN_FRM_ERROR_ALREADY_ISSUED, + OPEN_FRM_NOT_A_VIEW, + OPEN_FRM_NOT_A_TABLE, + OPEN_FRM_NEEDS_REBUILD +}; + +/** + Control block to access table statistics loaded + from persistent statistical tables +*/ + +class TABLE_STATISTICS_CB +{ + class Statistics_state + { + enum state_codes + { + EMPTY, /** data is not loaded */ + LOADING, /** data is being loaded in some connection */ + READY /** data is loaded and available for use */ + }; + int32 state; + + public: + /** No state copy */ + Statistics_state &operator=(const Statistics_state &) { return *this; } + + /** Checks if data loading have been completed */ + bool is_ready() const + { + return my_atomic_load32_explicit(const_cast<int32*>(&state), + MY_MEMORY_ORDER_ACQUIRE) == READY; + } + + /** + Sets mutual exclusion for data loading + + If stats are in LOADING state, waits until state change. + + @return + @retval true atomic EMPTY -> LOADING transfer completed, ok to load + @retval false stats are in READY state, no need to load + */ + bool start_load() + { + for (;;) + { + int32 expected= EMPTY; + if (my_atomic_cas32_weak_explicit(&state, &expected, LOADING, + MY_MEMORY_ORDER_RELAXED, + MY_MEMORY_ORDER_RELAXED)) + return true; + if (expected == READY) + return false; + (void) LF_BACKOFF(); + } + } + + /** Marks data available for subsequent use */ + void end_load() + { + DBUG_ASSERT(my_atomic_load32_explicit(&state, MY_MEMORY_ORDER_RELAXED) == + LOADING); + my_atomic_store32_explicit(&state, READY, MY_MEMORY_ORDER_RELEASE); + } + + /** Restores empty state on error (e.g. OOM) */ + void abort_load() + { + DBUG_ASSERT(my_atomic_load32_explicit(&state, MY_MEMORY_ORDER_RELAXED) == + LOADING); + my_atomic_store32_explicit(&state, EMPTY, MY_MEMORY_ORDER_RELAXED); + } + }; + + class Statistics_state stats_state; + class Statistics_state hist_state; + +public: + MEM_ROOT mem_root; /* MEM_ROOT to allocate statistical data for the table */ + Table_statistics *table_stats; /* Structure to access the statistical data */ + ulong total_hist_size; /* Total size of all histograms */ + + bool histograms_are_ready() const + { + return !total_hist_size || hist_state.is_ready(); + } + + bool start_histograms_load() + { + return total_hist_size && hist_state.start_load(); + } + + void end_histograms_load() { hist_state.end_load(); } + void abort_histograms_load() { hist_state.abort_load(); } + bool stats_are_ready() const { return stats_state.is_ready(); } + bool start_stats_load() { return stats_state.start_load(); } + void end_stats_load() { stats_state.end_load(); } + void abort_stats_load() { stats_state.abort_load(); } +}; + +/** + This structure is shared between different table objects. There is one + instance of table share per one table in the database. +*/ + +struct TABLE_SHARE +{ + TABLE_SHARE() {} /* Remove gcc warning */ + + /** Category of this table. */ + TABLE_CATEGORY table_category; + + /* hash of field names (contains pointers to elements of field array) */ + HASH name_hash; /* hash of field names */ + MEM_ROOT mem_root; + TYPELIB keynames; /* Pointers to keynames */ + TYPELIB fieldnames; /* Pointer to fieldnames */ + TYPELIB *intervals; /* pointer to interval info */ + mysql_mutex_t LOCK_ha_data; /* To protect access to ha_data */ + mysql_mutex_t LOCK_share; /* To protect TABLE_SHARE */ + + TDC_element *tdc; + + LEX_CUSTRING tabledef_version; + + engine_option_value *option_list; /* text options for table */ + ha_table_option_struct *option_struct; /* structure with parsed options */ + + /* The following is copied to each TABLE on OPEN */ + Field **field; + Field **found_next_number_field; + KEY *key_info; /* data of keys in database */ + Virtual_column_info **check_constraints; + uint *blob_field; /* Index to blobs in Field arrray*/ + LEX_CUSTRING vcol_defs; /* definitions of generated columns */ + + TABLE_STATISTICS_CB stats_cb; + + uchar *default_values; /* row with default values */ + LEX_CSTRING comment; /* Comment about table */ + CHARSET_INFO *table_charset; /* Default charset of string fields */ + + MY_BITMAP *check_set; /* Fields used by check constrant */ + MY_BITMAP all_set; + /* + Key which is used for looking-up table in table cache and in the list + of thread's temporary tables. Has the form of: + "database_name\0table_name\0" + optional part for temporary tables. + + Note that all three 'table_cache_key', 'db' and 'table_name' members + must be set (and be non-zero) for tables in table cache. They also + should correspond to each other. + To ensure this one can use set_table_cache() methods. + */ + LEX_CSTRING table_cache_key; + LEX_CSTRING db; /* Pointer to db */ + LEX_CSTRING table_name; /* Table name (for open) */ + LEX_CSTRING path; /* Path to .frm file (from datadir) */ + LEX_CSTRING normalized_path; /* unpack_filename(path) */ + LEX_CSTRING connect_string; + + /* + Set of keys in use, implemented as a Bitmap. + Excludes keys disabled by ALTER TABLE ... DISABLE KEYS. + */ + key_map keys_in_use; + key_map keys_for_keyread; + ha_rows min_rows, max_rows; /* create information */ + ulong avg_row_length; /* create information */ + ulong mysql_version; /* 0 if .frm is created before 5.0 */ + ulong reclength; /* Recordlength */ + /* Stored record length. No generated-only virtual fields are included */ + ulong stored_rec_length; + + plugin_ref db_plugin; /* storage engine plugin */ + inline handlerton *db_type() const /* table_type for handler */ + { + return is_view ? view_pseudo_hton : + db_plugin ? plugin_hton(db_plugin) : NULL; + } + enum row_type row_type; /* How rows are stored */ + enum Table_type table_type; + enum tmp_table_type tmp_table; + + /** Transactional or not. */ + enum ha_choice transactional; + /** Per-page checksums or not. */ + enum ha_choice page_checksum; + + uint key_block_size; /* create key_block_size, if used */ + uint stats_sample_pages; /* number of pages to sample during + stats estimation, if used, otherwise 0. */ + enum_stats_auto_recalc stats_auto_recalc; /* Automatic recalc of stats. */ + uint null_bytes, last_null_bit_pos; + /* + Same as null_bytes, except that if there is only a 'delete-marker' in + the record then this value is 0. + */ + uint null_bytes_for_compare; + uint fields; /* number of fields */ + /* number of stored fields, purely virtual not included */ + uint stored_fields; + uint virtual_fields; /* number of purely virtual fields */ + /* number of purely virtual not stored blobs */ + uint virtual_not_stored_blob_fields; + uint null_fields; /* number of null fields */ + uint blob_fields; /* number of blob fields */ + uint varchar_fields; /* number of varchar fields */ + uint default_fields; /* number of default fields */ + uint visible_fields; /* number of visible fields */ + + uint default_expressions; + uint table_check_constraints, field_check_constraints; + + uint rec_buff_length; /* Size of table->record[] buffer */ + uint keys, key_parts; + uint ext_key_parts; /* Total number of key parts in extended keys */ + uint max_key_length, max_unique_length; + uint uniques; /* Number of UNIQUE index */ + uint db_create_options; /* Create options from database */ + uint db_options_in_use; /* Options in use */ + uint db_record_offset; /* if HA_REC_IN_SEQ */ + uint rowid_field_offset; /* Field_nr +1 to rowid field */ + /* Primary key index number, used in TABLE::key_info[] */ + uint primary_key; + uint next_number_index; /* autoincrement key number */ + uint next_number_key_offset; /* autoinc keypart offset in a key */ + uint next_number_keypart; /* autoinc keypart number in a key */ + enum open_frm_error error; /* error from open_table_def() */ + uint open_errno; /* error from open_table_def() */ + uint column_bitmap_size; + uchar frm_version; + + enum enum_v_keys { NOT_INITIALIZED=0, NO_V_KEYS, V_KEYS }; + enum_v_keys check_set_initialized; + + bool use_ext_keys; /* Extended keys can be used */ + bool null_field_first; + bool system; /* Set if system table (one record) */ + bool not_usable_by_query_cache; + bool online_backup; /* Set if on-line backup supported */ + /* + This is used by log tables, for tables that have their own internal + binary logging or for tables that doesn't support statement or row logging + */ + bool no_replicate; + bool crashed; + bool is_view; + bool can_cmp_whole_record; + /* This is set for temporary tables where CREATE was binary logged */ + bool table_creation_was_logged; + bool non_determinstic_insert; + bool vcols_need_refixing; + bool has_update_default_function; + bool can_do_row_logging; /* 1 if table supports RBR */ + bool long_unique_table; + + ulong table_map_id; /* for row-based replication */ + + /* + Things that are incompatible between the stored version and the + current version. This is a set of HA_CREATE... bits that can be used + to modify create_info->used_fields for ALTER TABLE. + */ + ulong incompatible_version; + + /** + For shares representing views File_parser object with view + definition read from .FRM file. + */ + const File_parser *view_def; + + /* For sequence tables, the current sequence state */ + SEQUENCE *sequence; + +#ifdef WITH_PARTITION_STORAGE_ENGINE + /* filled in when reading from frm */ + bool auto_partitioned; + char *partition_info_str; + uint partition_info_str_len; + uint partition_info_buffer_size; + plugin_ref default_part_plugin; +#endif + + /** + System versioning and application-time periods support. + */ + struct period_info_t + { + uint16 start_fieldno; + uint16 end_fieldno; + Lex_ident name; + Lex_ident constr_name; + uint unique_keys; + Field *start_field(TABLE_SHARE *s) const + { + return s->field[start_fieldno]; + } + Field *end_field(TABLE_SHARE *s) const + { + return s->field[end_fieldno]; + } + }; + + vers_kind_t versioned; + period_info_t vers; + period_info_t period; + + bool init_period_from_extra2(period_info_t *period, const uchar *data, + const uchar *end); + + Field *vers_start_field() + { + DBUG_ASSERT(versioned); + return field[vers.start_fieldno]; + } + + Field *vers_end_field() + { + DBUG_ASSERT(versioned); + return field[vers.end_fieldno]; + } + + Field *period_start_field() const + { + DBUG_ASSERT(period.name); + return field[period.start_fieldno]; + } + + Field *period_end_field() const + { + DBUG_ASSERT(period.name); + return field[period.end_fieldno]; + } + + /** + Cache the checked structure of this table. + + The pointer data is used to describe the structure that + a instance of the table must have. Each element of the + array specifies a field that must exist on the table. + + The pointer is cached in order to perform the check only + once -- when the table is loaded from the disk. + */ + const TABLE_FIELD_DEF *table_field_def_cache; + + /** Main handler's share */ + Handler_share *ha_share; + + /** Instrumentation for this table share. */ + PSI_table_share *m_psi; + + inline void reset() { bzero((void*)this, sizeof(*this)); } + + /* + Set share's table cache key and update its db and table name appropriately. + + SYNOPSIS + set_table_cache_key() + key_buff Buffer with already built table cache key to be + referenced from share. + key_length Key length. + + NOTES + Since 'key_buff' buffer will be referenced from share it should has same + life-time as share itself. + This method automatically ensures that TABLE_SHARE::table_name/db have + appropriate values by using table cache key as their source. + */ + + void set_table_cache_key(char *key_buff, uint key_length) + { + table_cache_key.str= key_buff; + table_cache_key.length= key_length; + /* + Let us use the fact that the key is "db/0/table_name/0" + optional + part for temporary tables. + */ + db.str= table_cache_key.str; + db.length= strlen(db.str); + table_name.str= db.str + db.length + 1; + table_name.length= strlen(table_name.str); + } + + + /* + Set share's table cache key and update its db and table name appropriately. + + SYNOPSIS + set_table_cache_key() + key_buff Buffer to be used as storage for table cache key + (should be at least key_length bytes). + key Value for table cache key. + key_length Key length. + + NOTE + Since 'key_buff' buffer will be used as storage for table cache key + it should has same life-time as share itself. + */ + + void set_table_cache_key(char *key_buff, const char *key, uint key_length) + { + memcpy(key_buff, key, key_length); + set_table_cache_key(key_buff, key_length); + } + + inline bool require_write_privileges() + { + return (table_category == TABLE_CATEGORY_LOG); + } + + inline ulong get_table_def_version() + { + return table_map_id; + } + + /** + Convert unrelated members of TABLE_SHARE to one enum + representing its type. + + @todo perhaps we need to have a member instead of a function. + */ + enum enum_table_ref_type get_table_ref_type() const + { + if (is_view) + return TABLE_REF_VIEW; + switch (tmp_table) { + case NO_TMP_TABLE: + return TABLE_REF_BASE_TABLE; + case SYSTEM_TMP_TABLE: + return TABLE_REF_I_S_TABLE; + default: + return TABLE_REF_TMP_TABLE; + } + } + /** + Return a table metadata version. + * for base tables and views, we return table_map_id. + It is assigned from a global counter incremented for each + new table loaded into the table definition cache (TDC). + * for temporary tables it's table_map_id again. But for + temporary tables table_map_id is assigned from + thd->query_id. The latter is assigned from a thread local + counter incremented for every new SQL statement. Since + temporary tables are thread-local, each temporary table + gets a unique id. + * for everything else (e.g. information schema tables), + the version id is zero. + + This choice of version id is a large compromise + to have a working prepared statement validation in 5.1. In + future version ids will be persistent, as described in WL#4180. + + Let's try to explain why and how this limited solution allows + to validate prepared statements. + + Firstly, sets (in mathematical sense) of version numbers + never intersect for different table types. Therefore, + version id of a temporary table is never compared with + a version id of a view, and vice versa. + + Secondly, for base tables and views, we know that each DDL flushes + the respective share from the TDC. This ensures that whenever + a table is altered or dropped and recreated, it gets a new + version id. + Unfortunately, since elements of the TDC are also flushed on + LRU basis, this choice of version ids leads to false positives. + E.g. when the TDC size is too small, we may have a SELECT + * FROM INFORMATION_SCHEMA.TABLES flush all its elements, which + in turn will lead to a validation error and a subsequent + reprepare of all prepared statements. This is + considered acceptable, since as long as prepared statements are + automatically reprepared, spurious invalidation is only + a performance hit. Besides, no better simple solution exists. + + For temporary tables, using thd->query_id ensures that if + a temporary table was altered or recreated, a new version id is + assigned. This suits validation needs very well and will perhaps + never change. + + Metadata of information schema tables never changes. + Thus we can safely assume 0 for a good enough version id. + + Finally, by taking into account table type, we always + track that a change has taken place when a view is replaced + with a base table, a base table is replaced with a temporary + table and so on. + + @sa TABLE_LIST::is_table_ref_id_equal() + */ + ulong get_table_ref_version() const + { + return (tmp_table == SYSTEM_TMP_TABLE) ? 0 : table_map_id; + } + + bool visit_subgraph(Wait_for_flush *waiting_ticket, + MDL_wait_for_graph_visitor *gvisitor); + + bool wait_for_old_version(THD *thd, struct timespec *abstime, + uint deadlock_weight); + /** Release resources and free memory occupied by the table share. */ + void destroy(); + + void set_use_ext_keys_flag(bool fl) + { + use_ext_keys= fl; + } + + uint actual_n_key_parts(THD *thd); + + LEX_CUSTRING *frm_image; ///< only during CREATE TABLE (@sa ha_create_table) + + /* + populates TABLE_SHARE from the table description in the binary frm image. + if 'write' is true, this frm image is also written into a corresponding + frm file, that serves as a persistent metadata cache to avoid + discovering the table over and over again + */ + int init_from_binary_frm_image(THD *thd, bool write, + const uchar *frm_image, size_t frm_length, + const uchar *par_image=0, + size_t par_length=0); + + /* + populates TABLE_SHARE from the table description, specified as the + complete CREATE TABLE sql statement. + if 'write' is true, this frm image is also written into a corresponding + frm file, that serves as a persistent metadata cache to avoid + discovering the table over and over again + */ + int init_from_sql_statement_string(THD *thd, bool write, + const char *sql, size_t sql_length); + /* + writes the frm image to an frm file, corresponding to this table + */ + bool write_frm_image(const uchar *frm_image, size_t frm_length); + bool write_par_image(const uchar *par_image, size_t par_length); + + /* Only used by tokudb */ + bool write_frm_image(void) + { return frm_image ? write_frm_image(frm_image->str, frm_image->length) : 0; } + + /* + returns an frm image for this table. + the memory is allocated and must be freed later + */ + bool read_frm_image(const uchar **frm_image, size_t *frm_length); + + /* frees the memory allocated in read_frm_image */ + void free_frm_image(const uchar *frm); + + void set_overlapped_keys(); +}; + +/* not NULL, but cannot be dereferenced */ +#define UNUSABLE_TABLE_SHARE ((TABLE_SHARE*)1) + +/** + Class is used as a BLOB field value storage for + intermediate GROUP_CONCAT results. Used only for + GROUP_CONCAT with DISTINCT or ORDER BY options. + */ + +class Blob_mem_storage: public Sql_alloc +{ +private: + MEM_ROOT storage; + /** + Sign that some values were cut + during saving into the storage. + */ + bool truncated_value; +public: + Blob_mem_storage() :truncated_value(false) + { + init_alloc_root(key_memory_blob_mem_storage, + &storage, MAX_FIELD_VARCHARLENGTH, 0, MYF(0)); + } + ~ Blob_mem_storage() + { + free_root(&storage, MYF(0)); + } + void reset() + { + free_root(&storage, MYF(MY_MARK_BLOCKS_FREE)); + truncated_value= false; + } + /** + Fuction creates duplicate of 'from' + string in 'storage' MEM_ROOT. + + @param from string to copy + @param length string length + + @retval Pointer to the copied string. + @retval 0 if an error occurred. + */ + char *store(const char *from, size_t length) + { + return (char*) memdup_root(&storage, from, length); + } + void set_truncated_value(bool is_truncated_value) + { + truncated_value= is_truncated_value; + } + bool is_truncated_value() { return truncated_value; } +}; + + +/* Information for one open table */ +enum index_hint_type +{ + INDEX_HINT_IGNORE, + INDEX_HINT_USE, + INDEX_HINT_FORCE +}; + +struct st_cond_statistic; + +#define CHECK_ROW_FOR_NULLS_TO_REJECT (1 << 0) +#define REJECT_ROW_DUE_TO_NULL_FIELDS (1 << 1) + +class SplM_opt_info; + +struct vers_select_conds_t; + +struct TABLE +{ + TABLE() {} /* Remove gcc warning */ + + TABLE_SHARE *s; + handler *file; + TABLE *next, *prev; + +private: + /** + Links for the list of all TABLE objects for this share. + Declared as private to avoid direct manipulation with those objects. + One should use methods of I_P_List template instead. + */ + TABLE *share_all_next, **share_all_prev; + TABLE *global_free_next, **global_free_prev; + friend struct All_share_tables; + friend struct Table_cache_instance; + +public: + + uint32 instance; /** Table cache instance this TABLE is belonging to */ + THD *in_use; /* Which thread uses this */ + + uchar *record[3]; /* Pointer to records */ + uchar *write_row_record; /* Used as optimisation in + THD::write_row */ + uchar *insert_values; /* used by INSERT ... UPDATE */ + /* + Map of keys that can be used to retrieve all data from this table + needed by the query without reading the row. + */ + key_map covering_keys, intersect_keys; + /* + A set of keys that can be used in the query that references this + table. + + All indexes disabled on the table's TABLE_SHARE (see TABLE::s) will be + subtracted from this set upon instantiation. Thus for any TABLE t it holds + that t.keys_in_use_for_query is a subset of t.s.keys_in_use. Generally we + must not introduce any new keys here (see setup_tables). + + The set is implemented as a bitmap. + */ + key_map keys_in_use_for_query; + /* Map of keys that can be used to calculate GROUP BY without sorting */ + key_map keys_in_use_for_group_by; + /* Map of keys that can be used to calculate ORDER BY without sorting */ + key_map keys_in_use_for_order_by; + /* Map of keys dependent on some constraint */ + key_map constraint_dependent_keys; + KEY *key_info; /* data of keys in database */ + + Field **field; /* Pointer to fields */ + Field **vfield; /* Pointer to virtual fields*/ + Field **default_field; /* Fields with non-constant DEFAULT */ + Field *next_number_field; /* Set if next_number is activated */ + Field *found_next_number_field; /* Set on open */ + Virtual_column_info **check_constraints; + + /* Table's triggers, 0 if there are no of them */ + Table_triggers_list *triggers; + TABLE_LIST *pos_in_table_list;/* Element referring to this table */ + /* Position in thd->locked_table_list under LOCK TABLES */ + TABLE_LIST *pos_in_locked_tables; + /* Tables used in DEFAULT and CHECK CONSTRAINT (normally sequence tables) */ + TABLE_LIST *internal_tables; + + /* + Not-null for temporary tables only. Non-null values means this table is + used to compute GROUP BY, it has a unique of GROUP BY columns. + (set by create_tmp_table) + */ + ORDER *group; + String alias; /* alias or table name */ + uchar *null_flags; + MY_BITMAP def_read_set, def_write_set, tmp_set; + MY_BITMAP def_rpl_write_set; + MY_BITMAP eq_join_set; /* used to mark equi-joined fields */ + MY_BITMAP cond_set; /* used to mark fields from sargable conditions*/ + /* Active column sets */ + MY_BITMAP *read_set, *write_set, *rpl_write_set; + /* On INSERT: fields that the user specified a value for */ + MY_BITMAP has_value_set; + + /* + The ID of the query that opened and is using this table. Has different + meanings depending on the table type. + + Temporary tables: + + table->query_id is set to thd->query_id for the duration of a statement + and is reset to 0 once it is closed by the same statement. A non-zero + table->query_id means that a statement is using the table even if it's + not the current statement (table is in use by some outer statement). + + Non-temporary tables: + + Under pre-locked or LOCK TABLES mode: query_id is set to thd->query_id + for the duration of a statement and is reset to 0 once it is closed by + the same statement. A non-zero query_id is used to control which tables + in the list of pre-opened and locked tables are actually being used. + */ + query_id_t query_id; + + /* + This structure is used for statistical data on the table that + is collected by the function collect_statistics_for_table + */ + Table_statistics *collected_stats; + + /* The estimate of the number of records in the table used by optimizer */ + ha_rows used_stat_records; + + key_map opt_range_keys; + /* + The following structure is filled for each key that has + opt_range_keys.is_set(key) == TRUE + */ + struct OPT_RANGE + { + uint key_parts; + uint ranges; + ha_rows rows; + double cost; + /* + If there is a range access by i-th index then the cost of + index only access for it is stored in index_only_costs[i] + */ + double index_only_cost; + } *opt_range; + /* + Bitmaps of key parts that =const for the duration of join execution. If + we're in a subquery, then the constant may be different across subquery + re-executions. + */ + key_part_map *const_key_parts; + + /* + Estimate of number of records that satisfy SARGable part of the table + condition, or table->file->records if no SARGable condition could be + constructed. + This value is used by join optimizer as an estimate of number of records + that will pass the table condition (condition that depends on fields of + this table and constants) + */ + ha_rows opt_range_condition_rows; + + double cond_selectivity; + List<st_cond_statistic> *cond_selectivity_sampling_explain; + + table_map map; /* ID bit of table (1,2,4,8,16...) */ + + uint lock_position; /* Position in MYSQL_LOCK.table */ + uint lock_data_start; /* Start pos. in MYSQL_LOCK.locks */ + uint lock_count; /* Number of locks */ + uint tablenr,used_fields; + uint temp_pool_slot; /* Used by intern temp tables */ + uint status; /* What's in record[0] */ + uint db_stat; /* mode of file as in handler.h */ + /* number of select if it is derived table */ + uint derived_select_number; + /* + Possible values: + - 0 by default + - JOIN_TYPE_{LEFT|RIGHT} if the table is inner w.r.t an outer join + operation + - 1 if the SELECT has mixed_implicit_grouping=1. example: + select max(col1), col2 from t1. In this case, the query produces + one row with all columns having NULL values. + + Interpetation: If maybe_null!=0, all fields of the table are considered + NULLable (and have NULL values when null_row=true) + */ + uint maybe_null; + int current_lock; /* Type of lock on table */ + bool copy_blobs; /* copy_blobs when storing */ + /* + Set if next_number_field is in the UPDATE fields of INSERT ... ON DUPLICATE + KEY UPDATE. + */ + bool next_number_field_updated; + + /* + If true, the current table row is considered to have all columns set to + NULL, including columns declared as "not null" (see maybe_null). + */ + bool null_row; + /* + No rows that contain null values can be placed into this table. + Currently this flag can be set to true only for a temporary table + that used to store the result of materialization of a subquery. + */ + bool no_rows_with_nulls; + /* + This field can contain two bit flags: + CHECK_ROW_FOR_NULLS_TO_REJECT + REJECT_ROW_DUE_TO_NULL_FIELDS + The first flag is set for the dynamic contexts where it is prohibited + to write any null into the table. + The second flag is set only if the first flag is set on. + The informs the outer scope that there was an attept to write null + into a field of the table in the context where it is prohibited. + This flag should be set off as soon as the first flag is set on. + Currently these flags are used only the tables tno_rows_with_nulls set + to true. + */ + uint8 null_catch_flags; + + /* + TODO: Each of the following flags take up 8 bits. They can just as easily + be put into one single unsigned long and instead of taking up 18 + bytes, it would take up 4. + */ + bool force_index; + + /** + Flag set when the statement contains FORCE INDEX FOR ORDER BY + See TABLE_LIST::process_index_hints(). + */ + bool force_index_order; + + /** + Flag set when the statement contains FORCE INDEX FOR GROUP BY + See TABLE_LIST::process_index_hints(). + */ + bool force_index_group; + /* + TRUE<=> this table was created with create_tmp_table(... distinct=TRUE..) + call + */ + bool distinct; + bool const_table,no_rows, used_for_duplicate_elimination; + /** + Forces DYNAMIC Aria row format for internal temporary tables. + */ + bool keep_row_order; + + bool no_keyread; + /** + If set, indicate that the table is not replicated by the server. + */ + bool locked_by_logger; + bool locked_by_name; + bool fulltext_searched; + bool no_cache; + /* To signal that the table is associated with a HANDLER statement */ + bool open_by_handler; + /* + To indicate that a non-null value of the auto_increment field + was provided by the user or retrieved from the current record. + Used only in the MODE_NO_AUTO_VALUE_ON_ZERO mode. + */ + bool auto_increment_field_not_null; + bool insert_or_update; /* Can be used by the handler */ + bool alias_name_used; /* true if table_name is alias */ + bool get_fields_in_item_tree; /* Signal to fix_field */ +private: + bool m_needs_reopen; + bool created; /* For tmp tables. TRUE <=> tmp table was actually created.*/ +public: +#ifdef HAVE_REPLICATION + /* used in RBR Triggers */ + bool master_had_triggers; +#endif + + REGINFO reginfo; /* field connections */ + MEM_ROOT mem_root; + /** + Initialized in Item_func_group_concat::setup for appropriate + temporary table if GROUP_CONCAT is used with ORDER BY | DISTINCT + and BLOB field count > 0. + */ + Blob_mem_storage *blob_storage; + GRANT_INFO grant; + /* + The arena which the items for expressions from the table definition + are associated with. + Currently only the items of the expressions for virtual columns are + associated with this arena. + TODO: To attach the partitioning expressions to this arena. + */ + Query_arena *expr_arena; +#ifdef WITH_PARTITION_STORAGE_ENGINE + partition_info *part_info; /* Partition related information */ + /* If true, all partitions have been pruned away */ + bool all_partitions_pruned_away; +#endif + uint max_keys; /* Size of allocated key_info array. */ + bool stats_is_read; /* Persistent statistics is read for the table */ + bool histograms_are_read; + MDL_ticket *mdl_ticket; + + /* + This is used only for potentially splittable materialized tables and it + points to the info used by the optimizer to apply splitting optimization + */ + SplM_opt_info *spl_opt_info; + key_map keys_usable_for_splitting; + + /* + Conjunction of the predicates of the form IS NOT NULL(f) where f refers to + a column of this TABLE such that they can be inferred from the condition + of the WHERE clause or from some ON expression of the processed select + and can be useful for range optimizer. + */ + Item *notnull_cond; + + inline void reset() { bzero((void*)this, sizeof(*this)); } + void init(THD *thd, TABLE_LIST *tl); + bool fill_item_list(List<Item> *item_list) const; + void reset_item_list(List<Item> *item_list, uint skip) const; + void clear_column_bitmaps(void); + void prepare_for_position(void); + MY_BITMAP *prepare_for_keyread(uint index, MY_BITMAP *map); + MY_BITMAP *prepare_for_keyread(uint index) + { return prepare_for_keyread(index, &tmp_set); } + void mark_index_columns(uint index, MY_BITMAP *bitmap); + void mark_index_columns_no_reset(uint index, MY_BITMAP *bitmap); + void mark_index_columns_for_read(uint index); + void restore_column_maps_after_keyread(MY_BITMAP *backup); + void mark_auto_increment_column(void); + void mark_columns_needed_for_update(void); + void mark_columns_needed_for_delete(void); + void mark_columns_needed_for_insert(void); + void mark_columns_per_binlog_row_image(void); + inline bool mark_column_with_deps(Field *field); + inline bool mark_virtual_column_with_deps(Field *field); + inline void mark_virtual_column_deps(Field *field); + bool mark_virtual_columns_for_write(bool insert_fl); + bool check_virtual_columns_marked_for_read(); + bool check_virtual_columns_marked_for_write(); + void mark_default_fields_for_write(bool insert_fl); + void mark_columns_used_by_virtual_fields(void); + void mark_check_constraint_columns_for_read(void); + int verify_constraints(bool ignore_failure); + inline void column_bitmaps_set(MY_BITMAP *read_set_arg) + { + read_set= read_set_arg; + if (file) + file->column_bitmaps_signal(); + } + inline void column_bitmaps_set(MY_BITMAP *read_set_arg, + MY_BITMAP *write_set_arg) + { + read_set= read_set_arg; + write_set= write_set_arg; + if (file) + file->column_bitmaps_signal(); + } + inline void column_bitmaps_set_no_signal(MY_BITMAP *read_set_arg, + MY_BITMAP *write_set_arg) + { + read_set= read_set_arg; + write_set= write_set_arg; + } + inline void use_all_columns() + { + column_bitmaps_set(&s->all_set, &s->all_set); + } + inline void use_all_stored_columns(); + inline void default_column_bitmaps() + { + read_set= &def_read_set; + write_set= &def_write_set; + rpl_write_set= 0; + } + /** Should this instance of the table be reopened? */ + inline bool needs_reopen() + { return !db_stat || m_needs_reopen; } + /* + Mark that all current connection instances of the table should be + reopen at end of statement + */ + void mark_table_for_reopen(); + /* Should only be called from Locked_tables_list::mark_table_for_reopen() */ + void internal_set_needs_reopen(bool value) + { + m_needs_reopen= value; + } + + bool alloc_keys(uint key_count); + bool check_tmp_key(uint key, uint key_parts, + uint (*next_field_no) (uchar *), uchar *arg); + bool add_tmp_key(uint key, uint key_parts, + uint (*next_field_no) (uchar *), uchar *arg, + bool unique); + void create_key_part_by_field(KEY_PART_INFO *key_part_info, + Field *field, uint fieldnr); + void use_index(int key_to_save); + void set_table_map(table_map map_arg, uint tablenr_arg) + { + map= map_arg; + tablenr= tablenr_arg; + } + + /// Return true if table is instantiated, and false otherwise. + bool is_created() const { return created; } + + /** + Set the table as "created", and enable flags in storage engine + that could not be enabled without an instantiated table. + */ + void set_created() + { + if (created) + return; + if (file->keyread_enabled()) + file->extra(HA_EXTRA_KEYREAD); + created= true; + } + + /* + Returns TRUE if the table is filled at execution phase (and so, the + optimizer must not do anything that depends on the contents of the table, + like range analysis or constant table detection) + */ + bool is_filled_at_execution(); + + bool update_const_key_parts(COND *conds); + + inline void initialize_opt_range_structures(); + + my_ptrdiff_t default_values_offset() const + { return (my_ptrdiff_t) (s->default_values - record[0]); } + + void move_fields(Field **ptr, const uchar *to, const uchar *from); + void remember_blob_values(String *blob_storage); + void restore_blob_values(String *blob_storage); + + uint actual_n_key_parts(KEY *keyinfo); + ulong actual_key_flags(KEY *keyinfo); + int update_virtual_field(Field *vf); + int update_virtual_fields(handler *h, enum_vcol_update_mode update_mode); + int update_default_fields(bool ignore_errors); + void evaluate_update_default_function(); + void reset_default_fields(); + inline ha_rows stat_records() { return used_stat_records; } + + void prepare_triggers_for_insert_stmt_or_event(); + bool prepare_triggers_for_delete_stmt_or_event(); + bool prepare_triggers_for_update_stmt_or_event(); + + Field **field_to_fill(); + bool validate_default_values_of_unset_fields(THD *thd) const; + + bool insert_all_rows_into_tmp_table(THD *thd, + TABLE *tmp_table, + TMP_TABLE_PARAM *tmp_table_param, + bool with_cleanup); + int fix_vcol_exprs(THD *thd); + Field *find_field_by_name(LEX_CSTRING *str) const; + bool export_structure(THD *thd, class Row_definition_list *defs); + bool is_splittable() { return spl_opt_info != NULL; } + void set_spl_opt_info(SplM_opt_info *spl_info); + void deny_splitting(); + double get_materialization_cost(); // Now used only if is_splittable()==true + void add_splitting_info_for_key_field(struct KEY_FIELD *key_field); + + key_map with_impossible_ranges; + + /* Number of cost info elements for possible range filters */ + uint range_rowid_filter_cost_info_elems; + /* Pointer to the array of cost info elements for range filters */ + Range_rowid_filter_cost_info *range_rowid_filter_cost_info; + /* The array of pointers to cost info elements for range filters */ + Range_rowid_filter_cost_info **range_rowid_filter_cost_info_ptr; + + void init_cost_info_for_usable_range_rowid_filters(THD *thd); + void prune_range_rowid_filters(); + void trace_range_rowid_filters(THD *thd) const; + Range_rowid_filter_cost_info * + best_range_rowid_filter_for_partial_join(uint access_key_no, + double records, + double access_cost_factor); + + /** + System Versioning support + */ + bool vers_write; + + bool versioned() const + { + return s->versioned; + } + + bool versioned(vers_kind_t type) const + { + DBUG_ASSERT(type); + return s->versioned == type; + } + + bool versioned_write() const + { + DBUG_ASSERT(versioned() || !vers_write); + return versioned() ? vers_write : false; + } + + bool versioned_write(vers_kind_t type) const + { + DBUG_ASSERT(type); + DBUG_ASSERT(versioned() || !vers_write); + return versioned(type) ? vers_write : false; + } + + Field *vers_start_field() const + { + DBUG_ASSERT(s->versioned); + return field[s->vers.start_fieldno]; + } + + Field *vers_end_field() const + { + DBUG_ASSERT(s->versioned); + return field[s->vers.end_fieldno]; + } + + Field *period_start_field() const + { + DBUG_ASSERT(s->period.name); + return field[s->period.start_fieldno]; + } + + Field *period_end_field() const + { + DBUG_ASSERT(s->period.name); + return field[s->period.end_fieldno]; + } + + + ulonglong vers_start_id() const; + ulonglong vers_end_id() const; + + int update_generated_fields(); + int period_make_insert(Item *src, Field *dst); + int insert_portion_of_time(THD *thd, const vers_select_conds_t &period_conds, + ha_rows *rows_inserted); + bool vers_check_update(List<Item> &items); + static bool check_period_overlaps(const KEY &key, const uchar *lhs, const uchar *rhs); + int delete_row(); + void vers_update_fields(); + void vers_update_end(); + void find_constraint_correlated_indexes(); + +/** Number of additional fields used in versioned tables */ +#define VERSIONING_FIELDS 2 +}; + + +/** + Helper class which specifies which members of TABLE are used for + participation in the list of used/unused TABLE objects for the share. +*/ + +struct TABLE_share +{ + static inline TABLE **next_ptr(TABLE *l) + { + return &l->next; + } + static inline TABLE ***prev_ptr(TABLE *l) + { + return (TABLE ***) &l->prev; + } +}; + +struct All_share_tables +{ + static inline TABLE **next_ptr(TABLE *l) + { + return &l->share_all_next; + } + static inline TABLE ***prev_ptr(TABLE *l) + { + return &l->share_all_prev; + } +}; + +typedef I_P_List <TABLE, All_share_tables> All_share_tables_list; + +enum enum_schema_table_state +{ + NOT_PROCESSED= 0, + PROCESSED_BY_CREATE_SORT_INDEX, + PROCESSED_BY_JOIN_EXEC +}; + +enum enum_fk_option { FK_OPTION_UNDEF, FK_OPTION_RESTRICT, FK_OPTION_CASCADE, + FK_OPTION_SET_NULL, FK_OPTION_NO_ACTION, FK_OPTION_SET_DEFAULT}; + +typedef struct st_foreign_key_info +{ + LEX_CSTRING *foreign_id; + LEX_CSTRING *foreign_db; + LEX_CSTRING *foreign_table; + LEX_CSTRING *referenced_db; + LEX_CSTRING *referenced_table; + enum_fk_option update_method; + enum_fk_option delete_method; + LEX_CSTRING *referenced_key_name; + List<LEX_CSTRING> foreign_fields; + List<LEX_CSTRING> referenced_fields; +} FOREIGN_KEY_INFO; + +LEX_CSTRING *fk_option_name(enum_fk_option opt); +bool fk_modifies_child(enum_fk_option opt); + +class IS_table_read_plan; + +/* + Types of derived tables. The ending part is a bitmap of phases that are + applicable to a derived table of the type. +*/ +#define DTYPE_ALGORITHM_UNDEFINED 0U +#define DTYPE_VIEW 1U +#define DTYPE_TABLE 2U +#define DTYPE_MERGE 4U +#define DTYPE_MATERIALIZE 8U +#define DTYPE_MULTITABLE 16U +#define DTYPE_MASK (DTYPE_VIEW|DTYPE_TABLE|DTYPE_MULTITABLE) + +/* + Phases of derived tables/views handling, see sql_derived.cc + Values are used as parts of a bitmap attached to derived table types. +*/ +#define DT_INIT 1U +#define DT_PREPARE 2U +#define DT_OPTIMIZE 4U +#define DT_MERGE 8U +#define DT_MERGE_FOR_INSERT 16U +#define DT_CREATE 32U +#define DT_FILL 64U +#define DT_REINIT 128U +#define DT_PHASES 8U +/* Phases that are applicable to all derived tables. */ +#define DT_COMMON (DT_INIT + DT_PREPARE + DT_REINIT + DT_OPTIMIZE) +/* Phases that are applicable only to materialized derived tables. */ +#define DT_MATERIALIZE (DT_CREATE + DT_FILL) + +#define DT_PHASES_MERGE (DT_COMMON | DT_MERGE | DT_MERGE_FOR_INSERT) +#define DT_PHASES_MATERIALIZE (DT_COMMON | DT_MATERIALIZE) + +#define VIEW_ALGORITHM_UNDEFINED 0 +/* Special value for ALTER VIEW: inherit original algorithm. */ +#define VIEW_ALGORITHM_INHERIT DTYPE_VIEW +#define VIEW_ALGORITHM_MERGE (DTYPE_VIEW | DTYPE_MERGE) +#define VIEW_ALGORITHM_TMPTABLE (DTYPE_VIEW | DTYPE_MATERIALIZE) + +/* + View algorithm values as stored in the FRM. Values differ from in-memory + representation for backward compatibility. +*/ + +#define VIEW_ALGORITHM_UNDEFINED_FRM 0U +#define VIEW_ALGORITHM_MERGE_FRM 1U +#define VIEW_ALGORITHM_TMPTABLE_FRM 2U + +#define JOIN_TYPE_LEFT 1U +#define JOIN_TYPE_RIGHT 2U +#define JOIN_TYPE_OUTER 4U /* Marker that this is an outer join */ + +/* view WITH CHECK OPTION parameter options */ +#define VIEW_CHECK_NONE 0 +#define VIEW_CHECK_LOCAL 1 +#define VIEW_CHECK_CASCADED 2 + +/* result of view WITH CHECK OPTION parameter check */ +#define VIEW_CHECK_OK 0 +#define VIEW_CHECK_ERROR 1 +#define VIEW_CHECK_SKIP 2 + +/** The threshold size a blob field buffer before it is freed */ +#define MAX_TDC_BLOB_SIZE 65536 + +/** number of bytes used by field positional indexes in frm */ +constexpr uint frm_fieldno_size= 2; +/** number of bytes used by key position number in frm */ +constexpr uint frm_keyno_size= 2; +static inline uint16 read_frm_fieldno(const uchar *data) +{ return uint2korr(data); } +static inline void store_frm_fieldno(uchar *data, uint16 fieldno) +{ int2store(data, fieldno); } +static inline uint16 read_frm_keyno(const uchar *data) +{ return uint2korr(data); } +static inline void store_frm_keyno(uchar *data, uint16 fieldno) +{ int2store(data, fieldno); } +static inline size_t extra2_str_size(size_t len) +{ return (len > 255 ? 3 : 1) + len; } + +class select_unit; +class TMP_TABLE_PARAM; + +Item *create_view_field(THD *thd, TABLE_LIST *view, Item **field_ref, + LEX_CSTRING *name); + +struct Field_translator +{ + Item *item; + LEX_CSTRING 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; /* Column reference of merge view. */ + Item_field *table_field; /* Column reference of table or temp view. */ + TABLE_LIST *table_ref; /* Original base table/view reference. */ + /* + 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); + LEX_CSTRING *name(); + Item *create_item(THD *thd); + Field *field(); + const char *safe_table_name(); + const char *safe_db_name(); + GRANT_INFO *grant(); +}; + + +/** + 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 +}; + + +class SJ_MATERIALIZATION_INFO; +class Index_hint; +class Item_in_subselect; + +/* trivial class, for %union in sql_yacc.yy */ +struct vers_history_point_t +{ + vers_kind_t unit; + Item *item; +}; + +class Vers_history_point : public vers_history_point_t +{ + void fix_item(); + +public: + Vers_history_point() { empty(); } + Vers_history_point(vers_kind_t unit_arg, Item *item_arg) + { + unit= unit_arg; + item= item_arg; + fix_item(); + } + Vers_history_point(vers_history_point_t p) + { + unit= p.unit; + item= p.item; + fix_item(); + } + void empty() { unit= VERS_TIMESTAMP; item= NULL; } + void print(String *str, enum_query_type, const char *prefix, size_t plen) const; + bool check_unit(THD *thd); + void bad_expression_data_type_error(const char *type) const; + bool eq(const vers_history_point_t &point) const; +}; + +struct vers_select_conds_t +{ + vers_system_time_t type; + vers_system_time_t orig_type; + bool used:1; + bool delete_history:1; + Vers_history_point start; + Vers_history_point end; + Lex_ident name; + + Item_field *field_start; + Item_field *field_end; + + const TABLE_SHARE::period_info_t *period; + + void empty() + { + type= SYSTEM_TIME_UNSPECIFIED; + orig_type= SYSTEM_TIME_UNSPECIFIED; + used= false; + delete_history= false; + start.empty(); + end.empty(); + } + + void init(vers_system_time_t _type, + Vers_history_point _start= Vers_history_point(), + Vers_history_point _end= Vers_history_point(), + Lex_ident _name= "SYSTEM_TIME") + { + type= _type; + orig_type= _type; + used= false; + delete_history= (type == SYSTEM_TIME_HISTORY || + type == SYSTEM_TIME_BEFORE); + start= _start; + end= _end; + name= _name; + } + + void set_all() + { + type= SYSTEM_TIME_ALL; + name= "SYSTEM_TIME"; + } + + void print(String *str, enum_query_type query_type) const; + + bool init_from_sysvar(THD *thd); + + bool is_set() const + { + return type != SYSTEM_TIME_UNSPECIFIED; + } + bool check_units(THD *thd); + bool was_set() const + { + return orig_type != SYSTEM_TIME_UNSPECIFIED; + } + bool need_setup() const + { + return type != SYSTEM_TIME_UNSPECIFIED && type != SYSTEM_TIME_ALL; + } + bool eq(const vers_select_conds_t &conds) const; +}; + +/* + 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) + - FROM-clause 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) + 2.5) TODO: Add derived tables description here + 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 nest (sj_on_expr!= NULL && sj_subq_pred!=NULL) + 4) jtbm semi-join (jtbm_subselect != NULL) +*/ + +/** last_leaf_for_name_resolutioning support. */ + +struct LEX; +class Index_hint; + +/* + @struct TABLE_CHAIN + @brief Subchain of global chain of table references + + The structure contains a pointer to the address of the next_global + pointer to the first TABLE_LIST objectof the subchain and the address + of the next_global pointer to the element right after the last + TABLE_LIST object of the subchain. For an empty subchain both pointers + have the same value. +*/ + +struct TABLE_CHAIN +{ + TABLE_CHAIN() {} + + TABLE_LIST **start_pos; + TABLE_LIST ** end_pos; + + void set_start_pos(TABLE_LIST **pos) { start_pos= pos; } + void set_end_pos(TABLE_LIST **pos) { end_pos= pos; } +}; + +struct TABLE_LIST +{ + TABLE_LIST() {} /* Remove gcc warning */ + + enum prelocking_types + { + PRELOCK_NONE, PRELOCK_ROUTINE, PRELOCK_FK + }; + + /** + Prepare TABLE_LIST that consists of one table instance to use in + open_and_lock_tables + */ + inline void reset() { bzero((void*)this, sizeof(*this)); } + inline void init_one_table(const LEX_CSTRING *db_arg, + const LEX_CSTRING *table_name_arg, + const LEX_CSTRING *alias_arg, + enum thr_lock_type lock_type_arg) + { + enum enum_mdl_type mdl_type; + if (lock_type_arg >= TL_WRITE_ALLOW_WRITE) + mdl_type= MDL_SHARED_WRITE; + else if (lock_type_arg == TL_READ_NO_INSERT) + mdl_type= MDL_SHARED_NO_WRITE; + else + mdl_type= MDL_SHARED_READ; + + reset(); + DBUG_ASSERT(!db_arg->str || strlen(db_arg->str) == db_arg->length); + DBUG_ASSERT(!table_name_arg->str || strlen(table_name_arg->str) == table_name_arg->length); + DBUG_ASSERT(!alias_arg || strlen(alias_arg->str) == alias_arg->length); + db= *db_arg; + table_name= *table_name_arg; + alias= (alias_arg ? *alias_arg : *table_name_arg); + lock_type= lock_type_arg; + updating= lock_type >= TL_WRITE_ALLOW_WRITE; + MDL_REQUEST_INIT(&mdl_request, MDL_key::TABLE, db.str, table_name.str, + mdl_type, MDL_TRANSACTION); + } + + TABLE_LIST(TABLE *table_arg, thr_lock_type lock_type) + { + DBUG_ASSERT(table_arg->s); + init_one_table(&table_arg->s->db, &table_arg->s->table_name, + NULL, lock_type); + table= table_arg; + vers_conditions.name= table->s->vers.name; + } + + inline void init_one_table_for_prelocking(const LEX_CSTRING *db_arg, + const LEX_CSTRING *table_name_arg, + const LEX_CSTRING *alias_arg, + enum thr_lock_type lock_type_arg, + prelocking_types prelocking_type, + TABLE_LIST *belong_to_view_arg, + uint8 trg_event_map_arg, + TABLE_LIST ***last_ptr, + my_bool insert_data) + + { + init_one_table(db_arg, table_name_arg, alias_arg, lock_type_arg); + cacheable_table= 1; + prelocking_placeholder= prelocking_type; + open_type= (prelocking_type == PRELOCK_ROUTINE ? + OT_TEMPORARY_OR_BASE : + OT_BASE_ONLY); + belong_to_view= belong_to_view_arg; + trg_event_map= trg_event_map_arg; + /* MDL is enough for read-only FK checks, we don't need the table */ + if (prelocking_type == PRELOCK_FK && lock_type < TL_WRITE_ALLOW_WRITE) + open_strategy= OPEN_STUB; + + **last_ptr= this; + prev_global= *last_ptr; + *last_ptr= &next_global; + for_insert_data= insert_data; + } + + + /* + List of tables local to a subquery (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; + /* link in a global list of all queries tables */ + TABLE_LIST *next_global, **prev_global; + LEX_CSTRING db; + LEX_CSTRING table_name; + LEX_CSTRING schema_table_name; + LEX_CSTRING alias; + const char *option; /* Used by cache index */ + Item *on_expr; /* Used with outer join */ + Name_resolution_context *on_context; /* For ON expressions */ + + 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; + /* Number of IN-compared expressions */ + uint sj_in_exprs; + + /* If this is a non-jtbm semi-join nest: corresponding subselect predicate */ + Item_in_subselect *sj_subq_pred; + + table_map original_subq_pred_used_tables; + + /* If this is a jtbm semi-join object: corresponding subselect predicate */ + Item_in_subselect *jtbm_subselect; + /* TODO: check if this can be joined with tablenr_exec */ + uint jtbm_table_no; + + SJ_MATERIALIZATION_INFO *sj_mat_info; + + /* + The structure of ON expression presented in the member above + can be changed during certain optimizations. This member + contains a snapshot of AND-OR structure of the ON expression + made after permanent transformations of the parse tree, and is + used to restore ON clause before every reexecution of a prepared + statement or stored procedure. + */ + Item *prep_on_expr; + COND_EQUAL *cond_equal; /* Used with outer join */ + /* + 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; + /* Field names in a USING clause for JOIN ... USING. */ + 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; + /* TRUE if join_columns contains all columns of this table reference. */ + 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; + /* Index names in a "... JOIN ... USE/IGNORE INDEX ..." clause. */ + List<Index_hint> *index_hints; + TABLE *table; /* opened table */ + ulonglong table_id; /* table id (from binlog) for opened table */ + /* + select_result for derived table to pass it from table creation to table + filling procedure + */ + select_unit *derived_result; + /* Stub used for materialized derived tables. */ + table_map map; /* ID bit of table (1,2,4,8,16...) */ + table_map get_map() + { + return jtbm_subselect? table_map(1) << jtbm_table_no : table->map; + } + uint get_tablenr() + { + return jtbm_subselect? jtbm_table_no : table->tablenr; + } + void set_tablenr(uint new_tablenr) + { + if (jtbm_subselect) + { + jtbm_table_no= new_tablenr; + } + if (table) + { + table->tablenr= new_tablenr; + table->map= table_map(1) << new_tablenr; + } + } + /* + 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; /* SELECT_LEX_UNIT of derived table */ + With_element *with; /* With element defining this table (if any) */ + /* Bitmap of the defining with element */ + table_map with_internal_reference_map; + TABLE_LIST * next_with_rec_ref; + bool is_derived_with_recursive_reference; + bool block_handle_derived; + /* The interface employed to materialize the table by a foreign engine */ + derived_handler *dt_handler; + /* The text of the query specifying the derived table */ + LEX_CSTRING derived_spec; + /* + The object used to organize execution of the query that specifies + the derived table by a foreign engine + */ + Pushdown_derived *pushdown_derived; + ST_SCHEMA_TABLE *schema_table; /* Information_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; + TMP_TABLE_PARAM *schema_table_param; + /* link to select_lex where this table was used */ + st_select_lex *select_lex; + LEX *view; /* link on VIEW lex for merging */ + Field_translator *field_translation; /* array of VIEW fields */ + /* pointer to element after last one in translation table above */ + Field_translator *field_translation_end; + bool field_translation_updated; + /* + 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; + /* most upper view this table belongs to */ + TABLE_LIST *belong_to_view; + /* A derived table this table belongs to */ + TABLE_LIST *belong_to_derived; + /* + The view directly referencing this table + (non-zero only for merged underlying tables of a view). + */ + TABLE_LIST *referencing_view; + + table_map view_used_tables; + table_map map_exec; + /* TODO: check if this can be joined with jtbm_table_no */ + uint tablenr_exec; + uint maybe_null_exec; + + /* Ptr to parent MERGE table list item. See top comment in ha_myisammrg.cc */ + 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; + bool allowed_show; + Item *where; /* VIEW WHERE clause condition */ + Item *check_option; /* WITH CHECK OPTION condition */ + LEX_STRING select_stmt; /* text of (CREATE/SELECT) statement */ + LEX_CSTRING md5; /* md5 of query text */ + LEX_CSTRING source; /* source of CREATE VIEW */ + LEX_CSTRING view_db; /* saved view database */ + LEX_CSTRING view_name; /* saved view name */ + LEX_STRING timestamp; /* GMT time stamp of last operation */ + LEX_USER definer; /* definer of view */ + ulonglong file_version; /* version of file's field set */ + ulonglong mariadb_version; /* version of server on creation */ + ulonglong updatable_view; /* VIEW can be updated */ + /** + @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; /* view is suid (TRUE dy default) */ + ulonglong with_check; /* WITH CHECK OPTION */ + /* + 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 + */ + uint8 derived_type; + GRANT_INFO grant; + /* data need by some engines in query cache*/ + ulonglong engine_data; + /* call back function for asking handler about caching in query cache */ + qc_engine_callback callback_func; + thr_lock_type lock_type; + + /* + Two fields below are set during parsing this table reference in the cases + when the table reference can be potentially a reference to a CTE table. + In this cases the fact that the reference is a reference to a CTE or not + will be ascertained at the very end of parsing of the query when referencies + to CTE are resolved. For references to CTE and to derived tables no mdl + requests are needed while for other table references they are. If a request + is possibly postponed the info that allows to issue this request must be + saved in 'mdl_type' and 'table_options'. + */ + enum_mdl_type mdl_type; + ulong table_options; + + uint outer_join; /* Which join type */ + uint shared; /* Used in multi-upd */ + bool updatable; /* VIEW/TABLE can be updated now */ + bool straight; /* optimize with prev table */ + bool updating; /* for replicate-do/ignore table */ + bool force_index; /* prefer index over table scan */ + bool ignore_leaves; /* preload only non-leaf nodes */ + bool crashed; /* Table was found crashed */ + table_map dep_tables; /* tables the table depends on */ + table_map on_expr_dep_tables; /* tables on expression depends on */ + struct st_nested_join *nested_join; /* if the element is a nested join */ + TABLE_LIST *embedding; /* nested join containing the table */ + List<TABLE_LIST> *join_list;/* join list the table belongs to */ + bool lifted; /* set to true when the table is moved to + the upper level at the parsing stage */ + bool cacheable_table; /* stop PS caching */ + /* used in multi-upd/views privilege check */ + 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; + /* TRUE if this merged view contain auto_increment field */ + bool contain_auto_increment; + bool compact_view_format; /* Use compact format for SHOW CREATE VIEW */ + /* view where processed */ + bool where_processed; + /* TRUE <=> VIEW CHECK OPTION expression has been processed */ + bool check_option_processed; + /* TABLE_TYPE_UNKNOWN if any type is acceptable */ + Table_type required_type; + handlerton *db_type; /* table_type for handler */ + char timestamp_buffer[MAX_DATETIME_WIDTH + 1]; + /* + 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. + */ + prelocking_types prelocking_placeholder; + /** + Indicates that if TABLE_LIST object corresponds to the table/view + which requires special handling. + */ + enum enum_open_strategy + { + /* Normal open. */ + OPEN_NORMAL= 0, + /* Associate a table share only if the the table exists. */ + OPEN_IF_EXISTS, + /* Don't associate a table share. */ + OPEN_STUB + } open_strategy; + /** TRUE if an alias for this table was specified in the SQL. */ + bool is_alias; + /** TRUE if the table is referred to in the statement using a fully + qualified name (<db_name>.<table_name>). + */ + bool is_fqtn; + + /* TRUE <=> derived table should be filled right after optimization. */ + bool fill_me; + /* TRUE <=> view/DT is merged. */ + /* TODO: replace with derived_type */ + bool merged; + bool merged_for_insert; + bool sequence; /* Part of NEXTVAL/CURVAL/LASTVAL */ + + /* + Items created by create_view_field and collected to change them in case + of materialization of the view/derived table + */ + List<Item> used_items; + /* Sublist (tail) of persistent used_items */ + List<Item> persistent_used_items; + + /* View creation context. */ + + 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_CSTRING view_client_cs_name; + LEX_CSTRING view_connection_cl_name; + + /* + View definition (SELECT-statement) in the UTF-form. + */ + + LEX_CSTRING view_body_utf8; + + /* End of view definition context. */ + + /** + 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. + + slave_fk_event_map is filled on the slave side with bitmaps value + representing row-based event operation to help find and prelock + possible FK constrain-related child tables. + */ + uint8 trg_event_map, slave_fk_event_map; + /* TRUE <=> this table is a const one and was optimized away. */ + bool optimized_away; + + /** + TRUE <=> already materialized. Valid only for materialized derived + tables/views. + */ + bool materialized; + /* I_S: Flags to open_table (e.g. OPEN_TABLE_ONLY or OPEN_VIEW_ONLY) */ + uint i_s_requested_object; + + bool prohibit_cond_pushdown; + + /* + I_S: how to read the tables (SKIP_OPEN_TABLE/OPEN_FRM_ONLY/OPEN_FULL_TABLE) + */ + uint table_open_method; + /* + I_S: where the schema table was filled + (this is a hack. The code should be able to figure out whether reading + from I_S should be done by create_sort_index() or by JOIN::exec.) + */ + enum enum_schema_table_state schema_table_state; + + /* Something like a "query plan" for reading INFORMATION_SCHEMA table */ + IS_table_read_plan *is_table_read_plan; + + MDL_request mdl_request; + +#ifdef WITH_PARTITION_STORAGE_ENGINE + /* List to carry partition names from PARTITION (...) clause in statement */ + List<String> *partition_names; +#endif /* WITH_PARTITION_STORAGE_ENGINE */ + + void calc_md5(const char *buffer); + int view_check_option(THD *thd, bool ignore_failure); + bool create_field_translation(THD *thd); + bool setup_underlying(THD *thd); + void cleanup_items(); + bool placeholder() + { + return derived || view || schema_table || !table; + } + void print(THD *thd, table_map eliminated_tables, String *str, + enum_query_type query_type); + bool check_single_table(TABLE_LIST **table, table_map map, + TABLE_LIST *view); + bool set_insert_values(MEM_ROOT *mem_root); + void hide_view_error(THD *thd); + TABLE_LIST *find_underlying_table(TABLE *table); + TABLE_LIST *first_leaf_for_name_resolution(); + TABLE_LIST *last_leaf_for_name_resolution(); + + /* System Versioning */ + vers_select_conds_t vers_conditions; + vers_select_conds_t period_conditions; + + bool has_period() const + { + return period_conditions.is_set(); + } + + my_bool for_insert_data; + + /** + @brief + Find the bottom in the chain of embedded table VIEWs. + + @detail + This is used for single-table UPDATE/DELETE when they are modifying a + single-table VIEW. + */ + TABLE_LIST *find_table_for_update() + { + TABLE_LIST *tbl= this; + while(!tbl->is_multitable() && tbl->single_table_updatable() && + tbl->merge_underlying_list) + { + tbl= tbl->merge_underlying_list; + } + return tbl; + } + TABLE *get_real_join_table(); + bool is_leaf_for_name_resolution(); + inline TABLE_LIST *top_table() + { return belong_to_view ? belong_to_view : this; } + inline bool prepare_check_option(THD *thd) + { + bool res= FALSE; + if (effective_with_check) + res= prep_check_option(thd, effective_with_check); + return res; + } + inline bool prepare_where(THD *thd, Item **conds, + bool no_where_clause) + { + if (!view || is_merged_derived()) + return prep_where(thd, conds, no_where_clause); + return FALSE; + } + + void register_want_access(privilege_t want_access); + bool prepare_security(THD *thd); +#ifndef NO_EMBEDDED_ACCESS_CHECKS + Security_context *find_view_security_context(THD *thd); + bool prepare_view_security_context(THD *thd); +#endif + /* + Cleanup for re-execution in a prepared statement or a stored + procedure. + */ + void reinit_before_use(THD *thd); + Item_subselect *containing_subselect(); + + /* + Compiles the tagged hints list and fills up TABLE::keys_in_use_for_query, + TABLE::keys_in_use_for_group_by, TABLE::keys_in_use_for_order_by, + TABLE::force_index and TABLE::covering_keys. + */ + bool process_index_hints(TABLE *table); + + /** + Compare the version of metadata from the previous execution + (if any) with values obtained from the current table + definition cache element. + + @sa check_and_update_table_version() + */ + inline bool is_table_ref_id_equal(TABLE_SHARE *s) const + { + return (m_table_ref_type == s->get_table_ref_type() && + m_table_ref_version == s->get_table_ref_version()); + } + + /** + Record the value of metadata version of the corresponding + table definition cache element in this parse tree node. + + @sa check_and_update_table_version() + */ + inline void set_table_ref_id(TABLE_SHARE *s) + { set_table_ref_id(s->get_table_ref_type(), s->get_table_ref_version()); } + + inline void set_table_ref_id(enum_table_ref_type table_ref_type_arg, + ulong table_ref_version_arg) + { + m_table_ref_type= table_ref_type_arg; + m_table_ref_version= table_ref_version_arg; + } + + /* Set of functions returning/setting state of a derived table/view. */ + bool is_non_derived() const { return (!derived_type); } + bool is_view_or_derived() const { return derived_type; } + bool is_view() const { return (derived_type & DTYPE_VIEW); } + bool is_derived() const { return (derived_type & DTYPE_TABLE); } + bool is_with_table(); + bool is_recursive_with_table(); + bool is_with_table_recursive_reference(); + void register_as_derived_with_rec_ref(With_element *rec_elem); + bool is_nonrecursive_derived_with_rec_ref(); + bool fill_recursive(THD *thd); + + inline void set_view() + { + derived_type= DTYPE_VIEW; + } + inline void set_derived() + { + derived_type= DTYPE_TABLE; + } + bool is_merged_derived() const { return (derived_type & DTYPE_MERGE); } + inline void set_merged_derived() + { + DBUG_ENTER("set_merged_derived"); + DBUG_PRINT("enter", ("Alias: '%s' Unit: %p", + (alias.str ? alias.str : "<NULL>"), + get_unit())); + derived_type= static_cast<uint8>((derived_type & DTYPE_MASK) | + DTYPE_TABLE | DTYPE_MERGE); + set_check_merged(); + DBUG_VOID_RETURN; + } + bool is_materialized_derived() const + { + return (derived_type & DTYPE_MATERIALIZE); + } + void set_materialized_derived() + { + DBUG_ENTER("set_materialized_derived"); + DBUG_PRINT("enter", ("Alias: '%s' Unit: %p", + (alias.str ? alias.str : "<NULL>"), + get_unit())); + derived= get_unit(); + derived_type= static_cast<uint8>((derived_type & + (derived ? DTYPE_MASK : DTYPE_VIEW)) | + DTYPE_TABLE | DTYPE_MATERIALIZE); + set_check_materialized(); + DBUG_VOID_RETURN; + } + bool is_multitable() const { return (derived_type & DTYPE_MULTITABLE); } + inline void set_multitable() + { + derived_type|= DTYPE_MULTITABLE; + } + bool set_as_with_table(THD *thd, With_element *with_elem); + void reset_const_table(); + bool handle_derived(LEX *lex, uint phases); + + /** + @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; } + + /** + @brief Returns the name of the database that the referenced table belongs + to. + */ + const char *get_db_name() const { return view != NULL ? view_db.str : db.str; } + + /** + @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. + */ + const char *get_table_name() const { return view != NULL ? view_name.str : table_name.str; } + bool is_active_sjm(); + bool is_jtbm() { return MY_TEST(jtbm_subselect != NULL); } + st_select_lex_unit *get_unit(); + st_select_lex *get_single_select(); + void wrap_into_nested_join(List<TABLE_LIST> &join_list); + bool init_derived(THD *thd, bool init_view); + int fetch_number_of_rows(); + bool change_refs_to_fields(); + + bool single_table_updatable(); + + bool is_inner_table_of_outer_join() + { + for (TABLE_LIST *tbl= this; tbl; tbl= tbl->embedding) + { + if (tbl->outer_join) + return true; + } + return false; + } + void set_lock_type(THD* thd, enum thr_lock_type lock); + + derived_handler *find_derived_handler(THD *thd); + TABLE_LIST *get_first_table(); + + void remove_join_columns() + { + if (join_columns) + { + join_columns->empty(); + join_columns= NULL; + is_join_columns_complete= FALSE; + } + } + +private: + bool prep_check_option(THD *thd, uint8 check_opt_type); + bool prep_where(THD *thd, Item **conds, bool no_where_clause); + void set_check_materialized(); +#ifndef DBUG_OFF + void set_check_merged(); +#else + inline void set_check_merged() {} +#endif + /** See comments for set_table_ref_id() */ + enum enum_table_ref_type m_table_ref_type; + /** See comments for set_table_ref_id() */ + ulong m_table_ref_version; +}; + +class Item; + +/* + Iterator over the fields of a generic table reference. +*/ + +class Field_iterator: public Sql_alloc +{ +public: + Field_iterator() {} /* Remove gcc warning */ + virtual ~Field_iterator() {} + virtual void set(TABLE_LIST *)= 0; + virtual void next()= 0; + virtual bool end_of_fields()= 0; /* Return 1 at end of list */ + virtual LEX_CSTRING *name()= 0; + virtual Item *create_item(THD *)= 0; + virtual Field *field()= 0; +}; + + +/* + Iterator over the fields of a base table, view with temporary + table, or subquery. +*/ + +class Field_iterator_table: public Field_iterator +{ + Field **ptr; +public: + Field_iterator_table() :ptr(0) {} + void set(TABLE_LIST *table) { ptr= table->table->field; } + void set_table(TABLE *table) { ptr= table->field; } + void next() { ptr++; } + bool end_of_fields() { return *ptr == 0; } + LEX_CSTRING *name(); + Item *create_item(THD *thd); + Field *field() { return *ptr; } +}; + + +/* Iterator over the fields of a merge view. */ + +class Field_iterator_view: public Field_iterator +{ + Field_translator *ptr, *array_end; + TABLE_LIST *view; +public: + Field_iterator_view() :ptr(0), array_end(0) {} + void set(TABLE_LIST *table); + void next() { ptr++; } + bool end_of_fields() { return ptr == array_end; } + LEX_CSTRING *name(); + Item *create_item(THD *thd); + Item **item_ptr() {return &ptr->item; } + Field *field() { return 0; } + inline Item *item() { return ptr->item; } + Field_translator *field_translator() { return ptr; } +}; + + +/* + Field_iterator interface to the list of materialized fields of a + NATURAL/USING join. +*/ + +class Field_iterator_natural_join: public Field_iterator +{ + List_iterator_fast<Natural_join_column> column_ref_it; + Natural_join_column *cur_column_ref; +public: + Field_iterator_natural_join() :cur_column_ref(NULL) {} + ~Field_iterator_natural_join() {} + void set(TABLE_LIST *table); + void next(); + bool end_of_fields() { return !cur_column_ref; } + LEX_CSTRING *name() { return cur_column_ref->name(); } + Item *create_item(THD *thd) { return cur_column_ref->create_item(thd); } + Field *field() { return cur_column_ref->field(); } + Natural_join_column *column_ref() { return cur_column_ref; } +}; + + +/* + Generic iterator over the fields of an arbitrary table reference. + + DESCRIPTION + This class unifies the various ways of iterating over the columns + of a table reference depending on the type of SQL entity it + represents. If such an entity represents a nested table reference, + this iterator encapsulates the iteration over the columns of the + members of the table reference. + + IMPLEMENTATION + The implementation assumes that all underlying NATURAL/USING table + references already contain their result columns and are linked into + the list TABLE_LIST::next_name_resolution_table. +*/ + +class Field_iterator_table_ref: public Field_iterator +{ + TABLE_LIST *table_ref, *first_leaf, *last_leaf; + Field_iterator_table table_field_it; + Field_iterator_view view_field_it; + Field_iterator_natural_join natural_join_it; + Field_iterator *field_it; + void set_field_iterator(); +public: + Field_iterator_table_ref() :field_it(NULL) {} + void set(TABLE_LIST *table); + void next(); + bool end_of_fields() + { return (table_ref == last_leaf && field_it->end_of_fields()); } + LEX_CSTRING *name() { return field_it->name(); } + const char *get_table_name(); + const char *get_db_name(); + GRANT_INFO *grant(); + Item *create_item(THD *thd) { return field_it->create_item(thd); } + Field *field() { return field_it->field(); } + Natural_join_column *get_or_create_column_ref(THD *thd, TABLE_LIST *parent_table_ref); + Natural_join_column *get_natural_column_ref(); +}; + + +#define JOIN_OP_NEST 1 +#define REBALANCED_NEST 2 + +typedef struct st_nested_join +{ + List<TABLE_LIST> join_list; /* list of elements in the nested join */ + /* + Currently the valid values for nest type are: + JOIN_OP_NEST - for nest created for JOIN operation used as an operand in + a join expression, contains 2 elements; + JOIN_OP_NEST | REBALANCED_NEST - nest created after tree re-balancing + in st_select_lex::add_cross_joined_table(), contains 1 element; + 0 - for all other nests. + Examples: + 1. SELECT * FROM t1 JOIN t2 LEFT JOIN t3 ON t2.a=t3.a; + Here the nest created for LEFT JOIN at first has nest_type==JOIN_OP_NEST. + After re-balancing in st_select_lex::add_cross_joined_table() this nest + has nest_type==JOIN_OP_NEST | REBALANCED_NEST. The nest for JOIN created + in st_select_lex::add_cross_joined_table() has nest_type== JOIN_OP_NEST. + 2. SELECT * FROM t1 JOIN (t2 LEFT JOIN t3 ON t2.a=t3.a) + Here the nest created for LEFT JOIN has nest_type==0, because it's not + an operand in a join expression. The nest created for JOIN has nest_type + set to JOIN_OP_NEST. + */ + uint nest_type; + /* + Bitmap of tables within this nested join (including those embedded within + its children), including tables removed by table elimination. + */ + table_map used_tables; + table_map not_null_tables; /* tables that rejects nulls */ + /** + 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; + /* + Used to count tables in the nested join in 2 isolated places: + 1. In make_outerjoin_info(). + 2. check_interleaving_with_nj/restore_prev_nj_state (these are called + by the join optimizer. + Before each use the counters are zeroed by reset_nj_counters. + */ + uint counter; + + /* + Number of elements in join_list that participate in the join plan choice: + - Base tables that were not removed by table elimination + - Join nests that were not removed by mark_join_nest_as_const + */ + uint n_tables; + nested_join_map nj_map; /* Bit used to identify this nested join*/ + /* + (Valid only for semi-join nests) Bitmap of tables outside the semi-join + that are used within the semi-join's ON condition. + */ + table_map sj_depends_on; + /* Outer non-trivially correlated tables */ + table_map sj_corr_tables; + List<Item_ptr> sj_outer_expr_list; + /** + True if this join nest node is completely covered by the query execution + plan. This means two things. + + 1. All tables on its @c join_list are covered by the plan. + + 2. All child join nest nodes are fully covered. + */ + bool is_fully_covered() const { return n_tables == counter; } +} NESTED_JOIN; + + +typedef struct st_changed_table_list +{ + struct st_changed_table_list *next; + char *key; + size_t 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 MY_BITMAP *tmp_use_all_columns(TABLE *table, + MY_BITMAP **bitmap) +{ + MY_BITMAP *old= *bitmap; + *bitmap= &table->s->all_set; + return old; +} + + +static inline void tmp_restore_column_map(MY_BITMAP **bitmap, + MY_BITMAP *old) +{ + *bitmap= old; +} + +/* The following is only needed for debugging */ + +static inline MY_BITMAP *dbug_tmp_use_all_columns(TABLE *table, + MY_BITMAP **bitmap) +{ +#ifdef DBUG_ASSERT_EXISTS + return tmp_use_all_columns(table, bitmap); +#else + return 0; +#endif +} + +static inline void dbug_tmp_restore_column_map(MY_BITMAP **bitmap, + MY_BITMAP *old) +{ +#ifdef DBUG_ASSERT_EXISTS + tmp_restore_column_map(bitmap, old); +#endif +} + + +/* + Variant of the above : handle both read and write sets. + Provide for the possiblity of the read set being the same as the write set +*/ +static inline void dbug_tmp_use_all_columns(TABLE *table, + MY_BITMAP **save, + MY_BITMAP **read_set, + MY_BITMAP **write_set) +{ +#ifdef DBUG_ASSERT_EXISTS + save[0]= *read_set; + save[1]= *write_set; + (void) tmp_use_all_columns(table, read_set); + (void) tmp_use_all_columns(table, write_set); +#endif +} + + +static inline void dbug_tmp_restore_column_maps(MY_BITMAP **read_set, + MY_BITMAP **write_set, + MY_BITMAP **old) +{ +#ifdef DBUG_ASSERT_EXISTS + tmp_restore_column_map(read_set, old[0]); + tmp_restore_column_map(write_set, old[1]); +#endif +} + +bool ok_for_lower_case_names(const char *names); + +enum get_table_share_flags { + GTS_TABLE = 1, + GTS_VIEW = 2, + GTS_NOLOCK = 4, + GTS_USE_DISCOVERY = 8, + GTS_FORCE_DISCOVERY = 16 +}; + +size_t max_row_length(TABLE *table, MY_BITMAP const *cols, const uchar *data); + +void init_mdl_requests(TABLE_LIST *table_list); + +enum open_frm_error open_table_from_share(THD *thd, TABLE_SHARE *share, + const LEX_CSTRING *alias, uint db_stat, uint prgflag, + uint ha_open_flags, TABLE *outparam, + bool is_create_table, + List<String> *partitions_to_open= NULL); +bool copy_keys_from_share(TABLE *outparam, MEM_ROOT *root); +bool fix_session_vcol_expr(THD *thd, Virtual_column_info *vcol); +bool fix_session_vcol_expr_for_read(THD *thd, Field *field, + Virtual_column_info *vcol); +bool parse_vcol_defs(THD *thd, MEM_ROOT *mem_root, TABLE *table, + bool *error_reported, vcol_init_mode expr); +TABLE_SHARE *alloc_table_share(const char *db, const char *table_name, + const char *key, uint key_length); +void init_tmp_table_share(THD *thd, TABLE_SHARE *share, const char *key, + uint key_length, + const char *table_name, const char *path); +void free_table_share(TABLE_SHARE *share); +enum open_frm_error open_table_def(THD *thd, TABLE_SHARE *share, + uint flags = GTS_TABLE); + +void open_table_error(TABLE_SHARE *share, enum open_frm_error error, + int db_errno); +void update_create_info_from_table(HA_CREATE_INFO *info, TABLE *form); +bool check_db_name(LEX_STRING *db); +bool check_column_name(const char *name); +bool 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); +char *get_field(MEM_ROOT *mem, Field *field); +bool get_field(MEM_ROOT *mem, Field *field, class String *res); + +bool validate_comment_length(THD *thd, LEX_CSTRING *comment, size_t max_len, + uint err_code, const char *name); + +int closefrm(TABLE *table); +void free_blobs(TABLE *table); +void free_field_buffers_larger_than(TABLE *table, uint32 size); +ulong get_form_pos(File file, uchar *head, TYPELIB *save_names); +void append_unescaped(String *res, const char *pos, size_t length); +void prepare_frm_header(THD *thd, uint reclength, uchar *fileinfo, + HA_CREATE_INFO *create_info, uint keys, KEY *key_info); +const char *fn_frm_ext(const char *name); + +/* Check that the integer is in the internal */ +static inline int set_zone(int nr,int min_zone,int max_zone) +{ + if (nr <= min_zone) + return min_zone; + if (nr >= max_zone) + return max_zone; + return nr; +} + +/* performance schema */ +extern LEX_CSTRING PERFORMANCE_SCHEMA_DB_NAME; + +extern LEX_CSTRING GENERAL_LOG_NAME; +extern LEX_CSTRING SLOW_LOG_NAME; +extern LEX_CSTRING TRANSACTION_REG_NAME; + +/* information schema */ +extern LEX_CSTRING INFORMATION_SCHEMA_NAME; +extern LEX_CSTRING MYSQL_SCHEMA_NAME; + +/* table names */ +extern LEX_CSTRING MYSQL_PROC_NAME; + +inline bool is_infoschema_db(const LEX_CSTRING *name) +{ + return lex_string_eq(&INFORMATION_SCHEMA_NAME, name); +} + +inline bool is_perfschema_db(const LEX_CSTRING *name) +{ + return lex_string_eq(&PERFORMANCE_SCHEMA_DB_NAME, name); +} + +inline void mark_as_null_row(TABLE *table) +{ + table->null_row=1; + table->status|=STATUS_NULL_ROW; + if (table->s->null_bytes) + bfill(table->null_flags,table->s->null_bytes,255); +} + +inline void unmark_as_null_row(TABLE *table) +{ + table->null_row=0; + table->status= STATUS_NO_RECORD; +} + +bool is_simple_order(ORDER *order); + +class Open_tables_backup; + +/** Transaction Registry Table (TRT) + + This table holds transaction IDs, their corresponding times and other + transaction-related data which is used for transaction order resolution. + When versioned table marks its records lifetime with transaction IDs, + TRT is used to get their actual timestamps. */ + +class TR_table: public TABLE_LIST +{ + THD *thd; + Open_tables_backup *open_tables_backup; + +public: + enum field_id_t { + FLD_TRX_ID= 0, + FLD_COMMIT_ID, + FLD_BEGIN_TS, + FLD_COMMIT_TS, + FLD_ISO_LEVEL, + FIELD_COUNT + }; + + enum enabled {NO, MAYBE, YES}; + static enum enabled use_transaction_registry; + + /** + @param[in,out] Thread handle + @param[in] Current transaction is read-write. + */ + TR_table(THD *_thd, bool rw= false); + /** + Opens a transaction_registry table. + + @retval true on error, false otherwise. + */ + bool open(); + ~TR_table(); + /** + @retval current thd + */ + THD *get_thd() const { return thd; } + /** + Stores value to internal transaction_registry TABLE object. + + @param[in] field number in a TABLE + @param[in] value to store + */ + void store(uint field_id, ulonglong val); + /** + Stores value to internal transaction_registry TABLE object. + + @param[in] field number in a TABLE + @param[in] value to store + */ + void store(uint field_id, timeval ts); + /** + Update the transaction_registry right before commit. + @param start_id transaction identifier at start + @param end_id transaction identifier at commit + + @retval false on success + @retval true on error (the transaction must be rolled back) + */ + bool update(ulonglong start_id, ulonglong end_id); + // return true if found; false if not found or error + bool query(ulonglong trx_id); + /** + Gets a row from transaction_registry with the closest commit_timestamp to + first argument. We can search for a value which a lesser or greater than + first argument. Also loads a row into an internal TABLE object. + + @param[in] timestamp + @param[in] true if we search for a lesser timestamp, false if greater + @retval true if exists, false it not exists or an error occurred + */ + bool query(MYSQL_TIME &commit_time, bool backwards); + /** + Checks whether transaction1 sees transaction0. + + @param[out] true if transaction1 sees transaction0, undefined on error and + when transaction1=transaction0 and false otherwise + @param[in] transaction_id of transaction1 + @param[in] transaction_id of transaction0 + @param[in] commit time of transaction1 or 0 if we want it to be queried + @param[in] isolation level (from handler.h) of transaction1 + @param[in] commit time of transaction0 or 0 if we want it to be queried + @retval true on error, false otherwise + */ + bool query_sees(bool &result, ulonglong trx_id1, ulonglong trx_id0, + ulonglong commit_id1= 0, + enum_tx_isolation iso_level1= ISO_READ_UNCOMMITTED, + ulonglong commit_id0= 0); + + /** + @retval transaction isolation level of a row from internal TABLE object. + */ + enum_tx_isolation iso_level() const; + /** + Stores transactioin isolation level to internal TABLE object. + */ + void store_iso_level(enum_tx_isolation iso_level) + { + DBUG_ASSERT(iso_level <= ISO_SERIALIZABLE); + store(FLD_ISO_LEVEL, iso_level + 1); + } + + /** + Writes a message to MariaDB log about incorrect transaction_registry schema. + + @param[in] a message explained what's incorrect in schema + */ + void warn_schema_incorrect(const char *reason); + /** + Checks whether transaction_registry table has a correct schema. + + @retval true if schema is incorrect and false otherwise + */ + bool check(bool error); + + TABLE * operator-> () const + { + return table; + } + Field * operator[] (uint field_id) const + { + DBUG_ASSERT(field_id < FIELD_COUNT); + return table->field[field_id]; + } + operator bool () const + { + return table; + } + bool operator== (const TABLE_LIST &subj) const + { + return (!cmp(&db, &subj.db) && !cmp(&table_name, &subj.table_name)); + } + bool operator!= (const TABLE_LIST &subj) const + { + return !(*this == subj); + } +}; + +#endif /* MYSQL_CLIENT */ + +#endif /* TABLE_INCLUDED */ |