diff options
Diffstat (limited to 'storage/xtradb/include/row0mysql.h')
| -rw-r--r-- | storage/xtradb/include/row0mysql.h | 932 |
1 files changed, 0 insertions, 932 deletions
diff --git a/storage/xtradb/include/row0mysql.h b/storage/xtradb/include/row0mysql.h deleted file mode 100644 index 4326f1208e5..00000000000 --- a/storage/xtradb/include/row0mysql.h +++ /dev/null @@ -1,932 +0,0 @@ -/***************************************************************************** - -Copyright (c) 2000, 2017, Oracle and/or its affiliates. All Rights Reserved. -Copyright (c) 2017, MariaDB Corporation. - -This program is free software; you can redistribute it and/or modify it under -the terms of the GNU General Public License as published by the Free Software -Foundation; version 2 of the License. - -This program is distributed in the hope that it will be useful, but WITHOUT -ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS -FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. - -You should have received a copy of the GNU General Public License along with -this program; if not, write to the Free Software Foundation, Inc., -51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA - -*****************************************************************************/ - -/**************************************************//** -@file include/row0mysql.h -Interface between Innobase row operations and MySQL. -Contains also create table and other data dictionary operations. - -Created 9/17/2000 Heikki Tuuri -*******************************************************/ - -#ifndef row0mysql_h -#define row0mysql_h - -#include "univ.i" -#include "data0data.h" -#include "que0types.h" -#include "dict0types.h" -#include "trx0types.h" -#include "row0types.h" -#include "btr0pcur.h" -#include "trx0types.h" -#include "fil0crypt.h" - -// Forward declaration -struct SysIndexCallback; - -extern ibool row_rollback_on_timeout; - -struct row_prebuilt_t; - -/*******************************************************************//** -Frees the blob heap in prebuilt when no longer needed. */ -UNIV_INTERN -void -row_mysql_prebuilt_free_blob_heap( -/*==============================*/ - row_prebuilt_t* prebuilt); /*!< in: prebuilt struct of a - ha_innobase:: table handle */ - -/*******************************************************************//** -Stores a >= 5.0.3 format true VARCHAR length to dest, in the MySQL row -format. -@return pointer to the data, we skip the 1 or 2 bytes at the start -that are used to store the len */ -UNIV_INTERN -byte* -row_mysql_store_true_var_len( -/*=========================*/ - byte* dest, /*!< in: where to store */ - ulint len, /*!< in: length, must fit in two bytes */ - ulint lenlen);/*!< in: storage length of len: either 1 or 2 bytes */ -/*******************************************************************//** -Reads a >= 5.0.3 format true VARCHAR length, in the MySQL row format, and -returns a pointer to the data. -@return pointer to the data, we skip the 1 or 2 bytes at the start -that are used to store the len */ -UNIV_INTERN -const byte* -row_mysql_read_true_varchar( -/*========================*/ - ulint* len, /*!< out: variable-length field length */ - const byte* field, /*!< in: field in the MySQL format */ - ulint lenlen);/*!< in: storage length of len: either 1 - or 2 bytes */ -/*******************************************************************//** -Stores a reference to a BLOB in the MySQL format. */ -UNIV_INTERN -void -row_mysql_store_blob_ref( -/*=====================*/ - byte* dest, /*!< in: where to store */ - ulint col_len,/*!< in: dest buffer size: determines into - how many bytes the BLOB length is stored, - the space for the length may vary from 1 - to 4 bytes */ - const void* data, /*!< in: BLOB data; if the value to store - is SQL NULL this should be NULL pointer */ - ulint len); /*!< in: BLOB length; if the value to store - is SQL NULL this should be 0; remember - also to set the NULL bit in the MySQL record - header! */ -/*******************************************************************//** -Reads a reference to a BLOB in the MySQL format. -@return pointer to BLOB data */ -UNIV_INTERN -const byte* -row_mysql_read_blob_ref( -/*====================*/ - ulint* len, /*!< out: BLOB length */ - const byte* ref, /*!< in: BLOB reference in the - MySQL format */ - ulint col_len); /*!< in: BLOB reference length - (not BLOB length) */ -/**************************************************************//** -Pad a column with spaces. */ -UNIV_INTERN -void -row_mysql_pad_col( -/*==============*/ - ulint mbminlen, /*!< in: minimum size of a character, - in bytes */ - byte* pad, /*!< out: padded buffer */ - ulint len); /*!< in: number of bytes to pad */ - -/**************************************************************//** -Stores a non-SQL-NULL field given in the MySQL format in the InnoDB format. -The counterpart of this function is row_sel_field_store_in_mysql_format() in -row0sel.cc. -@return up to which byte we used buf in the conversion */ -UNIV_INTERN -byte* -row_mysql_store_col_in_innobase_format( -/*===================================*/ - dfield_t* dfield, /*!< in/out: dfield where dtype - information must be already set when - this function is called! */ - byte* buf, /*!< in/out: buffer for a converted - integer value; this must be at least - col_len long then! NOTE that dfield - may also get a pointer to 'buf', - therefore do not discard this as long - as dfield is used! */ - ibool row_format_col, /*!< TRUE if the mysql_data is from - a MySQL row, FALSE if from a MySQL - key value; - in MySQL, a true VARCHAR storage - format differs in a row and in a - key value: in a key value the length - is always stored in 2 bytes! */ - const byte* mysql_data, /*!< in: MySQL column value, not - SQL NULL; NOTE that dfield may also - get a pointer to mysql_data, - therefore do not discard this as long - as dfield is used! */ - ulint col_len, /*!< in: MySQL column length; NOTE that - this is the storage length of the - column in the MySQL format row, not - necessarily the length of the actual - payload data; if the column is a true - VARCHAR then this is irrelevant */ - ulint comp); /*!< in: nonzero=compact format */ -/****************************************************************//** -Handles user errors and lock waits detected by the database engine. -@return true if it was a lock wait and we should continue running the -query thread */ -UNIV_INTERN -bool -row_mysql_handle_errors( -/*====================*/ - dberr_t* new_err,/*!< out: possible new error encountered in - rollback, or the old error which was - during the function entry */ - trx_t* trx, /*!< in: transaction */ - que_thr_t* thr, /*!< in: query thread, or NULL */ - trx_savept_t* savept) /*!< in: savepoint, or NULL */ - MY_ATTRIBUTE((nonnull(1,2))); -/********************************************************************//** -Create a prebuilt struct for a MySQL table handle. -@return own: a prebuilt struct */ -UNIV_INTERN -row_prebuilt_t* -row_create_prebuilt( -/*================*/ - dict_table_t* table, /*!< in: Innobase table handle */ - ulint mysql_row_len); /*!< in: length in bytes of a row in - the MySQL format */ -/********************************************************************//** -Free a prebuilt struct for a MySQL table handle. */ -UNIV_INTERN -void -row_prebuilt_free( -/*==============*/ - row_prebuilt_t* prebuilt, /*!< in, own: prebuilt struct */ - ibool dict_locked); /*!< in: TRUE=data dictionary locked */ -/*********************************************************************//** -Updates the transaction pointers in query graphs stored in the prebuilt -struct. */ -UNIV_INTERN -void -row_update_prebuilt_trx( -/*====================*/ - row_prebuilt_t* prebuilt, /*!< in/out: prebuilt struct - in MySQL handle */ - trx_t* trx); /*!< in: transaction handle */ -/*********************************************************************//** -Sets an AUTO_INC type lock on the table mentioned in prebuilt. The -AUTO_INC lock gives exclusive access to the auto-inc counter of the -table. The lock is reserved only for the duration of an SQL statement. -It is not compatible with another AUTO_INC or exclusive lock on the -table. -@return error code or DB_SUCCESS */ -UNIV_INTERN -dberr_t -row_lock_table_autoinc_for_mysql( -/*=============================*/ - row_prebuilt_t* prebuilt) /*!< in: prebuilt struct in the MySQL - table handle */ - MY_ATTRIBUTE((nonnull, warn_unused_result)); -/*********************************************************************//** -Sets a table lock on the table mentioned in prebuilt. -@return error code or DB_SUCCESS */ -UNIV_INTERN -dberr_t -row_lock_table_for_mysql( -/*=====================*/ - row_prebuilt_t* prebuilt, /*!< in: prebuilt struct in the MySQL - table handle */ - dict_table_t* table, /*!< in: table to lock, or NULL - if prebuilt->table should be - locked as - prebuilt->select_lock_type */ - ulint mode) /*!< in: lock mode of table - (ignored if table==NULL) */ - MY_ATTRIBUTE((nonnull(1))); -/*********************************************************************//** -Does an insert for MySQL. -@return error code or DB_SUCCESS */ -UNIV_INTERN -dberr_t -row_insert_for_mysql( -/*=================*/ - byte* mysql_rec, /*!< in: row in the MySQL format */ - row_prebuilt_t* prebuilt) /*!< in: prebuilt struct in MySQL - handle */ - MY_ATTRIBUTE((nonnull, warn_unused_result)); -/*********************************************************************//** -Builds a dummy query graph used in selects. */ -UNIV_INTERN -void -row_prebuild_sel_graph( -/*===================*/ - row_prebuilt_t* prebuilt); /*!< in: prebuilt struct in MySQL - handle */ -/*********************************************************************//** -Gets pointer to a prebuilt update vector used in updates. If the update -graph has not yet been built in the prebuilt struct, then this function -first builds it. -@return prebuilt update vector */ -UNIV_INTERN -upd_t* -row_get_prebuilt_update_vector( -/*===========================*/ - row_prebuilt_t* prebuilt); /*!< in: prebuilt struct in MySQL - handle */ -/*********************************************************************//** -Checks if a table is such that we automatically created a clustered -index on it (on row id). -@return TRUE if the clustered index was generated automatically */ -UNIV_INTERN -ibool -row_table_got_default_clust_index( -/*==============================*/ - const dict_table_t* table); /*!< in: table */ -/*********************************************************************//** -Does an update or delete of a row for MySQL. -@return error code or DB_SUCCESS */ -UNIV_INTERN -dberr_t -row_update_for_mysql( -/*=================*/ - byte* mysql_rec, /*!< in: the row to be updated, in - the MySQL format */ - row_prebuilt_t* prebuilt) /*!< in: prebuilt struct in MySQL - handle */ - MY_ATTRIBUTE((nonnull, warn_unused_result)); -/*********************************************************************//** -This can only be used when srv_locks_unsafe_for_binlog is TRUE or this -session is using a READ COMMITTED or READ UNCOMMITTED isolation level. -Before calling this function row_search_for_mysql() must have -initialized prebuilt->new_rec_locks to store the information which new -record locks really were set. This function removes a newly set -clustered index record lock under prebuilt->pcur or -prebuilt->clust_pcur. Thus, this implements a 'mini-rollback' that -releases the latest clustered index record lock we set. */ -UNIV_INTERN -void -row_unlock_for_mysql( -/*=================*/ - row_prebuilt_t* prebuilt, /*!< in/out: prebuilt struct in MySQL - handle */ - ibool has_latches_on_recs)/*!< in: TRUE if called - so that we have the latches on - the records under pcur and - clust_pcur, and we do not need - to reposition the cursors. */ - MY_ATTRIBUTE((nonnull)); -/*********************************************************************//** -Checks if a table name contains the string "/#sql" which denotes temporary -tables in MySQL. -@return true if temporary table */ -UNIV_INTERN -bool -row_is_mysql_tmp_table_name( -/*========================*/ - const char* name) MY_ATTRIBUTE((warn_unused_result)); - /*!< in: table name in the form - 'database/tablename' */ - -/*********************************************************************//** -Creates an query graph node of 'update' type to be used in the MySQL -interface. -@return own: update node */ -UNIV_INTERN -upd_node_t* -row_create_update_node_for_mysql( -/*=============================*/ - dict_table_t* table, /*!< in: table to update */ - mem_heap_t* heap); /*!< in: mem heap from which allocated */ -/**********************************************************************//** -Does a cascaded delete or set null in a foreign key operation. -@return error code or DB_SUCCESS */ -UNIV_INTERN -dberr_t -row_update_cascade_for_mysql( -/*=========================*/ - que_thr_t* thr, /*!< in: query thread */ - upd_node_t* node, /*!< in: update node used in the cascade - or set null operation */ - dict_table_t* table) /*!< in: table where we do the operation */ - MY_ATTRIBUTE((nonnull, warn_unused_result)); -/*********************************************************************//** -Locks the data dictionary exclusively for performing a table create or other -data dictionary modification operation. */ -UNIV_INTERN -void -row_mysql_lock_data_dictionary_func( -/*================================*/ - trx_t* trx, /*!< in/out: transaction */ - const char* file, /*!< in: file name */ - ulint line); /*!< in: line number */ -#define row_mysql_lock_data_dictionary(trx) \ - row_mysql_lock_data_dictionary_func(trx, __FILE__, __LINE__) -/*********************************************************************//** -Unlocks the data dictionary exclusive lock. */ -UNIV_INTERN -void -row_mysql_unlock_data_dictionary( -/*=============================*/ - trx_t* trx); /*!< in/out: transaction */ -/*********************************************************************//** -Locks the data dictionary in shared mode from modifications, for performing -foreign key check, rollback, or other operation invisible to MySQL. */ -UNIV_INTERN -void -row_mysql_freeze_data_dictionary_func( -/*==================================*/ - trx_t* trx, /*!< in/out: transaction */ - const char* file, /*!< in: file name */ - ulint line); /*!< in: line number */ -#define row_mysql_freeze_data_dictionary(trx) \ - row_mysql_freeze_data_dictionary_func(trx, __FILE__, __LINE__) -/*********************************************************************//** -Unlocks the data dictionary shared lock. */ -UNIV_INTERN -void -row_mysql_unfreeze_data_dictionary( -/*===============================*/ - trx_t* trx); /*!< in/out: transaction */ -/*********************************************************************//** -Creates a table for MySQL. If the name of the table ends in -one of "innodb_monitor", "innodb_lock_monitor", "innodb_tablespace_monitor", -"innodb_table_monitor", then this will also start the printing of monitor -output by the master thread. If the table name ends in "innodb_mem_validate", -InnoDB will try to invoke mem_validate(). On failure the transaction will -be rolled back. -@return error code or DB_SUCCESS */ -UNIV_INTERN -dberr_t -row_create_table_for_mysql( -/*=======================*/ - dict_table_t* table, /*!< in, own: table definition - (will be freed, or on DB_SUCCESS - added to the data dictionary cache) */ - trx_t* trx, /*!< in/out: transaction */ - bool commit, /*!< in: if true, commit the transaction */ - fil_encryption_t mode, /*!< in: encryption mode */ - ulint key_id) /*!< in: encryption key_id */ - __attribute__((nonnull, warn_unused_result)); -/*********************************************************************//** -Does an index creation operation for MySQL. TODO: currently failure -to create an index results in dropping the whole table! This is no problem -currently as all indexes must be created at the same time as the table. -@return error number or DB_SUCCESS */ -UNIV_INTERN -dberr_t -row_create_index_for_mysql( -/*=======================*/ - dict_index_t* index, /*!< in, own: index definition - (will be freed) */ - trx_t* trx, /*!< in: transaction handle */ - const ulint* field_lengths) /*!< in: if not NULL, must contain - dict_index_get_n_fields(index) - actual field lengths for the - index columns, which are - then checked for not being too - large. */ - MY_ATTRIBUTE((nonnull(1,2), warn_unused_result)); -/*********************************************************************//** -Scans a table create SQL string and adds to the data dictionary -the foreign key constraints declared in the string. This function -should be called after the indexes for a table have been created. -Each foreign key constraint must be accompanied with indexes in -bot participating tables. The indexes are allowed to contain more -fields than mentioned in the constraint. -@return error code or DB_SUCCESS */ -UNIV_INTERN -dberr_t -row_table_add_foreign_constraints( -/*==============================*/ - trx_t* trx, /*!< in: transaction */ - const char* sql_string, /*!< in: table create statement where - foreign keys are declared like: - FOREIGN KEY (a, b) REFERENCES table2(c, d), - table2 can be written also with the - database name before it: test.table2 */ - size_t sql_length, /*!< in: length of sql_string */ - const char* name, /*!< in: table full name in the - normalized form - database_name/table_name */ - ibool reject_fks) /*!< in: if TRUE, fail with error - code DB_CANNOT_ADD_CONSTRAINT if - any foreign keys are found. */ - MY_ATTRIBUTE((nonnull, warn_unused_result)); -/*********************************************************************//** -The master thread in srv0srv.cc calls this regularly to drop tables which -we must drop in background after queries to them have ended. Such lazy -dropping of tables is needed in ALTER TABLE on Unix. -@return how many tables dropped + remaining tables in list */ -UNIV_INTERN -ulint -row_drop_tables_for_mysql_in_background(void); -/*=========================================*/ -/*********************************************************************//** -Get the background drop list length. NOTE: the caller must own the kernel -mutex! -@return how many tables in list */ -UNIV_INTERN -ulint -row_get_background_drop_list_len_low(void); -/*======================================*/ -/*********************************************************************//** -Sets an exclusive lock on a table. -@return error code or DB_SUCCESS */ -UNIV_INTERN -dberr_t -row_mysql_lock_table( -/*=================*/ - trx_t* trx, /*!< in/out: transaction */ - dict_table_t* table, /*!< in: table to lock */ - enum lock_mode mode, /*!< in: LOCK_X or LOCK_S */ - const char* op_info) /*!< in: string for trx->op_info */ - MY_ATTRIBUTE((nonnull, warn_unused_result)); - -/*********************************************************************//** -Truncates a table for MySQL. -@return error code or DB_SUCCESS */ -UNIV_INTERN -dberr_t -row_truncate_table_for_mysql( -/*=========================*/ - dict_table_t* table, /*!< in: table handle */ - trx_t* trx) /*!< in: transaction handle */ - MY_ATTRIBUTE((nonnull, warn_unused_result)); -/*********************************************************************//** -Drops a table for MySQL. If the name of the dropped table ends in -one of "innodb_monitor", "innodb_lock_monitor", "innodb_tablespace_monitor", -"innodb_table_monitor", then this will also stop the printing of monitor -output by the master thread. If the data dictionary was not already locked -by the transaction, the transaction will be committed. Otherwise, the -data dictionary will remain locked. -@return error code or DB_SUCCESS */ -UNIV_INTERN -dberr_t -row_drop_table_for_mysql( -/*=====================*/ - const char* name, /*!< in: table name */ - trx_t* trx, /*!< in: dictionary transaction handle */ - bool drop_db,/*!< in: true=dropping whole database */ - ibool create_failed,/*!<in: TRUE=create table failed - because e.g. foreign key column - type mismatch. */ - bool nonatomic = true) - /*!< in: whether it is permitted - to release and reacquire dict_operation_lock */ - MY_ATTRIBUTE((nonnull)); -/*********************************************************************//** -Drop all temporary tables during crash recovery. */ -UNIV_INTERN -void -row_mysql_drop_temp_tables(void); -/*============================*/ - -/*********************************************************************//** -Discards the tablespace of a table which stored in an .ibd file. Discarding -means that this function deletes the .ibd file and assigns a new table id for -the table. Also the flag table->ibd_file_missing is set TRUE. -@return error code or DB_SUCCESS */ -UNIV_INTERN -dberr_t -row_discard_tablespace_for_mysql( -/*=============================*/ - const char* name, /*!< in: table name */ - trx_t* trx) /*!< in: transaction handle */ - MY_ATTRIBUTE((nonnull, warn_unused_result)); -/*****************************************************************//** -Imports a tablespace. The space id in the .ibd file must match the space id -of the table in the data dictionary. -@return error code or DB_SUCCESS */ -UNIV_INTERN -dberr_t -row_import_tablespace_for_mysql( -/*============================*/ - dict_table_t* table, /*!< in/out: table */ - row_prebuilt_t* prebuilt) /*!< in: prebuilt struct in MySQL */ - MY_ATTRIBUTE((nonnull, warn_unused_result)); -/*********************************************************************//** -Drops a database for MySQL. -@return error code or DB_SUCCESS */ -UNIV_INTERN -dberr_t -row_drop_database_for_mysql( -/*========================*/ - const char* name, /*!< in: database name which ends to '/' */ - trx_t* trx) /*!< in: transaction handle */ - MY_ATTRIBUTE((nonnull)); -/*********************************************************************//** -Renames a table for MySQL. -@return error code or DB_SUCCESS */ -UNIV_INTERN -dberr_t -row_rename_table_for_mysql( -/*=======================*/ - const char* old_name, /*!< in: old table name */ - const char* new_name, /*!< in: new table name */ - trx_t* trx, /*!< in/out: transaction */ - bool commit) /*!< in: whether to commit trx */ - MY_ATTRIBUTE((nonnull, warn_unused_result)); -/*********************************************************************//** -Checks that the index contains entries in an ascending order, unique -constraint is not broken, and calculates the number of index entries -in the read view of the current transaction. -@return true if ok */ -UNIV_INTERN -bool -row_check_index_for_mysql( -/*======================*/ - row_prebuilt_t* prebuilt, /*!< in: prebuilt struct - in MySQL handle */ - const dict_index_t* index, /*!< in: index */ - ulint* n_rows) /*!< out: number of entries - seen in the consistent read */ - MY_ATTRIBUTE((nonnull, warn_unused_result)); -/*********************************************************************//** -Determines if a table is a magic monitor table. -@return true if monitor table */ -UNIV_INTERN -bool -row_is_magic_monitor_table( -/*=======================*/ - const char* table_name) /*!< in: name of the table, in the - form database/table_name */ - MY_ATTRIBUTE((nonnull, warn_unused_result)); -/*********************************************************************//** -Initialize this module */ -UNIV_INTERN -void -row_mysql_init(void); -/*================*/ - -/*********************************************************************//** -Close this module */ -UNIV_INTERN -void -row_mysql_close(void); -/*=================*/ - -/*********************************************************************//** -Reassigns the table identifier of a table. -@return error code or DB_SUCCESS */ -UNIV_INTERN -dberr_t -row_mysql_table_id_reassign( -/*========================*/ - dict_table_t* table, /*!< in/out: table */ - trx_t* trx, /*!< in/out: transaction */ - table_id_t* new_id) /*!< out: new table id */ - MY_ATTRIBUTE((nonnull, warn_unused_result)); - -/* A struct describing a place for an individual column in the MySQL -row format which is presented to the table handler in ha_innobase. -This template struct is used to speed up row transformations between -Innobase and MySQL. */ - -struct mysql_row_templ_t { - ulint col_no; /*!< column number of the column */ - ulint rec_field_no; /*!< field number of the column in an - Innobase record in the current index; - not defined if template_type is - ROW_MYSQL_WHOLE_ROW */ - bool rec_field_is_prefix; /* is this field in a prefix index? */ - ulint rec_prefix_field_no; /* record field, even if just a - prefix; same as rec_field_no when not a - prefix, otherwise rec_field_no is - ULINT_UNDEFINED but this is the true - field number*/ - ulint clust_rec_field_no; /*!< field number of the column in an - Innobase record in the clustered index; - not defined if template_type is - ROW_MYSQL_WHOLE_ROW */ - ulint icp_rec_field_no; /*!< field number of the column in an - Innobase record in the current index; - not defined unless - index condition pushdown is used */ - ulint mysql_col_offset; /*!< offset of the column in the MySQL - row format */ - ulint mysql_col_len; /*!< length of the column in the MySQL - row format */ - ulint mysql_null_byte_offset; /*!< MySQL NULL bit byte offset in a - MySQL record */ - ulint mysql_null_bit_mask; /*!< bit mask to get the NULL bit, - zero if column cannot be NULL */ - ulint type; /*!< column type in Innobase mtype - numbers DATA_CHAR... */ - ulint mysql_type; /*!< MySQL type code; this is always - < 256 */ - ulint mysql_length_bytes; /*!< if mysql_type - == DATA_MYSQL_TRUE_VARCHAR, this tells - whether we should use 1 or 2 bytes to - store the MySQL true VARCHAR data - length at the start of row in the MySQL - format (NOTE that the MySQL key value - format always uses 2 bytes for the data - len) */ - ulint charset; /*!< MySQL charset-collation code - of the column, or zero */ - ulint mbminlen; /*!< minimum length of a char, in bytes, - or zero if not a char type */ - ulint mbmaxlen; /*!< maximum length of a char, in bytes, - or zero if not a char type */ - ulint is_unsigned; /*!< if a column type is an integer - type and this field is != 0, then - it is an unsigned integer type */ -}; - -#define MYSQL_FETCH_CACHE_SIZE 8 -/* After fetching this many rows, we start caching them in fetch_cache */ -#define MYSQL_FETCH_CACHE_THRESHOLD 4 - -#define ROW_PREBUILT_ALLOCATED 78540783 -#define ROW_PREBUILT_FREED 26423527 - -/** A struct for (sometimes lazily) prebuilt structures in an Innobase table - -handle used within MySQL; these are used to save CPU time. */ - -struct row_prebuilt_t { - ulint magic_n; /*!< this magic number is set to - ROW_PREBUILT_ALLOCATED when created, - or ROW_PREBUILT_FREED when the - struct has been freed */ - dict_table_t* table; /*!< Innobase table handle */ - dict_index_t* index; /*!< current index for a search, if - any */ - trx_t* trx; /*!< current transaction handle */ - unsigned sql_stat_start:1;/*!< TRUE when we start processing of - an SQL statement: we may have to set - an intention lock on the table, - create a consistent read view etc. */ - unsigned mysql_has_locked:1;/*!< this is set TRUE when MySQL - calls external_lock on this handle - with a lock flag, and set FALSE when - with the F_UNLOCK flag */ - unsigned clust_index_was_generated:1; - /*!< if the user did not define a - primary key in MySQL, then Innobase - automatically generated a clustered - index where the ordering column is - the row id: in this case this flag - is set to TRUE */ - unsigned index_usable:1; /*!< caches the value of - row_merge_is_index_usable(trx,index) */ - unsigned read_just_key:1;/*!< set to 1 when MySQL calls - ha_innobase::extra with the - argument HA_EXTRA_KEYREAD; it is enough - to read just columns defined in - the index (i.e., no read of the - clustered index record necessary) */ - unsigned used_in_HANDLER:1;/*!< TRUE if we have been using this - handle in a MySQL HANDLER low level - index cursor command: then we must - store the pcur position even in a - unique search from a clustered index, - because HANDLER allows NEXT and PREV - in such a situation */ - unsigned template_type:2;/*!< ROW_MYSQL_WHOLE_ROW, - ROW_MYSQL_REC_FIELDS, - ROW_MYSQL_DUMMY_TEMPLATE, or - ROW_MYSQL_NO_TEMPLATE */ - unsigned n_template:10; /*!< number of elements in the - template */ - unsigned null_bitmap_len:10;/*!< number of bytes in the SQL NULL - bitmap at the start of a row in the - MySQL format */ - unsigned need_to_access_clustered:1; /*!< if we are fetching - columns through a secondary index - and at least one column is not in - the secondary index, then this is - set to TRUE; note that sometimes this - is set but we later optimize out the - clustered index lookup */ - unsigned templ_contains_blob:1;/*!< TRUE if the template contains - a column with DATA_BLOB == - get_innobase_type_from_mysql_type(); - not to be confused with InnoDB - externally stored columns - (VARCHAR can be off-page too) */ - mysql_row_templ_t* mysql_template;/*!< template used to transform - rows fast between MySQL and Innobase - formats; memory for this template - is not allocated from 'heap' */ - mem_heap_t* heap; /*!< memory heap from which - these auxiliary structures are - allocated when needed */ - ins_node_t* ins_node; /*!< Innobase SQL insert node - used to perform inserts - to the table */ - byte* ins_upd_rec_buff;/*!< buffer for storing data converted - to the Innobase format from the MySQL - format */ - const byte* default_rec; /*!< the default values of all columns - (a "default row") in MySQL format */ - ulint hint_need_to_fetch_extra_cols; - /*!< normally this is set to 0; if this - is set to ROW_RETRIEVE_PRIMARY_KEY, - then we should at least retrieve all - columns in the primary key; if this - is set to ROW_RETRIEVE_ALL_COLS, then - we must retrieve all columns in the - key (if read_just_key == 1), or all - columns in the table */ - upd_node_t* upd_node; /*!< Innobase SQL update node used - to perform updates and deletes */ - trx_id_t trx_id; /*!< The table->def_trx_id when - ins_graph was built */ - que_fork_t* ins_graph; /*!< Innobase SQL query graph used - in inserts. Will be rebuilt on - trx_id or n_indexes mismatch. */ - que_fork_t* upd_graph; /*!< Innobase SQL query graph used - in updates or deletes */ - btr_pcur_t pcur; /*!< persistent cursor used in selects - and updates */ - btr_pcur_t clust_pcur; /*!< persistent cursor used in - some selects and updates */ - que_fork_t* sel_graph; /*!< dummy query graph used in - selects */ - dtuple_t* search_tuple; /*!< prebuilt dtuple used in selects */ - byte row_id[DATA_ROW_ID_LEN]; - /*!< if the clustered index was - generated, the row id of the - last row fetched is stored - here */ - doc_id_t fts_doc_id; /* if the table has an FTS index on - it then we fetch the doc_id. - FTS-FIXME: Currently we fetch it always - but in the future we must only fetch - it when FTS columns are being - updated */ - dtuple_t* clust_ref; /*!< prebuilt dtuple used in - sel/upd/del */ - ulint select_lock_type;/*!< LOCK_NONE, LOCK_S, or LOCK_X */ - ulint stored_select_lock_type;/*!< this field is used to - remember the original select_lock_type - that was decided in ha_innodb.cc, - ::store_lock(), ::external_lock(), - etc. */ - ulint row_read_type; /*!< ROW_READ_WITH_LOCKS if row locks - should be the obtained for records - under an UPDATE or DELETE cursor. - If innodb_locks_unsafe_for_binlog - is TRUE, this can be set to - ROW_READ_TRY_SEMI_CONSISTENT, so that - if the row under an UPDATE or DELETE - cursor was locked by another - transaction, InnoDB will resort - to reading the last committed value - ('semi-consistent read'). Then, - this field will be set to - ROW_READ_DID_SEMI_CONSISTENT to - indicate that. If the row does not - match the WHERE condition, MySQL will - invoke handler::unlock_row() to - clear the flag back to - ROW_READ_TRY_SEMI_CONSISTENT and - to simply skip the row. If - the row matches, the next call to - row_search_for_mysql() will lock - the row. - This eliminates lock waits in some - cases; note that this breaks - serializability. */ - ulint new_rec_locks; /*!< normally 0; if - srv_locks_unsafe_for_binlog is - TRUE or session is using READ - COMMITTED or READ UNCOMMITTED - isolation level, set in - row_search_for_mysql() if we set a new - record lock on the secondary - or clustered index; this is - used in row_unlock_for_mysql() - when releasing the lock under - the cursor if we determine - after retrieving the row that - it does not need to be locked - ('mini-rollback') */ - ulint mysql_prefix_len;/*!< byte offset of the end of - the last requested column */ - ulint mysql_row_len; /*!< length in bytes of a row in the - MySQL format */ - ulint n_rows_fetched; /*!< number of rows fetched after - positioning the current cursor */ - ulint fetch_direction;/*!< ROW_SEL_NEXT or ROW_SEL_PREV */ - byte* fetch_cache[MYSQL_FETCH_CACHE_SIZE]; - /*!< a cache for fetched rows if we - fetch many rows from the same cursor: - it saves CPU time to fetch them in a - batch; we reserve mysql_row_len - bytes for each such row; these - pointers point 4 bytes past the - allocated mem buf start, because - there is a 4 byte magic number at the - start and at the end */ - ibool keep_other_fields_on_keyread; /*!< when using fetch - cache with HA_EXTRA_KEYREAD, don't - overwrite other fields in mysql row - row buffer.*/ - ulint fetch_cache_first;/*!< position of the first not yet - fetched row in fetch_cache */ - ulint n_fetch_cached; /*!< number of not yet fetched rows - in fetch_cache */ - mem_heap_t* blob_heap; /*!< in SELECTS BLOB fields are copied - to this heap */ - mem_heap_t* old_vers_heap; /*!< memory heap where a previous - version is built in consistent read */ - bool in_fts_query; /*!< Whether we are in a FTS query */ - /*----------------------*/ - ulonglong autoinc_last_value; - /*!< last value of AUTO-INC interval */ - ulonglong autoinc_increment;/*!< The increment step of the auto - increment column. Value must be - greater than or equal to 1. Required to - calculate the next value */ - ulonglong autoinc_offset; /*!< The offset passed to - get_auto_increment() by MySQL. Required - to calculate the next value */ - dberr_t autoinc_error; /*!< The actual error code encountered - while trying to init or read the - autoinc value from the table. We - store it here so that we can return - it to MySQL */ - /*----------------------*/ - void* idx_cond; /*!< In ICP, pointer to a ha_innobase, - passed to innobase_index_cond(). - NULL if index condition pushdown is - not used. */ - ulint idx_cond_n_cols;/*!< Number of fields in idx_cond_cols. - 0 if and only if idx_cond == NULL. */ - /*----------------------*/ - ulint magic_n2; /*!< this should be the same as - magic_n */ - /*----------------------*/ - unsigned innodb_api:1; /*!< whether this is a InnoDB API - query */ - const rec_t* innodb_api_rec; /*!< InnoDB API search result */ - byte* srch_key_val1; /*!< buffer used in converting - search key values from MySQL format - to InnoDB format.*/ - byte* srch_key_val2; /*!< buffer used in converting - search key values from MySQL format - to InnoDB format.*/ - uint srch_key_val_len; /*!< Size of search key */ - -}; - -/** Callback for row_mysql_sys_index_iterate() */ -struct SysIndexCallback { - virtual ~SysIndexCallback() { } - - /** Callback method - @param mtr - current mini transaction - @param pcur - persistent cursor. */ - virtual void operator()(mtr_t* mtr, btr_pcur_t* pcur) throw() = 0; -}; - -#define ROW_PREBUILT_FETCH_MAGIC_N 465765687 - -#define ROW_MYSQL_WHOLE_ROW 0 -#define ROW_MYSQL_REC_FIELDS 1 -#define ROW_MYSQL_NO_TEMPLATE 2 -#define ROW_MYSQL_DUMMY_TEMPLATE 3 /* dummy template used in - row_scan_and_check_index */ - -/* Values for hint_need_to_fetch_extra_cols */ -#define ROW_RETRIEVE_PRIMARY_KEY 1 -#define ROW_RETRIEVE_ALL_COLS 2 - -/* Values for row_read_type */ -#define ROW_READ_WITH_LOCKS 0 -#define ROW_READ_TRY_SEMI_CONSISTENT 1 -#define ROW_READ_DID_SEMI_CONSISTENT 2 - -#ifndef UNIV_NONINL -#include "row0mysql.ic" -#endif - -#endif /* row0mysql.h */ |