1 /* 2 Copyright (c) 2000, 2016, Oracle and/or its affiliates. 3 Copyright (c) 2009, 2021, MariaDB Corporation. 4 5 This program is free software; you can redistribute it and/or modify 6 it under the terms of the GNU General Public License as published by 7 the Free Software Foundation; version 2 of the License. 8 9 This program is distributed in the hope that it will be useful, 10 but WITHOUT ANY WARRANTY; without even the implied warranty of 11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 GNU General Public License for more details. 13 14 You should have received a copy of the GNU General Public License 15 along with this program; if not, write to the Free Software 16 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */ 17 18 #ifndef SQL_CLASS_INCLUDED 19 #define SQL_CLASS_INCLUDED 20 21 /* Classes in mysql */ 22 23 #include "dur_prop.h" 24 #include <waiting_threads.h> 25 #include "sql_const.h" 26 #include <mysql/plugin_audit.h> 27 #include "log.h" 28 #include "rpl_tblmap.h" 29 #include "mdl.h" 30 #include "field.h" // Create_field 31 #include "probes_mysql.h" 32 #include "sql_locale.h" /* my_locale_st */ 33 #include "sql_profile.h" /* PROFILING */ 34 #include "scheduler.h" /* thd_scheduler */ 35 #include "protocol.h" /* Protocol_text, Protocol_binary */ 36 #include "violite.h" /* vio_is_connected */ 37 #include "thr_lock.h" /* thr_lock_type, THR_LOCK_DATA, THR_LOCK_INFO */ 38 #include "thr_timer.h" 39 #include "thr_malloc.h" 40 #include "log_slow.h" /* LOG_SLOW_DISABLE_... */ 41 #include <my_tree.h> 42 43 #include "sql_digest_stream.h" // sql_digest_state 44 45 #include <mysql/psi/mysql_stage.h> 46 #include <mysql/psi/mysql_statement.h> 47 #include <mysql/psi/mysql_idle.h> 48 #include <mysql/psi/mysql_table.h> 49 #include <mysql_com_server.h> 50 #include "session_tracker.h" 51 52 extern "C" 53 void set_thd_stage_info(void *thd, 54 const PSI_stage_info *new_stage, 55 PSI_stage_info *old_stage, 56 const char *calling_func, 57 const char *calling_file, 58 const unsigned int calling_line); 59 60 #define THD_STAGE_INFO(thd, stage) \ 61 (thd)->enter_stage(&stage, __func__, __FILE__, __LINE__) 62 63 #include "my_apc.h" 64 #include "rpl_gtid.h" 65 #include "wsrep_mysqld.h" 66 67 class Reprepare_observer; 68 class Relay_log_info; 69 struct rpl_group_info; 70 class Rpl_filter; 71 class Query_log_event; 72 class Load_log_event; 73 class sp_rcontext; 74 class sp_cache; 75 class Lex_input_stream; 76 class Parser_state; 77 class Rows_log_event; 78 class Sroutine_hash_entry; 79 class user_var_entry; 80 struct Trans_binlog_info; 81 class rpl_io_thread_info; 82 class rpl_sql_thread_info; 83 84 enum enum_ha_read_modes { RFIRST, RNEXT, RPREV, RLAST, RKEY, RNEXT_SAME }; 85 enum enum_duplicates { DUP_ERROR, DUP_REPLACE, DUP_UPDATE }; 86 enum enum_delay_key_write { DELAY_KEY_WRITE_NONE, DELAY_KEY_WRITE_ON, 87 DELAY_KEY_WRITE_ALL }; 88 enum enum_slave_exec_mode { SLAVE_EXEC_MODE_STRICT, 89 SLAVE_EXEC_MODE_IDEMPOTENT, 90 SLAVE_EXEC_MODE_LAST_BIT }; 91 enum enum_slave_run_triggers_for_rbr { SLAVE_RUN_TRIGGERS_FOR_RBR_NO, 92 SLAVE_RUN_TRIGGERS_FOR_RBR_YES, 93 SLAVE_RUN_TRIGGERS_FOR_RBR_LOGGING}; 94 enum enum_slave_type_conversions { SLAVE_TYPE_CONVERSIONS_ALL_LOSSY, 95 SLAVE_TYPE_CONVERSIONS_ALL_NON_LOSSY}; 96 97 /* 98 MARK_COLUMNS_READ: A column is goind to be read. 99 MARK_COLUMNS_WRITE: A column is going to be written to. 100 MARK_COLUMNS_READ: A column is goind to be read. 101 A bit in read set is set to inform handler that the field 102 is to be read. If field list contains duplicates, then 103 thd->dup_field is set to point to the last found 104 duplicate. 105 MARK_COLUMNS_WRITE: A column is going to be written to. 106 A bit is set in write set to inform handler that it needs 107 to update this field in write_row and update_row. 108 */ 109 enum enum_column_usage 110 { COLUMNS_READ, COLUMNS_WRITE, MARK_COLUMNS_READ, MARK_COLUMNS_WRITE}; 111 112 static inline bool should_mark_column(enum_column_usage column_usage) 113 { return column_usage >= MARK_COLUMNS_READ; } 114 115 enum enum_filetype { FILETYPE_CSV, FILETYPE_XML }; 116 117 enum enum_binlog_row_image { 118 /** PKE in the before image and changed columns in the after image */ 119 BINLOG_ROW_IMAGE_MINIMAL= 0, 120 /** Whenever possible, before and after image contain all columns except blobs. */ 121 BINLOG_ROW_IMAGE_NOBLOB= 1, 122 /** All columns in both before and after image. */ 123 BINLOG_ROW_IMAGE_FULL= 2 124 }; 125 126 127 /* Bits for different SQL modes modes (including ANSI mode) */ 128 #define MODE_REAL_AS_FLOAT (1ULL << 0) 129 #define MODE_PIPES_AS_CONCAT (1ULL << 1) 130 #define MODE_ANSI_QUOTES (1ULL << 2) 131 #define MODE_IGNORE_SPACE (1ULL << 3) 132 #define MODE_IGNORE_BAD_TABLE_OPTIONS (1ULL << 4) 133 #define MODE_ONLY_FULL_GROUP_BY (1ULL << 5) 134 #define MODE_NO_UNSIGNED_SUBTRACTION (1ULL << 6) 135 #define MODE_NO_DIR_IN_CREATE (1ULL << 7) 136 #define MODE_POSTGRESQL (1ULL << 8) 137 #define MODE_ORACLE (1ULL << 9) 138 #define MODE_MSSQL (1ULL << 10) 139 #define MODE_DB2 (1ULL << 11) 140 #define MODE_MAXDB (1ULL << 12) 141 #define MODE_NO_KEY_OPTIONS (1ULL << 13) 142 #define MODE_NO_TABLE_OPTIONS (1ULL << 14) 143 #define MODE_NO_FIELD_OPTIONS (1ULL << 15) 144 #define MODE_MYSQL323 (1ULL << 16) 145 #define MODE_MYSQL40 (1ULL << 17) 146 #define MODE_ANSI (1ULL << 18) 147 #define MODE_NO_AUTO_VALUE_ON_ZERO (1ULL << 19) 148 #define MODE_NO_BACKSLASH_ESCAPES (1ULL << 20) 149 #define MODE_STRICT_TRANS_TABLES (1ULL << 21) 150 #define MODE_STRICT_ALL_TABLES (1ULL << 22) 151 #define MODE_NO_ZERO_IN_DATE (1ULL << 23) 152 #define MODE_NO_ZERO_DATE (1ULL << 24) 153 #define MODE_INVALID_DATES (1ULL << 25) 154 #define MODE_ERROR_FOR_DIVISION_BY_ZERO (1ULL << 26) 155 #define MODE_TRADITIONAL (1ULL << 27) 156 #define MODE_NO_AUTO_CREATE_USER (1ULL << 28) 157 #define MODE_HIGH_NOT_PRECEDENCE (1ULL << 29) 158 #define MODE_NO_ENGINE_SUBSTITUTION (1ULL << 30) 159 #define MODE_PAD_CHAR_TO_FULL_LENGTH (1ULL << 31) 160 #define MODE_EMPTY_STRING_IS_NULL (1ULL << 32) 161 #define MODE_SIMULTANEOUS_ASSIGNMENT (1ULL << 33) 162 163 /* Bits for different old style modes */ 164 #define OLD_MODE_NO_DUP_KEY_WARNINGS_WITH_IGNORE (1 << 0) 165 #define OLD_MODE_NO_PROGRESS_INFO (1 << 1) 166 #define OLD_MODE_ZERO_DATE_TIME_CAST (1 << 2) 167 168 extern char internal_table_name[2]; 169 extern char empty_c_string[1]; 170 extern MYSQL_PLUGIN_IMPORT const char **errmesg; 171 172 extern bool volatile shutdown_in_progress; 173 174 extern "C" LEX_STRING * thd_query_string (MYSQL_THD thd); 175 extern "C" size_t thd_query_safe(MYSQL_THD thd, char *buf, size_t buflen); 176 177 /** 178 @class CSET_STRING 179 @brief Character set armed LEX_STRING 180 */ 181 class CSET_STRING 182 { 183 private: 184 LEX_STRING string; 185 CHARSET_INFO *cs; 186 public: 187 CSET_STRING() : cs(&my_charset_bin) 188 { 189 string.str= NULL; 190 string.length= 0; 191 } 192 CSET_STRING(char *str_arg, size_t length_arg, CHARSET_INFO *cs_arg) : 193 cs(cs_arg) 194 { 195 DBUG_ASSERT(cs_arg != NULL); 196 string.str= str_arg; 197 string.length= length_arg; 198 } 199 200 inline char *str() const { return string.str; } 201 inline size_t length() const { return string.length; } 202 CHARSET_INFO *charset() const { return cs; } 203 204 friend LEX_STRING * thd_query_string (MYSQL_THD thd); 205 }; 206 207 208 #define TC_HEURISTIC_RECOVER_COMMIT 1 209 #define TC_HEURISTIC_RECOVER_ROLLBACK 2 210 extern ulong tc_heuristic_recover; 211 212 typedef struct st_user_var_events 213 { 214 user_var_entry *user_var_event; 215 char *value; 216 size_t length; 217 Item_result type; 218 uint charset_number; 219 bool unsigned_flag; 220 } BINLOG_USER_VAR_EVENT; 221 222 /* 223 The COPY_INFO structure is used by INSERT/REPLACE code. 224 The schema of the row counting by the INSERT/INSERT ... ON DUPLICATE KEY 225 UPDATE code: 226 If a row is inserted then the copied variable is incremented. 227 If a row is updated by the INSERT ... ON DUPLICATE KEY UPDATE and the 228 new data differs from the old one then the copied and the updated 229 variables are incremented. 230 The touched variable is incremented if a row was touched by the update part 231 of the INSERT ... ON DUPLICATE KEY UPDATE no matter whether the row 232 was actually changed or not. 233 */ 234 typedef struct st_copy_info { 235 ha_rows records; /**< Number of processed records */ 236 ha_rows deleted; /**< Number of deleted records */ 237 ha_rows updated; /**< Number of updated records */ 238 ha_rows copied; /**< Number of copied records */ 239 ha_rows error_count; 240 ha_rows touched; /* Number of touched records */ 241 enum enum_duplicates handle_duplicates; 242 int escape_char, last_errno; 243 bool ignore; 244 /* for INSERT ... UPDATE */ 245 List<Item> *update_fields; 246 List<Item> *update_values; 247 /* for VIEW ... WITH CHECK OPTION */ 248 TABLE_LIST *view; 249 TABLE_LIST *table_list; /* Normal table */ 250 } COPY_INFO; 251 252 253 class Key_part_spec :public Sql_alloc { 254 public: 255 LEX_CSTRING field_name; 256 uint length; 257 bool generated; 258 Key_part_spec(const LEX_CSTRING *name, uint len, bool gen= false) 259 : field_name(*name), length(len), generated(gen) 260 {} 261 bool operator==(const Key_part_spec& other) const; 262 /** 263 Construct a copy of this Key_part_spec. field_name is copied 264 by-pointer as it is known to never change. At the same time 265 'length' may be reset in mysql_prepare_create_table, and this 266 is why we supply it with a copy. 267 268 @return If out of memory, 0 is returned and an error is set in 269 THD. 270 */ 271 Key_part_spec *clone(MEM_ROOT *mem_root) const 272 { return new (mem_root) Key_part_spec(*this); } 273 }; 274 275 276 class Alter_drop :public Sql_alloc { 277 public: 278 enum drop_type {KEY, COLUMN, FOREIGN_KEY, CHECK_CONSTRAINT }; 279 const char *name; 280 enum drop_type type; 281 bool drop_if_exists; 282 Alter_drop(enum drop_type par_type,const char *par_name, bool par_exists) 283 :name(par_name), type(par_type), drop_if_exists(par_exists) 284 { 285 DBUG_ASSERT(par_name != NULL); 286 } 287 /** 288 Used to make a clone of this object for ALTER/CREATE TABLE 289 @sa comment for Key_part_spec::clone 290 */ 291 Alter_drop *clone(MEM_ROOT *mem_root) const 292 { return new (mem_root) Alter_drop(*this); } 293 const char *type_name() 294 { 295 return type == COLUMN ? "COLUMN" : 296 type == CHECK_CONSTRAINT ? "CONSTRAINT" : 297 type == KEY ? "INDEX" : "FOREIGN KEY"; 298 } 299 }; 300 301 302 class Alter_column :public Sql_alloc { 303 public: 304 const char *name; 305 Virtual_column_info *default_value; 306 bool alter_if_exists; 307 Alter_column(const char *par_name, Virtual_column_info *expr, bool par_exists) 308 :name(par_name), default_value(expr), alter_if_exists(par_exists) {} 309 /** 310 Used to make a clone of this object for ALTER/CREATE TABLE 311 @sa comment for Key_part_spec::clone 312 */ 313 Alter_column *clone(MEM_ROOT *mem_root) const 314 { return new (mem_root) Alter_column(*this); } 315 }; 316 317 318 class Key :public Sql_alloc, public DDL_options { 319 public: 320 enum Keytype { PRIMARY, UNIQUE, MULTIPLE, FULLTEXT, SPATIAL, FOREIGN_KEY}; 321 enum Keytype type; 322 KEY_CREATE_INFO key_create_info; 323 List<Key_part_spec> columns; 324 LEX_CSTRING name; 325 engine_option_value *option_list; 326 bool generated; 327 bool invisible; 328 329 Key(enum Keytype type_par, const LEX_CSTRING *name_arg, 330 ha_key_alg algorithm_arg, bool generated_arg, DDL_options_st ddl_options) 331 :DDL_options(ddl_options), 332 type(type_par), key_create_info(default_key_create_info), 333 name(*name_arg), option_list(NULL), generated(generated_arg), 334 invisible(false) 335 { 336 key_create_info.algorithm= algorithm_arg; 337 } 338 Key(enum Keytype type_par, const LEX_CSTRING *name_arg, 339 KEY_CREATE_INFO *key_info_arg, 340 bool generated_arg, List<Key_part_spec> *cols, 341 engine_option_value *create_opt, DDL_options_st ddl_options) 342 :DDL_options(ddl_options), 343 type(type_par), key_create_info(*key_info_arg), columns(*cols), 344 name(*name_arg), option_list(create_opt), generated(generated_arg), 345 invisible(false) 346 {} 347 Key(const Key &rhs, MEM_ROOT *mem_root); 348 virtual ~Key() {} 349 /* Equality comparison of keys (ignoring name) */ 350 friend bool foreign_key_prefix(Key *a, Key *b); 351 /** 352 Used to make a clone of this object for ALTER/CREATE TABLE 353 @sa comment for Key_part_spec::clone 354 */ 355 virtual Key *clone(MEM_ROOT *mem_root) const 356 { return new (mem_root) Key(*this, mem_root); } 357 }; 358 359 360 class Foreign_key: public Key { 361 public: 362 enum fk_match_opt { FK_MATCH_UNDEF, FK_MATCH_FULL, 363 FK_MATCH_PARTIAL, FK_MATCH_SIMPLE}; 364 LEX_CSTRING ref_db; 365 LEX_CSTRING ref_table; 366 List<Key_part_spec> ref_columns; 367 enum enum_fk_option delete_opt, update_opt; 368 enum fk_match_opt match_opt; 369 Foreign_key(const LEX_CSTRING *name_arg, List<Key_part_spec> *cols, 370 const LEX_CSTRING *ref_db_arg, const LEX_CSTRING *ref_table_arg, 371 List<Key_part_spec> *ref_cols, 372 enum_fk_option delete_opt_arg, enum_fk_option update_opt_arg, 373 fk_match_opt match_opt_arg, 374 DDL_options ddl_options) 375 :Key(FOREIGN_KEY, name_arg, &default_key_create_info, 0, cols, NULL, 376 ddl_options), 377 ref_db(*ref_db_arg), ref_table(*ref_table_arg), ref_columns(*ref_cols), 378 delete_opt(delete_opt_arg), update_opt(update_opt_arg), 379 match_opt(match_opt_arg) 380 { 381 // We don't check for duplicate FKs. 382 key_create_info.check_for_duplicate_indexes= false; 383 } 384 Foreign_key(const Foreign_key &rhs, MEM_ROOT *mem_root); 385 /** 386 Used to make a clone of this object for ALTER/CREATE TABLE 387 @sa comment for Key_part_spec::clone 388 */ 389 virtual Key *clone(MEM_ROOT *mem_root) const 390 { return new (mem_root) Foreign_key(*this, mem_root); } 391 /* Used to validate foreign key options */ 392 bool validate(List<Create_field> &table_fields); 393 }; 394 395 typedef struct st_mysql_lock 396 { 397 TABLE **table; 398 THR_LOCK_DATA **locks; 399 uint table_count,lock_count; 400 uint flags; 401 } MYSQL_LOCK; 402 403 404 class LEX_COLUMN : public Sql_alloc 405 { 406 public: 407 String column; 408 uint rights; 409 LEX_COLUMN (const String& x,const uint& y ): column (x),rights (y) {} 410 }; 411 412 class MY_LOCALE; 413 414 /** 415 Query_cache_tls -- query cache thread local data. 416 */ 417 418 struct Query_cache_block; 419 420 struct Query_cache_tls 421 { 422 /* 423 'first_query_block' should be accessed only via query cache 424 functions and methods to maintain proper locking. 425 */ 426 Query_cache_block *first_query_block; 427 void set_first_query_block(Query_cache_block *first_query_block_arg) 428 { 429 first_query_block= first_query_block_arg; 430 } 431 432 Query_cache_tls() :first_query_block(NULL) {} 433 }; 434 435 /* SIGNAL / RESIGNAL / GET DIAGNOSTICS */ 436 437 /** 438 This enumeration list all the condition item names of a condition in the 439 SQL condition area. 440 */ 441 typedef enum enum_diag_condition_item_name 442 { 443 /* 444 Conditions that can be set by the user (SIGNAL/RESIGNAL), 445 and by the server implementation. 446 */ 447 448 DIAG_CLASS_ORIGIN= 0, 449 FIRST_DIAG_SET_PROPERTY= DIAG_CLASS_ORIGIN, 450 DIAG_SUBCLASS_ORIGIN= 1, 451 DIAG_CONSTRAINT_CATALOG= 2, 452 DIAG_CONSTRAINT_SCHEMA= 3, 453 DIAG_CONSTRAINT_NAME= 4, 454 DIAG_CATALOG_NAME= 5, 455 DIAG_SCHEMA_NAME= 6, 456 DIAG_TABLE_NAME= 7, 457 DIAG_COLUMN_NAME= 8, 458 DIAG_CURSOR_NAME= 9, 459 DIAG_MESSAGE_TEXT= 10, 460 DIAG_MYSQL_ERRNO= 11, 461 LAST_DIAG_SET_PROPERTY= DIAG_MYSQL_ERRNO 462 } Diag_condition_item_name; 463 464 /** 465 Name of each diagnostic condition item. 466 This array is indexed by Diag_condition_item_name. 467 */ 468 extern const LEX_CSTRING Diag_condition_item_names[]; 469 470 /** 471 These states are bit coded with HARD. For each state there must be a pair 472 <state_even_num>, and <state_odd_num>_HARD. 473 */ 474 enum killed_state 475 { 476 NOT_KILLED= 0, 477 KILL_HARD_BIT= 1, /* Bit for HARD KILL */ 478 KILL_BAD_DATA= 2, 479 KILL_BAD_DATA_HARD= 3, 480 KILL_QUERY= 4, 481 KILL_QUERY_HARD= 5, 482 /* 483 ABORT_QUERY signals to the query processor to stop execution ASAP without 484 issuing an error. Instead a warning is issued, and when possible a partial 485 query result is returned to the client. 486 */ 487 ABORT_QUERY= 6, 488 ABORT_QUERY_HARD= 7, 489 KILL_TIMEOUT= 8, 490 KILL_TIMEOUT_HARD= 9, 491 /* 492 When binlog reading thread connects to the server it kills 493 all the binlog threads with the same ID. 494 */ 495 KILL_SLAVE_SAME_ID= 10, 496 /* 497 All of the following killed states will kill the connection 498 KILL_CONNECTION must be the first of these and it must start with 499 an even number (becasue of HARD bit)! 500 */ 501 KILL_CONNECTION= 12, 502 KILL_CONNECTION_HARD= 13, 503 KILL_SYSTEM_THREAD= 14, 504 KILL_SYSTEM_THREAD_HARD= 15, 505 KILL_SERVER= 16, 506 KILL_SERVER_HARD= 17, 507 /* 508 Used in threadpool to signal wait timeout. 509 */ 510 KILL_WAIT_TIMEOUT= 18, 511 KILL_WAIT_TIMEOUT_HARD= 19 512 513 }; 514 515 #define killed_mask_hard(killed) ((killed_state) ((killed) & ~KILL_HARD_BIT)) 516 517 enum killed_type 518 { 519 KILL_TYPE_ID, 520 KILL_TYPE_USER, 521 KILL_TYPE_QUERY 522 }; 523 524 #include "sql_lex.h" /* Must be here */ 525 526 class Delayed_insert; 527 class select_result; 528 class Time_zone; 529 530 #define THD_SENTRY_MAGIC 0xfeedd1ff 531 #define THD_SENTRY_GONE 0xdeadbeef 532 533 #define THD_CHECK_SENTRY(thd) DBUG_ASSERT(thd->dbug_sentry == THD_SENTRY_MAGIC) 534 535 typedef struct system_variables 536 { 537 /* 538 How dynamically allocated system variables are handled: 539 540 The global_system_variables and max_system_variables are "authoritative" 541 They both should have the same 'version' and 'size'. 542 When attempting to access a dynamic variable, if the session version 543 is out of date, then the session version is updated and realloced if 544 neccessary and bytes copied from global to make up for missing data. 545 546 Note that one should use my_bool instead of bool here, as the variables 547 are used with my_getopt.c 548 */ 549 ulong dynamic_variables_version; 550 char* dynamic_variables_ptr; 551 uint dynamic_variables_head; /* largest valid variable offset */ 552 uint dynamic_variables_size; /* how many bytes are in use */ 553 554 ulonglong max_heap_table_size; 555 ulonglong tmp_memory_table_size; 556 ulonglong tmp_disk_table_size; 557 ulonglong long_query_time; 558 ulonglong max_statement_time; 559 ulonglong optimizer_switch; 560 sql_mode_t sql_mode; ///< which non-standard SQL behaviour should be enabled 561 sql_mode_t old_behavior; ///< which old SQL behaviour should be enabled 562 ulonglong option_bits; ///< OPTION_xxx constants, e.g. OPTION_PROFILING 563 ulonglong join_buff_space_limit; 564 ulonglong log_slow_filter; 565 ulonglong log_slow_verbosity; 566 ulonglong log_slow_disabled_statements; 567 ulonglong log_disabled_statements; 568 ulonglong bulk_insert_buff_size; 569 ulonglong join_buff_size; 570 ulonglong sortbuff_size; 571 ulonglong default_regex_flags; 572 ulonglong max_mem_used; 573 574 /** 575 Place holders to store Multi-source variables in sys_var.cc during 576 update and show of variables. 577 */ 578 ulonglong slave_skip_counter; 579 ulonglong max_relay_log_size; 580 581 ha_rows select_limit; 582 ha_rows max_join_size; 583 ha_rows expensive_subquery_limit; 584 ulong auto_increment_increment, auto_increment_offset; 585 #ifdef WITH_WSREP 586 /* 587 Stored values of the auto_increment_increment and auto_increment_offset 588 that are will be restored when wsrep_auto_increment_control will be set 589 to 'OFF', because the setting it to 'ON' leads to overwriting of the 590 original values (which are set by the user) by calculated ones (which 591 are based on the cluster size): 592 */ 593 ulong saved_auto_increment_increment, saved_auto_increment_offset; 594 #endif /* WITH_WSREP */ 595 uint eq_range_index_dive_limit; 596 ulong column_compression_zlib_strategy; 597 ulong lock_wait_timeout; 598 ulong join_cache_level; 599 ulong max_allowed_packet; 600 ulong max_error_count; 601 ulong max_length_for_sort_data; 602 ulong max_recursive_iterations; 603 ulong max_sort_length; 604 ulong max_tmp_tables; 605 ulong max_insert_delayed_threads; 606 ulong min_examined_row_limit; 607 ulong multi_range_count; 608 ulong net_buffer_length; 609 ulong net_interactive_timeout; 610 ulong net_read_timeout; 611 ulong net_retry_count; 612 ulong net_wait_timeout; 613 ulong net_write_timeout; 614 ulong optimizer_prune_level; 615 ulong optimizer_search_depth; 616 ulong optimizer_selectivity_sampling_limit; 617 ulong optimizer_use_condition_selectivity; 618 ulong use_stat_tables; 619 ulong histogram_size; 620 ulong histogram_type; 621 ulong preload_buff_size; 622 ulong profiling_history_size; 623 ulong read_buff_size; 624 ulong read_rnd_buff_size; 625 ulong mrr_buff_size; 626 ulong div_precincrement; 627 /* Total size of all buffers used by the subselect_rowid_merge_engine. */ 628 ulong rowid_merge_buff_size; 629 ulong max_sp_recursion_depth; 630 ulong default_week_format; 631 ulong max_seeks_for_key; 632 ulong range_alloc_block_size; 633 ulong query_alloc_block_size; 634 ulong query_prealloc_size; 635 ulong trans_alloc_block_size; 636 ulong trans_prealloc_size; 637 ulong log_warnings; 638 /* Flags for slow log filtering */ 639 ulong log_slow_rate_limit; 640 ulong binlog_format; ///< binlog format for this thd (see enum_binlog_format) 641 ulong binlog_row_image; 642 ulong progress_report_time; 643 ulong completion_type; 644 ulong query_cache_type; 645 ulong tx_isolation; 646 ulong updatable_views_with_limit; 647 ulong alter_algorithm; 648 int max_user_connections; 649 ulong server_id; 650 /** 651 In slave thread we need to know in behalf of which 652 thread the query is being run to replicate temp tables properly 653 */ 654 my_thread_id pseudo_thread_id; 655 /** 656 When replicating an event group with GTID, keep these values around so 657 slave binlog can receive the same GTID as the original. 658 */ 659 uint32 gtid_domain_id; 660 uint64 gtid_seq_no; 661 662 uint group_concat_max_len; 663 664 /** 665 Default transaction access mode. READ ONLY (true) or READ WRITE (false). 666 */ 667 my_bool tx_read_only; 668 my_bool low_priority_updates; 669 my_bool query_cache_wlock_invalidate; 670 my_bool keep_files_on_create; 671 672 my_bool old_mode; 673 my_bool old_passwords; 674 my_bool big_tables; 675 my_bool only_standard_compliant_cte; 676 my_bool query_cache_strip_comments; 677 my_bool sql_log_slow; 678 my_bool sql_log_bin; 679 /* 680 A flag to help detect whether binary logging was temporarily disabled 681 (see tmp_disable_binlog(A) macro). 682 */ 683 my_bool sql_log_bin_off; 684 my_bool binlog_annotate_row_events; 685 my_bool binlog_direct_non_trans_update; 686 my_bool column_compression_zlib_wrap; 687 688 plugin_ref table_plugin; 689 plugin_ref tmp_table_plugin; 690 plugin_ref enforced_table_plugin; 691 692 /* Only charset part of these variables is sensible */ 693 CHARSET_INFO *character_set_filesystem; 694 CHARSET_INFO *character_set_client; 695 CHARSET_INFO *character_set_results; 696 697 /* Both charset and collation parts of these variables are important */ 698 CHARSET_INFO *collation_server; 699 CHARSET_INFO *collation_database; 700 CHARSET_INFO *collation_connection; 701 702 /* Names. These will be allocated in buffers in thd */ 703 LEX_CSTRING default_master_connection; 704 705 /* Error messages */ 706 MY_LOCALE *lc_messages; 707 const char ***errmsgs; /* lc_messages->errmsg->errmsgs */ 708 709 /* Locale Support */ 710 MY_LOCALE *lc_time_names; 711 712 Time_zone *time_zone; 713 714 my_bool sysdate_is_now; 715 716 /* deadlock detection */ 717 ulong wt_timeout_short, wt_deadlock_search_depth_short; 718 ulong wt_timeout_long, wt_deadlock_search_depth_long; 719 720 my_bool wsrep_on; 721 my_bool wsrep_causal_reads; 722 my_bool wsrep_dirty_reads; 723 uint wsrep_sync_wait; 724 ulong wsrep_retry_autocommit; 725 ulong wsrep_OSU_method; 726 double long_query_time_double, max_statement_time_double; 727 728 my_bool pseudo_slave_mode; 729 730 char *session_track_system_variables; 731 ulong session_track_transaction_info; 732 my_bool session_track_schema; 733 my_bool session_track_state_change; 734 735 ulong threadpool_priority; 736 737 uint idle_transaction_timeout; 738 uint idle_readonly_transaction_timeout; 739 uint idle_write_transaction_timeout; 740 uint column_compression_threshold; 741 uint column_compression_zlib_level; 742 uint in_subquery_conversion_threshold; 743 744 vers_asof_timestamp_t vers_asof_timestamp; 745 ulong vers_alter_history; 746 } SV; 747 748 /** 749 Per thread status variables. 750 Must be long/ulong up to last_system_status_var so that 751 add_to_status/add_diff_to_status can work. 752 */ 753 754 typedef struct system_status_var 755 { 756 ulong column_compressions; 757 ulong column_decompressions; 758 ulong com_stat[(uint) SQLCOM_END]; 759 ulong com_create_tmp_table; 760 ulong com_drop_tmp_table; 761 ulong com_other; 762 ulong com_multi; 763 764 ulong com_stmt_prepare; 765 ulong com_stmt_reprepare; 766 ulong com_stmt_execute; 767 ulong com_stmt_send_long_data; 768 ulong com_stmt_fetch; 769 ulong com_stmt_reset; 770 ulong com_stmt_close; 771 772 ulong com_register_slave; 773 ulong created_tmp_disk_tables_; 774 ulong created_tmp_tables_; 775 ulong ha_commit_count; 776 ulong ha_delete_count; 777 ulong ha_read_first_count; 778 ulong ha_read_last_count; 779 ulong ha_read_key_count; 780 ulong ha_read_next_count; 781 ulong ha_read_prev_count; 782 ulong ha_read_retry_count; 783 ulong ha_read_rnd_count; 784 ulong ha_read_rnd_next_count; 785 ulong ha_read_rnd_deleted_count; 786 787 /* 788 This number doesn't include calls to the default implementation and 789 calls made by range access. The intent is to count only calls made by 790 BatchedKeyAccess. 791 */ 792 ulong ha_mrr_init_count; 793 ulong ha_mrr_key_refills_count; 794 ulong ha_mrr_rowid_refills_count; 795 796 ulong ha_rollback_count; 797 ulong ha_update_count; 798 ulong ha_write_count; 799 /* The following are for internal temporary tables */ 800 ulong ha_tmp_update_count; 801 ulong ha_tmp_write_count; 802 ulong ha_tmp_delete_count; 803 ulong ha_prepare_count; 804 ulong ha_icp_attempts; 805 ulong ha_icp_match; 806 ulong ha_discover_count; 807 ulong ha_savepoint_count; 808 ulong ha_savepoint_rollback_count; 809 ulong ha_external_lock_count; 810 811 ulong opened_tables; 812 ulong opened_shares; 813 ulong opened_views; /* +1 opening a view */ 814 815 ulong select_full_join_count_; 816 ulong select_full_range_join_count_; 817 ulong select_range_count_; 818 ulong select_range_check_count_; 819 ulong select_scan_count_; 820 ulong update_scan_count; 821 ulong delete_scan_count; 822 ulong executed_triggers; 823 ulong long_query_count; 824 ulong filesort_merge_passes_; 825 ulong filesort_range_count_; 826 ulong filesort_rows_; 827 ulong filesort_scan_count_; 828 ulong filesort_pq_sorts_; 829 830 /* Features used */ 831 ulong feature_custom_aggregate_functions; /* +1 when custom aggregate 832 functions are used */ 833 ulong feature_dynamic_columns; /* +1 when creating a dynamic column */ 834 ulong feature_fulltext; /* +1 when MATCH is used */ 835 ulong feature_gis; /* +1 opening a table with GIS features */ 836 ulong feature_invisible_columns; /* +1 opening a table with invisible column */ 837 ulong feature_json; /* +1 when JSON function appears in the statement */ 838 ulong feature_locale; /* +1 when LOCALE is set */ 839 ulong feature_subquery; /* +1 when subqueries are used */ 840 ulong feature_system_versioning; /* +1 opening a table WITH SYSTEM VERSIONING */ 841 ulong feature_timezone; /* +1 when XPATH is used */ 842 ulong feature_trigger; /* +1 opening a table with triggers */ 843 ulong feature_xml; /* +1 when XPATH is used */ 844 ulong feature_window_functions; /* +1 when window functions are used */ 845 846 /* From MASTER_GTID_WAIT usage */ 847 ulong master_gtid_wait_timeouts; /* Number of timeouts */ 848 ulong master_gtid_wait_time; /* Time in microseconds */ 849 ulong master_gtid_wait_count; 850 851 ulong empty_queries; 852 ulong access_denied_errors; 853 ulong lost_connections; 854 ulong max_statement_time_exceeded; 855 /* 856 Number of statements sent from the client 857 */ 858 ulong questions; 859 /* 860 IMPORTANT! 861 SEE last_system_status_var DEFINITION BELOW. 862 Below 'last_system_status_var' are all variables that cannot be handled 863 automatically by add_to_status()/add_diff_to_status(). 864 */ 865 ulonglong bytes_received; 866 ulonglong bytes_sent; 867 ulonglong rows_read; 868 ulonglong rows_sent; 869 ulonglong rows_tmp_read; 870 ulonglong binlog_bytes_written; 871 ulonglong table_open_cache_hits; 872 ulonglong table_open_cache_misses; 873 ulonglong table_open_cache_overflows; 874 double last_query_cost; 875 double cpu_time, busy_time; 876 uint32 threads_running; 877 /* Don't initialize */ 878 /* Memory used for thread local storage */ 879 int64 max_local_memory_used; 880 volatile int64 local_memory_used; 881 /* Memory allocated for global usage */ 882 volatile int64 global_memory_used; 883 } STATUS_VAR; 884 885 /* 886 This is used for 'SHOW STATUS'. It must be updated to the last ulong 887 variable in system_status_var which is makes sense to add to the global 888 counter 889 */ 890 891 #define last_system_status_var questions 892 #define last_cleared_system_status_var local_memory_used 893 894 /* 895 Global status variables 896 */ 897 898 extern ulong feature_files_opened_with_delayed_keys, feature_check_constraint; 899 900 void add_to_status(STATUS_VAR *to_var, STATUS_VAR *from_var); 901 902 void add_diff_to_status(STATUS_VAR *to_var, STATUS_VAR *from_var, 903 STATUS_VAR *dec_var); 904 905 uint calc_sum_of_all_status(STATUS_VAR *to); 906 static inline void calc_sum_of_all_status_if_needed(STATUS_VAR *to) 907 { 908 if (to->local_memory_used == 0) 909 { 910 mysql_mutex_lock(&LOCK_status); 911 *to= global_status_var; 912 mysql_mutex_unlock(&LOCK_status); 913 calc_sum_of_all_status(to); 914 DBUG_ASSERT(to->local_memory_used); 915 } 916 } 917 918 /* 919 Update global_memory_used. We have to do this with atomic_add as the 920 global value can change outside of LOCK_status. 921 */ 922 static inline void update_global_memory_status(int64 size) 923 { 924 DBUG_PRINT("info", ("global memory_used: %lld size: %lld", 925 (longlong) global_status_var.global_memory_used, 926 size)); 927 // workaround for gcc 4.2.4-1ubuntu4 -fPIE (from DEB_BUILD_HARDENING=1) 928 int64 volatile * volatile ptr= &global_status_var.global_memory_used; 929 my_atomic_add64_explicit(ptr, size, MY_MEMORY_ORDER_RELAXED); 930 } 931 932 /** 933 Get collation by name, send error to client on failure. 934 @param name Collation name 935 @param name_cs Character set of the name string 936 @return 937 @retval NULL on error 938 @retval Pointter to CHARSET_INFO with the given name on success 939 */ 940 static inline CHARSET_INFO * 941 mysqld_collation_get_by_name(const char *name, 942 CHARSET_INFO *name_cs= system_charset_info) 943 { 944 CHARSET_INFO *cs; 945 MY_CHARSET_LOADER loader; 946 my_charset_loader_init_mysys(&loader); 947 if (!(cs= my_collation_get_by_name(&loader, name, MYF(0)))) 948 { 949 ErrConvString err(name, name_cs); 950 my_error(ER_UNKNOWN_COLLATION, MYF(0), err.ptr()); 951 if (loader.error[0]) 952 push_warning_printf(current_thd, 953 Sql_condition::WARN_LEVEL_WARN, 954 ER_UNKNOWN_COLLATION, "%s", loader.error); 955 } 956 return cs; 957 } 958 959 static inline bool is_supported_parser_charset(CHARSET_INFO *cs) 960 { 961 return MY_TEST(cs->mbminlen == 1 && cs->number != 17 /* filename */); 962 } 963 964 #ifdef MYSQL_SERVER 965 966 void free_tmp_table(THD *thd, TABLE *entry); 967 968 969 /* The following macro is to make init of Query_arena simpler */ 970 #ifdef DBUG_ASSERT_EXISTS 971 #define INIT_ARENA_DBUG_INFO is_backup_arena= 0; is_reprepared= FALSE; 972 #else 973 #define INIT_ARENA_DBUG_INFO 974 #endif 975 976 class Query_arena 977 { 978 public: 979 /* 980 List of items created in the parser for this query. Every item puts 981 itself to the list on creation (see Item::Item() for details)) 982 */ 983 Item *free_list; 984 MEM_ROOT *mem_root; // Pointer to current memroot 985 #ifdef DBUG_ASSERT_EXISTS 986 bool is_backup_arena; /* True if this arena is used for backup. */ 987 bool is_reprepared; 988 #endif 989 /* 990 The states relfects three diffrent life cycles for three 991 different types of statements: 992 Prepared statement: STMT_INITIALIZED -> STMT_PREPARED -> STMT_EXECUTED. 993 Stored procedure: STMT_INITIALIZED_FOR_SP -> STMT_EXECUTED. 994 Other statements: STMT_CONVENTIONAL_EXECUTION never changes. 995 */ 996 enum enum_state 997 { 998 STMT_INITIALIZED= 0, STMT_INITIALIZED_FOR_SP= 1, STMT_PREPARED= 2, 999 STMT_CONVENTIONAL_EXECUTION= 3, STMT_EXECUTED= 4, STMT_ERROR= -1 1000 }; 1001 1002 enum_state state; 1003 1004 public: 1005 /* We build without RTTI, so dynamic_cast can't be used. */ 1006 enum Type 1007 { 1008 STATEMENT, PREPARED_STATEMENT, STORED_PROCEDURE, TABLE_ARENA 1009 }; 1010 1011 Query_arena(MEM_ROOT *mem_root_arg, enum enum_state state_arg) : 1012 free_list(0), mem_root(mem_root_arg), state(state_arg) 1013 { INIT_ARENA_DBUG_INFO; } 1014 /* 1015 This constructor is used only when Query_arena is created as 1016 backup storage for another instance of Query_arena. 1017 */ 1018 Query_arena() { INIT_ARENA_DBUG_INFO; } 1019 1020 virtual Type type() const; 1021 virtual ~Query_arena() {}; 1022 1023 inline bool is_stmt_prepare() const { return state == STMT_INITIALIZED; } 1024 inline bool is_stmt_prepare_or_first_sp_execute() const 1025 { return (int)state < (int)STMT_PREPARED; } 1026 inline bool is_stmt_prepare_or_first_stmt_execute() const 1027 { return (int)state <= (int)STMT_PREPARED; } 1028 inline bool is_stmt_execute() const 1029 { return state == STMT_PREPARED || state == STMT_EXECUTED; } 1030 inline bool is_conventional() const 1031 { return state == STMT_CONVENTIONAL_EXECUTION; } 1032 1033 inline void* alloc(size_t size) { return alloc_root(mem_root,size); } 1034 inline void* calloc(size_t size) 1035 { 1036 void *ptr; 1037 if (likely((ptr=alloc_root(mem_root,size)))) 1038 bzero(ptr, size); 1039 return ptr; 1040 } 1041 inline char *strdup(const char *str) 1042 { return strdup_root(mem_root,str); } 1043 inline char *strmake(const char *str, size_t size) 1044 { return strmake_root(mem_root,str,size); } 1045 inline void *memdup(const void *str, size_t size) 1046 { return memdup_root(mem_root,str,size); } 1047 inline void *memdup_w_gap(const void *str, size_t size, size_t gap) 1048 { 1049 void *ptr; 1050 if (likely((ptr= alloc_root(mem_root,size+gap)))) 1051 memcpy(ptr,str,size); 1052 return ptr; 1053 } 1054 1055 void set_query_arena(Query_arena *set); 1056 1057 void free_items(); 1058 /* Close the active state associated with execution of this statement */ 1059 virtual void cleanup_stmt(); 1060 }; 1061 1062 1063 class Query_arena_memroot: public Query_arena, public Sql_alloc 1064 { 1065 public: 1066 Query_arena_memroot(MEM_ROOT *mem_root_arg, enum enum_state state_arg) : 1067 Query_arena(mem_root_arg, state_arg) 1068 {} 1069 Query_arena_memroot() : Query_arena() 1070 {} 1071 1072 virtual ~Query_arena_memroot() {} 1073 }; 1074 1075 1076 class Query_arena_stmt 1077 { 1078 THD *thd; 1079 Query_arena backup; 1080 Query_arena *arena; 1081 1082 public: 1083 Query_arena_stmt(THD *_thd); 1084 ~Query_arena_stmt(); 1085 bool arena_replaced() 1086 { 1087 return arena != NULL; 1088 } 1089 }; 1090 1091 1092 class Server_side_cursor; 1093 1094 /** 1095 @class Statement 1096 @brief State of a single command executed against this connection. 1097 1098 One connection can contain a lot of simultaneously running statements, 1099 some of which could be: 1100 - prepared, that is, contain placeholders, 1101 - opened as cursors. We maintain 1 to 1 relationship between 1102 statement and cursor - if user wants to create another cursor for his 1103 query, we create another statement for it. 1104 To perform some action with statement we reset THD part to the state of 1105 that statement, do the action, and then save back modified state from THD 1106 to the statement. It will be changed in near future, and Statement will 1107 be used explicitly. 1108 */ 1109 1110 class Statement: public ilink, public Query_arena 1111 { 1112 Statement(const Statement &rhs); /* not implemented: */ 1113 Statement &operator=(const Statement &rhs); /* non-copyable */ 1114 public: 1115 /* 1116 Uniquely identifies each statement object in thread scope; change during 1117 statement lifetime. FIXME: must be const 1118 */ 1119 ulong id; 1120 1121 enum enum_column_usage column_usage; 1122 1123 LEX_CSTRING name; /* name for named prepared statements */ 1124 LEX *lex; // parse tree descriptor 1125 /* 1126 Points to the query associated with this statement. It's const, but 1127 we need to declare it char * because all table handlers are written 1128 in C and need to point to it. 1129 1130 Note that if we set query = NULL, we must at the same time set 1131 query_length = 0, and protect the whole operation with 1132 LOCK_thd_data mutex. To avoid crashes in races, if we do not 1133 know that thd->query cannot change at the moment, we should print 1134 thd->query like this: 1135 (1) reserve the LOCK_thd_data mutex; 1136 (2) print or copy the value of query and query_length 1137 (3) release LOCK_thd_data mutex. 1138 This printing is needed at least in SHOW PROCESSLIST and SHOW 1139 ENGINE INNODB STATUS. 1140 */ 1141 CSET_STRING query_string; 1142 /* 1143 If opt_query_cache_strip_comments is set, this contains query without 1144 comments. If not set, it contains pointer to query_string. 1145 */ 1146 String base_query; 1147 1148 1149 inline char *query() const { return query_string.str(); } 1150 inline uint32 query_length() const 1151 { 1152 return static_cast<uint32>(query_string.length()); 1153 } 1154 inline char *query_end() const 1155 { 1156 return query_string.str() + query_string.length(); 1157 } 1158 CHARSET_INFO *query_charset() const { return query_string.charset(); } 1159 void set_query_inner(const CSET_STRING &string_arg) 1160 { 1161 query_string= string_arg; 1162 } 1163 void set_query_inner(char *query_arg, uint32 query_length_arg, 1164 CHARSET_INFO *cs_arg) 1165 { 1166 set_query_inner(CSET_STRING(query_arg, query_length_arg, cs_arg)); 1167 } 1168 void reset_query_inner() 1169 { 1170 set_query_inner(CSET_STRING()); 1171 } 1172 /** 1173 Name of the current (default) database. 1174 1175 If there is the current (default) database, "db.str" contains its name. If 1176 there is no current (default) database, "db.str" is NULL and "db.length" is 1177 0. In other words, db must either be NULL, or contain a 1178 valid database name. 1179 */ 1180 1181 LEX_CSTRING db; 1182 1183 /* This is set to 1 of last call to send_result_to_client() was ok */ 1184 my_bool query_cache_is_applicable; 1185 1186 /* This constructor is called for backup statements */ 1187 Statement() {} 1188 1189 Statement(LEX *lex_arg, MEM_ROOT *mem_root_arg, 1190 enum enum_state state_arg, ulong id_arg); 1191 virtual ~Statement(); 1192 1193 /* Assign execution context (note: not all members) of given stmt to self */ 1194 virtual void set_statement(Statement *stmt); 1195 void set_n_backup_statement(Statement *stmt, Statement *backup); 1196 void restore_backup_statement(Statement *stmt, Statement *backup); 1197 /* return class type */ 1198 virtual Type type() const; 1199 }; 1200 1201 1202 /** 1203 Container for all statements created/used in a connection. 1204 Statements in Statement_map have unique Statement::id (guaranteed by id 1205 assignment in Statement::Statement) 1206 Non-empty statement names are unique too: attempt to insert a new statement 1207 with duplicate name causes older statement to be deleted 1208 1209 Statements are auto-deleted when they are removed from the map and when the 1210 map is deleted. 1211 */ 1212 1213 class Statement_map 1214 { 1215 public: 1216 Statement_map(); 1217 1218 int insert(THD *thd, Statement *statement); 1219 1220 Statement *find_by_name(LEX_CSTRING *name) 1221 { 1222 Statement *stmt; 1223 stmt= (Statement*)my_hash_search(&names_hash, (uchar*)name->str, 1224 name->length); 1225 return stmt; 1226 } 1227 1228 Statement *find(ulong id) 1229 { 1230 if (last_found_statement == 0 || id != last_found_statement->id) 1231 { 1232 Statement *stmt; 1233 stmt= (Statement *) my_hash_search(&st_hash, (uchar *) &id, sizeof(id)); 1234 if (stmt && stmt->name.str) 1235 return NULL; 1236 last_found_statement= stmt; 1237 } 1238 return last_found_statement; 1239 } 1240 /* 1241 Close all cursors of this connection that use tables of a storage 1242 engine that has transaction-specific state and therefore can not 1243 survive COMMIT or ROLLBACK. Currently all but MyISAM cursors are closed. 1244 */ 1245 void close_transient_cursors(); 1246 void erase(Statement *statement); 1247 /* Erase all statements (calls Statement destructor) */ 1248 void reset(); 1249 ~Statement_map(); 1250 private: 1251 HASH st_hash; 1252 HASH names_hash; 1253 I_List<Statement> transient_cursor_list; 1254 Statement *last_found_statement; 1255 }; 1256 1257 struct st_savepoint { 1258 struct st_savepoint *prev; 1259 char *name; 1260 uint length; 1261 Ha_trx_info *ha_list; 1262 /** State of metadata locks before this savepoint was set. */ 1263 MDL_savepoint mdl_savepoint; 1264 }; 1265 1266 enum xa_states {XA_NOTR=0, XA_ACTIVE, XA_IDLE, XA_PREPARED, XA_ROLLBACK_ONLY}; 1267 extern const char *xa_state_names[]; 1268 class XID_cache_element; 1269 1270 typedef struct st_xid_state { 1271 /* For now, this is only used to catch duplicated external xids */ 1272 XID xid; // transaction identifier 1273 enum xa_states xa_state; // used by external XA only 1274 /* Error reported by the Resource Manager (RM) to the Transaction Manager. */ 1275 uint rm_error; 1276 XID_cache_element *xid_cache_element; 1277 1278 /** 1279 Check that XA transaction has an uncommitted work. Report an error 1280 to the user in case when there is an uncommitted work for XA transaction. 1281 1282 @return result of check 1283 @retval false XA transaction is NOT in state IDLE, PREPARED 1284 or ROLLBACK_ONLY. 1285 @retval true XA transaction is in state IDLE or PREPARED 1286 or ROLLBACK_ONLY. 1287 */ 1288 1289 bool check_has_uncommitted_xa() const 1290 { 1291 if (xa_state == XA_IDLE || 1292 xa_state == XA_PREPARED || 1293 xa_state == XA_ROLLBACK_ONLY) 1294 { 1295 my_error(ER_XAER_RMFAIL, MYF(0), xa_state_names[xa_state]); 1296 return true; 1297 } 1298 return false; 1299 } 1300 } XID_STATE; 1301 1302 void xid_cache_init(void); 1303 void xid_cache_free(void); 1304 XID_STATE *xid_cache_search(THD *thd, XID *xid); 1305 bool xid_cache_insert(XID *xid, enum xa_states xa_state); 1306 bool xid_cache_insert(THD *thd, XID_STATE *xid_state); 1307 void xid_cache_delete(THD *thd, XID_STATE *xid_state); 1308 int xid_cache_iterate(THD *thd, my_hash_walk_action action, void *argument); 1309 1310 /** 1311 @class Security_context 1312 @brief A set of THD members describing the current authenticated user. 1313 */ 1314 1315 class Security_context { 1316 public: 1317 Security_context() {} /* Remove gcc warning */ 1318 /* 1319 host - host of the client 1320 user - user of the client, set to NULL until the user has been read from 1321 the connection 1322 priv_user - The user privilege we are using. May be "" for anonymous user. 1323 ip - client IP 1324 */ 1325 const char *host; 1326 const char *user, *ip; 1327 char priv_user[USERNAME_LENGTH]; 1328 char proxy_user[USERNAME_LENGTH + MAX_HOSTNAME + 5]; 1329 /* The host privilege we are using */ 1330 char priv_host[MAX_HOSTNAME]; 1331 /* The role privilege we are using */ 1332 char priv_role[USERNAME_LENGTH]; 1333 /* The external user (if available) */ 1334 char *external_user; 1335 /* points to host if host is available, otherwise points to ip */ 1336 const char *host_or_ip; 1337 ulong master_access; /* Global privileges from mysql.user */ 1338 ulong db_access; /* Privileges for current db */ 1339 1340 void init(); 1341 void destroy(); 1342 void skip_grants(); 1343 inline char *priv_host_name() 1344 { 1345 return (*priv_host ? priv_host : (char *)"%"); 1346 } 1347 1348 bool set_user(char *user_arg); 1349 1350 #ifndef NO_EMBEDDED_ACCESS_CHECKS 1351 bool 1352 change_security_context(THD *thd, 1353 LEX_CSTRING *definer_user, 1354 LEX_CSTRING *definer_host, 1355 LEX_CSTRING *db, 1356 Security_context **backup); 1357 1358 void 1359 restore_security_context(THD *thd, Security_context *backup); 1360 #endif 1361 bool user_matches(Security_context *); 1362 }; 1363 1364 1365 /** 1366 A registry for item tree transformations performed during 1367 query optimization. We register only those changes which require 1368 a rollback to re-execute a prepared statement or stored procedure 1369 yet another time. 1370 */ 1371 1372 struct Item_change_record; 1373 class Item_change_list 1374 { 1375 I_List<Item_change_record> change_list; 1376 public: 1377 void nocheck_register_item_tree_change(Item **place, Item *old_value, 1378 MEM_ROOT *runtime_memroot); 1379 void check_and_register_item_tree_change(Item **place, Item **new_value, 1380 MEM_ROOT *runtime_memroot); 1381 void rollback_item_tree_changes(); 1382 void move_elements_to(Item_change_list *to) 1383 { 1384 change_list.move_elements_to(&to->change_list); 1385 } 1386 bool is_empty() { return change_list.is_empty(); } 1387 }; 1388 1389 1390 class Item_change_list_savepoint: public Item_change_list 1391 { 1392 public: 1393 Item_change_list_savepoint(Item_change_list *list) 1394 { 1395 list->move_elements_to(this); 1396 } 1397 void rollback(Item_change_list *list) 1398 { 1399 list->rollback_item_tree_changes(); 1400 move_elements_to(list); 1401 } 1402 ~Item_change_list_savepoint() 1403 { 1404 DBUG_ASSERT(is_empty()); 1405 } 1406 }; 1407 1408 1409 /** 1410 Type of locked tables mode. 1411 See comment for THD::locked_tables_mode for complete description. 1412 */ 1413 1414 enum enum_locked_tables_mode 1415 { 1416 LTM_NONE= 0, 1417 LTM_LOCK_TABLES, 1418 LTM_PRELOCKED, 1419 LTM_PRELOCKED_UNDER_LOCK_TABLES, 1420 LTM_always_last 1421 }; 1422 1423 /** 1424 The following structure is an extension to TABLE_SHARE and is 1425 exclusively for temporary tables. 1426 1427 @note: 1428 Although, TDC_element has data members (like next, prev & 1429 all_tables) to store the list of TABLE_SHARE & TABLE objects 1430 related to a particular TABLE_SHARE, they cannot be moved to 1431 TABLE_SHARE in order to be reused for temporary tables. This 1432 is because, as concurrent threads iterating through hash of 1433 TDC_element's may need access to all_tables, but if all_tables 1434 is made part of TABLE_SHARE, then TDC_element->share->all_tables 1435 is not always guaranteed to be valid, as TDC_element can live 1436 longer than TABLE_SHARE. 1437 */ 1438 struct TMP_TABLE_SHARE : public TABLE_SHARE 1439 { 1440 private: 1441 /* 1442 Link to all temporary table shares. Declared as private to 1443 avoid direct manipulation with those objects. One should 1444 use methods of I_P_List template instead. 1445 */ 1446 TMP_TABLE_SHARE *tmp_next; 1447 TMP_TABLE_SHARE **tmp_prev; 1448 1449 friend struct All_tmp_table_shares; 1450 1451 public: 1452 /* 1453 Doubly-linked (back-linked) lists of used and unused TABLE objects 1454 for this share. 1455 */ 1456 All_share_tables_list all_tmp_tables; 1457 }; 1458 1459 /** 1460 Helper class which specifies which members of TMP_TABLE_SHARE are 1461 used for participation in the list of temporary tables. 1462 */ 1463 1464 struct All_tmp_table_shares 1465 { 1466 static inline TMP_TABLE_SHARE **next_ptr(TMP_TABLE_SHARE *l) 1467 { 1468 return &l->tmp_next; 1469 } 1470 static inline TMP_TABLE_SHARE ***prev_ptr(TMP_TABLE_SHARE *l) 1471 { 1472 return &l->tmp_prev; 1473 } 1474 }; 1475 1476 /* Also used in rpl_rli.h. */ 1477 typedef I_P_List <TMP_TABLE_SHARE, All_tmp_table_shares> All_tmp_tables_list; 1478 1479 /** 1480 Class that holds information about tables which were opened and locked 1481 by the thread. It is also used to save/restore this information in 1482 push_open_tables_state()/pop_open_tables_state(). 1483 */ 1484 1485 class Open_tables_state 1486 { 1487 public: 1488 /** 1489 As part of class THD, this member is set during execution 1490 of a prepared statement. When it is set, it is used 1491 by the locking subsystem to report a change in table metadata. 1492 1493 When Open_tables_state part of THD is reset to open 1494 a system or INFORMATION_SCHEMA table, the member is cleared 1495 to avoid spurious ER_NEED_REPREPARE errors -- system and 1496 INFORMATION_SCHEMA tables are not subject to metadata version 1497 tracking. 1498 @sa check_and_update_table_version() 1499 */ 1500 Reprepare_observer *m_reprepare_observer; 1501 1502 /** 1503 List of regular tables in use by this thread. Contains temporary and 1504 base tables that were opened with @see open_tables(). 1505 */ 1506 TABLE *open_tables; 1507 1508 /** 1509 A list of temporary tables used by this thread. This includes 1510 user-level temporary tables, created with CREATE TEMPORARY TABLE, 1511 and internal temporary tables, created, e.g., to resolve a SELECT, 1512 or for an intermediate table used in ALTER. 1513 */ 1514 All_tmp_tables_list *temporary_tables; 1515 1516 /* 1517 Derived tables. 1518 */ 1519 TABLE *derived_tables; 1520 1521 /* 1522 Temporary tables created for recursive table references. 1523 */ 1524 TABLE *rec_tables; 1525 1526 /* 1527 During a MySQL session, one can lock tables in two modes: automatic 1528 or manual. In automatic mode all necessary tables are locked just before 1529 statement execution, and all acquired locks are stored in 'lock' 1530 member. Unlocking takes place automatically as well, when the 1531 statement ends. 1532 Manual mode comes into play when a user issues a 'LOCK TABLES' 1533 statement. In this mode the user can only use the locked tables. 1534 Trying to use any other tables will give an error. 1535 The locked tables are also stored in this member, however, 1536 thd->locked_tables_mode is turned on. Manual locking is described in 1537 the 'LOCK_TABLES' chapter of the MySQL manual. 1538 See also lock_tables() for details. 1539 */ 1540 MYSQL_LOCK *lock; 1541 1542 /* 1543 CREATE-SELECT keeps an extra lock for the table being 1544 created. This field is used to keep the extra lock available for 1545 lower level routines, which would otherwise miss that lock. 1546 */ 1547 MYSQL_LOCK *extra_lock; 1548 1549 /* 1550 Enum enum_locked_tables_mode and locked_tables_mode member are 1551 used to indicate whether the so-called "locked tables mode" is on, 1552 and what kind of mode is active. 1553 1554 Locked tables mode is used when it's necessary to open and 1555 lock many tables at once, for usage across multiple 1556 (sub-)statements. 1557 This may be necessary either for queries that use stored functions 1558 and triggers, in which case the statements inside functions and 1559 triggers may be executed many times, or for implementation of 1560 LOCK TABLES, in which case the opened tables are reused by all 1561 subsequent statements until a call to UNLOCK TABLES. 1562 1563 The kind of locked tables mode employed for stored functions and 1564 triggers is also called "prelocked mode". 1565 In this mode, first open_tables() call to open the tables used 1566 in a statement analyses all functions used by the statement 1567 and adds all indirectly used tables to the list of tables to 1568 open and lock. 1569 It also marks the parse tree of the statement as requiring 1570 prelocking. After that, lock_tables() locks the entire list 1571 of tables and changes THD::locked_tables_modeto LTM_PRELOCKED. 1572 All statements executed inside functions or triggers 1573 use the prelocked tables, instead of opening their own ones. 1574 Prelocked mode is turned off automatically once close_thread_tables() 1575 of the main statement is called. 1576 */ 1577 enum enum_locked_tables_mode locked_tables_mode; 1578 uint current_tablenr; 1579 1580 enum enum_flags { 1581 BACKUPS_AVAIL = (1U << 0) /* There are backups available */ 1582 }; 1583 1584 /* 1585 Flags with information about the open tables state. 1586 */ 1587 uint state_flags; 1588 /** 1589 This constructor initializes Open_tables_state instance which can only 1590 be used as backup storage. To prepare Open_tables_state instance for 1591 operations which open/lock/close tables (e.g. open_table()) one has to 1592 call init_open_tables_state(). 1593 */ 1594 Open_tables_state() : state_flags(0U) { } 1595 1596 void set_open_tables_state(Open_tables_state *state) 1597 { 1598 *this= *state; 1599 } 1600 1601 void reset_open_tables_state(THD *thd) 1602 { 1603 open_tables= 0; 1604 temporary_tables= 0; 1605 derived_tables= 0; 1606 rec_tables= 0; 1607 extra_lock= 0; 1608 lock= 0; 1609 locked_tables_mode= LTM_NONE; 1610 state_flags= 0U; 1611 m_reprepare_observer= NULL; 1612 } 1613 }; 1614 1615 1616 /** 1617 Storage for backup of Open_tables_state. Must 1618 be used only to open system tables (TABLE_CATEGORY_SYSTEM 1619 and TABLE_CATEGORY_LOG). 1620 */ 1621 1622 class Open_tables_backup: public Open_tables_state 1623 { 1624 public: 1625 /** 1626 When we backup the open tables state to open a system 1627 table or tables, we want to save state of metadata 1628 locks which were acquired before the backup. It is used 1629 to release metadata locks on system tables after they are 1630 no longer used. 1631 */ 1632 MDL_savepoint mdl_system_tables_svp; 1633 }; 1634 1635 /** 1636 @class Sub_statement_state 1637 @brief Used to save context when executing a function or trigger 1638 1639 operations on stat tables aren't technically a sub-statement, but they are 1640 similar in a sense that they cannot change the transaction status. 1641 */ 1642 1643 /* Defines used for Sub_statement_state::in_sub_stmt */ 1644 1645 #define SUB_STMT_TRIGGER 1 1646 #define SUB_STMT_FUNCTION 2 1647 #define SUB_STMT_STAT_TABLES 4 1648 1649 1650 class Sub_statement_state 1651 { 1652 public: 1653 Discrete_interval auto_inc_interval_for_cur_row; 1654 Discrete_intervals_list auto_inc_intervals_forced; 1655 SAVEPOINT *savepoints; 1656 ulonglong option_bits; 1657 ulonglong first_successful_insert_id_in_prev_stmt; 1658 ulonglong first_successful_insert_id_in_cur_stmt, insert_id_for_cur_row; 1659 ulonglong limit_found_rows; 1660 ulonglong tmp_tables_size; 1661 ulonglong client_capabilities; 1662 ulonglong cuted_fields, sent_row_count, examined_row_count; 1663 ulonglong affected_rows; 1664 ulonglong bytes_sent_old; 1665 ulong tmp_tables_used; 1666 ulong tmp_tables_disk_used; 1667 ulong query_plan_fsort_passes; 1668 ulong query_plan_flags; 1669 uint in_sub_stmt; /* 0, SUB_STMT_TRIGGER or SUB_STMT_FUNCTION */ 1670 bool enable_slow_log; 1671 bool last_insert_id_used; 1672 enum enum_check_fields count_cuted_fields; 1673 }; 1674 1675 1676 /* Flags for the THD::system_thread variable */ 1677 enum enum_thread_type 1678 { 1679 NON_SYSTEM_THREAD= 0, 1680 SYSTEM_THREAD_DELAYED_INSERT= 1, 1681 SYSTEM_THREAD_SLAVE_IO= 2, 1682 SYSTEM_THREAD_SLAVE_SQL= 4, 1683 SYSTEM_THREAD_EVENT_SCHEDULER= 8, 1684 SYSTEM_THREAD_EVENT_WORKER= 16, 1685 SYSTEM_THREAD_BINLOG_BACKGROUND= 32, 1686 SYSTEM_THREAD_SLAVE_BACKGROUND= 64, 1687 SYSTEM_THREAD_GENERIC= 128, 1688 SYSTEM_THREAD_SEMISYNC_MASTER_BACKGROUND= 256 1689 }; 1690 1691 inline char const * 1692 show_system_thread(enum_thread_type thread) 1693 { 1694 #define RETURN_NAME_AS_STRING(NAME) case (NAME): return #NAME 1695 switch (thread) { 1696 static char buf[64]; 1697 RETURN_NAME_AS_STRING(NON_SYSTEM_THREAD); 1698 RETURN_NAME_AS_STRING(SYSTEM_THREAD_DELAYED_INSERT); 1699 RETURN_NAME_AS_STRING(SYSTEM_THREAD_SLAVE_IO); 1700 RETURN_NAME_AS_STRING(SYSTEM_THREAD_SLAVE_SQL); 1701 RETURN_NAME_AS_STRING(SYSTEM_THREAD_EVENT_SCHEDULER); 1702 RETURN_NAME_AS_STRING(SYSTEM_THREAD_EVENT_WORKER); 1703 RETURN_NAME_AS_STRING(SYSTEM_THREAD_SLAVE_BACKGROUND); 1704 RETURN_NAME_AS_STRING(SYSTEM_THREAD_SEMISYNC_MASTER_BACKGROUND); 1705 default: 1706 sprintf(buf, "<UNKNOWN SYSTEM THREAD: %d>", thread); 1707 return buf; 1708 } 1709 #undef RETURN_NAME_AS_STRING 1710 } 1711 1712 /** 1713 This class represents the interface for internal error handlers. 1714 Internal error handlers are exception handlers used by the server 1715 implementation. 1716 */ 1717 1718 class Internal_error_handler 1719 { 1720 protected: 1721 Internal_error_handler() : 1722 m_prev_internal_handler(NULL) 1723 {} 1724 1725 virtual ~Internal_error_handler() {} 1726 1727 public: 1728 /** 1729 Handle a sql condition. 1730 This method can be implemented by a subclass to achieve any of the 1731 following: 1732 - mask a warning/error internally, prevent exposing it to the user, 1733 - mask a warning/error and throw another one instead. 1734 When this method returns true, the sql condition is considered 1735 'handled', and will not be propagated to upper layers. 1736 It is the responsability of the code installing an internal handler 1737 to then check for trapped conditions, and implement logic to recover 1738 from the anticipated conditions trapped during runtime. 1739 1740 This mechanism is similar to C++ try/throw/catch: 1741 - 'try' correspond to <code>THD::push_internal_handler()</code>, 1742 - 'throw' correspond to <code>my_error()</code>, 1743 which invokes <code>my_message_sql()</code>, 1744 - 'catch' correspond to checking how/if an internal handler was invoked, 1745 before removing it from the exception stack with 1746 <code>THD::pop_internal_handler()</code>. 1747 1748 @param thd the calling thread 1749 @param cond the condition raised. 1750 @return true if the condition is handled 1751 */ 1752 virtual bool handle_condition(THD *thd, 1753 uint sql_errno, 1754 const char* sqlstate, 1755 Sql_condition::enum_warning_level *level, 1756 const char* msg, 1757 Sql_condition ** cond_hdl) = 0; 1758 1759 private: 1760 Internal_error_handler *m_prev_internal_handler; 1761 friend class THD; 1762 }; 1763 1764 1765 /** 1766 Implements the trivial error handler which cancels all error states 1767 and prevents an SQLSTATE to be set. 1768 */ 1769 1770 class Dummy_error_handler : public Internal_error_handler 1771 { 1772 public: 1773 bool handle_condition(THD *thd, 1774 uint sql_errno, 1775 const char* sqlstate, 1776 Sql_condition::enum_warning_level *level, 1777 const char* msg, 1778 Sql_condition ** cond_hdl) 1779 { 1780 /* Ignore error */ 1781 return TRUE; 1782 } 1783 Dummy_error_handler() {} /* Remove gcc warning */ 1784 }; 1785 1786 1787 /** 1788 Implements the trivial error handler which counts errors as they happen. 1789 */ 1790 1791 class Counting_error_handler : public Internal_error_handler 1792 { 1793 public: 1794 int errors; 1795 bool handle_condition(THD *thd, 1796 uint sql_errno, 1797 const char* sqlstate, 1798 Sql_condition::enum_warning_level *level, 1799 const char* msg, 1800 Sql_condition ** cond_hdl) 1801 { 1802 if (*level == Sql_condition::WARN_LEVEL_ERROR) 1803 errors++; 1804 return false; 1805 } 1806 Counting_error_handler() : errors(0) {} 1807 }; 1808 1809 1810 /** 1811 This class is an internal error handler implementation for 1812 DROP TABLE statements. The thing is that there may be warnings during 1813 execution of these statements, which should not be exposed to the user. 1814 This class is intended to silence such warnings. 1815 */ 1816 1817 class Drop_table_error_handler : public Internal_error_handler 1818 { 1819 public: 1820 Drop_table_error_handler() {} 1821 1822 public: 1823 bool handle_condition(THD *thd, 1824 uint sql_errno, 1825 const char* sqlstate, 1826 Sql_condition::enum_warning_level *level, 1827 const char* msg, 1828 Sql_condition ** cond_hdl); 1829 1830 private: 1831 }; 1832 1833 1834 /** 1835 Internal error handler to process an error from MDL_context::upgrade_lock() 1836 and mysql_lock_tables(). Used by implementations of HANDLER READ and 1837 LOCK TABLES LOCAL. 1838 */ 1839 1840 class MDL_deadlock_and_lock_abort_error_handler: public Internal_error_handler 1841 { 1842 public: 1843 virtual 1844 bool handle_condition(THD *thd, 1845 uint sql_errno, 1846 const char *sqlstate, 1847 Sql_condition::enum_warning_level *level, 1848 const char* msg, 1849 Sql_condition **cond_hdl); 1850 1851 bool need_reopen() const { return m_need_reopen; }; 1852 void init() { m_need_reopen= FALSE; }; 1853 private: 1854 bool m_need_reopen; 1855 }; 1856 1857 1858 /** 1859 Tables that were locked with LOCK TABLES statement. 1860 1861 Encapsulates a list of TABLE_LIST instances for tables 1862 locked by LOCK TABLES statement, memory root for metadata locks, 1863 and, generally, the context of LOCK TABLES statement. 1864 1865 In LOCK TABLES mode, the locked tables are kept open between 1866 statements. 1867 Therefore, we can't allocate metadata locks on execution memory 1868 root -- as well as tables, the locks need to stay around till 1869 UNLOCK TABLES is called. 1870 The locks are allocated in the memory root encapsulated in this 1871 class. 1872 1873 Some SQL commands, like FLUSH TABLE or ALTER TABLE, demand that 1874 the tables they operate on are closed, at least temporarily. 1875 This class encapsulates a list of TABLE_LIST instances, one 1876 for each base table from LOCK TABLES list, 1877 which helps conveniently close the TABLEs when it's necessary 1878 and later reopen them. 1879 1880 Implemented in sql_base.cc 1881 */ 1882 1883 class Locked_tables_list 1884 { 1885 public: 1886 MEM_ROOT m_locked_tables_root; 1887 private: 1888 TABLE_LIST *m_locked_tables; 1889 TABLE_LIST **m_locked_tables_last; 1890 /** An auxiliary array used only in reopen_tables(). */ 1891 TABLE_LIST **m_reopen_array; 1892 /** 1893 Count the number of tables in m_locked_tables list. We can't 1894 rely on thd->lock->table_count because it excludes 1895 non-transactional temporary tables. We need to know 1896 an exact number of TABLE objects. 1897 */ 1898 uint m_locked_tables_count; 1899 public: 1900 bool some_table_marked_for_reopen; 1901 1902 Locked_tables_list() 1903 :m_locked_tables(NULL), 1904 m_locked_tables_last(&m_locked_tables), 1905 m_reopen_array(NULL), 1906 m_locked_tables_count(0), 1907 some_table_marked_for_reopen(0) 1908 { 1909 init_sql_alloc(&m_locked_tables_root, "Locked_tables_list", 1910 MEM_ROOT_BLOCK_SIZE, 0, 1911 MYF(MY_THREAD_SPECIFIC)); 1912 } 1913 void unlock_locked_tables(THD *thd); 1914 void unlock_locked_table(THD *thd, MDL_ticket *mdl_ticket); 1915 ~Locked_tables_list() 1916 { 1917 reset(); 1918 } 1919 void reset(); 1920 bool init_locked_tables(THD *thd); 1921 TABLE_LIST *locked_tables() { return m_locked_tables; } 1922 void unlink_from_list(THD *thd, TABLE_LIST *table_list, 1923 bool remove_from_locked_tables); 1924 void unlink_all_closed_tables(THD *thd, 1925 MYSQL_LOCK *lock, 1926 size_t reopen_count); 1927 bool reopen_tables(THD *thd, bool need_reopen); 1928 bool restore_lock(THD *thd, TABLE_LIST *dst_table_list, TABLE *table, 1929 MYSQL_LOCK *lock); 1930 void add_back_last_deleted_lock(TABLE_LIST *dst_table_list); 1931 void mark_table_for_reopen(THD *thd, TABLE *table); 1932 }; 1933 1934 1935 /** 1936 Storage engine specific thread local data. 1937 */ 1938 1939 struct Ha_data 1940 { 1941 /** 1942 Storage engine specific thread local data. 1943 Lifetime: one user connection. 1944 */ 1945 void *ha_ptr; 1946 /** 1947 0: Life time: one statement within a transaction. If @@autocommit is 1948 on, also represents the entire transaction. 1949 @sa trans_register_ha() 1950 1951 1: Life time: one transaction within a connection. 1952 If the storage engine does not participate in a transaction, 1953 this should not be used. 1954 @sa trans_register_ha() 1955 */ 1956 Ha_trx_info ha_info[2]; 1957 /** 1958 NULL: engine is not bound to this thread 1959 non-NULL: engine is bound to this thread, engine shutdown forbidden 1960 */ 1961 plugin_ref lock; 1962 Ha_data() :ha_ptr(NULL) {} 1963 }; 1964 1965 /** 1966 An instance of the global read lock in a connection. 1967 Implemented in lock.cc. 1968 */ 1969 1970 class Global_read_lock 1971 { 1972 public: 1973 enum enum_grl_state 1974 { 1975 GRL_NONE, 1976 GRL_ACQUIRED, 1977 GRL_ACQUIRED_AND_BLOCKS_COMMIT 1978 }; 1979 1980 Global_read_lock() 1981 : m_state(GRL_NONE), 1982 m_mdl_global_shared_lock(NULL), 1983 m_mdl_blocks_commits_lock(NULL) 1984 {} 1985 1986 bool lock_global_read_lock(THD *thd); 1987 void unlock_global_read_lock(THD *thd); 1988 /** 1989 Check if this connection can acquire protection against GRL and 1990 emit error if otherwise. 1991 */ 1992 bool can_acquire_protection() const 1993 { 1994 if (m_state) 1995 { 1996 my_error(ER_CANT_UPDATE_WITH_READLOCK, MYF(0)); 1997 return TRUE; 1998 } 1999 return FALSE; 2000 } 2001 bool make_global_read_lock_block_commit(THD *thd); 2002 bool is_acquired() const { return m_state != GRL_NONE; } 2003 void set_explicit_lock_duration(THD *thd); 2004 private: 2005 enum_grl_state m_state; 2006 /** 2007 In order to acquire the global read lock, the connection must 2008 acquire shared metadata lock in GLOBAL namespace, to prohibit 2009 all DDL. 2010 */ 2011 MDL_ticket *m_mdl_global_shared_lock; 2012 /** 2013 Also in order to acquire the global read lock, the connection 2014 must acquire a shared metadata lock in COMMIT namespace, to 2015 prohibit commits. 2016 */ 2017 MDL_ticket *m_mdl_blocks_commits_lock; 2018 }; 2019 2020 2021 /* 2022 Class to facilitate the commit of one transactions waiting for the commit of 2023 another transaction to complete first. 2024 2025 This is used during (parallel) replication, to allow different transactions 2026 to be applied in parallel, but still commit in order. 2027 2028 The transaction that wants to wait for a prior commit must first register 2029 to wait with register_wait_for_prior_commit(waitee). Such registration 2030 must be done holding the waitee->LOCK_wait_commit, to prevent the other 2031 THD from disappearing during the registration. 2032 2033 Then during commit, if a THD is registered to wait, it will call 2034 wait_for_prior_commit() as part of ha_commit_trans(). If no wait is 2035 registered, or if the waitee for has already completed commit, then 2036 wait_for_prior_commit() returns immediately. 2037 2038 And when a THD that may be waited for has completed commit (more precisely 2039 commit_ordered()), then it must call wakeup_subsequent_commits() to wake 2040 up any waiters. Note that this must be done at a point that is guaranteed 2041 to be later than any waiters registering themselves. It is safe to call 2042 wakeup_subsequent_commits() multiple times, as waiters are removed from 2043 registration as part of the wakeup. 2044 2045 The reason for separate register and wait calls is that this allows to 2046 register the wait early, at a point where the waited-for THD is known to 2047 exist. And then the actual wait can be done much later, where the 2048 waited-for THD may have been long gone. By registering early, the waitee 2049 can signal before disappearing. 2050 */ 2051 struct wait_for_commit 2052 { 2053 /* 2054 The LOCK_wait_commit protects the fields subsequent_commits_list and 2055 wakeup_subsequent_commits_running (for a waitee), and the pointer 2056 waiterr and associated COND_wait_commit (for a waiter). 2057 */ 2058 mysql_mutex_t LOCK_wait_commit; 2059 mysql_cond_t COND_wait_commit; 2060 /* List of threads that did register_wait_for_prior_commit() on us. */ 2061 wait_for_commit *subsequent_commits_list; 2062 /* Link field for entries in subsequent_commits_list. */ 2063 wait_for_commit *next_subsequent_commit; 2064 /* 2065 Our waitee, if we did register_wait_for_prior_commit(), and were not 2066 yet woken up. Else NULL. 2067 2068 When this is cleared for wakeup, the COND_wait_commit condition is 2069 signalled. 2070 */ 2071 wait_for_commit *waitee; 2072 /* 2073 Generic pointer for use by the transaction coordinator to optimise the 2074 waiting for improved group commit. 2075 2076 Currently used by binlog TC to signal that a waiter is ready to commit, so 2077 that the waitee can grab it and group commit it directly. It is free to be 2078 used by another transaction coordinator for similar purposes. 2079 */ 2080 void *opaque_pointer; 2081 /* The wakeup error code from the waitee. 0 means no error. */ 2082 int wakeup_error; 2083 /* 2084 Flag set when wakeup_subsequent_commits_running() is active, see comments 2085 on that function for details. 2086 */ 2087 bool wakeup_subsequent_commits_running; 2088 /* 2089 This flag can be set when a commit starts, but has not completed yet. 2090 It is used by binlog group commit to allow a waiting transaction T2 to 2091 join the group commit of an earlier transaction T1. When T1 has queued 2092 itself for group commit, it will set the commit_started flag. Then when 2093 T2 becomes ready to commit and needs to wait for T1 to commit first, T2 2094 can queue itself before waiting, and thereby participate in the same 2095 group commit as T1. 2096 */ 2097 bool commit_started; 2098 2099 void register_wait_for_prior_commit(wait_for_commit *waitee); 2100 int wait_for_prior_commit(THD *thd) 2101 { 2102 /* 2103 Quick inline check, to avoid function call and locking in the common case 2104 where no wakeup is registered, or a registered wait was already signalled. 2105 */ 2106 if (waitee) 2107 return wait_for_prior_commit2(thd); 2108 else 2109 { 2110 if (wakeup_error) 2111 my_error(ER_PRIOR_COMMIT_FAILED, MYF(0)); 2112 return wakeup_error; 2113 } 2114 } 2115 void wakeup_subsequent_commits(int wakeup_error_arg) 2116 { 2117 /* 2118 Do the check inline, so only the wakeup case takes the cost of a function 2119 call for every commmit. 2120 2121 Note that the check is done without locking. It is the responsibility of 2122 the user of the wakeup facility to ensure that no waiters can register 2123 themselves after the last call to wakeup_subsequent_commits(). 2124 2125 This avoids having to take another lock for every commit, which would be 2126 pointless anyway - even if we check under lock, there is nothing to 2127 prevent a waiter from arriving just after releasing the lock. 2128 */ 2129 if (subsequent_commits_list) 2130 wakeup_subsequent_commits2(wakeup_error_arg); 2131 } 2132 void unregister_wait_for_prior_commit() 2133 { 2134 if (waitee) 2135 unregister_wait_for_prior_commit2(); 2136 else 2137 wakeup_error= 0; 2138 } 2139 /* 2140 Remove a waiter from the list in the waitee. Used to unregister a wait. 2141 The caller must be holding the locks of both waiter and waitee. 2142 */ 2143 void remove_from_list(wait_for_commit **next_ptr_ptr) 2144 { 2145 wait_for_commit *cur; 2146 2147 while ((cur= *next_ptr_ptr) != NULL) 2148 { 2149 if (cur == this) 2150 { 2151 *next_ptr_ptr= this->next_subsequent_commit; 2152 break; 2153 } 2154 next_ptr_ptr= &cur->next_subsequent_commit; 2155 } 2156 waitee= NULL; 2157 } 2158 2159 void wakeup(int wakeup_error); 2160 2161 int wait_for_prior_commit2(THD *thd); 2162 void wakeup_subsequent_commits2(int wakeup_error); 2163 void unregister_wait_for_prior_commit2(); 2164 2165 wait_for_commit(); 2166 ~wait_for_commit(); 2167 void reinit(); 2168 }; 2169 2170 extern "C" void my_message_sql(uint error, const char *str, myf MyFlags); 2171 2172 /** 2173 @class THD 2174 For each client connection we create a separate thread with THD serving as 2175 a thread/connection descriptor 2176 */ 2177 2178 class THD :public Statement, 2179 /* 2180 This is to track items changed during execution of a prepared 2181 statement/stored procedure. It's created by 2182 nocheck_register_item_tree_change() in memory root of THD, 2183 and freed in rollback_item_tree_changes(). 2184 For conventional execution it's always empty. 2185 */ 2186 public Item_change_list, 2187 public MDL_context_owner, 2188 public Open_tables_state 2189 { 2190 private: 2191 inline bool is_stmt_prepare() const 2192 { DBUG_ASSERT(0); return Statement::is_stmt_prepare(); } 2193 2194 inline bool is_stmt_prepare_or_first_sp_execute() const 2195 { DBUG_ASSERT(0); return Statement::is_stmt_prepare_or_first_sp_execute(); } 2196 2197 inline bool is_stmt_prepare_or_first_stmt_execute() const 2198 { DBUG_ASSERT(0); return Statement::is_stmt_prepare_or_first_stmt_execute(); } 2199 2200 inline bool is_conventional() const 2201 { DBUG_ASSERT(0); return Statement::is_conventional(); } 2202 2203 void dec_thread_count(void) 2204 { 2205 DBUG_ASSERT(thread_count > 0); 2206 thread_safe_decrement32(&thread_count); 2207 signal_thd_deleted(); 2208 } 2209 2210 2211 void inc_thread_count(void) 2212 { 2213 thread_safe_increment32(&thread_count); 2214 } 2215 2216 public: 2217 MDL_context mdl_context; 2218 2219 /* Used to execute base64 coded binlog events in MySQL server */ 2220 Relay_log_info* rli_fake; 2221 rpl_group_info* rgi_fake; 2222 /* Slave applier execution context */ 2223 rpl_group_info* rgi_slave; 2224 2225 union { 2226 rpl_io_thread_info *rpl_io_info; 2227 rpl_sql_thread_info *rpl_sql_info; 2228 } system_thread_info; 2229 2230 void reset_for_next_command(bool do_clear_errors= 1); 2231 /* 2232 Constant for THD::where initialization in the beginning of every query. 2233 2234 It's needed because we do not save/restore THD::where normally during 2235 primary (non subselect) query execution. 2236 */ 2237 static const char * const DEFAULT_WHERE; 2238 2239 #ifdef EMBEDDED_LIBRARY 2240 struct st_mysql *mysql; 2241 unsigned long client_stmt_id; 2242 unsigned long client_param_count; 2243 struct st_mysql_bind *client_params; 2244 char *extra_data; 2245 ulong extra_length; 2246 struct st_mysql_data *cur_data; 2247 struct st_mysql_data *first_data; 2248 struct st_mysql_data **data_tail; 2249 void clear_data_list(); 2250 struct st_mysql_data *alloc_new_dataset(); 2251 /* 2252 In embedded server it points to the statement that is processed 2253 in the current query. We store some results directly in statement 2254 fields then. 2255 */ 2256 struct st_mysql_stmt *current_stmt; 2257 #endif 2258 #ifdef HAVE_QUERY_CACHE 2259 Query_cache_tls query_cache_tls; 2260 #endif 2261 NET net; // client connection descriptor 2262 /** Aditional network instrumentation for the server only. */ 2263 NET_SERVER m_net_server_extension; 2264 scheduler_functions *scheduler; // Scheduler for this connection 2265 Protocol *protocol; // Current protocol 2266 Protocol_text protocol_text; // Normal protocol 2267 Protocol_binary protocol_binary; // Binary protocol 2268 HASH user_vars; // hash for user variables 2269 String packet; // dynamic buffer for network I/O 2270 String convert_buffer; // buffer for charset conversions 2271 struct my_rnd_struct rand; // used for authentication 2272 struct system_variables variables; // Changeable local variables 2273 struct system_status_var status_var; // Per thread statistic vars 2274 struct system_status_var org_status_var; // For user statistics 2275 struct system_status_var *initial_status_var; /* used by show status */ 2276 THR_LOCK_INFO lock_info; // Locking info of this thread 2277 /** 2278 Protects THD data accessed from other threads: 2279 - thd->query and thd->query_length (used by SHOW ENGINE 2280 INNODB STATUS and SHOW PROCESSLIST 2281 - thd->db (used in SHOW PROCESSLIST) 2282 Is locked when THD is deleted. 2283 */ 2284 mysql_mutex_t LOCK_thd_data; 2285 /* 2286 Protects: 2287 - kill information 2288 - mysys_var (used by KILL statement and shutdown). 2289 - Also ensures that THD is not deleted while mutex is hold 2290 */ 2291 mysql_mutex_t LOCK_thd_kill; 2292 2293 /* all prepared statements and cursors of this connection */ 2294 Statement_map stmt_map; 2295 2296 /* Last created prepared statement */ 2297 Statement *last_stmt; 2298 inline void set_last_stmt(Statement *stmt) 2299 { last_stmt= (is_error() ? NULL : stmt); } 2300 inline void clear_last_stmt() { last_stmt= NULL; } 2301 2302 /* 2303 A pointer to the stack frame of handle_one_connection(), 2304 which is called first in the thread for handling a client 2305 */ 2306 char *thread_stack; 2307 2308 /** 2309 Currently selected catalog. 2310 */ 2311 char *catalog; 2312 2313 /** 2314 @note 2315 Some members of THD (currently 'Statement::db', 2316 'catalog' and 'query') are set and alloced by the slave SQL thread 2317 (for the THD of that thread); that thread is (and must remain, for now) 2318 the only responsible for freeing these 3 members. If you add members 2319 here, and you add code to set them in replication, don't forget to 2320 free_them_and_set_them_to_0 in replication properly. For details see 2321 the 'err:' label of the handle_slave_sql() in sql/slave.cc. 2322 2323 @see handle_slave_sql 2324 */ 2325 2326 Security_context main_security_ctx; 2327 Security_context *security_ctx; 2328 2329 /* 2330 Points to info-string that we show in SHOW PROCESSLIST 2331 You are supposed to update thd->proc_info only if you have coded 2332 a time-consuming piece that MySQL can get stuck in for a long time. 2333 2334 Set it using the thd_proc_info(THD *thread, const char *message) 2335 macro/function. 2336 2337 This member is accessed and assigned without any synchronization. 2338 Therefore, it may point only to constant (statically 2339 allocated) strings, which memory won't go away over time. 2340 */ 2341 const char *proc_info; 2342 2343 private: 2344 unsigned int m_current_stage_key; 2345 2346 public: 2347 void enter_stage(const PSI_stage_info *stage, 2348 const char *calling_func, 2349 const char *calling_file, 2350 const unsigned int calling_line) 2351 { 2352 DBUG_PRINT("THD::enter_stage", ("%s at %s:%d", stage->m_name, 2353 calling_file, calling_line)); 2354 DBUG_ASSERT(stage); 2355 m_current_stage_key= stage->m_key; 2356 proc_info= stage->m_name; 2357 #if defined(ENABLED_PROFILING) 2358 profiling.status_change(proc_info, calling_func, calling_file, 2359 calling_line); 2360 #endif 2361 #ifdef HAVE_PSI_THREAD_INTERFACE 2362 MYSQL_SET_STAGE(m_current_stage_key, calling_file, calling_line); 2363 #endif 2364 } 2365 2366 void backup_stage(PSI_stage_info *stage) 2367 { 2368 stage->m_key= m_current_stage_key; 2369 stage->m_name= proc_info; 2370 } 2371 2372 const char *get_proc_info() const 2373 { return proc_info; } 2374 2375 /* 2376 Used in error messages to tell user in what part of MySQL we found an 2377 error. E. g. when where= "having clause", if fix_fields() fails, user 2378 will know that the error was in having clause. 2379 */ 2380 const char *where; 2381 2382 /* Needed by MariaDB semi sync replication */ 2383 Trans_binlog_info *semisync_info; 2384 /* If this is a semisync slave connection. */ 2385 bool semi_sync_slave; 2386 ulonglong client_capabilities; /* What the client supports */ 2387 ulong max_client_packet_length; 2388 2389 HASH handler_tables_hash; 2390 /* 2391 A thread can hold named user-level locks. This variable 2392 contains granted tickets if a lock is present. See item_func.cc and 2393 chapter 'Miscellaneous functions', for functions GET_LOCK, RELEASE_LOCK. 2394 */ 2395 HASH ull_hash; 2396 /* Hash of used seqeunces (for PREVIOUS value) */ 2397 HASH sequences; 2398 #ifdef DBUG_ASSERT_EXISTS 2399 uint dbug_sentry; // watch out for memory corruption 2400 #endif 2401 struct st_my_thread_var *mysys_var; 2402 2403 /* Original charset number from the first client packet, or COM_CHANGE_USER*/ 2404 CHARSET_INFO *org_charset; 2405 private: 2406 /* 2407 Type of current query: COM_STMT_PREPARE, COM_QUERY, etc. Set from 2408 first byte of the packet in do_command() 2409 */ 2410 enum enum_server_command m_command; 2411 2412 public: 2413 uint32 file_id; // for LOAD DATA INFILE 2414 /* remote (peer) port */ 2415 uint16 peer_port; 2416 my_time_t start_time; // start_time and its sec_part 2417 ulong start_time_sec_part; // are almost always used separately 2418 my_hrtime_t user_time; 2419 // track down slow pthread_create 2420 ulonglong prior_thr_create_utime, thr_create_utime; 2421 ulonglong start_utime, utime_after_lock, utime_after_query; 2422 2423 // Process indicator 2424 struct { 2425 /* 2426 true, if the currently running command can send progress report 2427 packets to a client. Set by mysql_execute_command() for safe commands 2428 See CF_REPORT_PROGRESS 2429 */ 2430 bool report_to_client; 2431 /* 2432 true, if we will send progress report packets to a client 2433 (client has requested them, see MARIADB_CLIENT_PROGRESS; report_to_client 2434 is true; not in sub-statement) 2435 */ 2436 bool report; 2437 uint stage, max_stage; 2438 ulonglong counter, max_counter; 2439 ulonglong next_report_time; 2440 Query_arena *arena; 2441 } progress; 2442 2443 thr_lock_type update_lock_default; 2444 Delayed_insert *di; 2445 2446 /* <> 0 if we are inside of trigger or stored function. */ 2447 uint in_sub_stmt; 2448 /* True when opt_userstat_running is set at start of query */ 2449 bool userstat_running; 2450 /* 2451 True if we have to log all errors. Are set by some engines to temporary 2452 force errors to the error log. 2453 */ 2454 bool log_all_errors; 2455 2456 /* Do not set socket timeouts for wait_timeout (used with threadpool) */ 2457 bool skip_wait_timeout; 2458 2459 bool prepare_derived_at_open; 2460 2461 /* Set to 1 if status of this THD is already in global status */ 2462 bool status_in_global; 2463 2464 /* 2465 To signal that the tmp table to be created is created for materialized 2466 derived table or a view. 2467 */ 2468 bool create_tmp_table_for_derived; 2469 2470 bool save_prep_leaf_list; 2471 2472 /* container for handler's private per-connection data */ 2473 Ha_data ha_data[MAX_HA]; 2474 2475 /** 2476 Bit field for the state of binlog warnings. 2477 2478 The first Lex::BINLOG_STMT_UNSAFE_COUNT bits list all types of 2479 unsafeness that the current statement has. 2480 2481 This must be a member of THD and not of LEX, because warnings are 2482 detected and issued in different places (@c 2483 decide_logging_format() and @c binlog_query(), respectively). 2484 Between these calls, the THD->lex object may change; e.g., if a 2485 stored routine is invoked. Only THD persists between the calls. 2486 */ 2487 uint32 binlog_unsafe_warning_flags; 2488 2489 #ifndef MYSQL_CLIENT 2490 binlog_cache_mngr * binlog_setup_trx_data(); 2491 2492 /* 2493 Public interface to write RBR events to the binlog 2494 */ 2495 void binlog_start_trans_and_stmt(); 2496 void binlog_set_stmt_begin(); 2497 int binlog_write_table_map(TABLE *table, bool is_transactional, 2498 my_bool *with_annotate= 0); 2499 int binlog_write_row(TABLE* table, bool is_transactional, 2500 const uchar *buf); 2501 int binlog_delete_row(TABLE* table, bool is_transactional, 2502 const uchar *buf); 2503 int binlog_update_row(TABLE* table, bool is_transactional, 2504 const uchar *old_data, const uchar *new_data); 2505 static void binlog_prepare_row_images(TABLE* table); 2506 2507 void set_server_id(uint32 sid) { variables.server_id = sid; } 2508 2509 /* 2510 Member functions to handle pending event for row-level logging. 2511 */ 2512 template <class RowsEventT> Rows_log_event* 2513 binlog_prepare_pending_rows_event(TABLE* table, uint32 serv_id, 2514 size_t needed, 2515 bool is_transactional, 2516 RowsEventT* hint); 2517 Rows_log_event* binlog_get_pending_rows_event(bool is_transactional) const; 2518 void binlog_set_pending_rows_event(Rows_log_event* ev, bool is_transactional); 2519 inline int binlog_flush_pending_rows_event(bool stmt_end) 2520 { 2521 return (binlog_flush_pending_rows_event(stmt_end, FALSE) || 2522 binlog_flush_pending_rows_event(stmt_end, TRUE)); 2523 } 2524 int binlog_flush_pending_rows_event(bool stmt_end, bool is_transactional); 2525 int binlog_remove_pending_rows_event(bool clear_maps, bool is_transactional); 2526 2527 /** 2528 Determine the binlog format of the current statement. 2529 2530 @retval 0 if the current statement will be logged in statement 2531 format. 2532 @retval nonzero if the current statement will be logged in row 2533 format. 2534 */ 2535 int is_current_stmt_binlog_format_row() const { 2536 DBUG_ASSERT(current_stmt_binlog_format == BINLOG_FORMAT_STMT || 2537 current_stmt_binlog_format == BINLOG_FORMAT_ROW); 2538 return current_stmt_binlog_format == BINLOG_FORMAT_ROW; 2539 } 2540 /** 2541 Determine if binlogging is disabled for this session 2542 @retval 0 if the current statement binlogging is disabled 2543 (could be because of binlog closed/binlog option 2544 is set to false). 2545 @retval 1 if the current statement will be binlogged 2546 */ 2547 inline bool is_current_stmt_binlog_disabled() const 2548 { 2549 return (!(variables.option_bits & OPTION_BIN_LOG) || 2550 !mysql_bin_log.is_open()); 2551 } 2552 2553 enum binlog_filter_state 2554 { 2555 BINLOG_FILTER_UNKNOWN, 2556 BINLOG_FILTER_CLEAR, 2557 BINLOG_FILTER_SET 2558 }; 2559 2560 inline void reset_binlog_local_stmt_filter() 2561 { 2562 m_binlog_filter_state= BINLOG_FILTER_UNKNOWN; 2563 } 2564 2565 inline void clear_binlog_local_stmt_filter() 2566 { 2567 DBUG_ASSERT(m_binlog_filter_state == BINLOG_FILTER_UNKNOWN); 2568 m_binlog_filter_state= BINLOG_FILTER_CLEAR; 2569 } 2570 2571 inline void set_binlog_local_stmt_filter() 2572 { 2573 DBUG_ASSERT(m_binlog_filter_state == BINLOG_FILTER_UNKNOWN); 2574 m_binlog_filter_state= BINLOG_FILTER_SET; 2575 } 2576 2577 inline binlog_filter_state get_binlog_local_stmt_filter() 2578 { 2579 return m_binlog_filter_state; 2580 } 2581 2582 private: 2583 /** 2584 Indicate if the current statement should be discarded 2585 instead of written to the binlog. 2586 This is used to discard special statements, such as 2587 DML or DDL that affects only 'local' (non replicated) 2588 tables, such as performance_schema.* 2589 */ 2590 binlog_filter_state m_binlog_filter_state; 2591 2592 /** 2593 Indicates the format in which the current statement will be 2594 logged. This can only be set from @c decide_logging_format(). 2595 */ 2596 enum_binlog_format current_stmt_binlog_format; 2597 2598 /* 2599 Number of outstanding table maps, i.e., table maps in the 2600 transaction cache. 2601 */ 2602 uint binlog_table_maps; 2603 public: 2604 void issue_unsafe_warnings(); 2605 void reset_unsafe_warnings() 2606 { binlog_unsafe_warning_flags= 0; } 2607 2608 uint get_binlog_table_maps() const { 2609 return binlog_table_maps; 2610 } 2611 void clear_binlog_table_maps() { 2612 binlog_table_maps= 0; 2613 } 2614 #endif /* MYSQL_CLIENT */ 2615 2616 public: 2617 2618 struct st_transactions { 2619 SAVEPOINT *savepoints; 2620 THD_TRANS all; // Trans since BEGIN WORK 2621 THD_TRANS stmt; // Trans for current statement 2622 bool on; // see ha_enable_transaction() 2623 XID_STATE xid_state; 2624 WT_THD wt; ///< for deadlock detection 2625 Rows_log_event *m_pending_rows_event; 2626 2627 struct st_trans_time : public timeval 2628 { 2629 void reset(THD *thd) 2630 { 2631 tv_sec= thd->query_start(); 2632 tv_usec= (long) thd->query_start_sec_part(); 2633 } 2634 } start_time; 2635 2636 /* 2637 Tables changed in transaction (that must be invalidated in query cache). 2638 List contain only transactional tables, that not invalidated in query 2639 cache (instead of full list of changed in transaction tables). 2640 */ 2641 CHANGED_TABLE_LIST* changed_tables; 2642 MEM_ROOT mem_root; // Transaction-life memory allocation pool 2643 void cleanup() 2644 { 2645 DBUG_ENTER("thd::cleanup"); 2646 changed_tables= 0; 2647 savepoints= 0; 2648 /* 2649 If rm_error is raised, it means that this piece of a distributed 2650 transaction has failed and must be rolled back. But the user must 2651 rollback it explicitly, so don't start a new distributed XA until 2652 then. 2653 */ 2654 if (!xid_state.rm_error) 2655 xid_state.xid.null(); 2656 free_root(&mem_root,MYF(MY_KEEP_PREALLOC)); 2657 DBUG_VOID_RETURN; 2658 } 2659 my_bool is_active() 2660 { 2661 return (all.ha_list != NULL); 2662 } 2663 st_transactions() 2664 { 2665 bzero((char*)this, sizeof(*this)); 2666 xid_state.xid.null(); 2667 init_sql_alloc(&mem_root, "THD::transactions", 2668 ALLOC_ROOT_MIN_BLOCK_SIZE, 0, 2669 MYF(MY_THREAD_SPECIFIC)); 2670 } 2671 } transaction; 2672 Global_read_lock global_read_lock; 2673 Field *dup_field; 2674 #ifndef __WIN__ 2675 sigset_t signals; 2676 #endif 2677 #ifdef SIGNAL_WITH_VIO_CLOSE 2678 Vio* active_vio; 2679 #endif 2680 2681 /* 2682 A permanent memory area of the statement. For conventional 2683 execution, the parsed tree and execution runtime reside in the same 2684 memory root. In this case stmt_arena points to THD. In case of 2685 a prepared statement or a stored procedure statement, thd->mem_root 2686 conventionally points to runtime memory, and thd->stmt_arena 2687 points to the memory of the PS/SP, where the parsed tree of the 2688 statement resides. Whenever you need to perform a permanent 2689 transformation of a parsed tree, you should allocate new memory in 2690 stmt_arena, to allow correct re-execution of PS/SP. 2691 Note: in the parser, stmt_arena == thd, even for PS/SP. 2692 */ 2693 Query_arena *stmt_arena; 2694 2695 void *bulk_param; 2696 2697 /* 2698 map for tables that will be updated for a multi-table update query 2699 statement, for other query statements, this will be zero. 2700 */ 2701 table_map table_map_for_update; 2702 2703 /* Tells if LAST_INSERT_ID(#) was called for the current statement */ 2704 bool arg_of_last_insert_id_function; 2705 /* 2706 ALL OVER THIS FILE, "insert_id" means "*automatically generated* value for 2707 insertion into an auto_increment column". 2708 */ 2709 /* 2710 This is the first autogenerated insert id which was *successfully* 2711 inserted by the previous statement (exactly, if the previous statement 2712 didn't successfully insert an autogenerated insert id, then it's the one 2713 of the statement before, etc). 2714 It can also be set by SET LAST_INSERT_ID=# or SELECT LAST_INSERT_ID(#). 2715 It is returned by LAST_INSERT_ID(). 2716 */ 2717 ulonglong first_successful_insert_id_in_prev_stmt; 2718 /* 2719 Variant of the above, used for storing in statement-based binlog. The 2720 difference is that the one above can change as the execution of a stored 2721 function progresses, while the one below is set once and then does not 2722 change (which is the value which statement-based binlog needs). 2723 */ 2724 ulonglong first_successful_insert_id_in_prev_stmt_for_binlog; 2725 /* 2726 This is the first autogenerated insert id which was *successfully* 2727 inserted by the current statement. It is maintained only to set 2728 first_successful_insert_id_in_prev_stmt when statement ends. 2729 */ 2730 ulonglong first_successful_insert_id_in_cur_stmt; 2731 /* 2732 We follow this logic: 2733 - when stmt starts, first_successful_insert_id_in_prev_stmt contains the 2734 first insert id successfully inserted by the previous stmt. 2735 - as stmt makes progress, handler::insert_id_for_cur_row changes; 2736 every time get_auto_increment() is called, 2737 auto_inc_intervals_in_cur_stmt_for_binlog is augmented with the 2738 reserved interval (if statement-based binlogging). 2739 - at first successful insertion of an autogenerated value, 2740 first_successful_insert_id_in_cur_stmt is set to 2741 handler::insert_id_for_cur_row. 2742 - when stmt goes to binlog, 2743 auto_inc_intervals_in_cur_stmt_for_binlog is binlogged if 2744 non-empty. 2745 - when stmt ends, first_successful_insert_id_in_prev_stmt is set to 2746 first_successful_insert_id_in_cur_stmt. 2747 */ 2748 /* 2749 stmt_depends_on_first_successful_insert_id_in_prev_stmt is set when 2750 LAST_INSERT_ID() is used by a statement. 2751 If it is set, first_successful_insert_id_in_prev_stmt_for_binlog will be 2752 stored in the statement-based binlog. 2753 This variable is CUMULATIVE along the execution of a stored function or 2754 trigger: if one substatement sets it to 1 it will stay 1 until the 2755 function/trigger ends, thus making sure that 2756 first_successful_insert_id_in_prev_stmt_for_binlog does not change anymore 2757 and is propagated to the caller for binlogging. 2758 */ 2759 bool stmt_depends_on_first_successful_insert_id_in_prev_stmt; 2760 /* 2761 List of auto_increment intervals reserved by the thread so far, for 2762 storage in the statement-based binlog. 2763 Note that its minimum is not first_successful_insert_id_in_cur_stmt: 2764 assuming a table with an autoinc column, and this happens: 2765 INSERT INTO ... VALUES(3); 2766 SET INSERT_ID=3; INSERT IGNORE ... VALUES (NULL); 2767 then the latter INSERT will insert no rows 2768 (first_successful_insert_id_in_cur_stmt == 0), but storing "INSERT_ID=3" 2769 in the binlog is still needed; the list's minimum will contain 3. 2770 This variable is cumulative: if several statements are written to binlog 2771 as one (stored functions or triggers are used) this list is the 2772 concatenation of all intervals reserved by all statements. 2773 */ 2774 Discrete_intervals_list auto_inc_intervals_in_cur_stmt_for_binlog; 2775 /* Used by replication and SET INSERT_ID */ 2776 Discrete_intervals_list auto_inc_intervals_forced; 2777 /* 2778 There is BUG#19630 where statement-based replication of stored 2779 functions/triggers with two auto_increment columns breaks. 2780 We however ensure that it works when there is 0 or 1 auto_increment 2781 column; our rules are 2782 a) on master, while executing a top statement involving substatements, 2783 first top- or sub- statement to generate auto_increment values wins the 2784 exclusive right to see its values be written to binlog (the write 2785 will be done by the statement or its caller), and the losers won't see 2786 their values be written to binlog. 2787 b) on slave, while replicating a top statement involving substatements, 2788 first top- or sub- statement to need to read auto_increment values from 2789 the master's binlog wins the exclusive right to read them (so the losers 2790 won't read their values from binlog but instead generate on their own). 2791 a) implies that we mustn't backup/restore 2792 auto_inc_intervals_in_cur_stmt_for_binlog. 2793 b) implies that we mustn't backup/restore auto_inc_intervals_forced. 2794 2795 If there are more than 1 auto_increment columns, then intervals for 2796 different columns may mix into the 2797 auto_inc_intervals_in_cur_stmt_for_binlog list, which is logically wrong, 2798 but there is no point in preventing this mixing by preventing intervals 2799 from the secondly inserted column to come into the list, as such 2800 prevention would be wrong too. 2801 What will happen in the case of 2802 INSERT INTO t1 (auto_inc) VALUES(NULL); 2803 where t1 has a trigger which inserts into an auto_inc column of t2, is 2804 that in binlog we'll store the interval of t1 and the interval of t2 (when 2805 we store intervals, soon), then in slave, t1 will use both intervals, t2 2806 will use none; if t1 inserts the same number of rows as on master, 2807 normally the 2nd interval will not be used by t1, which is fine. t2's 2808 values will be wrong if t2's internal auto_increment counter is different 2809 from what it was on master (which is likely). In 5.1, in mixed binlogging 2810 mode, row-based binlogging is used for such cases where two 2811 auto_increment columns are inserted. 2812 */ 2813 inline void record_first_successful_insert_id_in_cur_stmt(ulonglong id_arg) 2814 { 2815 if (first_successful_insert_id_in_cur_stmt == 0) 2816 first_successful_insert_id_in_cur_stmt= id_arg; 2817 } 2818 inline ulonglong read_first_successful_insert_id_in_prev_stmt(void) 2819 { 2820 if (!stmt_depends_on_first_successful_insert_id_in_prev_stmt) 2821 { 2822 /* It's the first time we read it */ 2823 first_successful_insert_id_in_prev_stmt_for_binlog= 2824 first_successful_insert_id_in_prev_stmt; 2825 stmt_depends_on_first_successful_insert_id_in_prev_stmt= 1; 2826 } 2827 return first_successful_insert_id_in_prev_stmt; 2828 } 2829 /* 2830 Used by Intvar_log_event::do_apply_event() and by "SET INSERT_ID=#" 2831 (mysqlbinlog). We'll soon add a variant which can take many intervals in 2832 argument. 2833 */ 2834 inline void force_one_auto_inc_interval(ulonglong next_id) 2835 { 2836 auto_inc_intervals_forced.empty(); // in case of multiple SET INSERT_ID 2837 auto_inc_intervals_forced.append(next_id, ULONGLONG_MAX, 0); 2838 } 2839 2840 ulonglong limit_found_rows; 2841 2842 private: 2843 /** 2844 Stores the result of ROW_COUNT() function. 2845 2846 ROW_COUNT() function is a MySQL extention, but we try to keep it 2847 similar to ROW_COUNT member of the GET DIAGNOSTICS stack of the SQL 2848 standard (see SQL99, part 2, search for ROW_COUNT). It's value is 2849 implementation defined for anything except INSERT, DELETE, UPDATE. 2850 2851 ROW_COUNT is assigned according to the following rules: 2852 2853 - In my_ok(): 2854 - for DML statements: to the number of affected rows; 2855 - for DDL statements: to 0. 2856 2857 - In my_eof(): to -1 to indicate that there was a result set. 2858 2859 We derive this semantics from the JDBC specification, where int 2860 java.sql.Statement.getUpdateCount() is defined to (sic) "return the 2861 current result as an update count; if the result is a ResultSet 2862 object or there are no more results, -1 is returned". 2863 2864 - In my_error(): to -1 to be compatible with the MySQL C API and 2865 MySQL ODBC driver. 2866 2867 - For SIGNAL statements: to 0 per WL#2110 specification (see also 2868 sql_signal.cc comment). Zero is used since that's the "default" 2869 value of ROW_COUNT in the diagnostics area. 2870 */ 2871 2872 longlong m_row_count_func; /* For the ROW_COUNT() function */ 2873 2874 public: 2875 inline longlong get_row_count_func() const 2876 { 2877 return m_row_count_func; 2878 } 2879 2880 inline void set_row_count_func(longlong row_count_func) 2881 { 2882 m_row_count_func= row_count_func; 2883 } 2884 inline void set_affected_rows(longlong row_count_func) 2885 { 2886 /* 2887 We have to add to affected_rows (used by slow log), as otherwise 2888 information for 'call' will be wrong 2889 */ 2890 affected_rows+= (row_count_func >= 0 ? row_count_func : 0); 2891 } 2892 2893 ha_rows cuted_fields; 2894 2895 private: 2896 /* 2897 number of rows we actually sent to the client, including "synthetic" 2898 rows in ROLLUP etc. 2899 */ 2900 ha_rows m_sent_row_count; 2901 2902 /** 2903 Number of rows read and/or evaluated for a statement. Used for 2904 slow log reporting. 2905 2906 An examined row is defined as a row that is read and/or evaluated 2907 according to a statement condition, including in 2908 create_sort_index(). Rows may be counted more than once, e.g., a 2909 statement including ORDER BY could possibly evaluate the row in 2910 filesort() before reading it for e.g. update. 2911 */ 2912 ha_rows m_examined_row_count; 2913 2914 public: 2915 ha_rows get_sent_row_count() const 2916 { return m_sent_row_count; } 2917 2918 ha_rows get_examined_row_count() const 2919 { return m_examined_row_count; } 2920 2921 ulonglong get_affected_rows() const 2922 { return affected_rows; } 2923 2924 void set_sent_row_count(ha_rows count); 2925 void set_examined_row_count(ha_rows count); 2926 2927 void inc_sent_row_count(ha_rows count); 2928 void inc_examined_row_count(ha_rows count); 2929 2930 void inc_status_created_tmp_disk_tables(); 2931 void inc_status_created_tmp_files(); 2932 void inc_status_created_tmp_tables(); 2933 void inc_status_select_full_join(); 2934 void inc_status_select_full_range_join(); 2935 void inc_status_select_range(); 2936 void inc_status_select_range_check(); 2937 void inc_status_select_scan(); 2938 void inc_status_sort_merge_passes(); 2939 void inc_status_sort_range(); 2940 void inc_status_sort_rows(ha_rows count); 2941 void inc_status_sort_scan(); 2942 void set_status_no_index_used(); 2943 void set_status_no_good_index_used(); 2944 2945 /** 2946 The number of rows and/or keys examined by the query, both read, 2947 changed or written. 2948 */ 2949 ulonglong accessed_rows_and_keys; 2950 2951 /** 2952 Check if the number of rows accessed by a statement exceeded 2953 LIMIT ROWS EXAMINED. If so, signal the query engine to stop execution. 2954 */ 2955 void check_limit_rows_examined() 2956 { 2957 if (++accessed_rows_and_keys > lex->limit_rows_examined_cnt) 2958 set_killed(ABORT_QUERY); 2959 } 2960 2961 USER_CONN *user_connect; 2962 CHARSET_INFO *db_charset; 2963 #if defined(ENABLED_PROFILING) 2964 PROFILING profiling; 2965 #endif 2966 2967 /** Current statement digest. */ 2968 sql_digest_state *m_digest; 2969 /** Current statement digest token array. */ 2970 unsigned char *m_token_array; 2971 /** Top level statement digest. */ 2972 sql_digest_state m_digest_state; 2973 2974 /** Current statement instrumentation. */ 2975 PSI_statement_locker *m_statement_psi; 2976 #ifdef HAVE_PSI_STATEMENT_INTERFACE 2977 /** Current statement instrumentation state. */ 2978 PSI_statement_locker_state m_statement_state; 2979 #endif /* HAVE_PSI_STATEMENT_INTERFACE */ 2980 /** Idle instrumentation. */ 2981 PSI_idle_locker *m_idle_psi; 2982 #ifdef HAVE_PSI_IDLE_INTERFACE 2983 /** Idle instrumentation state. */ 2984 PSI_idle_locker_state m_idle_state; 2985 #endif /* HAVE_PSI_IDLE_INTERFACE */ 2986 2987 /* 2988 Id of current query. Statement can be reused to execute several queries 2989 query_id is global in context of the whole MySQL server. 2990 ID is automatically generated from mutex-protected counter. 2991 It's used in handler code for various purposes: to check which columns 2992 from table are necessary for this select, to check if it's necessary to 2993 update auto-updatable fields (like auto_increment and timestamp). 2994 */ 2995 query_id_t query_id; 2996 ulong col_access; 2997 2998 /* Statement id is thread-wide. This counter is used to generate ids */ 2999 ulong statement_id_counter; 3000 ulong rand_saved_seed1, rand_saved_seed2; 3001 3002 /* The following variables are used when printing to slow log */ 3003 ulong query_plan_flags; 3004 ulong query_plan_fsort_passes; 3005 ulong tmp_tables_used; 3006 ulong tmp_tables_disk_used; 3007 ulonglong tmp_tables_size; 3008 ulonglong bytes_sent_old; 3009 ulonglong affected_rows; /* Number of changed rows */ 3010 3011 pthread_t real_id; /* For debugging */ 3012 my_thread_id thread_id, thread_dbug_id; 3013 uint32 os_thread_id; 3014 uint tmp_table, global_disable_checkpoint; 3015 uint server_status,open_options; 3016 enum enum_thread_type system_thread; 3017 /* 3018 Current or next transaction isolation level. 3019 When a connection is established, the value is taken from 3020 @@session.tx_isolation (default transaction isolation for 3021 the session), which is in turn taken from @@global.tx_isolation 3022 (the global value). 3023 If there is no transaction started, this variable 3024 holds the value of the next transaction's isolation level. 3025 When a transaction starts, the value stored in this variable 3026 becomes "actual". 3027 At transaction commit or rollback, we assign this variable 3028 again from @@session.tx_isolation. 3029 The only statement that can otherwise change the value 3030 of this variable is SET TRANSACTION ISOLATION LEVEL. 3031 Its purpose is to effect the isolation level of the next 3032 transaction in this session. When this statement is executed, 3033 the value in this variable is changed. However, since 3034 this statement is only allowed when there is no active 3035 transaction, this assignment (naturally) only affects the 3036 upcoming transaction. 3037 At the end of the current active transaction the value is 3038 be reset again from @@session.tx_isolation, as described 3039 above. 3040 */ 3041 enum_tx_isolation tx_isolation; 3042 /* 3043 Current or next transaction access mode. 3044 See comment above regarding tx_isolation. 3045 */ 3046 bool tx_read_only; 3047 enum_check_fields count_cuted_fields; 3048 3049 DYNAMIC_ARRAY user_var_events; /* For user variables replication */ 3050 MEM_ROOT *user_var_events_alloc; /* Allocate above array elements here */ 3051 3052 /* 3053 Define durability properties that engines may check to 3054 improve performance. Not yet used in MariaDB 3055 */ 3056 enum durability_properties durability_property; 3057 3058 /* 3059 If checking this in conjunction with a wait condition, please 3060 include a check after enter_cond() if you want to avoid a race 3061 condition. For details see the implementation of awake(), 3062 especially the "broadcast" part. 3063 */ 3064 killed_state volatile killed; 3065 3066 /* 3067 The following is used if one wants to have a specific error number and 3068 text for the kill 3069 */ 3070 struct err_info 3071 { 3072 int no; 3073 const char msg[256]; 3074 } *killed_err; 3075 3076 /* See also thd_killed() */ 3077 inline bool check_killed(bool dont_send_error_message= 0) 3078 { 3079 if (unlikely(killed)) 3080 { 3081 if (!dont_send_error_message) 3082 send_kill_message(); 3083 return TRUE; 3084 } 3085 if (apc_target.have_apc_requests()) 3086 apc_target.process_apc_requests(); 3087 return FALSE; 3088 } 3089 3090 /* scramble - random string sent to client on handshake */ 3091 char scramble[SCRAMBLE_LENGTH+1]; 3092 3093 /* 3094 If this is a slave, the name of the connection stored here. 3095 This is used for taging error messages in the log files. 3096 */ 3097 LEX_CSTRING connection_name; 3098 char default_master_connection_buff[MAX_CONNECTION_NAME+1]; 3099 uint8 password; /* 0, 1 or 2 */ 3100 uint8 failed_com_change_user; 3101 bool slave_thread; 3102 bool extra_port; /* If extra connection */ 3103 bool no_errors; 3104 3105 /** 3106 Set to TRUE if execution of the current compound statement 3107 can not continue. In particular, disables activation of 3108 CONTINUE or EXIT handlers of stored routines. 3109 Reset in the end of processing of the current user request, in 3110 @see THD::reset_for_next_command(). 3111 */ 3112 bool is_fatal_error; 3113 /** 3114 Set by a storage engine to request the entire 3115 transaction (that possibly spans multiple engines) to 3116 rollback. Reset in ha_rollback. 3117 */ 3118 bool transaction_rollback_request; 3119 /** 3120 TRUE if we are in a sub-statement and the current error can 3121 not be safely recovered until we left the sub-statement mode. 3122 In particular, disables activation of CONTINUE and EXIT 3123 handlers inside sub-statements. E.g. if it is a deadlock 3124 error and requires a transaction-wide rollback, this flag is 3125 raised (traditionally, MySQL first has to close all the reads 3126 via @see handler::ha_index_or_rnd_end() and only then perform 3127 the rollback). 3128 Reset to FALSE when we leave the sub-statement mode. 3129 */ 3130 bool is_fatal_sub_stmt_error; 3131 bool rand_used, time_zone_used; 3132 bool query_start_sec_part_used; 3133 /* for IS NULL => = last_insert_id() fix in remove_eq_conds() */ 3134 bool substitute_null_with_insert_id; 3135 bool in_lock_tables; 3136 bool bootstrap, cleanup_done, free_connection_done; 3137 3138 /** is set if some thread specific value(s) used in a statement. */ 3139 bool thread_specific_used; 3140 /** 3141 is set if a statement accesses a temporary table created through 3142 CREATE TEMPORARY TABLE. 3143 */ 3144 private: 3145 bool charset_is_system_charset, charset_is_collation_connection; 3146 bool charset_is_character_set_filesystem; 3147 public: 3148 bool enable_slow_log; /* Enable slow log for current statement */ 3149 bool abort_on_warning; 3150 bool got_warning; /* Set on call to push_warning() */ 3151 /* set during loop of derived table processing */ 3152 bool derived_tables_processing; 3153 bool tablespace_op; /* This is TRUE in DISCARD/IMPORT TABLESPACE */ 3154 /* True if we have to log the current statement */ 3155 bool log_current_statement; 3156 /** 3157 True if a slave error. Causes the slave to stop. Not the same 3158 as the statement execution error (is_error()), since 3159 a statement may be expected to return an error, e.g. because 3160 it returned an error on master, and this is OK on the slave. 3161 */ 3162 bool is_slave_error; 3163 /* 3164 True when a transaction is queued up for binlog group commit. 3165 Used so that if another transaction needs to wait for a row lock held by 3166 this transaction, it can signal to trigger the group commit immediately, 3167 skipping the normal --binlog-commit-wait-count wait. 3168 */ 3169 bool waiting_on_group_commit; 3170 /* 3171 Set true when another transaction goes to wait on a row lock held by this 3172 transaction. Used together with waiting_on_group_commit. 3173 */ 3174 bool has_waiter; 3175 /* 3176 In case of a slave, set to the error code the master got when executing 3177 the query. 0 if no error on the master. 3178 */ 3179 int slave_expected_error; 3180 enum_sql_command last_sql_command; // Last sql_command exceuted in mysql_execute_command() 3181 3182 sp_rcontext *spcont; // SP runtime context 3183 sp_cache *sp_proc_cache; 3184 sp_cache *sp_func_cache; 3185 sp_cache *sp_package_spec_cache; 3186 sp_cache *sp_package_body_cache; 3187 3188 /** number of name_const() substitutions, see sp_head.cc:subst_spvars() */ 3189 uint query_name_consts; 3190 3191 /* 3192 If we do a purge of binary logs, log index info of the threads 3193 that are currently reading it needs to be adjusted. To do that 3194 each thread that is using LOG_INFO needs to adjust the pointer to it 3195 */ 3196 LOG_INFO* current_linfo; 3197 NET* slave_net; // network connection from slave -> m. 3198 3199 /* 3200 Used to update global user stats. The global user stats are updated 3201 occasionally with the 'diff' variables. After the update, the 'diff' 3202 variables are reset to 0. 3203 */ 3204 /* Time when the current thread connected to MySQL. */ 3205 time_t current_connect_time; 3206 /* Last time when THD stats were updated in global_user_stats. */ 3207 time_t last_global_update_time; 3208 /* Number of commands not reflected in global_user_stats yet. */ 3209 uint select_commands, update_commands, other_commands; 3210 ulonglong start_cpu_time; 3211 ulonglong start_bytes_received; 3212 3213 /* Used by the sys_var class to store temporary values */ 3214 union 3215 { 3216 my_bool my_bool_value; 3217 int int_value; 3218 uint uint_value; 3219 long long_value; 3220 ulong ulong_value; 3221 ulonglong ulonglong_value; 3222 double double_value; 3223 void *ptr_value; 3224 } sys_var_tmp; 3225 3226 struct { 3227 /* 3228 If true, mysql_bin_log::write(Log_event) call will not write events to 3229 binlog, and maintain 2 below variables instead (use 3230 mysql_bin_log.start_union_events to turn this on) 3231 */ 3232 bool do_union; 3233 /* 3234 If TRUE, at least one mysql_bin_log::write(Log_event) call has been 3235 made after last mysql_bin_log.start_union_events() call. 3236 */ 3237 bool unioned_events; 3238 /* 3239 If TRUE, at least one mysql_bin_log::write(Log_event e), where 3240 e.cache_stmt == TRUE call has been made after last 3241 mysql_bin_log.start_union_events() call. 3242 */ 3243 bool unioned_events_trans; 3244 3245 /* 3246 'queries' (actually SP statements) that run under inside this binlog 3247 union have thd->query_id >= first_query_id. 3248 */ 3249 query_id_t first_query_id; 3250 } binlog_evt_union; 3251 3252 mysql_cond_t COND_wsrep_thd; 3253 /** 3254 Internal parser state. 3255 Note that since the parser is not re-entrant, we keep only one parser 3256 state here. This member is valid only when executing code during parsing. 3257 */ 3258 Parser_state *m_parser_state; 3259 3260 Locked_tables_list locked_tables_list; 3261 3262 #ifdef WITH_PARTITION_STORAGE_ENGINE 3263 partition_info *work_part_info; 3264 #endif 3265 3266 #ifndef EMBEDDED_LIBRARY 3267 /** 3268 Array of active audit plugins which have been used by this THD. 3269 This list is later iterated to invoke release_thd() on those 3270 plugins. 3271 */ 3272 DYNAMIC_ARRAY audit_class_plugins; 3273 /** 3274 Array of bits indicating which audit classes have already been 3275 added to the list of audit plugins which are currently in use. 3276 */ 3277 unsigned long audit_class_mask[MYSQL_AUDIT_CLASS_MASK_SIZE]; 3278 int audit_plugin_version; 3279 #endif 3280 3281 #if defined(ENABLED_DEBUG_SYNC) 3282 /* Debug Sync facility. See debug_sync.cc. */ 3283 struct st_debug_sync_control *debug_sync_control; 3284 #endif /* defined(ENABLED_DEBUG_SYNC) */ 3285 /** 3286 @param id thread identifier 3287 @param is_wsrep_applier thread type 3288 */ 3289 THD(my_thread_id id, bool is_wsrep_applier= false); 3290 3291 ~THD(); 3292 3293 void init(); 3294 /* 3295 Initialize memory roots necessary for query processing and (!) 3296 pre-allocate memory for it. We can't do that in THD constructor because 3297 there are use cases (acl_init, delayed inserts, watcher threads, 3298 killing mysqld) where it's vital to not allocate excessive and not used 3299 memory. Note, that we still don't return error from init_for_queries(): 3300 if preallocation fails, we should notice that at the first call to 3301 alloc_root. 3302 */ 3303 void init_for_queries(); 3304 void update_all_stats(); 3305 void update_stats(void); 3306 void change_user(void); 3307 void cleanup(void); 3308 void cleanup_after_query(); 3309 void free_connection(); 3310 void reset_for_reuse(); 3311 bool store_globals(); 3312 void reset_globals(); 3313 #ifdef SIGNAL_WITH_VIO_CLOSE 3314 inline void set_active_vio(Vio* vio) 3315 { 3316 mysql_mutex_lock(&LOCK_thd_data); 3317 active_vio = vio; 3318 mysql_mutex_unlock(&LOCK_thd_data); 3319 } 3320 inline void clear_active_vio() 3321 { 3322 mysql_mutex_lock(&LOCK_thd_data); 3323 active_vio = 0; 3324 mysql_mutex_unlock(&LOCK_thd_data); 3325 } 3326 void close_active_vio(); 3327 #endif 3328 void awake_no_mutex(killed_state state_to_set); 3329 void awake(killed_state state_to_set) 3330 { 3331 mysql_mutex_lock(&LOCK_thd_kill); 3332 awake_no_mutex(state_to_set); 3333 mysql_mutex_unlock(&LOCK_thd_kill); 3334 } 3335 3336 /** Disconnect the associated communication endpoint. */ 3337 void disconnect(); 3338 3339 3340 /* 3341 Allows this thread to serve as a target for others to schedule Async 3342 Procedure Calls on. 3343 3344 It's possible to schedule any code to be executed this way, by 3345 inheriting from the Apc_call object. Currently, only 3346 Show_explain_request uses this. 3347 */ 3348 Apc_target apc_target; 3349 3350 #ifndef MYSQL_CLIENT 3351 enum enum_binlog_query_type { 3352 /* The query can be logged in row format or in statement format. */ 3353 ROW_QUERY_TYPE, 3354 3355 /* The query has to be logged in statement format. */ 3356 STMT_QUERY_TYPE, 3357 3358 QUERY_TYPE_COUNT 3359 }; 3360 3361 int binlog_query(enum_binlog_query_type qtype, 3362 char const *query, ulong query_len, bool is_trans, 3363 bool direct, bool suppress_use, 3364 int errcode); 3365 #endif 3366 3367 inline void 3368 enter_cond(mysql_cond_t *cond, mysql_mutex_t* mutex, 3369 const PSI_stage_info *stage, PSI_stage_info *old_stage, 3370 const char *src_function, const char *src_file, 3371 int src_line) 3372 { 3373 mysql_mutex_assert_owner(mutex); 3374 mysys_var->current_mutex = mutex; 3375 mysys_var->current_cond = cond; 3376 if (old_stage) 3377 backup_stage(old_stage); 3378 if (stage) 3379 enter_stage(stage, src_function, src_file, src_line); 3380 } 3381 inline void exit_cond(const PSI_stage_info *stage, 3382 const char *src_function, const char *src_file, 3383 int src_line) 3384 { 3385 /* 3386 Putting the mutex unlock in thd->exit_cond() ensures that 3387 mysys_var->current_mutex is always unlocked _before_ mysys_var->mutex is 3388 locked (if that would not be the case, you'll get a deadlock if someone 3389 does a THD::awake() on you). 3390 */ 3391 mysql_mutex_unlock(mysys_var->current_mutex); 3392 mysql_mutex_lock(&mysys_var->mutex); 3393 mysys_var->current_mutex = 0; 3394 mysys_var->current_cond = 0; 3395 if (stage) 3396 enter_stage(stage, src_function, src_file, src_line); 3397 mysql_mutex_unlock(&mysys_var->mutex); 3398 return; 3399 } 3400 virtual int is_killed() { return killed; } 3401 virtual THD* get_thd() { return this; } 3402 3403 /** 3404 A callback to the server internals that is used to address 3405 special cases of the locking protocol. 3406 Invoked when acquiring an exclusive lock, for each thread that 3407 has a conflicting shared metadata lock. 3408 3409 This function: 3410 - aborts waiting of the thread on a data lock, to make it notice 3411 the pending exclusive lock and back off. 3412 - if the thread is an INSERT DELAYED thread, sends it a KILL 3413 signal to terminate it. 3414 3415 @note This function does not wait for the thread to give away its 3416 locks. Waiting is done outside for all threads at once. 3417 3418 @param ctx_in_use The MDL context owner (thread) to wake up. 3419 @param needs_thr_lock_abort Indicates that to wake up thread 3420 this call needs to abort its waiting 3421 on table-level lock. 3422 3423 @retval TRUE if the thread was woken up 3424 @retval FALSE otherwise. 3425 */ 3426 virtual bool notify_shared_lock(MDL_context_owner *ctx_in_use, 3427 bool needs_thr_lock_abort); 3428 3429 // End implementation of MDL_context_owner interface. 3430 3431 inline bool is_strict_mode() const 3432 { 3433 return (bool) (variables.sql_mode & (MODE_STRICT_TRANS_TABLES | 3434 MODE_STRICT_ALL_TABLES)); 3435 } 3436 inline bool backslash_escapes() const 3437 { 3438 return !MY_TEST(variables.sql_mode & MODE_NO_BACKSLASH_ESCAPES); 3439 } 3440 const Type_handler *type_handler_for_datetime() const; 3441 bool timestamp_to_TIME(MYSQL_TIME *ltime, my_time_t ts, 3442 ulong sec_part, ulonglong fuzzydate); 3443 inline my_time_t query_start() { return start_time; } 3444 inline ulong query_start_sec_part() 3445 { query_start_sec_part_used=1; return start_time_sec_part; } 3446 MYSQL_TIME query_start_TIME(); 3447 3448 private: 3449 struct { 3450 my_hrtime_t start; 3451 my_time_t sec; 3452 ulong sec_part; 3453 } system_time; 3454 3455 void set_system_time() 3456 { 3457 my_hrtime_t hrtime= my_hrtime(); 3458 my_time_t sec= hrtime_to_my_time(hrtime); 3459 ulong sec_part= hrtime_sec_part(hrtime); 3460 if (sec > system_time.sec || 3461 (sec == system_time.sec && sec_part > system_time.sec_part) || 3462 hrtime.val < system_time.start.val) 3463 { 3464 system_time.sec= sec; 3465 system_time.sec_part= sec_part; 3466 system_time.start= hrtime; 3467 } 3468 else 3469 { 3470 if (system_time.sec_part < TIME_MAX_SECOND_PART) 3471 system_time.sec_part++; 3472 else 3473 { 3474 system_time.sec++; 3475 system_time.sec_part= 0; 3476 } 3477 } 3478 } 3479 3480 public: 3481 timeval transaction_time() 3482 { 3483 if (!in_multi_stmt_transaction_mode()) 3484 transaction.start_time.reset(this); 3485 return transaction.start_time; 3486 } 3487 3488 inline void set_start_time() 3489 { 3490 if (user_time.val) 3491 { 3492 start_time= hrtime_to_my_time(user_time); 3493 start_time_sec_part= hrtime_sec_part(user_time); 3494 } 3495 else 3496 { 3497 set_system_time(); 3498 start_time= system_time.sec; 3499 start_time_sec_part= system_time.sec_part; 3500 } 3501 PSI_CALL_set_thread_start_time(start_time); 3502 } 3503 inline void set_time() 3504 { 3505 set_start_time(); 3506 start_utime= utime_after_lock= microsecond_interval_timer(); 3507 } 3508 /* only used in SET @@timestamp=... */ 3509 inline void set_time(my_hrtime_t t) 3510 { 3511 user_time= t; 3512 set_time(); 3513 } 3514 /* 3515 this is only used by replication and BINLOG command. 3516 usecs > TIME_MAX_SECOND_PART means "was not in binlog" 3517 */ 3518 inline void set_time(my_time_t t, ulong sec_part) 3519 { 3520 if (opt_secure_timestamp > (slave_thread ? SECTIME_REPL : SECTIME_SUPER)) 3521 set_time(); // note that BINLOG itself requires SUPER 3522 else 3523 { 3524 if (sec_part <= TIME_MAX_SECOND_PART) 3525 { 3526 start_time= system_time.sec= t; 3527 start_time_sec_part= system_time.sec_part= sec_part; 3528 } 3529 else if (t != system_time.sec) 3530 { 3531 start_time= system_time.sec= t; 3532 start_time_sec_part= system_time.sec_part= 0; 3533 } 3534 else 3535 { 3536 start_time= t; 3537 start_time_sec_part= ++system_time.sec_part; 3538 } 3539 user_time.val= hrtime_from_time(start_time) + start_time_sec_part; 3540 PSI_CALL_set_thread_start_time(start_time); 3541 start_utime= utime_after_lock= microsecond_interval_timer(); 3542 } 3543 } 3544 void set_time_after_lock() 3545 { 3546 utime_after_lock= microsecond_interval_timer(); 3547 MYSQL_SET_STATEMENT_LOCK_TIME(m_statement_psi, 3548 (utime_after_lock - start_utime)); 3549 } 3550 ulonglong current_utime() { return microsecond_interval_timer(); } 3551 3552 /* Tell SHOW PROCESSLIST to show time from this point */ 3553 inline void set_time_for_next_stage() 3554 { 3555 utime_after_query= current_utime(); 3556 } 3557 3558 /** 3559 Update server status after execution of a top level statement. 3560 Currently only checks if a query was slow, and assigns 3561 the status accordingly. 3562 Evaluate the current time, and if it exceeds the long-query-time 3563 setting, mark the query as slow. 3564 */ 3565 void update_server_status() 3566 { 3567 set_time_for_next_stage(); 3568 if (utime_after_query >= utime_after_lock + variables.long_query_time) 3569 server_status|= SERVER_QUERY_WAS_SLOW; 3570 } 3571 inline ulonglong found_rows(void) 3572 { 3573 return limit_found_rows; 3574 } 3575 /** 3576 Returns TRUE if session is in a multi-statement transaction mode. 3577 3578 OPTION_NOT_AUTOCOMMIT: When autocommit is off, a multi-statement 3579 transaction is implicitly started on the first statement after a 3580 previous transaction has been ended. 3581 3582 OPTION_BEGIN: Regardless of the autocommit status, a multi-statement 3583 transaction can be explicitly started with the statements "START 3584 TRANSACTION", "BEGIN [WORK]", "[COMMIT | ROLLBACK] AND CHAIN", etc. 3585 3586 Note: this doesn't tell you whether a transaction is active. 3587 A session can be in multi-statement transaction mode, and yet 3588 have no active transaction, e.g., in case of: 3589 set @@autocommit=0; 3590 set @a= 3; <-- these statements don't 3591 set transaction isolation level serializable; <-- start an active 3592 flush tables; <-- transaction 3593 3594 I.e. for the above scenario this function returns TRUE, even 3595 though no active transaction has begun. 3596 @sa in_active_multi_stmt_transaction() 3597 */ 3598 inline bool in_multi_stmt_transaction_mode() 3599 { 3600 return variables.option_bits & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN); 3601 } 3602 /** 3603 TRUE if the session is in a multi-statement transaction mode 3604 (@sa in_multi_stmt_transaction_mode()) *and* there is an 3605 active transaction, i.e. there is an explicit start of a 3606 transaction with BEGIN statement, or implicit with a 3607 statement that uses a transactional engine. 3608 3609 For example, these scenarios don't start an active transaction 3610 (even though the server is in multi-statement transaction mode): 3611 3612 set @@autocommit=0; 3613 select * from nontrans_table; 3614 set @var=TRUE; 3615 flush tables; 3616 3617 Note, that even for a statement that starts a multi-statement 3618 transaction (i.e. select * from trans_table), this 3619 flag won't be set until we open the statement's tables 3620 and the engines register themselves for the transaction 3621 (see trans_register_ha()), 3622 hence this method is reliable to use only after 3623 open_tables() has completed. 3624 3625 Why do we need a flag? 3626 ---------------------- 3627 We need to maintain a (at first glance redundant) 3628 session flag, rather than looking at thd->transaction.all.ha_list 3629 because of explicit start of a transaction with BEGIN. 3630 3631 I.e. in case of 3632 BEGIN; 3633 select * from nontrans_t1; <-- in_active_multi_stmt_transaction() is true 3634 */ 3635 inline bool in_active_multi_stmt_transaction() 3636 { 3637 return server_status & SERVER_STATUS_IN_TRANS; 3638 } 3639 inline bool fill_information_schema_tables() 3640 { 3641 return !stmt_arena->is_stmt_prepare(); 3642 } 3643 inline void* trans_alloc(size_t size) 3644 { 3645 return alloc_root(&transaction.mem_root,size); 3646 } 3647 3648 LEX_STRING *make_lex_string(LEX_STRING *lex_str, const char* str, size_t length) 3649 { 3650 if (!(lex_str->str= strmake_root(mem_root, str, length))) 3651 { 3652 lex_str->length= 0; 3653 return 0; 3654 } 3655 lex_str->length= length; 3656 return lex_str; 3657 } 3658 LEX_CSTRING *make_lex_string(LEX_CSTRING *lex_str, const char* str, size_t length) 3659 { 3660 if (!(lex_str->str= strmake_root(mem_root, str, length))) 3661 { 3662 lex_str->length= 0; 3663 return 0; 3664 } 3665 lex_str->length= length; 3666 return lex_str; 3667 } 3668 // Remove double quotes: aaa""bbb -> aaa"bbb 3669 bool quote_unescape(LEX_CSTRING *dst, const LEX_CSTRING *src, char quote) 3670 { 3671 const char *tmp= src->str; 3672 const char *tmpend= src->str + src->length; 3673 char *to; 3674 if (!(dst->str= to= (char *) alloc(src->length + 1))) 3675 { 3676 dst->length= 0; // Safety 3677 return true; 3678 } 3679 for ( ; tmp < tmpend; ) 3680 { 3681 if ((*to++= *tmp++) == quote) 3682 tmp++; // Skip double quotes 3683 } 3684 *to= 0; // End null for safety 3685 dst->length= to - dst->str; 3686 return false; 3687 } 3688 3689 LEX_CSTRING *make_clex_string(const char* str, size_t length) 3690 { 3691 LEX_CSTRING *lex_str; 3692 char *tmp; 3693 if (unlikely(!(lex_str= (LEX_CSTRING *)alloc_root(mem_root, 3694 sizeof(LEX_CSTRING) + 3695 length+1)))) 3696 return 0; 3697 tmp= (char*) (lex_str+1); 3698 lex_str->str= tmp; 3699 memcpy(tmp, str, length); 3700 tmp[length]= 0; 3701 lex_str->length= length; 3702 return lex_str; 3703 } 3704 LEX_CSTRING *make_clex_string(const LEX_CSTRING from) 3705 { 3706 return make_clex_string(from.str, from.length); 3707 } 3708 3709 // Allocate LEX_STRING for character set conversion 3710 bool alloc_lex_string(LEX_STRING *dst, size_t length) 3711 { 3712 if (likely((dst->str= (char*) alloc(length)))) 3713 return false; 3714 dst->length= 0; // Safety 3715 return true; // EOM 3716 } 3717 bool convert_string(LEX_STRING *to, CHARSET_INFO *to_cs, 3718 const char *from, size_t from_length, 3719 CHARSET_INFO *from_cs); 3720 bool convert_string(LEX_CSTRING *to, CHARSET_INFO *to_cs, 3721 const char *from, size_t from_length, 3722 CHARSET_INFO *from_cs) 3723 { 3724 LEX_STRING tmp; 3725 bool rc= convert_string(&tmp, to_cs, from, from_length, from_cs); 3726 to->str= tmp.str; 3727 to->length= tmp.length; 3728 return rc; 3729 } 3730 bool convert_string(LEX_CSTRING *to, CHARSET_INFO *tocs, 3731 const LEX_CSTRING *from, CHARSET_INFO *fromcs, 3732 bool simple_copy_is_possible) 3733 { 3734 if (!simple_copy_is_possible) 3735 return unlikely(convert_string(to, tocs, from->str, from->length, fromcs)); 3736 *to= *from; 3737 return false; 3738 } 3739 /* 3740 Convert a strings between character sets. 3741 Uses my_convert_fix(), which uses an mb_wc .. mc_mb loop internally. 3742 dstcs and srccs cannot be &my_charset_bin. 3743 */ 3744 bool convert_fix(CHARSET_INFO *dstcs, LEX_STRING *dst, 3745 CHARSET_INFO *srccs, const char *src, size_t src_length, 3746 String_copier *status); 3747 3748 /* 3749 Same as above, but additionally sends ER_INVALID_CHARACTER_STRING 3750 in case of bad byte sequences or Unicode conversion problems. 3751 */ 3752 bool convert_with_error(CHARSET_INFO *dstcs, LEX_STRING *dst, 3753 CHARSET_INFO *srccs, 3754 const char *src, size_t src_length); 3755 /* 3756 If either "dstcs" or "srccs" is &my_charset_bin, 3757 then performs native copying using cs->cset->copy_fix(). 3758 Otherwise, performs Unicode conversion using convert_fix(). 3759 */ 3760 bool copy_fix(CHARSET_INFO *dstcs, LEX_STRING *dst, 3761 CHARSET_INFO *srccs, const char *src, size_t src_length, 3762 String_copier *status); 3763 3764 /* 3765 Same as above, but additionally sends ER_INVALID_CHARACTER_STRING 3766 in case of bad byte sequences or Unicode conversion problems. 3767 */ 3768 bool copy_with_error(CHARSET_INFO *dstcs, LEX_STRING *dst, 3769 CHARSET_INFO *srccs, const char *src, size_t src_length); 3770 3771 bool convert_string(String *s, CHARSET_INFO *from_cs, CHARSET_INFO *to_cs); 3772 3773 /* 3774 Check if the string is wellformed, raise an error if not wellformed. 3775 @param str - The string to check. 3776 @param length - the string length. 3777 */ 3778 bool check_string_for_wellformedness(const char *str, 3779 size_t length, 3780 CHARSET_INFO *cs) const; 3781 3782 bool to_ident_sys_alloc(Lex_ident_sys_st *to, const Lex_ident_cli_st *from); 3783 3784 /* 3785 Create a string literal with optional client->connection conversion. 3786 @param str - the string in the client character set 3787 @param length - length of the string 3788 @param repertoire - the repertoire of the string 3789 */ 3790 Item_basic_constant *make_string_literal(const char *str, size_t length, 3791 uint repertoire); 3792 Item_basic_constant *make_string_literal(const Lex_string_with_metadata_st &str) 3793 { 3794 uint repertoire= str.repertoire(variables.character_set_client); 3795 return make_string_literal(str.str, str.length, repertoire); 3796 } 3797 Item_basic_constant *make_string_literal_nchar(const Lex_string_with_metadata_st &str); 3798 Item_basic_constant *make_string_literal_charset(const Lex_string_with_metadata_st &str, 3799 CHARSET_INFO *cs); 3800 bool make_text_string_sys(LEX_CSTRING *to, 3801 const Lex_string_with_metadata_st *from) 3802 { 3803 return convert_string(to, system_charset_info, 3804 from, charset(), charset_is_system_charset); 3805 } 3806 bool make_text_string_connection(LEX_CSTRING *to, 3807 const Lex_string_with_metadata_st *from) 3808 { 3809 return convert_string(to, variables.collation_connection, 3810 from, charset(), charset_is_collation_connection); 3811 } 3812 bool make_text_string_filesystem(LEX_CSTRING *to, 3813 const Lex_string_with_metadata_st *from) 3814 { 3815 return convert_string(to, variables.character_set_filesystem, 3816 from, charset(), charset_is_character_set_filesystem); 3817 } 3818 void add_changed_table(TABLE *table); 3819 void add_changed_table(const char *key, size_t key_length); 3820 CHANGED_TABLE_LIST * changed_table_dup(const char *key, size_t key_length); 3821 int prepare_explain_fields(select_result *result, List<Item> *field_list, 3822 uint8 explain_flags, bool is_analyze); 3823 int send_explain_fields(select_result *result, uint8 explain_flags, 3824 bool is_analyze); 3825 void make_explain_field_list(List<Item> &field_list, uint8 explain_flags, 3826 bool is_analyze); 3827 void make_explain_json_field_list(List<Item> &field_list, bool is_analyze); 3828 3829 /** 3830 Clear the current error, if any. 3831 We do not clear is_fatal_error or is_fatal_sub_stmt_error since we 3832 assume this is never called if the fatal error is set. 3833 3834 @todo: To silence an error, one should use Internal_error_handler 3835 mechanism. Issuing an error that can be possibly later "cleared" is not 3836 compatible with other installed error handlers and audit plugins. 3837 */ 3838 inline void clear_error(bool clear_diagnostics= 0) 3839 { 3840 DBUG_ENTER("clear_error"); 3841 if (get_stmt_da()->is_error() || clear_diagnostics) 3842 get_stmt_da()->reset_diagnostics_area(); 3843 is_slave_error= 0; 3844 if (killed == KILL_BAD_DATA) 3845 reset_killed(); 3846 DBUG_VOID_RETURN; 3847 } 3848 3849 #ifndef EMBEDDED_LIBRARY 3850 inline bool vio_ok() const { return net.vio != 0; } 3851 /** Return FALSE if connection to client is broken. */ 3852 bool is_connected() 3853 { 3854 /* 3855 All system threads (e.g., the slave IO thread) are connected but 3856 not using vio. So this function always returns true for all 3857 system threads. 3858 */ 3859 return system_thread || (vio_ok() ? vio_is_connected(net.vio) : FALSE); 3860 } 3861 #else 3862 inline bool vio_ok() const { return TRUE; } 3863 inline bool is_connected() { return TRUE; } 3864 #endif 3865 /** 3866 Mark the current error as fatal. Warning: this does not 3867 set any error, it sets a property of the error, so must be 3868 followed or prefixed with my_error(). 3869 */ 3870 inline void fatal_error() 3871 { 3872 DBUG_ASSERT(get_stmt_da()->is_error() || killed); 3873 is_fatal_error= 1; 3874 DBUG_PRINT("error",("Fatal error set")); 3875 } 3876 /** 3877 TRUE if there is an error in the error stack. 3878 3879 Please use this method instead of direct access to 3880 net.report_error. 3881 3882 If TRUE, the current (sub)-statement should be aborted. 3883 The main difference between this member and is_fatal_error 3884 is that a fatal error can not be handled by a stored 3885 procedure continue handler, whereas a normal error can. 3886 3887 To raise this flag, use my_error(). 3888 */ 3889 inline bool is_error() const { return m_stmt_da->is_error(); } 3890 void set_bulk_execution(void *bulk) 3891 { 3892 bulk_param= bulk; 3893 m_stmt_da->set_bulk_execution(MY_TEST(bulk)); 3894 } 3895 bool is_bulk_op() const { return MY_TEST(bulk_param); } 3896 3897 /// Returns Diagnostics-area for the current statement. 3898 Diagnostics_area *get_stmt_da() 3899 { return m_stmt_da; } 3900 3901 /// Returns Diagnostics-area for the current statement. 3902 const Diagnostics_area *get_stmt_da() const 3903 { return m_stmt_da; } 3904 3905 /// Sets Diagnostics-area for the current statement. 3906 void set_stmt_da(Diagnostics_area *da) 3907 { m_stmt_da= da; } 3908 3909 inline CHARSET_INFO *charset() const { return variables.character_set_client; } 3910 void update_charset(); 3911 void update_charset(CHARSET_INFO *character_set_client, 3912 CHARSET_INFO *collation_connection) 3913 { 3914 variables.character_set_client= character_set_client; 3915 variables.collation_connection= collation_connection; 3916 update_charset(); 3917 } 3918 void update_charset(CHARSET_INFO *character_set_client, 3919 CHARSET_INFO *collation_connection, 3920 CHARSET_INFO *character_set_results) 3921 { 3922 variables.character_set_client= character_set_client; 3923 variables.collation_connection= collation_connection; 3924 variables.character_set_results= character_set_results; 3925 update_charset(); 3926 } 3927 3928 inline Query_arena *activate_stmt_arena_if_needed(Query_arena *backup) 3929 { 3930 /* 3931 Use the persistent arena if we are in a prepared statement or a stored 3932 procedure statement and we have not already changed to use this arena. 3933 */ 3934 if (!stmt_arena->is_conventional() && mem_root != stmt_arena->mem_root) 3935 { 3936 set_n_backup_active_arena(stmt_arena, backup); 3937 return stmt_arena; 3938 } 3939 return 0; 3940 } 3941 3942 3943 bool is_item_tree_change_register_required() 3944 { 3945 return !stmt_arena->is_conventional() 3946 || stmt_arena->type() == Query_arena::TABLE_ARENA; 3947 } 3948 3949 void change_item_tree(Item **place, Item *new_value) 3950 { 3951 DBUG_ENTER("THD::change_item_tree"); 3952 DBUG_PRINT("enter", ("Register: %p (%p) <- %p", 3953 *place, place, new_value)); 3954 /* TODO: check for OOM condition here */ 3955 if (is_item_tree_change_register_required()) 3956 nocheck_register_item_tree_change(place, *place, mem_root); 3957 *place= new_value; 3958 DBUG_VOID_RETURN; 3959 } 3960 /** 3961 Make change in item tree after checking whether it needs registering 3962 3963 3964 @param place place where we should assign new value 3965 @param new_value place of the new value 3966 3967 @details 3968 see check_and_register_item_tree_change details 3969 */ 3970 void check_and_register_item_tree(Item **place, Item **new_value) 3971 { 3972 if (!stmt_arena->is_conventional()) 3973 check_and_register_item_tree_change(place, new_value, mem_root); 3974 /* 3975 We have to use memcpy instead of *place= *new_value merge to 3976 avoid problems with strict aliasing. 3977 */ 3978 memcpy((char*) place, new_value, sizeof(*new_value)); 3979 } 3980 3981 /* 3982 Cleanup statement parse state (parse tree, lex) and execution 3983 state after execution of a non-prepared SQL statement. 3984 */ 3985 void end_statement(); 3986 3987 /* 3988 Mark thread to be killed, with optional error number and string. 3989 string is not released, so it has to be allocted on thd mem_root 3990 or be a global string 3991 3992 Ensure that we don't replace a kill with a lesser one. For example 3993 if user has done 'kill_connection' we shouldn't replace it with 3994 KILL_QUERY. 3995 */ 3996 inline void set_killed(killed_state killed_arg, 3997 int killed_errno_arg= 0, 3998 const char *killed_err_msg_arg= 0) 3999 { 4000 mysql_mutex_lock(&LOCK_thd_kill); 4001 set_killed_no_mutex(killed_arg, killed_errno_arg, killed_err_msg_arg); 4002 mysql_mutex_unlock(&LOCK_thd_kill); 4003 } 4004 /* 4005 This is only used by THD::awake where we need to keep the lock mutex 4006 locked over some time. 4007 It's ok to have this inline, as in most cases killed_errno_arg will 4008 be a constant 0 and most of the function will disappear. 4009 */ 4010 inline void set_killed_no_mutex(killed_state killed_arg, 4011 int killed_errno_arg= 0, 4012 const char *killed_err_msg_arg= 0) 4013 { 4014 if (killed <= killed_arg) 4015 { 4016 killed= killed_arg; 4017 if (killed_errno_arg) 4018 { 4019 /* 4020 If alloc fails, we only remember the killed flag. 4021 The worst things that can happen is that we get 4022 a suboptimal error message. 4023 */ 4024 killed_err= (err_info*) alloc_root(&main_mem_root, sizeof(*killed_err)); 4025 if (likely(killed_err)) 4026 { 4027 killed_err->no= killed_errno_arg; 4028 ::strmake((char*) killed_err->msg, killed_err_msg_arg, 4029 sizeof(killed_err->msg)-1); 4030 } 4031 } 4032 } 4033 } 4034 int killed_errno(); 4035 void reset_killed(); 4036 inline void reset_kill_query() 4037 { 4038 if (killed < KILL_CONNECTION) 4039 { 4040 reset_killed(); 4041 mysys_var->abort= 0; 4042 } 4043 } 4044 inline void send_kill_message() 4045 { 4046 mysql_mutex_lock(&LOCK_thd_kill); 4047 int err= killed_errno(); 4048 if (err) 4049 my_message(err, killed_err ? killed_err->msg : ER_THD(this, err), 4050 MYF(0)); 4051 mysql_mutex_unlock(&LOCK_thd_kill); 4052 } 4053 /* return TRUE if we will abort query if we make a warning now */ 4054 inline bool really_abort_on_warning() 4055 { 4056 return (abort_on_warning && 4057 (!transaction.stmt.modified_non_trans_table || 4058 (variables.sql_mode & MODE_STRICT_ALL_TABLES))); 4059 } 4060 void set_status_var_init(); 4061 void reset_n_backup_open_tables_state(Open_tables_backup *backup); 4062 void restore_backup_open_tables_state(Open_tables_backup *backup); 4063 void reset_sub_statement_state(Sub_statement_state *backup, uint new_state); 4064 void restore_sub_statement_state(Sub_statement_state *backup); 4065 void store_slow_query_state(Sub_statement_state *backup); 4066 void reset_slow_query_state(); 4067 void add_slow_query_state(Sub_statement_state *backup); 4068 void set_n_backup_active_arena(Query_arena *set, Query_arena *backup); 4069 void restore_active_arena(Query_arena *set, Query_arena *backup); 4070 4071 inline void get_binlog_format(enum_binlog_format *format, 4072 enum_binlog_format *current_format) 4073 { 4074 *format= (enum_binlog_format) variables.binlog_format; 4075 *current_format= current_stmt_binlog_format; 4076 } 4077 inline enum_binlog_format get_current_stmt_binlog_format() 4078 { 4079 return current_stmt_binlog_format; 4080 } 4081 inline void set_binlog_format(enum_binlog_format format, 4082 enum_binlog_format current_format) 4083 { 4084 DBUG_ENTER("set_binlog_format"); 4085 variables.binlog_format= format; 4086 current_stmt_binlog_format= current_format; 4087 DBUG_VOID_RETURN; 4088 } 4089 inline void set_binlog_format_stmt() 4090 { 4091 DBUG_ENTER("set_binlog_format_stmt"); 4092 variables.binlog_format= BINLOG_FORMAT_STMT; 4093 current_stmt_binlog_format= BINLOG_FORMAT_STMT; 4094 DBUG_VOID_RETURN; 4095 } 4096 /* 4097 @todo Make these methods private or remove them completely. Only 4098 decide_logging_format should call them. /Sven 4099 */ 4100 inline void set_current_stmt_binlog_format_row_if_mixed() 4101 { 4102 DBUG_ENTER("set_current_stmt_binlog_format_row_if_mixed"); 4103 /* 4104 This should only be called from decide_logging_format. 4105 4106 @todo Once we have ensured this, uncomment the following 4107 statement, remove the big comment below that, and remove the 4108 in_sub_stmt==0 condition from the following 'if'. 4109 */ 4110 /* DBUG_ASSERT(in_sub_stmt == 0); */ 4111 /* 4112 If in a stored/function trigger, the caller should already have done the 4113 change. We test in_sub_stmt to prevent introducing bugs where people 4114 wouldn't ensure that, and would switch to row-based mode in the middle 4115 of executing a stored function/trigger (which is too late, see also 4116 reset_current_stmt_binlog_format_row()); this condition will make their 4117 tests fail and so force them to propagate the 4118 lex->binlog_row_based_if_mixed upwards to the caller. 4119 */ 4120 if ((wsrep_binlog_format() == BINLOG_FORMAT_MIXED) && (in_sub_stmt == 0)) 4121 set_current_stmt_binlog_format_row(); 4122 4123 DBUG_VOID_RETURN; 4124 } 4125 4126 inline void set_current_stmt_binlog_format(enum_binlog_format format) 4127 { 4128 current_stmt_binlog_format= format; 4129 } 4130 4131 inline void set_current_stmt_binlog_format_row() 4132 { 4133 DBUG_ENTER("set_current_stmt_binlog_format_row"); 4134 current_stmt_binlog_format= BINLOG_FORMAT_ROW; 4135 DBUG_VOID_RETURN; 4136 } 4137 /* Set binlog format temporarily to statement. Returns old format */ 4138 inline enum_binlog_format set_current_stmt_binlog_format_stmt() 4139 { 4140 enum_binlog_format orig_format= current_stmt_binlog_format; 4141 DBUG_ENTER("set_current_stmt_binlog_format_stmt"); 4142 current_stmt_binlog_format= BINLOG_FORMAT_STMT; 4143 DBUG_RETURN(orig_format); 4144 } 4145 inline void restore_stmt_binlog_format(enum_binlog_format format) 4146 { 4147 DBUG_ENTER("restore_stmt_binlog_format"); 4148 DBUG_ASSERT(!is_current_stmt_binlog_format_row()); 4149 current_stmt_binlog_format= format; 4150 DBUG_VOID_RETURN; 4151 } 4152 inline void reset_current_stmt_binlog_format_row() 4153 { 4154 DBUG_ENTER("reset_current_stmt_binlog_format_row"); 4155 /* 4156 If there are temporary tables, don't reset back to 4157 statement-based. Indeed it could be that: 4158 CREATE TEMPORARY TABLE t SELECT UUID(); # row-based 4159 # and row-based does not store updates to temp tables 4160 # in the binlog. 4161 INSERT INTO u SELECT * FROM t; # stmt-based 4162 and then the INSERT will fail as data inserted into t was not logged. 4163 So we continue with row-based until the temp table is dropped. 4164 If we are in a stored function or trigger, we mustn't reset in the 4165 middle of its execution (as the binary logging way of a stored function 4166 or trigger is decided when it starts executing, depending for example on 4167 the caller (for a stored function: if caller is SELECT or 4168 INSERT/UPDATE/DELETE...). 4169 */ 4170 DBUG_PRINT("debug", 4171 ("temporary_tables: %s, in_sub_stmt: %s, system_thread: %s", 4172 YESNO(has_thd_temporary_tables()), YESNO(in_sub_stmt), 4173 show_system_thread(system_thread))); 4174 if (in_sub_stmt == 0) 4175 { 4176 if (wsrep_binlog_format() == BINLOG_FORMAT_ROW) 4177 set_current_stmt_binlog_format_row(); 4178 else if (!has_thd_temporary_tables()) 4179 set_current_stmt_binlog_format_stmt(); 4180 } 4181 DBUG_VOID_RETURN; 4182 } 4183 4184 /** 4185 Set the current database; use deep copy of C-string. 4186 4187 @param new_db a pointer to the new database name. 4188 @param new_db_len length of the new database name. 4189 4190 Initialize the current database from a NULL-terminated string with 4191 length. If we run out of memory, we free the current database and 4192 return TRUE. This way the user will notice the error as there will be 4193 no current database selected (in addition to the error message set by 4194 malloc). 4195 4196 @note This operation just sets {db, db_length}. Switching the current 4197 database usually involves other actions, like switching other database 4198 attributes including security context. In the future, this operation 4199 will be made private and more convenient interface will be provided. 4200 4201 @return Operation status 4202 @retval FALSE Success 4203 @retval TRUE Out-of-memory error 4204 */ 4205 bool set_db(const LEX_CSTRING *new_db); 4206 4207 /** Set the current database, without copying */ 4208 void reset_db(const LEX_CSTRING *new_db); 4209 4210 /* 4211 Copy the current database to the argument. Use the current arena to 4212 allocate memory for a deep copy: current database may be freed after 4213 a statement is parsed but before it's executed. 4214 4215 Can only be called by owner of thd (no mutex protection) 4216 */ 4217 bool copy_db_to(LEX_CSTRING *to) 4218 { 4219 if (db.str == NULL) 4220 { 4221 /* 4222 No default database is set. In this case if it's guaranteed that 4223 no CTE can be used in the statement then we can throw an error right 4224 now at the parser stage. Otherwise the decision about throwing such 4225 a message must be postponed until a post-parser stage when we are able 4226 to resolve all CTE names as we don't need this message to be thrown 4227 for any CTE references. 4228 */ 4229 if (!lex->with_cte_resolution) 4230 my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0)); 4231 return TRUE; 4232 } 4233 4234 to->str= strmake(db.str, db.length); 4235 to->length= db.length; 4236 return to->str == NULL; /* True on error */ 4237 } 4238 /* Get db name or "". Use for printing current db */ 4239 const char *get_db() 4240 { return safe_str(db.str); } 4241 4242 thd_scheduler event_scheduler; 4243 4244 public: 4245 inline Internal_error_handler *get_internal_handler() 4246 { return m_internal_handler; } 4247 4248 /** 4249 Add an internal error handler to the thread execution context. 4250 @param handler the exception handler to add 4251 */ 4252 void push_internal_handler(Internal_error_handler *handler); 4253 4254 private: 4255 /** 4256 Handle a sql condition. 4257 @param sql_errno the condition error number 4258 @param sqlstate the condition sqlstate 4259 @param level the condition level 4260 @param msg the condition message text 4261 @param[out] cond_hdl the sql condition raised, if any 4262 @return true if the condition is handled 4263 */ 4264 bool handle_condition(uint sql_errno, 4265 const char* sqlstate, 4266 Sql_condition::enum_warning_level *level, 4267 const char* msg, 4268 Sql_condition ** cond_hdl); 4269 4270 public: 4271 /** 4272 Remove the error handler last pushed. 4273 */ 4274 Internal_error_handler *pop_internal_handler(); 4275 4276 /** 4277 Raise an exception condition. 4278 @param code the MYSQL_ERRNO error code of the error 4279 */ 4280 void raise_error(uint code); 4281 4282 /** 4283 Raise an exception condition, with a formatted message. 4284 @param code the MYSQL_ERRNO error code of the error 4285 */ 4286 void raise_error_printf(uint code, ...); 4287 4288 /** 4289 Raise a completion condition (warning). 4290 @param code the MYSQL_ERRNO error code of the warning 4291 */ 4292 void raise_warning(uint code); 4293 4294 /** 4295 Raise a completion condition (warning), with a formatted message. 4296 @param code the MYSQL_ERRNO error code of the warning 4297 */ 4298 void raise_warning_printf(uint code, ...); 4299 4300 /** 4301 Raise a completion condition (note), with a fixed message. 4302 @param code the MYSQL_ERRNO error code of the note 4303 */ 4304 void raise_note(uint code); 4305 4306 /** 4307 Raise an completion condition (note), with a formatted message. 4308 @param code the MYSQL_ERRNO error code of the note 4309 */ 4310 void raise_note_printf(uint code, ...); 4311 4312 /** 4313 @brief Push an error message into MySQL error stack with line 4314 and position information. 4315 4316 This function provides semantic action implementers with a way 4317 to push the famous "You have a syntax error near..." error 4318 message into the error stack, which is normally produced only if 4319 a parse error is discovered internally by the Bison generated 4320 parser. 4321 */ 4322 void parse_error(const char *err_text, const char *yytext) 4323 { 4324 Lex_input_stream *lip= &m_parser_state->m_lip; 4325 if (!yytext && !(yytext= lip->get_tok_start())) 4326 yytext= ""; 4327 /* Push an error into the error stack */ 4328 ErrConvString err(yytext, strlen(yytext), variables.character_set_client); 4329 my_printf_error(ER_PARSE_ERROR, ER_THD(this, ER_PARSE_ERROR), MYF(0), 4330 err_text, err.ptr(), lip->yylineno); 4331 } 4332 void parse_error(uint err_number, const char *yytext= 0) 4333 { 4334 parse_error(ER_THD(this, err_number), yytext); 4335 } 4336 void parse_error() 4337 { 4338 parse_error(ER_SYNTAX_ERROR); 4339 } 4340 #ifdef mysqld_error_find_printf_error_used 4341 void parse_error(const char *t) 4342 { 4343 } 4344 #endif 4345 private: 4346 /* 4347 Only the implementation of the SIGNAL and RESIGNAL statements 4348 is permitted to raise SQL conditions in a generic way, 4349 or to raise them by bypassing handlers (RESIGNAL). 4350 To raise a SQL condition, the code should use the public 4351 raise_error() or raise_warning() methods provided by class THD. 4352 */ 4353 friend class Sql_cmd_common_signal; 4354 friend class Sql_cmd_signal; 4355 friend class Sql_cmd_resignal; 4356 friend void push_warning(THD*, Sql_condition::enum_warning_level, uint, const char*); 4357 friend void my_message_sql(uint, const char *, myf); 4358 4359 /** 4360 Raise a generic SQL condition. 4361 @param sql_errno the condition error number 4362 @param sqlstate the condition SQLSTATE 4363 @param level the condition level 4364 @param msg the condition message text 4365 @return The condition raised, or NULL 4366 */ 4367 Sql_condition* 4368 raise_condition(uint sql_errno, 4369 const char* sqlstate, 4370 Sql_condition::enum_warning_level level, 4371 const char* msg) 4372 { 4373 return raise_condition(sql_errno, sqlstate, level, 4374 Sql_user_condition_identity(), msg); 4375 } 4376 4377 /** 4378 Raise a generic or a user defined SQL condition. 4379 @param ucid - the user condition identity 4380 (or an empty identity if not a user condition) 4381 @param sql_errno - the condition error number 4382 @param sqlstate - the condition SQLSTATE 4383 @param level - the condition level 4384 @param msg - the condition message text 4385 @return The condition raised, or NULL 4386 */ 4387 Sql_condition* 4388 raise_condition(uint sql_errno, 4389 const char* sqlstate, 4390 Sql_condition::enum_warning_level level, 4391 const Sql_user_condition_identity &ucid, 4392 const char* msg); 4393 4394 Sql_condition* 4395 raise_condition(const Sql_condition *cond) 4396 { 4397 Sql_condition *raised= raise_condition(cond->get_sql_errno(), 4398 cond->get_sqlstate(), 4399 cond->get_level(), 4400 *cond/*Sql_user_condition_identity*/, 4401 cond->get_message_text()); 4402 if (raised) 4403 raised->copy_opt_attributes(cond); 4404 return raised; 4405 } 4406 4407 public: 4408 /** Overloaded to guard query/query_length fields */ 4409 virtual void set_statement(Statement *stmt); 4410 void set_command(enum enum_server_command command) 4411 { 4412 m_command= command; 4413 #ifdef HAVE_PSI_THREAD_INTERFACE 4414 PSI_STATEMENT_CALL(set_thread_command)(m_command); 4415 #endif 4416 } 4417 inline enum enum_server_command get_command() const 4418 { return m_command; } 4419 4420 /** 4421 Assign a new value to thd->query and thd->query_id and mysys_var. 4422 Protected with LOCK_thd_data mutex. 4423 */ 4424 void set_query(char *query_arg, size_t query_length_arg, 4425 CHARSET_INFO *cs_arg) 4426 { 4427 set_query(CSET_STRING(query_arg, query_length_arg, cs_arg)); 4428 } 4429 void set_query(char *query_arg, size_t query_length_arg) /*Mutex protected*/ 4430 { 4431 set_query(CSET_STRING(query_arg, query_length_arg, charset())); 4432 } 4433 void set_query(const CSET_STRING &string_arg) 4434 { 4435 mysql_mutex_lock(&LOCK_thd_data); 4436 set_query_inner(string_arg); 4437 mysql_mutex_unlock(&LOCK_thd_data); 4438 4439 PSI_CALL_set_thread_info(query(), query_length()); 4440 } 4441 void reset_query() /* Mutex protected */ 4442 { set_query(CSET_STRING()); } 4443 void set_query_and_id(char *query_arg, uint32 query_length_arg, 4444 CHARSET_INFO *cs, query_id_t new_query_id); 4445 void set_query_id(query_id_t new_query_id) 4446 { 4447 query_id= new_query_id; 4448 } 4449 void set_open_tables(TABLE *open_tables_arg) 4450 { 4451 mysql_mutex_lock(&LOCK_thd_data); 4452 open_tables= open_tables_arg; 4453 mysql_mutex_unlock(&LOCK_thd_data); 4454 } 4455 void set_mysys_var(struct st_my_thread_var *new_mysys_var); 4456 void enter_locked_tables_mode(enum_locked_tables_mode mode_arg) 4457 { 4458 DBUG_ASSERT(locked_tables_mode == LTM_NONE); 4459 4460 if (mode_arg == LTM_LOCK_TABLES) 4461 { 4462 /* 4463 When entering LOCK TABLES mode we should set explicit duration 4464 for all metadata locks acquired so far in order to avoid releasing 4465 them till UNLOCK TABLES statement. 4466 We don't do this when entering prelocked mode since sub-statements 4467 don't release metadata locks and restoring status-quo after leaving 4468 prelocking mode gets complicated. 4469 */ 4470 mdl_context.set_explicit_duration_for_all_locks(); 4471 } 4472 4473 locked_tables_mode= mode_arg; 4474 } 4475 void leave_locked_tables_mode(); 4476 /* Relesae transactional locks if there are no active transactions */ 4477 void release_transactional_locks() 4478 { 4479 if (!(server_status & 4480 (SERVER_STATUS_IN_TRANS | SERVER_STATUS_IN_TRANS_READONLY))) 4481 mdl_context.release_transactional_locks(); 4482 } 4483 int decide_logging_format(TABLE_LIST *tables); 4484 /* 4485 In Some cases when decide_logging_format is called it does not have all 4486 information to decide the logging format. So that cases we call decide_logging_format_2 4487 at later stages in execution. 4488 One example would be binlog format for IODKU but column with unique key is not inserted. 4489 We dont have inserted columns info when we call decide_logging_format so on later stage we call 4490 decide_logging_format_low 4491 4492 @returns 0 if no format is changed 4493 1 if there is change in binlog format 4494 */ 4495 int decide_logging_format_low(TABLE *table); 4496 4497 enum need_invoker { INVOKER_NONE=0, INVOKER_USER, INVOKER_ROLE}; 4498 void binlog_invoker(bool role) { m_binlog_invoker= role ? INVOKER_ROLE : INVOKER_USER; } 4499 enum need_invoker need_binlog_invoker() { return m_binlog_invoker; } 4500 void get_definer(LEX_USER *definer, bool role); 4501 void set_invoker(const LEX_CSTRING *user, const LEX_CSTRING *host) 4502 { 4503 invoker.user= *user; 4504 invoker.host= *host; 4505 } 4506 LEX_CSTRING get_invoker_user() { return invoker.user; } 4507 LEX_CSTRING get_invoker_host() { return invoker.host; } 4508 bool has_invoker() { return invoker.user.length > 0; } 4509 4510 void print_aborted_warning(uint threshold, const char *reason) 4511 { 4512 if (global_system_variables.log_warnings > threshold) 4513 { 4514 Security_context *sctx= &main_security_ctx; 4515 sql_print_warning(ER_THD(this, ER_NEW_ABORTING_CONNECTION), 4516 thread_id, (db.str ? db.str : "unconnected"), 4517 sctx->user ? sctx->user : "unauthenticated", 4518 sctx->host_or_ip, reason); 4519 } 4520 } 4521 4522 public: 4523 void clear_wakeup_ready() { wakeup_ready= false; } 4524 /* 4525 Sleep waiting for others to wake us up with signal_wakeup_ready(). 4526 Must call clear_wakeup_ready() before waiting. 4527 */ 4528 void wait_for_wakeup_ready(); 4529 /* Wake this thread up from wait_for_wakeup_ready(). */ 4530 void signal_wakeup_ready(); 4531 4532 void add_status_to_global() 4533 { 4534 DBUG_ASSERT(status_in_global == 0); 4535 mysql_mutex_lock(&LOCK_status); 4536 add_to_status(&global_status_var, &status_var); 4537 /* Mark that this THD status has already been added in global status */ 4538 status_var.global_memory_used= 0; 4539 status_in_global= 1; 4540 mysql_mutex_unlock(&LOCK_status); 4541 } 4542 4543 wait_for_commit *wait_for_commit_ptr; 4544 int wait_for_prior_commit() 4545 { 4546 if (wait_for_commit_ptr) 4547 return wait_for_commit_ptr->wait_for_prior_commit(this); 4548 return 0; 4549 } 4550 void wakeup_subsequent_commits(int wakeup_error) 4551 { 4552 if (wait_for_commit_ptr) 4553 wait_for_commit_ptr->wakeup_subsequent_commits(wakeup_error); 4554 } 4555 wait_for_commit *suspend_subsequent_commits() { 4556 wait_for_commit *suspended= wait_for_commit_ptr; 4557 wait_for_commit_ptr= NULL; 4558 return suspended; 4559 } 4560 void resume_subsequent_commits(wait_for_commit *suspended) { 4561 DBUG_ASSERT(!wait_for_commit_ptr); 4562 wait_for_commit_ptr= suspended; 4563 } 4564 4565 void mark_transaction_to_rollback(bool all); 4566 private: 4567 4568 /** The current internal error handler for this thread, or NULL. */ 4569 Internal_error_handler *m_internal_handler; 4570 4571 /** 4572 The lex to hold the parsed tree of conventional (non-prepared) queries. 4573 Whereas for prepared and stored procedure statements we use an own lex 4574 instance for each new query, for conventional statements we reuse 4575 the same lex. (@see mysql_parse for details). 4576 */ 4577 LEX main_lex; 4578 /** 4579 This memory root is used for two purposes: 4580 - for conventional queries, to allocate structures stored in main_lex 4581 during parsing, and allocate runtime data (execution plan, etc.) 4582 during execution. 4583 - for prepared queries, only to allocate runtime data. The parsed 4584 tree itself is reused between executions and thus is stored elsewhere. 4585 */ 4586 MEM_ROOT main_mem_root; 4587 Diagnostics_area main_da; 4588 Diagnostics_area *m_stmt_da; 4589 4590 /** 4591 It will be set if CURRENT_USER() or CURRENT_ROLE() is called in account 4592 management statements or default definer is set in CREATE/ALTER SP, SF, 4593 Event, TRIGGER or VIEW statements. 4594 4595 Current user or role will be binlogged into Query_log_event if 4596 m_binlog_invoker is not NONE; It will be stored into invoker_host and 4597 invoker_user by SQL thread. 4598 */ 4599 enum need_invoker m_binlog_invoker; 4600 4601 /** 4602 It points to the invoker in the Query_log_event. 4603 SQL thread use it as the default definer in CREATE/ALTER SP, SF, Event, 4604 TRIGGER or VIEW statements or current user in account management 4605 statements if it is not NULL. 4606 */ 4607 AUTHID invoker; 4608 4609 public: 4610 #ifndef EMBEDDED_LIBRARY 4611 Session_tracker session_tracker; 4612 #endif //EMBEDDED_LIBRARY 4613 /* 4614 Flag, mutex and condition for a thread to wait for a signal from another 4615 thread. 4616 4617 Currently used to wait for group commit to complete, can also be used for 4618 other purposes. 4619 */ 4620 bool wakeup_ready; 4621 mysql_mutex_t LOCK_wakeup_ready; 4622 mysql_cond_t COND_wakeup_ready; 4623 /* 4624 The GTID assigned to the last commit. If no GTID was assigned to any commit 4625 so far, this is indicated by last_commit_gtid.seq_no == 0. 4626 */ 4627 private: 4628 rpl_gtid m_last_commit_gtid; 4629 4630 public: 4631 rpl_gtid get_last_commit_gtid() { return m_last_commit_gtid; } 4632 void set_last_commit_gtid(rpl_gtid >id); 4633 4634 4635 LF_PINS *tdc_hash_pins; 4636 LF_PINS *xid_hash_pins; 4637 bool fix_xid_hash_pins(); 4638 4639 /* Members related to temporary tables. */ 4640 public: 4641 /* Opened table states. */ 4642 enum Temporary_table_state { 4643 TMP_TABLE_IN_USE, 4644 TMP_TABLE_NOT_IN_USE, 4645 TMP_TABLE_ANY 4646 }; 4647 bool has_thd_temporary_tables(); 4648 4649 TABLE *create_and_open_tmp_table(handlerton *hton, 4650 LEX_CUSTRING *frm, 4651 const char *path, 4652 const char *db, 4653 const char *table_name, 4654 bool open_in_engine, 4655 bool open_internal_tables); 4656 4657 TABLE *find_temporary_table(const char *db, const char *table_name, 4658 Temporary_table_state state= TMP_TABLE_IN_USE); 4659 TABLE *find_temporary_table(const TABLE_LIST *tl, 4660 Temporary_table_state state= TMP_TABLE_IN_USE); 4661 4662 TMP_TABLE_SHARE *find_tmp_table_share_w_base_key(const char *key, 4663 uint key_length); 4664 TMP_TABLE_SHARE *find_tmp_table_share(const char *db, 4665 const char *table_name); 4666 TMP_TABLE_SHARE *find_tmp_table_share(const TABLE_LIST *tl); 4667 TMP_TABLE_SHARE *find_tmp_table_share(const char *key, size_t key_length); 4668 4669 bool open_temporary_table(TABLE_LIST *tl); 4670 bool open_temporary_tables(TABLE_LIST *tl); 4671 4672 bool close_temporary_tables(); 4673 bool rename_temporary_table(TABLE *table, const LEX_CSTRING *db, 4674 const LEX_CSTRING *table_name); 4675 bool drop_temporary_table(TABLE *table, bool *is_trans, bool delete_table); 4676 bool rm_temporary_table(handlerton *hton, const char *path); 4677 void mark_tmp_tables_as_free_for_reuse(); 4678 void mark_tmp_table_as_free_for_reuse(TABLE *table); 4679 4680 TMP_TABLE_SHARE* save_tmp_table_share(TABLE *table); 4681 void restore_tmp_table_share(TMP_TABLE_SHARE *share); 4682 void close_unused_temporary_table_instances(const TABLE_LIST *tl); 4683 4684 private: 4685 /* Whether a lock has been acquired? */ 4686 bool m_tmp_tables_locked; 4687 4688 bool has_temporary_tables(); 4689 uint create_tmp_table_def_key(char *key, const char *db, 4690 const char *table_name); 4691 TMP_TABLE_SHARE *create_temporary_table(handlerton *hton, LEX_CUSTRING *frm, 4692 const char *path, const char *db, 4693 const char *table_name); 4694 TABLE *find_temporary_table(const char *key, uint key_length, 4695 Temporary_table_state state); 4696 TABLE *open_temporary_table(TMP_TABLE_SHARE *share, const char *alias, 4697 bool open_in_engine); 4698 bool find_and_use_tmp_table(const TABLE_LIST *tl, TABLE **out_table); 4699 bool use_temporary_table(TABLE *table, TABLE **out_table); 4700 void close_temporary_table(TABLE *table); 4701 bool log_events_and_free_tmp_shares(); 4702 void free_tmp_table_share(TMP_TABLE_SHARE *share, bool delete_table); 4703 void free_temporary_table(TABLE *table); 4704 bool lock_temporary_tables(); 4705 void unlock_temporary_tables(); 4706 4707 inline uint tmpkeyval(TMP_TABLE_SHARE *share) 4708 { 4709 return uint4korr(share->table_cache_key.str + 4710 share->table_cache_key.length - 4); 4711 } 4712 4713 inline TMP_TABLE_SHARE *tmp_table_share(TABLE *table) 4714 { 4715 DBUG_ASSERT(table->s->tmp_table); 4716 return static_cast<TMP_TABLE_SHARE *>(table->s); 4717 } 4718 4719 public: 4720 inline ulong wsrep_binlog_format() const 4721 { 4722 return WSREP_FORMAT(variables.binlog_format); 4723 } 4724 4725 #ifdef WITH_WSREP 4726 const bool wsrep_applier; /* dedicated slave applier thread */ 4727 bool wsrep_applier_closing; /* applier marked to close */ 4728 bool wsrep_client_thread; /* to identify client threads*/ 4729 bool wsrep_PA_safe; 4730 bool wsrep_converted_lock_session; 4731 bool wsrep_apply_toi; /* applier processing in TOI */ 4732 enum wsrep_exec_mode wsrep_exec_mode; 4733 query_id_t wsrep_last_query_id; 4734 enum wsrep_query_state wsrep_query_state; 4735 enum wsrep_conflict_state wsrep_conflict_state; 4736 wsrep_trx_meta_t wsrep_trx_meta; 4737 uint32 wsrep_rand; 4738 Relay_log_info *wsrep_rli; 4739 rpl_group_info *wsrep_rgi; 4740 wsrep_ws_handle_t wsrep_ws_handle; 4741 ulong wsrep_retry_counter; // of autocommit 4742 char *wsrep_retry_query; 4743 size_t wsrep_retry_query_len; 4744 enum enum_server_command wsrep_retry_command; 4745 enum wsrep_consistency_check_mode 4746 wsrep_consistency_check; 4747 int wsrep_mysql_replicated; 4748 const char *wsrep_TOI_pre_query; /* a query to apply before 4749 the actual TOI query */ 4750 size_t wsrep_TOI_pre_query_len; 4751 wsrep_po_handle_t wsrep_po_handle; 4752 size_t wsrep_po_cnt; 4753 #ifdef GTID_SUPPORT 4754 rpl_sid wsrep_po_sid; 4755 #endif /* GTID_SUPPORT */ 4756 void *wsrep_apply_format; 4757 char wsrep_info[128]; /* string for dynamic proc info */ 4758 /* 4759 When enabled, do not replicate/binlog updates from the current table that's 4760 being processed. At the moment, it is used to keep mysql.gtid_slave_pos 4761 table updates from being replicated to other nodes via galera replication. 4762 */ 4763 bool wsrep_ignore_table; 4764 wsrep_gtid_t wsrep_sync_wait_gtid; 4765 ulong wsrep_affected_rows; 4766 bool wsrep_replicate_GTID; 4767 bool wsrep_skip_wsrep_GTID; 4768 /* This flag is set when innodb do an intermediate commit to 4769 processing the LOAD DATA INFILE statement by splitting it into 10K 4770 rows chunks. If flag is set, then binlog rotation is not performed 4771 while intermediate transaction try to commit, because in this case 4772 rotation causes unregistration of innodb handler. Later innodb handler 4773 registered again, but replication of last chunk of rows is skipped 4774 by the innodb engine: */ 4775 bool wsrep_split_flag; 4776 #endif /* WITH_WSREP */ 4777 4778 /* Handling of timeouts for commands */ 4779 thr_timer_t query_timer; 4780 4781 public: 4782 void set_query_timer() 4783 { 4784 #ifndef EMBEDDED_LIBRARY 4785 /* 4786 Don't start a query timer if 4787 - If timeouts are not set 4788 - if we are in a stored procedure or sub statement 4789 - If this is a slave thread 4790 - If we already have set a timeout (happens when running prepared 4791 statements that calls mysql_execute_command()) 4792 */ 4793 if (!variables.max_statement_time || spcont || in_sub_stmt || 4794 slave_thread || query_timer.expired == 0) 4795 return; 4796 thr_timer_settime(&query_timer, variables.max_statement_time); 4797 #endif 4798 } 4799 void reset_query_timer() 4800 { 4801 #ifndef EMBEDDED_LIBRARY 4802 if (spcont || in_sub_stmt || slave_thread) 4803 return; 4804 if (!query_timer.expired) 4805 thr_timer_end(&query_timer); 4806 #endif 4807 } 4808 void restore_set_statement_var() 4809 { 4810 main_lex.restore_set_statement_var(); 4811 } 4812 /* Copy relevant `stmt` transaction flags to `all` transaction. */ 4813 void merge_unsafe_rollback_flags() 4814 { 4815 if (transaction.stmt.modified_non_trans_table) 4816 transaction.all.modified_non_trans_table= TRUE; 4817 transaction.all.m_unsafe_rollback_flags|= 4818 (transaction.stmt.m_unsafe_rollback_flags & 4819 (THD_TRANS::MODIFIED_NON_TRANS_TABLE | 4820 THD_TRANS::DID_WAIT | THD_TRANS::CREATED_TEMP_TABLE | 4821 THD_TRANS::DROPPED_TEMP_TABLE | THD_TRANS::DID_DDL | 4822 THD_TRANS::EXECUTED_TABLE_ADMIN_CMD)); 4823 } 4824 /* 4825 Reset current_linfo 4826 Setting current_linfo to 0 needs to be done with LOCK_thread_count to 4827 ensure that adjust_linfo_offsets doesn't use a structure that may 4828 be deleted. 4829 */ 4830 inline void reset_current_linfo() 4831 { 4832 mysql_mutex_lock(&LOCK_thread_count); 4833 current_linfo= 0; 4834 mysql_mutex_unlock(&LOCK_thread_count); 4835 } 4836 4837 bool sql_parser(LEX *old_lex, LEX *lex, 4838 char *str, uint str_len, bool stmt_prepare_mode); 4839 4840 4841 uint get_net_wait_timeout() 4842 { 4843 if (in_active_multi_stmt_transaction()) 4844 { 4845 if (transaction.all.is_trx_read_write()) 4846 { 4847 if (variables.idle_write_transaction_timeout > 0) 4848 return variables.idle_write_transaction_timeout; 4849 } 4850 else 4851 { 4852 if (variables.idle_readonly_transaction_timeout > 0) 4853 return variables.idle_readonly_transaction_timeout; 4854 } 4855 4856 if (variables.idle_transaction_timeout > 0) 4857 return variables.idle_transaction_timeout; 4858 } 4859 4860 return variables.net_wait_timeout; 4861 } 4862 4863 /** 4864 Switch to a sublex, to parse a substatement or an expression. 4865 */ 4866 void set_local_lex(sp_lex_local *sublex) 4867 { 4868 DBUG_ASSERT(lex->sphead); 4869 lex= sublex; 4870 /* Reset part of parser state which needs this. */ 4871 m_parser_state->m_yacc.reset_before_substatement(); 4872 } 4873 4874 /** 4875 Switch back from a sublex (currently pointed by this->lex) to the old lex. 4876 Sublex is merged to "oldlex" and this->lex is set to "oldlex". 4877 4878 This method is called after parsing a substatement or an expression. 4879 set_local_lex() must be previously called. 4880 @param oldlex - The old lex which was active before set_local_lex(). 4881 @returns - false on success, true on error (failed to merge LEX's). 4882 4883 See also sp_head::merge_lex(). 4884 */ 4885 bool restore_from_local_lex_to_old_lex(LEX *oldlex); 4886 4887 Item *sp_fix_func_item(Item **it_addr); 4888 Item *sp_prepare_func_item(Item **it_addr, uint cols= 1); 4889 bool sp_eval_expr(Field *result_field, Item **expr_item_ptr); 4890 }; 4891 4892 inline void add_to_active_threads(THD *thd) 4893 { 4894 mysql_mutex_lock(&LOCK_thread_count); 4895 threads.append(thd); 4896 mysql_mutex_unlock(&LOCK_thread_count); 4897 } 4898 4899 /* 4900 This should be called when you want to delete a thd that was not 4901 running any queries. 4902 */ 4903 4904 inline void unlink_not_visible_thd(THD *thd) 4905 { 4906 mysql_mutex_lock(&LOCK_thread_count); 4907 thd->unlink(); 4908 mysql_mutex_unlock(&LOCK_thread_count); 4909 } 4910 4911 /** A short cut for thd->get_stmt_da()->set_ok_status(). */ 4912 4913 inline void 4914 my_ok(THD *thd, ulonglong affected_rows_arg= 0, ulonglong id= 0, 4915 const char *message= NULL) 4916 { 4917 thd->set_row_count_func(affected_rows_arg); 4918 thd->set_affected_rows(affected_rows_arg); 4919 thd->get_stmt_da()->set_ok_status(affected_rows_arg, id, message); 4920 } 4921 4922 4923 /** A short cut for thd->get_stmt_da()->set_eof_status(). */ 4924 4925 inline void 4926 my_eof(THD *thd) 4927 { 4928 thd->set_row_count_func(-1); 4929 thd->get_stmt_da()->set_eof_status(thd); 4930 4931 TRANSACT_TRACKER(add_trx_state(thd, TX_RESULT_SET)); 4932 } 4933 4934 #define tmp_disable_binlog(A) \ 4935 {ulonglong tmp_disable_binlog__save_options= (A)->variables.option_bits; \ 4936 (A)->variables.option_bits&= ~OPTION_BIN_LOG; \ 4937 (A)->variables.sql_log_bin_off= 1; 4938 4939 #define reenable_binlog(A) \ 4940 (A)->variables.option_bits= tmp_disable_binlog__save_options; \ 4941 (A)->variables.sql_log_bin_off= 0;} 4942 4943 4944 inline sql_mode_t sql_mode_for_dates(THD *thd) 4945 { 4946 return thd->variables.sql_mode & 4947 (MODE_NO_ZERO_DATE | MODE_NO_ZERO_IN_DATE | MODE_INVALID_DATES); 4948 } 4949 4950 /* 4951 Used to hold information about file and file structure in exchange 4952 via non-DB file (...INTO OUTFILE..., ...LOAD DATA...) 4953 XXX: We never call destructor for objects of this class. 4954 */ 4955 4956 class sql_exchange :public Sql_alloc 4957 { 4958 public: 4959 enum enum_filetype filetype; /* load XML, Added by Arnold & Erik */ 4960 const char *file_name; 4961 String *field_term,*enclosed,*line_term,*line_start,*escaped; 4962 bool opt_enclosed; 4963 bool dumpfile; 4964 ulong skip_lines; 4965 CHARSET_INFO *cs; 4966 sql_exchange(const char *name, bool dumpfile_flag, 4967 enum_filetype filetype_arg= FILETYPE_CSV); 4968 bool escaped_given(void) const; 4969 }; 4970 4971 /* 4972 This is used to get result from a select 4973 */ 4974 4975 class JOIN; 4976 4977 /* Pure interface for sending tabular data */ 4978 class select_result_sink: public Sql_alloc 4979 { 4980 public: 4981 THD *thd; 4982 select_result_sink(THD *thd_arg): thd(thd_arg) {} 4983 /* 4984 send_data returns 0 on ok, 1 on error and -1 if data was ignored, for 4985 example for a duplicate row entry written to a temp table. 4986 */ 4987 virtual int send_data(List<Item> &items)=0; 4988 virtual ~select_result_sink() {}; 4989 void reset(THD *thd_arg) { thd= thd_arg; } 4990 }; 4991 4992 class select_result_interceptor; 4993 4994 /* 4995 Interface for sending tabular data, together with some other stuff: 4996 4997 - Primary purpose seems to be seding typed tabular data: 4998 = the DDL is sent with send_fields() 4999 = the rows are sent with send_data() 5000 Besides that, 5001 - there seems to be an assumption that the sent data is a result of 5002 SELECT_LEX_UNIT *unit, 5003 - nest_level is used by SQL parser 5004 */ 5005 5006 class select_result :public select_result_sink 5007 { 5008 protected: 5009 /* 5010 All descendant classes have their send_data() skip the first 5011 unit->offset_limit_cnt rows sent. Select_materialize 5012 also uses unit->get_column_types(). 5013 */ 5014 SELECT_LEX_UNIT *unit; 5015 /* Something used only by the parser: */ 5016 public: 5017 ha_rows est_records; /* estimated number of records in the result */ 5018 select_result(THD *thd_arg): select_result_sink(thd_arg), est_records(0) {} 5019 void set_unit(SELECT_LEX_UNIT *unit_arg) { unit= unit_arg; } 5020 virtual ~select_result() {}; 5021 /** 5022 Change wrapped select_result. 5023 5024 Replace the wrapped result object with new_result and call 5025 prepare() and prepare2() on new_result. 5026 5027 This base class implementation doesn't wrap other select_results. 5028 5029 @param new_result The new result object to wrap around 5030 5031 @retval false Success 5032 @retval true Error 5033 */ 5034 virtual bool change_result(select_result *new_result) 5035 { 5036 return false; 5037 } 5038 virtual int prepare(List<Item> &list, SELECT_LEX_UNIT *u) 5039 { 5040 unit= u; 5041 return 0; 5042 } 5043 virtual int prepare2(JOIN *join) { return 0; } 5044 /* 5045 Because of peculiarities of prepared statements protocol 5046 we need to know number of columns in the result set (if 5047 there is a result set) apart from sending columns metadata. 5048 */ 5049 virtual uint field_count(List<Item> &fields) const 5050 { return fields.elements; } 5051 virtual bool send_result_set_metadata(List<Item> &list, uint flags)=0; 5052 virtual bool initialize_tables (JOIN *join) { return 0; } 5053 virtual bool send_eof()=0; 5054 /** 5055 Check if this query returns a result set and therefore is allowed in 5056 cursors and set an error message if it is not the case. 5057 5058 @retval FALSE success 5059 @retval TRUE error, an error message is set 5060 */ 5061 virtual bool check_simple_select() const; 5062 virtual void abort_result_set() {} 5063 /* 5064 Cleanup instance of this class for next execution of a prepared 5065 statement/stored procedure. 5066 */ 5067 virtual void cleanup(); 5068 void set_thd(THD *thd_arg) { thd= thd_arg; } 5069 void reset(THD *thd_arg) 5070 { 5071 select_result_sink::reset(thd_arg); 5072 unit= NULL; 5073 } 5074 #ifdef EMBEDDED_LIBRARY 5075 virtual void begin_dataset() {} 5076 #else 5077 void begin_dataset() {} 5078 #endif 5079 virtual void update_used_tables() {} 5080 5081 /* this method is called just before the first row of the table can be read */ 5082 virtual void prepare_to_read_rows() {} 5083 5084 void reset_offset_limit() 5085 { 5086 unit->offset_limit_cnt= 0; 5087 } 5088 5089 /* 5090 This returns 5091 - NULL if the class sends output row to the client 5092 - this if the output is set elsewhere (a file, @variable, or table). 5093 */ 5094 virtual select_result_interceptor *result_interceptor()=0; 5095 5096 /* 5097 This method is used to distinguish an normal SELECT from the cursor 5098 structure discovery for cursor%ROWTYPE routine variables. 5099 If this method returns "true", then a SELECT execution performs only 5100 all preparation stages, but does not fetch any rows. 5101 */ 5102 virtual bool view_structure_only() const { return false; } 5103 }; 5104 5105 5106 /* 5107 This is a select_result_sink which simply writes all data into a (temporary) 5108 table. Creation/deletion of the table is outside of the scope of the class 5109 5110 It is aimed at capturing SHOW EXPLAIN output, so: 5111 - Unlike select_result class, we don't assume that the sent data is an 5112 output of a SELECT_LEX_UNIT (and so we dont apply "LIMIT x,y" from the 5113 unit) 5114 - We don't try to convert the target table to MyISAM 5115 */ 5116 5117 class select_result_explain_buffer : public select_result_sink 5118 { 5119 public: 5120 select_result_explain_buffer(THD *thd_arg, TABLE *table_arg) : 5121 select_result_sink(thd_arg), dst_table(table_arg) {}; 5122 5123 TABLE *dst_table; /* table to write into */ 5124 5125 /* The following is called in the child thread: */ 5126 int send_data(List<Item> &items); 5127 }; 5128 5129 5130 /* 5131 This is a select_result_sink which stores the data in text form. 5132 5133 It is only used to save EXPLAIN output. 5134 */ 5135 5136 class select_result_text_buffer : public select_result_sink 5137 { 5138 public: 5139 select_result_text_buffer(THD *thd_arg): select_result_sink(thd_arg) {} 5140 int send_data(List<Item> &items); 5141 bool send_result_set_metadata(List<Item> &fields, uint flag); 5142 5143 void save_to(String *res); 5144 private: 5145 int append_row(List<Item> &items, bool send_names); 5146 5147 List<char*> rows; 5148 int n_columns; 5149 }; 5150 5151 5152 /* 5153 Base class for select_result descendands which intercept and 5154 transform result set rows. As the rows are not sent to the client, 5155 sending of result set metadata should be suppressed as well. 5156 */ 5157 5158 class select_result_interceptor: public select_result 5159 { 5160 public: 5161 select_result_interceptor(THD *thd_arg): 5162 select_result(thd_arg), suppress_my_ok(false) 5163 { 5164 DBUG_ENTER("select_result_interceptor::select_result_interceptor"); 5165 DBUG_PRINT("enter", ("this %p", this)); 5166 DBUG_VOID_RETURN; 5167 } /* Remove gcc warning */ 5168 uint field_count(List<Item> &fields) const { return 0; } 5169 bool send_result_set_metadata(List<Item> &fields, uint flag) { return FALSE; } 5170 select_result_interceptor *result_interceptor() { return this; } 5171 5172 /* 5173 Instruct the object to not call my_ok(). Client output will be handled 5174 elsewhere. (this is used by ANALYZE $stmt feature). 5175 */ 5176 void disable_my_ok_calls() { suppress_my_ok= true; } 5177 void reset(THD *thd_arg) 5178 { 5179 select_result::reset(thd_arg); 5180 suppress_my_ok= false; 5181 } 5182 protected: 5183 bool suppress_my_ok; 5184 }; 5185 5186 5187 class sp_cursor_statistics 5188 { 5189 protected: 5190 ulonglong m_fetch_count; // Number of FETCH commands since last OPEN 5191 ulonglong m_row_count; // Number of successful FETCH since last OPEN 5192 bool m_found; // If last FETCH fetched a row 5193 public: 5194 sp_cursor_statistics() 5195 :m_fetch_count(0), 5196 m_row_count(0), 5197 m_found(false) 5198 { } 5199 bool found() const 5200 { return m_found; } 5201 5202 ulonglong row_count() const 5203 { return m_row_count; } 5204 5205 ulonglong fetch_count() const 5206 { return m_fetch_count; } 5207 void reset() { *this= sp_cursor_statistics(); } 5208 }; 5209 5210 5211 /* A mediator between stored procedures and server side cursors */ 5212 class sp_lex_keeper; 5213 class sp_cursor: public sp_cursor_statistics 5214 { 5215 private: 5216 /// An interceptor of cursor result set used to implement 5217 /// FETCH <cname> INTO <varlist>. 5218 class Select_fetch_into_spvars: public select_result_interceptor 5219 { 5220 List<sp_variable> *spvar_list; 5221 uint field_count; 5222 bool m_view_structure_only; 5223 bool send_data_to_variable_list(List<sp_variable> &vars, List<Item> &items); 5224 public: 5225 Select_fetch_into_spvars(THD *thd_arg, bool view_structure_only) 5226 :select_result_interceptor(thd_arg), 5227 m_view_structure_only(view_structure_only) 5228 {} 5229 void reset(THD *thd_arg) 5230 { 5231 select_result_interceptor::reset(thd_arg); 5232 spvar_list= NULL; 5233 field_count= 0; 5234 } 5235 uint get_field_count() { return field_count; } 5236 void set_spvar_list(List<sp_variable> *vars) { spvar_list= vars; } 5237 5238 virtual bool send_eof() { return FALSE; } 5239 virtual int send_data(List<Item> &items); 5240 virtual int prepare(List<Item> &list, SELECT_LEX_UNIT *u); 5241 virtual bool view_structure_only() const { return m_view_structure_only; } 5242 }; 5243 5244 public: 5245 sp_cursor() 5246 :result(NULL, false), 5247 m_lex_keeper(NULL), 5248 server_side_cursor(NULL) 5249 { } 5250 sp_cursor(THD *thd_arg, sp_lex_keeper *lex_keeper, bool view_structure_only) 5251 :result(thd_arg, view_structure_only), 5252 m_lex_keeper(lex_keeper), 5253 server_side_cursor(NULL) 5254 {} 5255 5256 virtual ~sp_cursor() 5257 { destroy(); } 5258 5259 sp_lex_keeper *get_lex_keeper() { return m_lex_keeper; } 5260 5261 int open(THD *thd); 5262 5263 int close(THD *thd); 5264 5265 my_bool is_open() 5266 { return MY_TEST(server_side_cursor); } 5267 5268 int fetch(THD *, List<sp_variable> *vars, bool error_on_no_data); 5269 5270 bool export_structure(THD *thd, Row_definition_list *list); 5271 5272 void reset(THD *thd_arg, sp_lex_keeper *lex_keeper) 5273 { 5274 sp_cursor_statistics::reset(); 5275 result.reset(thd_arg); 5276 m_lex_keeper= lex_keeper; 5277 server_side_cursor= NULL; 5278 } 5279 5280 private: 5281 Select_fetch_into_spvars result; 5282 sp_lex_keeper *m_lex_keeper; 5283 Server_side_cursor *server_side_cursor; 5284 void destroy(); 5285 }; 5286 5287 5288 class select_send :public select_result { 5289 /** 5290 True if we have sent result set metadata to the client. 5291 In this case the client always expects us to end the result 5292 set with an eof or error packet 5293 */ 5294 bool is_result_set_started; 5295 public: 5296 select_send(THD *thd_arg): 5297 select_result(thd_arg), is_result_set_started(FALSE) {} 5298 bool send_result_set_metadata(List<Item> &list, uint flags); 5299 int send_data(List<Item> &items); 5300 bool send_eof(); 5301 virtual bool check_simple_select() const { return FALSE; } 5302 void abort_result_set(); 5303 virtual void cleanup(); 5304 select_result_interceptor *result_interceptor() { return NULL; } 5305 }; 5306 5307 5308 /* 5309 We need this class, because select_send::send_eof() will call ::my_eof. 5310 5311 See also class Protocol_discard. 5312 */ 5313 5314 class select_send_analyze : public select_send 5315 { 5316 bool send_result_set_metadata(List<Item> &list, uint flags) { return 0; } 5317 bool send_eof() { return 0; } 5318 void abort_result_set() {} 5319 public: 5320 select_send_analyze(THD *thd_arg): select_send(thd_arg) {} 5321 }; 5322 5323 5324 class select_to_file :public select_result_interceptor { 5325 protected: 5326 sql_exchange *exchange; 5327 File file; 5328 IO_CACHE cache; 5329 ha_rows row_count; 5330 char path[FN_REFLEN]; 5331 5332 public: 5333 select_to_file(THD *thd_arg, sql_exchange *ex): 5334 select_result_interceptor(thd_arg), exchange(ex), file(-1),row_count(0L) 5335 { path[0]=0; } 5336 ~select_to_file(); 5337 bool send_eof(); 5338 void cleanup(); 5339 }; 5340 5341 5342 #define ESCAPE_CHARS "ntrb0ZN" // keep synchronous with READ_INFO::unescape 5343 5344 5345 /* 5346 List of all possible characters of a numeric value text representation. 5347 */ 5348 #define NUMERIC_CHARS ".0123456789e+-" 5349 5350 5351 class select_export :public select_to_file { 5352 uint field_term_length; 5353 int field_sep_char,escape_char,line_sep_char; 5354 int field_term_char; // first char of FIELDS TERMINATED BY or MAX_INT 5355 /* 5356 The is_ambiguous_field_sep field is true if a value of the field_sep_char 5357 field is one of the 'n', 't', 'r' etc characters 5358 (see the READ_INFO::unescape method and the ESCAPE_CHARS constant value). 5359 */ 5360 bool is_ambiguous_field_sep; 5361 /* 5362 The is_ambiguous_field_term is true if field_sep_char contains the first 5363 char of the FIELDS TERMINATED BY (ENCLOSED BY is empty), and items can 5364 contain this character. 5365 */ 5366 bool is_ambiguous_field_term; 5367 /* 5368 The is_unsafe_field_sep field is true if a value of the field_sep_char 5369 field is one of the '0'..'9', '+', '-', '.' and 'e' characters 5370 (see the NUMERIC_CHARS constant value). 5371 */ 5372 bool is_unsafe_field_sep; 5373 bool fixed_row_size; 5374 CHARSET_INFO *write_cs; // output charset 5375 public: 5376 select_export(THD *thd_arg, sql_exchange *ex): select_to_file(thd_arg, ex) {} 5377 ~select_export(); 5378 int prepare(List<Item> &list, SELECT_LEX_UNIT *u); 5379 int send_data(List<Item> &items); 5380 }; 5381 5382 5383 class select_dump :public select_to_file { 5384 public: 5385 select_dump(THD *thd_arg, sql_exchange *ex): select_to_file(thd_arg, ex) {} 5386 int prepare(List<Item> &list, SELECT_LEX_UNIT *u); 5387 int send_data(List<Item> &items); 5388 }; 5389 5390 5391 class select_insert :public select_result_interceptor { 5392 public: 5393 TABLE_LIST *table_list; 5394 TABLE *table; 5395 List<Item> *fields; 5396 ulonglong autoinc_value_of_last_inserted_row; // autogenerated or not 5397 COPY_INFO info; 5398 bool insert_into_view; 5399 select_insert(THD *thd_arg, TABLE_LIST *table_list_par, 5400 TABLE *table_par, List<Item> *fields_par, 5401 List<Item> *update_fields, List<Item> *update_values, 5402 enum_duplicates duplic, bool ignore); 5403 ~select_insert(); 5404 int prepare(List<Item> &list, SELECT_LEX_UNIT *u); 5405 virtual int prepare2(JOIN *join); 5406 virtual int send_data(List<Item> &items); 5407 virtual void store_values(List<Item> &values); 5408 virtual bool can_rollback_data() { return 0; } 5409 bool prepare_eof(); 5410 bool send_ok_packet(); 5411 bool send_eof(); 5412 virtual void abort_result_set(); 5413 /* not implemented: select_insert is never re-used in prepared statements */ 5414 void cleanup(); 5415 }; 5416 5417 5418 class select_create: public select_insert { 5419 TABLE_LIST *create_table; 5420 Table_specification_st *create_info; 5421 TABLE_LIST *select_tables; 5422 Alter_info *alter_info; 5423 Field **field; 5424 /* lock data for tmp table */ 5425 MYSQL_LOCK *m_lock; 5426 /* m_lock or thd->extra_lock */ 5427 MYSQL_LOCK **m_plock; 5428 bool exit_done; 5429 TMP_TABLE_SHARE *saved_tmp_table_share; 5430 5431 public: 5432 select_create(THD *thd_arg, TABLE_LIST *table_arg, 5433 Table_specification_st *create_info_par, 5434 Alter_info *alter_info_arg, 5435 List<Item> &select_fields,enum_duplicates duplic, bool ignore, 5436 TABLE_LIST *select_tables_arg): 5437 select_insert(thd_arg, table_arg, NULL, &select_fields, 0, 0, duplic, 5438 ignore), 5439 create_table(table_arg), 5440 create_info(create_info_par), 5441 select_tables(select_tables_arg), 5442 alter_info(alter_info_arg), 5443 m_plock(NULL), exit_done(0), 5444 saved_tmp_table_share(0) 5445 {} 5446 int prepare(List<Item> &list, SELECT_LEX_UNIT *u); 5447 5448 int binlog_show_create_table(TABLE **tables, uint count); 5449 void store_values(List<Item> &values); 5450 bool send_eof(); 5451 virtual void abort_result_set(); 5452 virtual bool can_rollback_data() { return 1; } 5453 5454 // Needed for access from local class MY_HOOKS in prepare(), since thd is proteted. 5455 const THD *get_thd(void) { return thd; } 5456 const HA_CREATE_INFO *get_create_info() { return create_info; }; 5457 int prepare2(JOIN *join) { return 0; } 5458 5459 private: 5460 TABLE *create_table_from_items(THD *thd, 5461 List<Item> *items, 5462 MYSQL_LOCK **lock, 5463 TABLEOP_HOOKS *hooks); 5464 }; 5465 5466 #include <myisam.h> 5467 5468 #ifdef WITH_ARIA_STORAGE_ENGINE 5469 #include <maria.h> 5470 #else 5471 #undef USE_ARIA_FOR_TMP_TABLES 5472 #endif 5473 5474 #ifdef USE_ARIA_FOR_TMP_TABLES 5475 #define TMP_ENGINE_COLUMNDEF MARIA_COLUMNDEF 5476 #define TMP_ENGINE_HTON maria_hton 5477 #define TMP_ENGINE_NAME "Aria" 5478 inline uint tmp_table_max_key_length() { return maria_max_key_length(); } 5479 inline uint tmp_table_max_key_parts() { return maria_max_key_segments(); } 5480 #else 5481 #define TMP_ENGINE_COLUMNDEF MI_COLUMNDEF 5482 #define TMP_ENGINE_HTON myisam_hton 5483 #define TMP_ENGINE_NAME "MyISAM" 5484 inline uint tmp_table_max_key_length() { return MI_MAX_KEY_LENGTH; } 5485 inline uint tmp_table_max_key_parts() { return MI_MAX_KEY_SEG; } 5486 #endif 5487 5488 /* 5489 Param to create temporary tables when doing SELECT:s 5490 NOTE 5491 This structure is copied using memcpy as a part of JOIN. 5492 */ 5493 5494 class TMP_TABLE_PARAM :public Sql_alloc 5495 { 5496 public: 5497 List<Item> copy_funcs; 5498 Copy_field *copy_field, *copy_field_end; 5499 uchar *group_buff; 5500 Item **items_to_copy; /* Fields in tmp table */ 5501 TMP_ENGINE_COLUMNDEF *recinfo, *start_recinfo; 5502 KEY *keyinfo; 5503 ha_rows end_write_records; 5504 /** 5505 Number of normal fields in the query, including those referred to 5506 from aggregate functions. Hence, "SELECT `field1`, 5507 SUM(`field2`) from t1" sets this counter to 2. 5508 5509 @see count_field_types 5510 */ 5511 uint field_count; 5512 /** 5513 Number of fields in the query that have functions. Includes both 5514 aggregate functions (e.g., SUM) and non-aggregates (e.g., RAND). 5515 Also counts functions referred to from aggregate functions, i.e., 5516 "SELECT SUM(RAND())" sets this counter to 2. 5517 5518 @see count_field_types 5519 */ 5520 uint func_count; 5521 /** 5522 Number of fields in the query that have aggregate functions. Note 5523 that the optimizer may choose to optimize away these fields by 5524 replacing them with constants, in which case sum_func_count will 5525 need to be updated. 5526 5527 @see opt_sum_query, count_field_types 5528 */ 5529 uint sum_func_count; 5530 uint hidden_field_count; 5531 uint group_parts,group_length,group_null_parts; 5532 uint quick_group; 5533 /** 5534 Enabled when we have atleast one outer_sum_func. Needed when used 5535 along with distinct. 5536 5537 @see create_tmp_table 5538 */ 5539 bool using_outer_summary_function; 5540 CHARSET_INFO *table_charset; 5541 bool schema_table; 5542 /* TRUE if the temp table is created for subquery materialization. */ 5543 bool materialized_subquery; 5544 /* TRUE if all columns of the table are guaranteed to be non-nullable */ 5545 bool force_not_null_cols; 5546 /* 5547 True if GROUP BY and its aggregate functions are already computed 5548 by a table access method (e.g. by loose index scan). In this case 5549 query execution should not perform aggregation and should treat 5550 aggregate functions as normal functions. 5551 */ 5552 bool precomputed_group_by; 5553 bool force_copy_fields; 5554 /* 5555 If TRUE, create_tmp_field called from create_tmp_table will convert 5556 all BIT fields to 64-bit longs. This is a workaround the limitation 5557 that MEMORY tables cannot index BIT columns. 5558 */ 5559 bool bit_fields_as_long; 5560 /* 5561 Whether to create or postpone actual creation of this temporary table. 5562 TRUE <=> create_tmp_table will create only the TABLE structure. 5563 */ 5564 bool skip_create_table; 5565 5566 TMP_TABLE_PARAM() 5567 :copy_field(0), group_parts(0), 5568 group_length(0), group_null_parts(0), 5569 using_outer_summary_function(0), 5570 schema_table(0), materialized_subquery(0), force_not_null_cols(0), 5571 precomputed_group_by(0), 5572 force_copy_fields(0), bit_fields_as_long(0), skip_create_table(0) 5573 {} 5574 ~TMP_TABLE_PARAM() 5575 { 5576 cleanup(); 5577 } 5578 void init(void); 5579 inline void cleanup(void) 5580 { 5581 if (copy_field) /* Fix for Intel compiler */ 5582 { 5583 delete [] copy_field; 5584 copy_field= NULL; 5585 copy_field_end= NULL; 5586 } 5587 } 5588 }; 5589 5590 5591 class select_unit :public select_result_interceptor 5592 { 5593 uint curr_step, prev_step, curr_sel; 5594 enum sub_select_type step; 5595 public: 5596 Item_int *intersect_mark; 5597 TMP_TABLE_PARAM tmp_table_param; 5598 int write_err; /* Error code from the last send_data->ha_write_row call. */ 5599 TABLE *table; 5600 5601 select_unit(THD *thd_arg): 5602 select_result_interceptor(thd_arg), 5603 intersect_mark(0), table(0) 5604 { 5605 init(); 5606 tmp_table_param.init(); 5607 } 5608 int prepare(List<Item> &list, SELECT_LEX_UNIT *u); 5609 /** 5610 Do prepare() and prepare2() if they have been postponed until 5611 column type information is computed (used by select_union_direct). 5612 5613 @param types Column types 5614 5615 @return false on success, true on failure 5616 */ 5617 virtual bool postponed_prepare(List<Item> &types) 5618 { return false; } 5619 int send_data(List<Item> &items); 5620 bool send_eof(); 5621 virtual bool flush(); 5622 void cleanup(); 5623 virtual bool create_result_table(THD *thd, List<Item> *column_types, 5624 bool is_distinct, ulonglong options, 5625 const LEX_CSTRING *alias, 5626 bool bit_fields_as_long, 5627 bool create_table, 5628 bool keep_row_order, 5629 uint hidden); 5630 TMP_TABLE_PARAM *get_tmp_table_param() { return &tmp_table_param; } 5631 void init() 5632 { 5633 curr_step= prev_step= 0; 5634 curr_sel= UINT_MAX; 5635 step= UNION_TYPE; 5636 write_err= 0; 5637 } 5638 void change_select(); 5639 }; 5640 5641 class select_union_recursive :public select_unit 5642 { 5643 public: 5644 /* The temporary table with the new records generated by one iterative step */ 5645 TABLE *incr_table; 5646 /* The TMP_TABLE_PARAM structure used to create incr_table */ 5647 TMP_TABLE_PARAM incr_table_param; 5648 /* One of tables from the list rec_tables (determined dynamically) */ 5649 TABLE *first_rec_table_to_update; 5650 /* 5651 The list of all recursive table references to the CTE for whose 5652 specification this select_union_recursive was created 5653 */ 5654 List<TABLE_LIST> rec_table_refs; 5655 /* 5656 The count of how many times cleanup() was called with cleaned==false 5657 for the unit specifying the recursive CTE for which this object was created 5658 or for the unit specifying a CTE that mutually recursive with this CTE. 5659 */ 5660 uint cleanup_count; 5661 5662 select_union_recursive(THD *thd_arg): 5663 select_unit(thd_arg), 5664 incr_table(0), first_rec_table_to_update(0), cleanup_count(0) 5665 { incr_table_param.init(); }; 5666 5667 int send_data(List<Item> &items); 5668 bool create_result_table(THD *thd, List<Item> *column_types, 5669 bool is_distinct, ulonglong options, 5670 const LEX_CSTRING *alias, 5671 bool bit_fields_as_long, 5672 bool create_table, 5673 bool keep_row_order, 5674 uint hidden); 5675 void cleanup(); 5676 }; 5677 5678 /** 5679 UNION result that is passed directly to the receiving select_result 5680 without filling a temporary table. 5681 5682 Function calls are forwarded to the wrapped select_result, but some 5683 functions are expected to be called only once for each query, so 5684 they are only executed for the first SELECT in the union (execept 5685 for send_eof(), which is executed only for the last SELECT). 5686 5687 This select_result is used when a UNION is not DISTINCT and doesn't 5688 have a global ORDER BY clause. @see st_select_lex_unit::prepare(). 5689 */ 5690 5691 class select_union_direct :public select_unit 5692 { 5693 private: 5694 /* Result object that receives all rows */ 5695 select_result *result; 5696 /* The last SELECT_LEX of the union */ 5697 SELECT_LEX *last_select_lex; 5698 5699 /* Wrapped result has received metadata */ 5700 bool done_send_result_set_metadata; 5701 /* Wrapped result has initialized tables */ 5702 bool done_initialize_tables; 5703 5704 /* Accumulated limit_found_rows */ 5705 ulonglong limit_found_rows; 5706 5707 /* Number of rows offset */ 5708 ha_rows offset; 5709 /* Number of rows limit + offset, @see select_union_direct::send_data() */ 5710 ha_rows limit; 5711 5712 public: 5713 /* Number of rows in the union */ 5714 ha_rows send_records; 5715 select_union_direct(THD *thd_arg, select_result *result_arg, 5716 SELECT_LEX *last_select_lex_arg): 5717 select_unit(thd_arg), result(result_arg), 5718 last_select_lex(last_select_lex_arg), 5719 done_send_result_set_metadata(false), done_initialize_tables(false), 5720 limit_found_rows(0) 5721 { send_records= 0; } 5722 bool change_result(select_result *new_result); 5723 uint field_count(List<Item> &fields) const 5724 { 5725 // Only called for top-level select_results, usually select_send 5726 DBUG_ASSERT(false); /* purecov: inspected */ 5727 return 0; /* purecov: inspected */ 5728 } 5729 bool postponed_prepare(List<Item> &types); 5730 bool send_result_set_metadata(List<Item> &list, uint flags); 5731 int send_data(List<Item> &items); 5732 bool initialize_tables (JOIN *join); 5733 bool send_eof(); 5734 bool flush() { return false; } 5735 bool check_simple_select() const 5736 { 5737 /* Only called for top-level select_results, usually select_send */ 5738 DBUG_ASSERT(false); /* purecov: inspected */ 5739 return false; /* purecov: inspected */ 5740 } 5741 void abort_result_set() 5742 { 5743 result->abort_result_set(); /* purecov: inspected */ 5744 } 5745 void cleanup() 5746 { 5747 send_records= 0; 5748 } 5749 void set_thd(THD *thd_arg) 5750 { 5751 /* 5752 Only called for top-level select_results, usually select_send, 5753 and for the results of subquery engines 5754 (select_<something>_subselect). 5755 */ 5756 DBUG_ASSERT(false); /* purecov: inspected */ 5757 } 5758 void reset_offset_limit_cnt() 5759 { 5760 // EXPLAIN should never output to a select_union_direct 5761 DBUG_ASSERT(false); /* purecov: inspected */ 5762 } 5763 void begin_dataset() 5764 { 5765 // Only called for sp_cursor::Select_fetch_into_spvars 5766 DBUG_ASSERT(false); /* purecov: inspected */ 5767 } 5768 }; 5769 5770 5771 /* Base subselect interface class */ 5772 class select_subselect :public select_result_interceptor 5773 { 5774 protected: 5775 Item_subselect *item; 5776 public: 5777 select_subselect(THD *thd_arg, Item_subselect *item_arg): 5778 select_result_interceptor(thd_arg), item(item_arg) {} 5779 int send_data(List<Item> &items)=0; 5780 bool send_eof() { return 0; }; 5781 }; 5782 5783 /* Single value subselect interface class */ 5784 class select_singlerow_subselect :public select_subselect 5785 { 5786 public: 5787 select_singlerow_subselect(THD *thd_arg, Item_subselect *item_arg): 5788 select_subselect(thd_arg, item_arg) 5789 {} 5790 int send_data(List<Item> &items); 5791 }; 5792 5793 5794 /* 5795 This class specializes select_union to collect statistics about the 5796 data stored in the temp table. Currently the class collects statistcs 5797 about NULLs. 5798 */ 5799 5800 class select_materialize_with_stats : public select_unit 5801 { 5802 protected: 5803 class Column_statistics 5804 { 5805 public: 5806 /* Count of NULLs per column. */ 5807 ha_rows null_count; 5808 /* The row number that contains the first NULL in a column. */ 5809 ha_rows min_null_row; 5810 /* The row number that contains the last NULL in a column. */ 5811 ha_rows max_null_row; 5812 }; 5813 5814 /* Array of statistics data per column. */ 5815 Column_statistics* col_stat; 5816 5817 /* 5818 The number of columns in the biggest sub-row that consists of only 5819 NULL values. 5820 */ 5821 uint max_nulls_in_row; 5822 /* 5823 Count of rows writtent to the temp table. This is redundant as it is 5824 already stored in handler::stats.records, however that one is relatively 5825 expensive to compute (given we need that for evry row). 5826 */ 5827 ha_rows count_rows; 5828 5829 protected: 5830 void reset(); 5831 5832 public: 5833 select_materialize_with_stats(THD *thd_arg): select_unit(thd_arg) 5834 { tmp_table_param.init(); } 5835 bool create_result_table(THD *thd, List<Item> *column_types, 5836 bool is_distinct, ulonglong options, 5837 const LEX_CSTRING *alias, 5838 bool bit_fields_as_long, 5839 bool create_table, 5840 bool keep_row_order, 5841 uint hidden); 5842 bool init_result_table(ulonglong select_options); 5843 int send_data(List<Item> &items); 5844 void cleanup(); 5845 ha_rows get_null_count_of_col(uint idx) 5846 { 5847 DBUG_ASSERT(idx < table->s->fields); 5848 return col_stat[idx].null_count; 5849 } 5850 ha_rows get_max_null_of_col(uint idx) 5851 { 5852 DBUG_ASSERT(idx < table->s->fields); 5853 return col_stat[idx].max_null_row; 5854 } 5855 ha_rows get_min_null_of_col(uint idx) 5856 { 5857 DBUG_ASSERT(idx < table->s->fields); 5858 return col_stat[idx].min_null_row; 5859 } 5860 uint get_max_nulls_in_row() { return max_nulls_in_row; } 5861 }; 5862 5863 5864 /* used in independent ALL/ANY optimisation */ 5865 class select_max_min_finder_subselect :public select_subselect 5866 { 5867 Item_cache *cache; 5868 bool (select_max_min_finder_subselect::*op)(); 5869 bool fmax; 5870 bool is_all; 5871 public: 5872 select_max_min_finder_subselect(THD *thd_arg, Item_subselect *item_arg, 5873 bool mx, bool all): 5874 select_subselect(thd_arg, item_arg), cache(0), fmax(mx), is_all(all) 5875 {} 5876 void cleanup(); 5877 int send_data(List<Item> &items); 5878 bool cmp_real(); 5879 bool cmp_int(); 5880 bool cmp_decimal(); 5881 bool cmp_str(); 5882 bool cmp_time(); 5883 }; 5884 5885 /* EXISTS subselect interface class */ 5886 class select_exists_subselect :public select_subselect 5887 { 5888 public: 5889 select_exists_subselect(THD *thd_arg, Item_subselect *item_arg): 5890 select_subselect(thd_arg, item_arg) {} 5891 int send_data(List<Item> &items); 5892 }; 5893 5894 5895 /* 5896 Optimizer and executor structure for the materialized semi-join info. This 5897 structure contains 5898 - The sj-materialization temporary table 5899 - Members needed to make index lookup or a full scan of the temptable. 5900 */ 5901 class SJ_MATERIALIZATION_INFO : public Sql_alloc 5902 { 5903 public: 5904 /* Optimal join sub-order */ 5905 struct st_position *positions; 5906 5907 uint tables; /* Number of tables in the sj-nest */ 5908 5909 /* Number of rows in the materialized table, before the de-duplication */ 5910 double rows_with_duplicates; 5911 5912 /* Expected #rows in the materialized table, after de-duplication */ 5913 double rows; 5914 5915 /* 5916 Cost to materialize - execute the sub-join and write rows into temp.table 5917 */ 5918 Cost_estimate materialization_cost; 5919 5920 /* Cost to make one lookup in the temptable */ 5921 Cost_estimate lookup_cost; 5922 5923 /* Cost of scanning the materialized table */ 5924 Cost_estimate scan_cost; 5925 5926 /* --- Execution structures ---------- */ 5927 5928 /* 5929 TRUE <=> This structure is used for execution. We don't necessarily pick 5930 sj-materialization, so some of SJ_MATERIALIZATION_INFO structures are not 5931 used by materialization 5932 */ 5933 bool is_used; 5934 5935 bool materialized; /* TRUE <=> materialization already performed */ 5936 /* 5937 TRUE - the temptable is read with full scan 5938 FALSE - we use the temptable for index lookups 5939 */ 5940 bool is_sj_scan; 5941 5942 /* The temptable and its related info */ 5943 TMP_TABLE_PARAM sjm_table_param; 5944 List<Item> sjm_table_cols; 5945 TABLE *table; 5946 5947 /* Structure used to make index lookups */ 5948 struct st_table_ref *tab_ref; 5949 Item *in_equality; /* See create_subq_in_equalities() */ 5950 5951 Item *join_cond; /* See comments in make_join_select() */ 5952 Copy_field *copy_field; /* Needed for SJ_Materialization scan */ 5953 }; 5954 5955 5956 /* Structs used when sorting */ 5957 struct SORT_FIELD_ATTR 5958 { 5959 uint length; /* Length of sort field */ 5960 uint suffix_length; /* Length suffix (0-4) */ 5961 }; 5962 5963 5964 struct SORT_FIELD: public SORT_FIELD_ATTR 5965 { 5966 Field *field; /* Field to sort */ 5967 Item *item; /* Item if not sorting fields */ 5968 bool reverse; /* if descending sort */ 5969 }; 5970 5971 5972 typedef struct st_sort_buffer { 5973 uint index; /* 0 or 1 */ 5974 uint sort_orders; 5975 uint change_pos; /* If sort-fields changed */ 5976 char **buff; 5977 SORT_FIELD *sortorder; 5978 } SORT_BUFFER; 5979 5980 /* Structure for db & table in sql_yacc */ 5981 5982 class Table_ident :public Sql_alloc 5983 { 5984 public: 5985 LEX_CSTRING db; 5986 LEX_CSTRING table; 5987 SELECT_LEX_UNIT *sel; 5988 inline Table_ident(THD *thd, const LEX_CSTRING *db_arg, 5989 const LEX_CSTRING *table_arg, 5990 bool force) 5991 :table(*table_arg), sel((SELECT_LEX_UNIT *)0) 5992 { 5993 if (!force && (thd->client_capabilities & CLIENT_NO_SCHEMA)) 5994 db= null_clex_str; 5995 else 5996 db= *db_arg; 5997 } 5998 inline Table_ident(const LEX_CSTRING *table_arg) 5999 :table(*table_arg), sel((SELECT_LEX_UNIT *)0) 6000 { 6001 db= null_clex_str; 6002 } 6003 /* 6004 This constructor is used only for the case when we create a derived 6005 table. A derived table has no name and doesn't belong to any database. 6006 Later, if there was an alias specified for the table, it will be set 6007 by add_table_to_list. 6008 */ 6009 inline Table_ident(SELECT_LEX_UNIT *s) : sel(s) 6010 { 6011 /* We must have a table name here as this is used with add_table_to_list */ 6012 db.str= empty_c_string; /* a subject to casedn_str */ 6013 db.length= 0; 6014 table.str= internal_table_name; 6015 table.length=1; 6016 } 6017 bool is_derived_table() const { return MY_TEST(sel); } 6018 inline void change_db(LEX_CSTRING *db_name) 6019 { 6020 db= *db_name; 6021 } 6022 bool resolve_table_rowtype_ref(THD *thd, Row_definition_list &defs); 6023 bool append_to(THD *thd, String *to) const; 6024 }; 6025 6026 6027 class Qualified_column_ident: public Table_ident 6028 { 6029 public: 6030 LEX_CSTRING m_column; 6031 public: 6032 Qualified_column_ident(const LEX_CSTRING *column) 6033 :Table_ident(&null_clex_str), 6034 m_column(*column) 6035 { } 6036 Qualified_column_ident(const LEX_CSTRING *table, const LEX_CSTRING *column) 6037 :Table_ident(table), 6038 m_column(*column) 6039 { } 6040 Qualified_column_ident(THD *thd, 6041 const LEX_CSTRING *db, 6042 const LEX_CSTRING *table, 6043 const LEX_CSTRING *column) 6044 :Table_ident(thd, db, table, false), 6045 m_column(*column) 6046 { } 6047 bool resolve_type_ref(THD *thd, Column_definition *def); 6048 bool append_to(THD *thd, String *to) const; 6049 }; 6050 6051 6052 // this is needed for user_vars hash 6053 class user_var_entry 6054 { 6055 CHARSET_INFO *m_charset; 6056 public: 6057 user_var_entry() {} /* Remove gcc warning */ 6058 LEX_CSTRING name; 6059 char *value; 6060 size_t length; 6061 query_id_t update_query_id, used_query_id; 6062 Item_result type; 6063 bool unsigned_flag; 6064 6065 double val_real(bool *null_value); 6066 longlong val_int(bool *null_value) const; 6067 String *val_str(bool *null_value, String *str, uint decimals); 6068 my_decimal *val_decimal(bool *null_value, my_decimal *result); 6069 CHARSET_INFO *charset() const { return m_charset; } 6070 void set_charset(CHARSET_INFO *cs) { m_charset= cs; } 6071 }; 6072 6073 user_var_entry *get_variable(HASH *hash, LEX_CSTRING *name, 6074 bool create_if_not_exists); 6075 6076 class SORT_INFO; 6077 class multi_delete :public select_result_interceptor 6078 { 6079 TABLE_LIST *delete_tables, *table_being_deleted; 6080 Unique **tempfiles; 6081 ha_rows deleted, found; 6082 uint num_of_tables; 6083 int error; 6084 bool do_delete; 6085 /* True if at least one table we delete from is transactional */ 6086 bool transactional_tables; 6087 /* True if at least one table we delete from is not transactional */ 6088 bool normal_tables; 6089 bool delete_while_scanning; 6090 /* 6091 error handling (rollback and binlogging) can happen in send_eof() 6092 so that afterward abort_result_set() needs to find out that. 6093 */ 6094 bool error_handled; 6095 6096 public: 6097 multi_delete(THD *thd_arg, TABLE_LIST *dt, uint num_of_tables); 6098 ~multi_delete(); 6099 int prepare(List<Item> &list, SELECT_LEX_UNIT *u); 6100 int send_data(List<Item> &items); 6101 bool initialize_tables (JOIN *join); 6102 int do_deletes(); 6103 int do_table_deletes(TABLE *table, SORT_INFO *sort_info, bool ignore); 6104 bool send_eof(); 6105 inline ha_rows num_deleted() const { return deleted; } 6106 virtual void abort_result_set(); 6107 void prepare_to_read_rows(); 6108 }; 6109 6110 6111 class multi_update :public select_result_interceptor 6112 { 6113 TABLE_LIST *all_tables; /* query/update command tables */ 6114 List<TABLE_LIST> *leaves; /* list of leaves of join table tree */ 6115 List<TABLE_LIST> updated_leaves; /* list of of updated leaves */ 6116 TABLE_LIST *update_tables; 6117 TABLE **tmp_tables, *main_table, *table_to_update; 6118 TMP_TABLE_PARAM *tmp_table_param; 6119 ha_rows updated, found; 6120 List <Item> *fields, *values; 6121 List <Item> **fields_for_table, **values_for_table; 6122 uint table_count; 6123 /* 6124 List of tables referenced in the CHECK OPTION condition of 6125 the updated view excluding the updated table. 6126 */ 6127 List <TABLE> unupdated_check_opt_tables; 6128 Copy_field *copy_field; 6129 enum enum_duplicates handle_duplicates; 6130 bool do_update, trans_safe; 6131 /* True if the update operation has made a change in a transactional table */ 6132 bool transactional_tables; 6133 bool ignore; 6134 /* 6135 error handling (rollback and binlogging) can happen in send_eof() 6136 so that afterward abort_result_set() needs to find out that. 6137 */ 6138 bool error_handled; 6139 6140 /* Need this to protect against multiple prepare() calls */ 6141 bool prepared; 6142 6143 // For System Versioning (may need to insert new fields to a table). 6144 ha_rows updated_sys_ver; 6145 6146 bool has_vers_fields; 6147 6148 public: 6149 multi_update(THD *thd_arg, TABLE_LIST *ut, List<TABLE_LIST> *leaves_list, 6150 List<Item> *fields, List<Item> *values, 6151 enum_duplicates handle_duplicates, bool ignore); 6152 ~multi_update(); 6153 bool init(THD *thd); 6154 int prepare(List<Item> &list, SELECT_LEX_UNIT *u); 6155 int send_data(List<Item> &items); 6156 bool initialize_tables (JOIN *join); 6157 int prepare2(JOIN *join); 6158 int do_updates(); 6159 bool send_eof(); 6160 inline ha_rows num_found() const { return found; } 6161 inline ha_rows num_updated() const { return updated; } 6162 virtual void abort_result_set(); 6163 void update_used_tables(); 6164 void prepare_to_read_rows(); 6165 }; 6166 6167 class my_var_sp; 6168 class my_var : public Sql_alloc { 6169 public: 6170 const LEX_CSTRING name; 6171 enum type { SESSION_VAR, LOCAL_VAR, PARAM_VAR }; 6172 type scope; 6173 my_var(const LEX_CSTRING *j, enum type s) : name(*j), scope(s) { } 6174 virtual ~my_var() {} 6175 virtual bool set(THD *thd, Item *val) = 0; 6176 virtual my_var_sp *get_my_var_sp() { return NULL; } 6177 }; 6178 6179 class my_var_sp: public my_var { 6180 const Sp_rcontext_handler *m_rcontext_handler; 6181 const Type_handler *m_type_handler; 6182 public: 6183 uint offset; 6184 /* 6185 Routine to which this Item_splocal belongs. Used for checking if correct 6186 runtime context is used for variable handling. 6187 */ 6188 sp_head *sp; 6189 my_var_sp(const Sp_rcontext_handler *rcontext_handler, 6190 const LEX_CSTRING *j, uint o, const Type_handler *type_handler, 6191 sp_head *s) 6192 : my_var(j, LOCAL_VAR), 6193 m_rcontext_handler(rcontext_handler), 6194 m_type_handler(type_handler), offset(o), sp(s) { } 6195 ~my_var_sp() { } 6196 bool set(THD *thd, Item *val); 6197 my_var_sp *get_my_var_sp() { return this; } 6198 const Type_handler *type_handler() const { return m_type_handler; } 6199 sp_rcontext *get_rcontext(sp_rcontext *local_ctx) const; 6200 }; 6201 6202 /* 6203 This class handles fields of a ROW SP variable when it's used as a OUT 6204 parameter in a stored procedure. 6205 */ 6206 class my_var_sp_row_field: public my_var_sp 6207 { 6208 uint m_field_offset; 6209 public: 6210 my_var_sp_row_field(const Sp_rcontext_handler *rcontext_handler, 6211 const LEX_CSTRING *varname, const LEX_CSTRING *fieldname, 6212 uint var_idx, uint field_idx, sp_head *s) 6213 :my_var_sp(rcontext_handler, varname, var_idx, 6214 &type_handler_double/*Not really used*/, s), 6215 m_field_offset(field_idx) 6216 { } 6217 bool set(THD *thd, Item *val); 6218 }; 6219 6220 class my_var_user: public my_var { 6221 public: 6222 my_var_user(const LEX_CSTRING *j) 6223 : my_var(j, SESSION_VAR) { } 6224 ~my_var_user() { } 6225 bool set(THD *thd, Item *val); 6226 }; 6227 6228 class select_dumpvar :public select_result_interceptor { 6229 ha_rows row_count; 6230 my_var_sp *m_var_sp_row; // Not NULL if SELECT INTO row_type_sp_variable 6231 bool send_data_to_var_list(List<Item> &items); 6232 public: 6233 List<my_var> var_list; 6234 select_dumpvar(THD *thd_arg) 6235 :select_result_interceptor(thd_arg), row_count(0), m_var_sp_row(NULL) 6236 { var_list.empty(); } 6237 ~select_dumpvar() {} 6238 int prepare(List<Item> &list, SELECT_LEX_UNIT *u); 6239 int send_data(List<Item> &items); 6240 bool send_eof(); 6241 virtual bool check_simple_select() const; 6242 void cleanup(); 6243 }; 6244 6245 /* Bits in sql_command_flags */ 6246 6247 #define CF_CHANGES_DATA (1U << 0) 6248 #define CF_REPORT_PROGRESS (1U << 1) 6249 #define CF_STATUS_COMMAND (1U << 2) 6250 #define CF_SHOW_TABLE_COMMAND (1U << 3) 6251 #define CF_WRITE_LOGS_COMMAND (1U << 4) 6252 6253 /** 6254 Must be set for SQL statements that may contain 6255 Item expressions and/or use joins and tables. 6256 Indicates that the parse tree of such statement may 6257 contain rule-based optimizations that depend on metadata 6258 (i.e. number of columns in a table), and consequently 6259 that the statement must be re-prepared whenever 6260 referenced metadata changes. Must not be set for 6261 statements that themselves change metadata, e.g. RENAME, 6262 ALTER and other DDL, since otherwise will trigger constant 6263 reprepare. Consequently, complex item expressions and 6264 joins are currently prohibited in these statements. 6265 */ 6266 #define CF_REEXECUTION_FRAGILE (1U << 5) 6267 /** 6268 Implicitly commit before the SQL statement is executed. 6269 6270 Statements marked with this flag will cause any active 6271 transaction to end (commit) before proceeding with the 6272 command execution. 6273 6274 This flag should be set for statements that probably can't 6275 be rolled back or that do not expect any previously metadata 6276 locked tables. 6277 */ 6278 #define CF_IMPLICT_COMMIT_BEGIN (1U << 6) 6279 /** 6280 Implicitly commit after the SQL statement. 6281 6282 Statements marked with this flag are automatically committed 6283 at the end of the statement. 6284 6285 This flag should be set for statements that will implicitly 6286 open and take metadata locks on system tables that should not 6287 be carried for the whole duration of a active transaction. 6288 */ 6289 #define CF_IMPLICIT_COMMIT_END (1U << 7) 6290 /** 6291 CF_IMPLICT_COMMIT_BEGIN and CF_IMPLICIT_COMMIT_END are used 6292 to ensure that the active transaction is implicitly committed 6293 before and after every DDL statement and any statement that 6294 modifies our currently non-transactional system tables. 6295 */ 6296 #define CF_AUTO_COMMIT_TRANS (CF_IMPLICT_COMMIT_BEGIN | CF_IMPLICIT_COMMIT_END) 6297 6298 /** 6299 Diagnostic statement. 6300 Diagnostic statements: 6301 - SHOW WARNING 6302 - SHOW ERROR 6303 - GET DIAGNOSTICS (WL#2111) 6304 do not modify the diagnostics area during execution. 6305 */ 6306 #define CF_DIAGNOSTIC_STMT (1U << 8) 6307 6308 /** 6309 Identifies statements that may generate row events 6310 and that may end up in the binary log. 6311 */ 6312 #define CF_CAN_GENERATE_ROW_EVENTS (1U << 9) 6313 6314 /** 6315 Identifies statements which may deal with temporary tables and for which 6316 temporary tables should be pre-opened to simplify privilege checks. 6317 */ 6318 #define CF_PREOPEN_TMP_TABLES (1U << 10) 6319 6320 /** 6321 Identifies statements for which open handlers should be closed in the 6322 beginning of the statement. 6323 */ 6324 #define CF_HA_CLOSE (1U << 11) 6325 6326 /** 6327 Identifies statements that can be explained with EXPLAIN. 6328 */ 6329 #define CF_CAN_BE_EXPLAINED (1U << 12) 6330 6331 /** Identifies statements which may generate an optimizer trace */ 6332 #define CF_OPTIMIZER_TRACE (1U << 14) 6333 6334 /** 6335 Identifies statements that should always be disallowed in 6336 read only transactions. 6337 */ 6338 #define CF_DISALLOW_IN_RO_TRANS (1U << 15) 6339 6340 /** 6341 Statement that need the binlog format to be unchanged. 6342 */ 6343 #define CF_FORCE_ORIGINAL_BINLOG_FORMAT (1U << 16) 6344 6345 /** 6346 Statement that inserts new rows (INSERT, REPLACE, LOAD, ALTER TABLE) 6347 */ 6348 #define CF_INSERTS_DATA (1U << 17) 6349 6350 /** 6351 Statement that updates existing rows (UPDATE, multi-update) 6352 */ 6353 #define CF_UPDATES_DATA (1U << 18) 6354 6355 /** 6356 Not logged into slow log as "admin commands" 6357 */ 6358 #define CF_ADMIN_COMMAND (1U << 19) 6359 6360 /** 6361 SP Bulk execution safe 6362 */ 6363 #define CF_PS_ARRAY_BINDING_SAFE (1U << 20) 6364 /** 6365 SP Bulk execution optimized 6366 */ 6367 #define CF_PS_ARRAY_BINDING_OPTIMIZED (1U << 21) 6368 /** 6369 If command creates or drops a table 6370 */ 6371 #define CF_SCHEMA_CHANGE (1U << 22) 6372 /** 6373 If command creates or drops a database 6374 */ 6375 #define CF_DB_CHANGE (1U << 23) 6376 6377 /* Bits in server_command_flags */ 6378 6379 /** 6380 Statement that deletes existing rows (DELETE, DELETE_MULTI) 6381 */ 6382 #define CF_DELETES_DATA (1U << 24) 6383 6384 /** 6385 Skip the increase of the global query id counter. Commonly set for 6386 commands that are stateless (won't cause any change on the server 6387 internal states). 6388 */ 6389 #define CF_SKIP_QUERY_ID (1U << 0) 6390 6391 /** 6392 Skip the increase of the number of statements that clients have 6393 sent to the server. Commonly used for commands that will cause 6394 a statement to be executed but the statement might have not been 6395 sent by the user (ie: stored procedure). 6396 */ 6397 #define CF_SKIP_QUESTIONS (1U << 1) 6398 #ifdef WITH_WSREP 6399 /** 6400 Do not check that wsrep snapshot is ready before allowing this command 6401 */ 6402 #define CF_SKIP_WSREP_CHECK (1U << 2) 6403 #else 6404 #define CF_SKIP_WSREP_CHECK 0 6405 #endif /* WITH_WSREP */ 6406 6407 /** 6408 Do not allow it for COM_MULTI batch 6409 */ 6410 #define CF_NO_COM_MULTI (1U << 3) 6411 6412 /* Inline functions */ 6413 6414 inline bool add_item_to_list(THD *thd, Item *item) 6415 { 6416 return thd->lex->current_select->add_item_to_list(thd, item); 6417 } 6418 6419 inline bool add_value_to_list(THD *thd, Item *value) 6420 { 6421 return thd->lex->value_list.push_back(value, thd->mem_root); 6422 } 6423 6424 inline bool add_order_to_list(THD *thd, Item *item, bool asc) 6425 { 6426 return thd->lex->current_select->add_order_to_list(thd, item, asc); 6427 } 6428 6429 inline bool add_gorder_to_list(THD *thd, Item *item, bool asc) 6430 { 6431 return thd->lex->current_select->add_gorder_to_list(thd, item, asc); 6432 } 6433 6434 inline bool add_group_to_list(THD *thd, Item *item, bool asc) 6435 { 6436 return thd->lex->current_select->add_group_to_list(thd, item, asc); 6437 } 6438 6439 inline Item *and_conds(THD *thd, Item *a, Item *b) 6440 { 6441 if (!b) return a; 6442 if (!a) return b; 6443 return new (thd->mem_root) Item_cond_and(thd, a, b); 6444 } 6445 6446 /* inline handler methods that need to know TABLE and THD structures */ 6447 inline void handler::increment_statistics(ulong SSV::*offset) const 6448 { 6449 status_var_increment(table->in_use->status_var.*offset); 6450 table->in_use->check_limit_rows_examined(); 6451 } 6452 6453 inline void handler::decrement_statistics(ulong SSV::*offset) const 6454 { 6455 status_var_decrement(table->in_use->status_var.*offset); 6456 } 6457 6458 6459 inline int handler::ha_ft_read(uchar *buf) 6460 { 6461 int error= ft_read(buf); 6462 if (!error) 6463 update_rows_read(); 6464 6465 table->status=error ? STATUS_NOT_FOUND: 0; 6466 return error; 6467 } 6468 6469 inline int handler::ha_rnd_pos_by_record(uchar *buf) 6470 { 6471 int error= rnd_pos_by_record(buf); 6472 table->status=error ? STATUS_NOT_FOUND: 0; 6473 return error; 6474 } 6475 6476 inline int handler::ha_read_first_row(uchar *buf, uint primary_key) 6477 { 6478 int error= read_first_row(buf, primary_key); 6479 if (!error) 6480 update_rows_read(); 6481 table->status=error ? STATUS_NOT_FOUND: 0; 6482 return error; 6483 } 6484 6485 inline int handler::ha_write_tmp_row(uchar *buf) 6486 { 6487 int error; 6488 MYSQL_INSERT_ROW_START(table_share->db.str, table_share->table_name.str); 6489 increment_statistics(&SSV::ha_tmp_write_count); 6490 TABLE_IO_WAIT(tracker, m_psi, PSI_TABLE_WRITE_ROW, MAX_KEY, 0, 6491 { error= write_row(buf); }) 6492 MYSQL_INSERT_ROW_DONE(error); 6493 return error; 6494 } 6495 6496 inline int handler::ha_delete_tmp_row(uchar *buf) 6497 { 6498 int error; 6499 MYSQL_DELETE_ROW_START(table_share->db.str, table_share->table_name.str); 6500 increment_statistics(&SSV::ha_tmp_delete_count); 6501 TABLE_IO_WAIT(tracker, m_psi, PSI_TABLE_DELETE_ROW, MAX_KEY, 0, 6502 { error= delete_row(buf); }) 6503 MYSQL_DELETE_ROW_DONE(error); 6504 return error; 6505 } 6506 6507 inline int handler::ha_update_tmp_row(const uchar *old_data, uchar *new_data) 6508 { 6509 int error; 6510 MYSQL_UPDATE_ROW_START(table_share->db.str, table_share->table_name.str); 6511 increment_statistics(&SSV::ha_tmp_update_count); 6512 TABLE_IO_WAIT(tracker, m_psi, PSI_TABLE_UPDATE_ROW, active_index, 0, 6513 { error= update_row(old_data, new_data);}) 6514 MYSQL_UPDATE_ROW_DONE(error); 6515 return error; 6516 } 6517 6518 6519 extern pthread_attr_t *get_connection_attrib(void); 6520 6521 /** 6522 Set thread entering a condition 6523 6524 This function should be called before putting a thread to wait for 6525 a condition. @a mutex should be held before calling this 6526 function. After being waken up, @f thd_exit_cond should be called. 6527 6528 @param thd The thread entering the condition, NULL means current thread 6529 @param cond The condition the thread is going to wait for 6530 @param mutex The mutex associated with the condition, this must be 6531 held before call this function 6532 @param stage The new process message for the thread 6533 @param old_stage The old process message for the thread 6534 @param src_function The caller source function name 6535 @param src_file The caller source file name 6536 @param src_line The caller source line number 6537 */ 6538 void thd_enter_cond(MYSQL_THD thd, mysql_cond_t *cond, mysql_mutex_t *mutex, 6539 const PSI_stage_info *stage, PSI_stage_info *old_stage, 6540 const char *src_function, const char *src_file, 6541 int src_line); 6542 6543 #define THD_ENTER_COND(P1, P2, P3, P4, P5) \ 6544 thd_enter_cond(P1, P2, P3, P4, P5, __func__, __FILE__, __LINE__) 6545 6546 /** 6547 Set thread leaving a condition 6548 6549 This function should be called after a thread being waken up for a 6550 condition. 6551 6552 @param thd The thread entering the condition, NULL means current thread 6553 @param stage The process message, ususally this should be the old process 6554 message before calling @f thd_enter_cond 6555 @param src_function The caller source function name 6556 @param src_file The caller source file name 6557 @param src_line The caller source line number 6558 */ 6559 void thd_exit_cond(MYSQL_THD thd, const PSI_stage_info *stage, 6560 const char *src_function, const char *src_file, 6561 int src_line); 6562 6563 #define THD_EXIT_COND(P1, P2) \ 6564 thd_exit_cond(P1, P2, __func__, __FILE__, __LINE__) 6565 6566 inline bool binlog_should_compress(size_t len) 6567 { 6568 return opt_bin_log_compress && 6569 len >= opt_bin_log_compress_min_len; 6570 } 6571 6572 6573 /** 6574 Save thd sql_mode on instantiation. 6575 On destruction it resets the mode to the previously stored value. 6576 */ 6577 class Sql_mode_save 6578 { 6579 public: 6580 Sql_mode_save(THD *thd) : thd(thd), old_mode(thd->variables.sql_mode) {} 6581 ~Sql_mode_save() { thd->variables.sql_mode = old_mode; } 6582 6583 private: 6584 THD *thd; 6585 sql_mode_t old_mode; // SQL mode saved at construction time. 6586 }; 6587 6588 class Abort_on_warning_instant_set 6589 { 6590 THD *m_thd; 6591 bool m_save_abort_on_warning; 6592 public: 6593 Abort_on_warning_instant_set(THD *thd, bool temporary_value) 6594 :m_thd(thd), m_save_abort_on_warning(thd->abort_on_warning) 6595 { 6596 thd->abort_on_warning= temporary_value; 6597 } 6598 ~Abort_on_warning_instant_set() 6599 { 6600 m_thd->abort_on_warning= m_save_abort_on_warning; 6601 } 6602 }; 6603 6604 class Switch_to_definer_security_ctx 6605 { 6606 public: 6607 Switch_to_definer_security_ctx(THD *thd, TABLE_LIST *table) : 6608 m_thd(thd), m_sctx(thd->security_ctx) 6609 { 6610 if (table->security_ctx) 6611 thd->security_ctx= table->security_ctx; 6612 } 6613 ~Switch_to_definer_security_ctx() { m_thd->security_ctx = m_sctx; } 6614 6615 private: 6616 THD *m_thd; 6617 Security_context *m_sctx; 6618 }; 6619 6620 6621 class Check_level_instant_set 6622 { 6623 THD *m_thd; 6624 enum_check_fields m_check_level; 6625 public: 6626 Check_level_instant_set(THD *thd, enum_check_fields temporary_value) 6627 :m_thd(thd), m_check_level(thd->count_cuted_fields) 6628 { 6629 thd->count_cuted_fields= temporary_value; 6630 } 6631 ~Check_level_instant_set() 6632 { 6633 m_thd->count_cuted_fields= m_check_level; 6634 } 6635 }; 6636 6637 6638 /** 6639 This class resembles the SQL Standard schema qualified object name: 6640 <schema qualified name> ::= [ <schema name> <period> ] <qualified identifier> 6641 */ 6642 class Database_qualified_name 6643 { 6644 public: 6645 LEX_CSTRING m_db; 6646 LEX_CSTRING m_name; 6647 Database_qualified_name(const LEX_CSTRING *db, const LEX_CSTRING *name) 6648 :m_db(*db), m_name(*name) 6649 { } 6650 Database_qualified_name(const LEX_CSTRING &db, const LEX_CSTRING &name) 6651 :m_db(db), m_name(name) 6652 { } 6653 Database_qualified_name(const char *db, size_t db_length, 6654 const char *name, size_t name_length) 6655 { 6656 m_db.str= db; 6657 m_db.length= db_length; 6658 m_name.str= name; 6659 m_name.length= name_length; 6660 } 6661 6662 bool eq(const Database_qualified_name *other) const 6663 { 6664 CHARSET_INFO *cs= lower_case_table_names ? 6665 &my_charset_utf8_general_ci : 6666 &my_charset_utf8_bin; 6667 return 6668 m_db.length == other->m_db.length && 6669 m_name.length == other->m_name.length && 6670 !my_strnncoll(cs, 6671 (const uchar *) m_db.str, m_db.length, 6672 (const uchar *) other->m_db.str, other->m_db.length) && 6673 !my_strnncoll(cs, 6674 (const uchar *) m_name.str, m_name.length, 6675 (const uchar *) other->m_name.str, other->m_name.length); 6676 } 6677 void copy(MEM_ROOT *mem_root, const LEX_CSTRING &db, 6678 const LEX_CSTRING &name); 6679 // Export db and name as a qualified name string: 'db.name' 6680 size_t make_qname(char *dst, size_t dstlen) const 6681 { 6682 return my_snprintf(dst, dstlen, "%.*s.%.*s", 6683 (int) m_db.length, m_db.str, 6684 (int) m_name.length, m_name.str); 6685 } 6686 // Export db and name as a qualified name string, allocate on mem_root. 6687 bool make_qname(MEM_ROOT *mem_root, LEX_CSTRING *dst) const 6688 { 6689 const uint dot= !!m_db.length; 6690 char *tmp; 6691 /* format: [database + dot] + name + '\0' */ 6692 dst->length= m_db.length + dot + m_name.length; 6693 if (unlikely(!(dst->str= tmp= (char*) alloc_root(mem_root, 6694 dst->length + 1)))) 6695 return true; 6696 sprintf(tmp, "%.*s%.*s%.*s", 6697 (int) m_db.length, (m_db.length ? m_db.str : ""), 6698 dot, ".", 6699 (int) m_name.length, m_name.str); 6700 DBUG_SLOW_ASSERT(ok_for_lower_case_names(m_db.str)); 6701 return false; 6702 } 6703 6704 bool make_package_routine_name(MEM_ROOT *mem_root, 6705 const LEX_CSTRING &package, 6706 const LEX_CSTRING &routine) 6707 { 6708 char *tmp; 6709 size_t length= package.length + 1 + routine.length + 1; 6710 if (unlikely(!(tmp= (char *) alloc_root(mem_root, length)))) 6711 return true; 6712 m_name.length= my_snprintf(tmp, length, "%.*s.%.*s", 6713 (int) package.length, package.str, 6714 (int) routine.length, routine.str); 6715 m_name.str= tmp; 6716 return false; 6717 } 6718 6719 bool make_package_routine_name(MEM_ROOT *mem_root, 6720 const LEX_CSTRING &db, 6721 const LEX_CSTRING &package, 6722 const LEX_CSTRING &routine) 6723 { 6724 if (unlikely(make_package_routine_name(mem_root, package, routine))) 6725 return true; 6726 if (unlikely(!(m_db.str= strmake_root(mem_root, db.str, db.length)))) 6727 return true; 6728 m_db.length= db.length; 6729 return false; 6730 } 6731 }; 6732 6733 6734 class ErrConvDQName: public ErrConv 6735 { 6736 const Database_qualified_name *m_name; 6737 public: 6738 ErrConvDQName(const Database_qualified_name *name) 6739 :m_name(name) 6740 { } 6741 const char *ptr() const 6742 { 6743 m_name->make_qname(err_buffer, sizeof(err_buffer)); 6744 return err_buffer; 6745 } 6746 }; 6747 6748 class Type_holder: public Sql_alloc, 6749 public Item_args, 6750 public Type_handler_hybrid_field_type, 6751 public Type_all_attributes, 6752 public Type_geometry_attributes 6753 { 6754 TYPELIB *m_typelib; 6755 bool m_maybe_null; 6756 public: 6757 Type_holder() 6758 :m_typelib(NULL), 6759 m_maybe_null(false) 6760 { } 6761 6762 void set_maybe_null(bool maybe_null_arg) { m_maybe_null= maybe_null_arg; } 6763 bool get_maybe_null() const { return m_maybe_null; } 6764 6765 uint decimal_precision() const 6766 { 6767 /* 6768 Type_holder is not used directly to create fields, so 6769 its virtual decimal_precision() is never called. 6770 We should eventually extend create_result_table() to accept 6771 an array of Type_holders directly, without having to allocate 6772 Item_type_holder's and put them into List<Item>. 6773 */ 6774 DBUG_ASSERT(0); 6775 return 0; 6776 } 6777 void set_geometry_type(uint type) 6778 { 6779 Type_geometry_attributes::set_geometry_type(type); 6780 } 6781 uint uint_geometry_type() const 6782 { 6783 return Type_geometry_attributes::get_geometry_type(); 6784 } 6785 void set_typelib(TYPELIB *typelib) 6786 { 6787 m_typelib= typelib; 6788 } 6789 TYPELIB *get_typelib() const 6790 { 6791 return m_typelib; 6792 } 6793 6794 bool aggregate_attributes(THD *thd) 6795 { 6796 for (uint i= 0; i < arg_count; i++) 6797 m_maybe_null|= args[i]->maybe_null; 6798 return 6799 type_handler()->Item_hybrid_func_fix_attributes(thd, 6800 "UNION", this, this, 6801 args, arg_count); 6802 } 6803 }; 6804 6805 6806 /* 6807 A helper class to set THD flags to emit warnings/errors in case of 6808 overflow/type errors during assigning values into the SP variable fields. 6809 Saves original flags values in constructor. 6810 Restores original flags in destructor. 6811 */ 6812 class Sp_eval_expr_state 6813 { 6814 THD *m_thd; 6815 enum_check_fields m_count_cuted_fields; 6816 bool m_abort_on_warning; 6817 bool m_stmt_modified_non_trans_table; 6818 void start() 6819 { 6820 m_thd->count_cuted_fields= CHECK_FIELD_ERROR_FOR_NULL; 6821 m_thd->abort_on_warning= m_thd->is_strict_mode(); 6822 m_thd->transaction.stmt.modified_non_trans_table= false; 6823 } 6824 void stop() 6825 { 6826 m_thd->count_cuted_fields= m_count_cuted_fields; 6827 m_thd->abort_on_warning= m_abort_on_warning; 6828 m_thd->transaction.stmt.modified_non_trans_table= 6829 m_stmt_modified_non_trans_table; 6830 } 6831 public: 6832 Sp_eval_expr_state(THD *thd) 6833 :m_thd(thd), 6834 m_count_cuted_fields(thd->count_cuted_fields), 6835 m_abort_on_warning(thd->abort_on_warning), 6836 m_stmt_modified_non_trans_table(thd->transaction.stmt. 6837 modified_non_trans_table) 6838 { 6839 start(); 6840 } 6841 ~Sp_eval_expr_state() 6842 { 6843 stop(); 6844 } 6845 }; 6846 6847 6848 #ifndef DBUG_OFF 6849 void dbug_serve_apcs(THD *thd, int n_calls); 6850 #endif 6851 6852 class ScopedStatementReplication 6853 { 6854 public: 6855 ScopedStatementReplication(THD *thd) : 6856 saved_binlog_format(thd 6857 ? thd->set_current_stmt_binlog_format_stmt() 6858 : BINLOG_FORMAT_MIXED), 6859 thd(thd) 6860 {} 6861 ~ScopedStatementReplication() 6862 { 6863 if (thd) 6864 thd->restore_stmt_binlog_format(saved_binlog_format); 6865 } 6866 6867 private: 6868 const enum_binlog_format saved_binlog_format; 6869 THD *const thd; 6870 }; 6871 6872 #endif /* MYSQL_SERVER */ 6873 #endif /* SQL_CLASS_INCLUDED */ 6874