diff options
Diffstat (limited to 'storage/innobase/include/dict0mem.h')
| -rw-r--r-- | storage/innobase/include/dict0mem.h | 544 |
1 files changed, 421 insertions, 123 deletions
diff --git a/storage/innobase/include/dict0mem.h b/storage/innobase/include/dict0mem.h index bf7d9931bed..596800ee8d2 100644 --- a/storage/innobase/include/dict0mem.h +++ b/storage/innobase/include/dict0mem.h @@ -46,10 +46,12 @@ Created 1/8/1996 Heikki Tuuri #include "gis0type.h" #include "fil0fil.h" #include "fil0crypt.h" +#include <sql_const.h> #include <set> #include <algorithm> #include <iterator> #include <ostream> +#include <mutex> /* Forward declaration. */ struct ib_rbt_t; @@ -575,6 +577,10 @@ struct dict_col_t{ this column. Our current max limit is 3072 (REC_VERSION_56_MAX_INDEX_COL_LEN) bytes. */ +private: + /** Special value of ind for a dropped column */ + static const unsigned DROPPED = 1023; +public: /** Detach a virtual column from an index. @param index being-freed index */ @@ -590,7 +596,7 @@ struct dict_col_t{ } def_val; /** Retrieve the column name. - @param[in] table the table of this column */ + @param table the table of this column */ const char *name(const dict_table_t &table) const; /** @return whether this is a virtual column */ @@ -605,7 +611,8 @@ struct dict_col_t{ ut_ad(mtype == DATA_INT || mtype == DATA_FIXBINARY); return mtype == DATA_INT; } - /** @return whether this is system versioned */ + /** @return whether this user column (not row_start, row_end) + has System Versioning property */ bool is_versioned() const { return !(~prtype & DATA_VERSIONED); } /** @return whether this is the system version start */ bool vers_sys_start() const @@ -619,29 +626,119 @@ struct dict_col_t{ } /** @return whether this is an instantly-added column */ - bool is_instant() const + bool is_added() const { DBUG_ASSERT(def_val.len != UNIV_SQL_DEFAULT || !def_val.data); return def_val.len != UNIV_SQL_DEFAULT; } + /** Flag the column instantly dropped */ + void set_dropped() { ind = DROPPED; } + /** Flag the column instantly dropped. + @param not_null whether the column was NOT NULL + @param len2 whether the length exceeds 255 bytes + @param fixed_len the fixed length in bytes, or 0 */ + void set_dropped(bool not_null, bool len2, unsigned fixed) + { + DBUG_ASSERT(!len2 || !fixed); + prtype= not_null ? DATA_NOT_NULL | DATA_BINARY_TYPE : DATA_BINARY_TYPE; + if (fixed) + { + mtype= DATA_FIXBINARY; + len= fixed; + } + else + { + mtype= DATA_BINARY; + len= len2 ? 65535 : 255; + } + mbminlen= mbmaxlen= 0; + ind= DROPPED; + ord_part= 0; + max_prefix= 0; + } + /** @return whether the column was instantly dropped */ + bool is_dropped() const { return ind == DROPPED; } + /** @return whether the column was instantly dropped + @param index the clustered index */ + inline bool is_dropped(const dict_index_t &index) const; + /** Get the default value of an instantly-added column. @param[out] len value length (in bytes), or UNIV_SQL_NULL @return default value @retval NULL if the default value is SQL NULL (len=UNIV_SQL_NULL) */ const byte *instant_value(ulint *len) const { - DBUG_ASSERT(is_instant()); + DBUG_ASSERT(is_added()); *len= def_val.len; return static_cast<const byte*>(def_val.data); } /** Remove the 'instant ADD' status of the column */ - void remove_instant() + void clear_instant() { - DBUG_ASSERT(is_instant()); def_val.len= UNIV_SQL_DEFAULT; def_val.data= NULL; } + + /** @return whether two columns have compatible data type encoding */ + bool same_type(const dict_col_t &other) const + { + if (mtype != other.mtype) + { + /* For latin1_swedish_ci, DATA_CHAR and DATA_VARCHAR + will be used instead of DATA_MYSQL and DATA_VARMYSQL. + As long as mtype,prtype are being written to InnoDB + data dictionary tables, we cannot simplify this. */ + switch (mtype) { + default: + return false; + case DATA_VARCHAR: + if (other.mtype != DATA_VARMYSQL) + return false; + goto check_encoding; + case DATA_VARMYSQL: + if (other.mtype != DATA_VARCHAR) + return false; + goto check_encoding; + case DATA_CHAR: + if (other.mtype != DATA_MYSQL) + return false; + goto check_encoding; + case DATA_MYSQL: + if (other.mtype != DATA_CHAR) + return false; + goto check_encoding; + } + } + else if (dtype_is_string_type(mtype)) + { + check_encoding: + const uint16_t cset= dtype_get_charset_coll(prtype); + const uint16_t ocset= dtype_get_charset_coll(other.prtype); + return cset == ocset || dict_col_t::same_encoding(cset, ocset); + } + + return true; + } + + /** @return whether two collations codes have the same character encoding */ + static bool same_encoding(uint16_t a, uint16_t b); + + /** Determine if the columns have the same format + except for is_nullable() and is_versioned(). + @param other column to compare to + @return whether the columns have the same format */ + bool same_format(const dict_col_t &other) const + { + return same_type(other) && len >= other.len && + mbminlen == other.mbminlen && mbmaxlen >= other.mbmaxlen && + !((prtype ^ other.prtype) & ~(DATA_NOT_NULL | DATA_VERSIONED | + CHAR_COLL_MASK << 16 | + DATA_LONG_TRUE_VARCHAR)); + } + + /** @return whether the column values are comparable by memcmp() */ + bool is_binary() const { return prtype & DATA_BINARY_TYPE; } }; /** Index information put in a list of virtual column structure. Index @@ -658,9 +755,6 @@ struct dict_v_idx_t { : index(index), nth_field(nth_field) {} }; -/** Index list to put in dict_v_col_t */ -typedef std::list<dict_v_idx_t, ut_allocator<dict_v_idx_t> > dict_v_idx_list; - /** Data structure for a virtual column in a table */ struct dict_v_col_t{ /** column structure */ @@ -670,15 +764,35 @@ struct dict_v_col_t{ dict_col_t** base_col; /** number of base column */ - ulint num_base; + unsigned num_base:10; /** column pos in table */ - ulint v_pos; + unsigned v_pos:10; - /** Virtual index list, and column position in the index, - the allocated memory is not from table->heap */ - dict_v_idx_list* v_indexes; + /** Virtual index list, and column position in the index */ + std::forward_list<dict_v_idx_t, ut_allocator<dict_v_idx_t> > + v_indexes; + /** Detach the column from an index. + @param index index to be detached from */ + void detach(const dict_index_t &index) + { + if (v_indexes.empty()) return; + auto i= v_indexes.before_begin(); + do { + auto prev = i++; + if (i == v_indexes.end()) + { + return; + } + if (i->index == &index) + { + v_indexes.erase_after(prev); + return; + } + } + while (i != v_indexes.end()); + } }; /** Data structure for newly added virtual column in a index. @@ -735,7 +849,8 @@ struct dict_s_col_t { }; /** list to put stored column for create_table_info_t */ -typedef std::list<dict_s_col_t, ut_allocator<dict_s_col_t> > dict_s_col_list; +typedef std::forward_list<dict_s_col_t, ut_allocator<dict_s_col_t> > +dict_s_col_list; /** @brief DICT_ANTELOPE_MAX_INDEX_COL_LEN is measured in bytes and is the maximum indexed column length (or indexed prefix length) in @@ -843,8 +958,11 @@ extern ulong zip_pad_max; an uncompressed page should be left as padding to avoid compression failures. This estimate is based on a self-adapting heuristic. */ struct zip_pad_info_t { - mysql_mutex_t mutex; /*!< mutex protecting the info */ - ulint pad; /*!< number of bytes used as pad */ + /** Dummy assignment operator for dict_index_t::clone() */ + zip_pad_info_t &operator=(const zip_pad_info_t&) { return *this; } + std::mutex mutex; /*!< mutex protecting the info */ + Atomic_relaxed<ulint> + pad; /*!< number of bytes used as pad */ ulint success;/*!< successful compression ops during current round */ ulint failure;/*!< failed compression ops during @@ -863,7 +981,7 @@ const char innobase_index_reserve_name[] = "GEN_CLUST_INDEX"; /** Data structure for an index. Most fields will be initialized to 0, NULL or FALSE in dict_mem_index_create(). */ -struct dict_index_t{ +struct dict_index_t { index_id_t id; /*!< id of the index */ mem_heap_t* heap; /*!< memory heap */ id_name_t name; /*!< index name */ @@ -925,13 +1043,13 @@ struct dict_index_t{ dictionary cache */ unsigned to_be_dropped:1; /*!< TRUE if the index is to be dropped; - protected by dict_operation_lock */ + protected by dict_sys.latch */ unsigned online_status:2; /*!< enum online_index_status. Transitions from ONLINE_INDEX_COMPLETE (to ONLINE_INDEX_CREATION) are protected - by dict_operation_lock and - dict_sys->mutex. Other changes are + by dict_sys.latch and + dict_sys.mutex. Other changes are protected by index->lock. */ unsigned uncommitted:1; /*!< a flag that is set for secondary indexes @@ -941,6 +1059,8 @@ struct dict_index_t{ #ifdef UNIV_DEBUG /** whether this is a dummy index object */ bool is_dummy; + /** whether btr_cur_instant_init() is in progress */ + bool in_instant_init; uint32_t magic_n;/*!< magic number */ /** Value of dict_index_t::magic_n */ # define DICT_INDEX_MAGIC_N 76789786 @@ -1019,8 +1139,14 @@ struct dict_index_t{ /* in which slot the next sample should be saved. */ /* @} */ - /** R-tree split sequence number */ - volatile int32 rtr_ssn; +private: + /** R-tree split sequence number */ + Atomic_relaxed<node_seq_t> rtr_ssn; +public: + void set_ssn(node_seq_t ssn) { rtr_ssn= ssn; } + node_seq_t assign_ssn() { return rtr_ssn.fetch_add(1) + 1; } + node_seq_t ssn() const { return rtr_ssn; } + rtr_info_track_t* rtr_track;/*!< tracking all R-Tree search cursors */ trx_id_t trx_id; /*!< id of the transaction that created this @@ -1060,7 +1186,7 @@ struct dict_index_t{ page cannot be read or decrypted */ inline bool is_readable() const; - /** @return whether instant ADD COLUMN is in effect */ + /** @return whether instant ALTER TABLE is in effect */ inline bool is_instant() const; /** @return whether the index is the primary key index @@ -1089,23 +1215,18 @@ struct dict_index_t{ bool has_virtual() const { return type & DICT_VIRTUAL; } /** @return the position of DB_TRX_ID */ - uint16_t db_trx_id() const { + unsigned db_trx_id() const { DBUG_ASSERT(is_primary()); DBUG_ASSERT(n_uniq); + DBUG_ASSERT(n_uniq <= MAX_REF_PARTS); return n_uniq; } /** @return the position of DB_ROLL_PTR */ - uint16_t db_roll_ptr() const - { - return static_cast<uint16_t>(db_trx_id() + 1); - } + unsigned db_roll_ptr() const { return db_trx_id() + 1; } /** @return the offset of the metadata BLOB field, or the first user field after the PRIMARY KEY,DB_TRX_ID,DB_ROLL_PTR */ - uint16_t first_user_field() const - { - return static_cast<uint16_t>(db_trx_id() + 2); - } + unsigned first_user_field() const { return db_trx_id() + 2; } /** @return whether the index is corrupted */ inline bool is_corrupted() const; @@ -1113,7 +1234,7 @@ struct dict_index_t{ /** Detach the virtual columns from the index that is to be removed. */ void detach_columns() { - if (!has_virtual()) + if (!has_virtual() || !cached) return; for (unsigned i= 0; i < n_fields; i++) { @@ -1154,24 +1275,20 @@ struct dict_index_t{ return fields[n].col->instant_value(len); } - /** Adjust clustered index metadata for instant ADD COLUMN. - @param[in] clustered index definition after instant ADD COLUMN */ - void instant_add_field(const dict_index_t& instant); - - /** Remove the 'instant ADD' status of a clustered index. - Protected by index root page x-latch or table X-lock. */ - void remove_instant() - { - DBUG_ASSERT(is_primary()); - if (!is_instant()) { - return; - } - for (unsigned i = n_core_fields; i < n_fields; i++) { - fields[i].col->remove_instant(); - } - n_core_fields = n_fields; - n_core_null_bytes = UT_BITS_IN_BYTES(unsigned(n_nullable)); - } + /** Adjust index metadata for instant ADD/DROP/reorder COLUMN. + @param[in] clustered index definition after instant ALTER TABLE */ + inline void instant_add_field(const dict_index_t& instant); + /** Remove instant ADD COLUMN metadata. */ + inline void clear_instant_add(); + /** Remove instant ALTER TABLE metadata. */ + inline void clear_instant_alter(); + + /** Construct the metadata record for instant ALTER TABLE. + @param[in] row dummy or default values for existing columns + @param[in,out] heap memory heap for allocations + @return metadata record */ + inline dtuple_t* + instant_metadata(const dtuple_t& row, mem_heap_t* heap) const; /** Check if record in clustered index is historical row. @param[in] rec clustered row @@ -1192,24 +1309,28 @@ struct dict_index_t{ @param n_vcol number of virtual columns to be added */ void assign_new_v_col(ulint n_vcol) { - new_vcol_info= static_cast<dict_add_v_col_info*>( - mem_heap_zalloc(heap, sizeof *new_vcol_info)); + new_vcol_info= static_cast<dict_add_v_col_info*> + (mem_heap_zalloc(heap, sizeof *new_vcol_info)); new_vcol_info->n_v_col= n_vcol; } /* @return whether index has new virtual column */ - bool has_new_v_col() const - { - return new_vcol_info != NULL; - } + bool has_new_v_col() const { return new_vcol_info; } /* @return number of newly added virtual column */ ulint get_new_n_vcol() const - { - if (new_vcol_info) - return new_vcol_info->n_v_col; - return 0; - } + { return new_vcol_info ? new_vcol_info->n_v_col : 0; } + + /** Reconstruct the clustered index fields. + @return whether metadata is incorrect */ + inline bool reconstruct_fields(); + + /** Check if the index contains a column or a prefix of that column. + @param[in] n column number + @param[in] is_virtual whether it is a virtual col + @return whether the index contains the column or its prefix */ + bool contains_col_or_prefix(ulint n, bool is_virtual) const + MY_ATTRIBUTE((warn_unused_result)); #ifdef BTR_CUR_HASH_ADAPT /** @return a clone of this */ @@ -1290,20 +1411,8 @@ struct dict_index_t{ @param index being-freed index */ inline void dict_col_t::detach(const dict_index_t &index) { - ut_ad(is_virtual()); - - if (dict_v_idx_list *v_indexes= reinterpret_cast<const dict_v_col_t*>(this) - ->v_indexes) - { - for (dict_v_idx_list::iterator i= v_indexes->begin(); - i != v_indexes->end(); i++) - { - if (i->index == &index) { - v_indexes->erase(i); - return; - } - } - } + if (is_virtual()) + reinterpret_cast<dict_v_col_t*>(this)->detach(index); } /** The status of online index creation */ @@ -1622,6 +1731,64 @@ struct dict_vcol_templ_t { dict_vcol_templ_t() : vtempl(0), mysql_table_query_id(~0ULL) {} }; +/** Metadata on clustered index fields starting from first_user_field() */ +class field_map_element_t +{ + /** Number of bits for representing a column number */ + static constexpr uint16_t IND_BITS = 10; + + /** Set if the column of the field has been instantly dropped */ + static constexpr uint16_t DROPPED = 1U << (IND_BITS + 5); + + /** Set if the column was dropped and originally declared NOT NULL */ + static constexpr uint16_t NOT_NULL = 1U << (IND_BITS + 4); + + /** Column index (if !(data & DROPPED)): table->cols[data & IND], + or field length (if (data & DROPPED)): + (data & IND) = 0 if variable-length with max_len < 256 bytes; + (data & IND) = 1 if variable-length with max_len > 255 bytes; + (data & IND) = 1 + L otherwise, with L=fixed length of the column */ + static constexpr uint16_t IND = (1U << IND_BITS) - 1; + + /** Field metadata */ + uint16_t data; + + void clear_not_null() { data &= ~NOT_NULL; } +public: + bool is_dropped() const { return data & DROPPED; } + void set_dropped() { data |= DROPPED; } + bool is_not_null() const { return data & NOT_NULL; } + void set_not_null() { ut_ad(is_dropped()); data |= NOT_NULL; } + uint16_t ind() const { return data & IND; } + void set_ind(uint16_t i) + { + DBUG_ASSERT(i <= IND); + DBUG_ASSERT(!ind()); + data |= i; + } + field_map_element_t& operator= (uint16_t value) + { + data = value; + return *this; + } + operator uint16_t() { return data; } +}; + +static_assert(sizeof(field_map_element_t) == 2, + "Size mismatch for a persistent data item!"); + +/** Instantly dropped or reordered columns */ +struct dict_instant_t +{ + /** Number of dropped columns */ + unsigned n_dropped; + /** Dropped columns */ + dict_col_t* dropped; + /** Map of clustered index non-PK fields[i - first_user_field()] + to table columns */ + field_map_element_t* field_map; +}; + /** These are used when MySQL FRM and InnoDB data dictionary are in inconsistent state. */ typedef enum { @@ -1640,11 +1807,7 @@ struct dict_table_t { /** Get reference count. @return current value of n_ref_count */ - inline int32 get_ref_count() - { - return my_atomic_load32_explicit(&n_ref_count, - MY_MEMORY_ORDER_RELAXED); - } + inline uint32_t get_ref_count() const { return n_ref_count; } /** Acquire the table handle. */ inline void acquire(); @@ -1664,6 +1827,9 @@ struct dict_table_t { return flags2 & DICT_TF2_TEMPORARY; } + /** @return whether the table is not in ROW_FORMAT=REDUNDANT */ + bool not_redundant() const { return flags & DICT_TF_COMPACT; } + /** @return whether this table is readable @retval true normally @retval false if this is a single-table tablespace @@ -1682,35 +1848,92 @@ struct dict_table_t { return strstr(name, "/" TEMP_FILE_PREFIX) != NULL; } - /** @return whether instant ADD COLUMN is in effect */ + /** @return whether instant ALTER TABLE is in effect */ bool is_instant() const { return(UT_LIST_GET_FIRST(indexes)->is_instant()); } - /** @return whether the table supports instant ADD COLUMN */ + /** @return whether the table supports instant ALTER TABLE */ bool supports_instant() const { return(!(flags & DICT_TF_MASK_ZIP_SSIZE)); } - /** Adjust metadata for instant ADD COLUMN. - @param[in] table table definition after instant ADD COLUMN */ - void instant_add_column(const dict_table_t& table); + /** @return the number of instantly dropped columns */ + unsigned n_dropped() const { return instant ? instant->n_dropped : 0; } + + /** Look up an old column. + @param[in] cols the old columns of the table + @param[in] col_map map from old table columns to altered ones + @param[in] n_cols number of old columns + @param[in] i the number of the new column + @return old column + @retval NULL if column i was added to the table */ + static const dict_col_t* find(const dict_col_t* cols, + const ulint* col_map, ulint n_cols, + ulint i) + { + for (ulint o = n_cols; o--; ) { + if (col_map[o] == i) { + return &cols[o]; + } + } + return NULL; + } - /** Roll back instant_add_column(). - @param[in] old_n_cols original n_cols - @param[in] old_cols original cols - @param[in] old_col_names original col_names */ - void rollback_instant( + /** Serialise metadata of dropped or reordered columns. + @param[in,out] heap memory heap for allocation + @param[out] field data field with the metadata */ + inline void serialise_columns(mem_heap_t* heap, dfield_t* field) const; + + /** Reconstruct dropped or reordered columns. + @param[in] metadata data from serialise_columns() + @param[in] len length of the metadata, in bytes + @return whether parsing the metadata failed */ + bool deserialise_columns(const byte* metadata, ulint len); + + /** Set is_instant() before instant_column(). + @param[in] old previous table definition + @param[in] col_map map from old.cols[] + and old.v_cols[] to this + @param[out] first_alter_pos 0, or + 1 + first changed column position */ + inline void prepare_instant(const dict_table_t& old, + const ulint* col_map, + unsigned& first_alter_pos); + + /** Adjust table metadata for instant ADD/DROP/reorder COLUMN. + @param[in] table table on which prepare_instant() was invoked + @param[in] col_map mapping from cols[] and v_cols[] to table + @return whether the metadata record must be updated */ + inline bool instant_column(const dict_table_t& table, + const ulint* col_map); + + /** Roll back instant_column(). + @param[in] old_n_cols original n_cols + @param[in] old_cols original cols + @param[in] old_col_names original col_names + @param[in] old_instant original instant structure + @param[in] old_fields original fields + @param[in] old_n_fields original number of fields + @param[in] old_n_core_fields original number of core fields + @param[in] old_n_v_cols original n_v_cols + @param[in] old_v_cols original v_cols + @param[in] old_v_col_names original v_col_names + @param[in] col_map column map */ + inline void rollback_instant( unsigned old_n_cols, dict_col_t* old_cols, - const char* old_col_names); - - /** Trim the instantly added columns when an insert into SYS_COLUMNS - is rolled back during ALTER TABLE or recovery. - @param[in] n number of surviving non-system columns */ - void rollback_instant(unsigned n); + const char* old_col_names, + dict_instant_t* old_instant, + dict_field_t* old_fields, + unsigned old_n_fields, + unsigned old_n_core_fields, + unsigned old_n_v_cols, + dict_v_col_t* old_v_cols, + const char* old_v_col_names, + const ulint* col_map); /** Add the table definition to the data dictionary cache */ void add_to_cache(); @@ -1728,23 +1951,28 @@ struct dict_table_t { void inc_fk_checks() { #ifdef UNIV_DEBUG - lint fk_checks= (lint) + int32_t fk_checks= #endif - my_atomic_addlint(&n_foreign_key_checks_running, 1); + n_foreign_key_checks_running++; ut_ad(fk_checks >= 0); } void dec_fk_checks() { #ifdef UNIV_DEBUG - lint fk_checks= (lint) + int32_t fk_checks= #endif - my_atomic_addlint(&n_foreign_key_checks_running, ulint(-1)); + n_foreign_key_checks_running--; ut_ad(fk_checks > 0); } /** For overflow fields returns potential max length stored inline */ - size_t get_overflow_field_local_len() const; + inline size_t get_overflow_field_local_len() const; +private: + /** Initialize instant->field_map. + @param[in] table table definition to copy from */ + inline void init_instant(const dict_table_t& table); +public: /** Id of the table. */ table_id_t id; /** Hash chain node. */ @@ -1803,8 +2031,7 @@ struct dict_table_t { /** TRUE if the table is to be dropped, but not yet actually dropped (could in the background drop list). It is turned on at the beginning of row_drop_table_for_mysql() and turned off just before we start to - update system tables for the drop. It is protected by - dict_operation_lock. */ + update system tables for the drop. It is protected by dict_sys.latch. */ unsigned to_be_dropped:1; /** Number of non-virtual columns defined so far. */ @@ -1854,6 +2081,9 @@ struct dict_table_t { reason s_cols is a part of dict_table_t */ dict_s_col_list* s_cols; + /** Instantly dropped or reordered columns, or NULL if none */ + dict_instant_t* instant; + /** Column names packed in a character string "name1\0name2\0...nameN\0". Until the string contains n_cols, it will be allocated from a temporary heap. The final string will be allocated @@ -1904,7 +2134,7 @@ struct dict_table_t { /** Count of how many foreign key check operations are currently being performed on the table. We cannot drop the table while there are foreign key checks running on it. */ - ulint n_foreign_key_checks_running; + Atomic_counter<int32_t> n_foreign_key_checks_running; /** Transactions whose view low limit is greater than this number are not allowed to store to the MySQL query cache or retrieve from it. @@ -1925,7 +2155,7 @@ struct dict_table_t { dict_foreign_set referenced_set; /** Statistics for query optimization. Mostly protected by - dict_sys->mutex. @{ */ + dict_sys.mutex. @{ */ /** TRUE if statistics have been calculated the first time after database startup or table creation. */ @@ -2007,7 +2237,7 @@ struct dict_table_t { /** The state of the background stats thread wrt this table. See BG_STAT_NONE, BG_STAT_IN_PROGRESS and BG_STAT_SHOULD_QUIT. - Writes are covered by dict_sys->mutex. Dirty reads are possible. */ + Writes are covered by dict_sys.mutex. Dirty reads are possible. */ #define BG_SCRUB_IN_PROGRESS ((byte)(1 << 2)) /*!< BG_SCRUB_IN_PROGRESS is set in @@ -2023,7 +2253,7 @@ struct dict_table_t { /** The state of the background stats thread wrt this table. See BG_STAT_NONE, BG_STAT_IN_PROGRESS and BG_STAT_SHOULD_QUIT. - Writes are covered by dict_sys->mutex. Dirty reads are possible. */ + Writes are covered by dict_sys.mutex. Dirty reads are possible. */ byte stats_bg_flag; bool stats_error_printed; @@ -2050,7 +2280,7 @@ struct dict_table_t { lock_t* autoinc_lock; /** Mutex protecting the autoinc counter and freed_indexes. */ - mysql_mutex_t autoinc_mutex; + std::mutex autoinc_mutex; /** Autoinc counter value to give to the next inserted row. */ ib_uint64_t autoinc; @@ -2085,7 +2315,7 @@ private: /** Count of how many handles are opened to this table. Dropping of the table is NOT allowed until this count gets to zero. MySQL does NOT itself check the number of open handles at DROP. */ - int32 n_ref_count; + Atomic_counter<uint32_t> n_ref_count; public: /** List of locks on the table. Protected by lock_sys.mutex. */ @@ -2137,12 +2367,15 @@ inline bool dict_index_t::is_readable() const { return table->is_readable(); } inline bool dict_index_t::is_instant() const { ut_ad(n_core_fields > 0); - ut_ad(n_core_fields <= n_fields); + ut_ad(n_core_fields <= n_fields || table->n_dropped()); ut_ad(n_core_fields == n_fields || (type & ~(DICT_UNIQUE | DICT_CORRUPT)) == DICT_CLUSTERED); ut_ad(n_core_fields == n_fields || table->supports_instant()); ut_ad(n_core_fields == n_fields || !table->is_temporary()); - return(n_core_fields != n_fields); + ut_ad(!table->instant || !table->is_temporary()); + + return n_core_fields != n_fields + || (is_primary() && table->instant); } inline bool dict_index_t::is_corrupted() const @@ -2152,6 +2385,81 @@ inline bool dict_index_t::is_corrupted() const || (table && table->corrupted)); } +inline void dict_index_t::clear_instant_add() +{ + DBUG_ASSERT(is_primary()); + DBUG_ASSERT(is_instant()); + DBUG_ASSERT(!table->instant); + for (unsigned i = n_core_fields; i < n_fields; i++) { + fields[i].col->clear_instant(); + } + n_core_fields = n_fields; + n_core_null_bytes = UT_BITS_IN_BYTES(unsigned(n_nullable)); +} + +inline void dict_index_t::clear_instant_alter() +{ + DBUG_ASSERT(is_primary()); + DBUG_ASSERT(n_fields == n_def); + + if (!table->instant) { + if (is_instant()) { + clear_instant_add(); + } + return; + } + +#ifndef DBUG_OFF + for (unsigned i = first_user_field(); i--; ) { + DBUG_ASSERT(!fields[i].col->is_dropped()); + DBUG_ASSERT(!fields[i].col->is_nullable()); + } +#endif + const dict_col_t* ai_col = table->persistent_autoinc + ? fields[table->persistent_autoinc - 1].col + : NULL; + dict_field_t* const begin = &fields[first_user_field()]; + dict_field_t* end = &fields[n_fields]; + + for (dict_field_t* d = begin; d < end; ) { + /* Move fields for dropped columns to the end. */ + if (!d->col->is_dropped()) { + d++; + } else { + if (d->col->is_nullable()) { + n_nullable--; + } + + std::swap(*d, *--end); + } + } + + DBUG_ASSERT(&fields[n_fields - table->n_dropped()] == end); + n_core_fields = n_fields = n_def = end - fields; + n_core_null_bytes = UT_BITS_IN_BYTES(n_nullable); + std::sort(begin, end, [](const dict_field_t& a, const dict_field_t& b) + { return a.col->ind < b.col->ind; }); + table->instant = NULL; + if (ai_col) { + auto a = std::find_if(fields, end, + [ai_col](const dict_field_t& f) + { return f.col == ai_col; }); + table->persistent_autoinc = (a == end) ? 0 : 1 + (a - fields); + } +} + +/** @return whether the column was instantly dropped +@param[in] index the clustered index */ +inline bool dict_col_t::is_dropped(const dict_index_t& index) const +{ + DBUG_ASSERT(index.is_primary()); + DBUG_ASSERT(!is_dropped() == !index.table->instant); + DBUG_ASSERT(!is_dropped() || (this >= index.table->instant->dropped + && this < index.table->instant->dropped + + index.table->instant->n_dropped)); + return is_dropped(); +} + /*******************************************************************//** Initialise the table lock list. */ void @@ -2172,16 +2480,6 @@ struct dict_foreign_add_to_referenced_table { } }; -/** Release the zip_pad_mutex of a given index. -@param[in,out] index index whose zip_pad_mutex is to be released */ -inline -void -dict_index_zip_pad_unlock( - dict_index_t* index) -{ - mysql_mutex_unlock(&index->zip_pad.mutex); -} - /** Check whether the col is used in spatial index or regular index. @param[in] col column to check @return spatial status */ |