sql_class.h 78.6 KB
Newer Older
unknown's avatar
unknown committed
1
/* Copyright (C) 2000-2006 MySQL AB
unknown's avatar
unknown committed
2

unknown's avatar
unknown committed
3 4
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
unknown's avatar
unknown committed
5
   the Free Software Foundation; version 2 of the License.
unknown's avatar
unknown committed
6

unknown's avatar
unknown committed
7 8 9 10
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
unknown's avatar
unknown committed
11

unknown's avatar
unknown committed
12 13 14 15 16 17 18
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */


/* Classes in mysql */

19
#ifdef USE_PRAGMA_INTERFACE
unknown's avatar
unknown committed
20 21 22
#pragma interface			/* gcc class implementation */
#endif

23 24
#include "log.h"
#include "rpl_tblmap.h"
25

26 27 28
struct st_relay_log_info;
typedef st_relay_log_info RELAY_LOG_INFO;

unknown's avatar
unknown committed
29 30
class Query_log_event;
class Load_log_event;
31
class Slave_log_event;
32
class sp_rcontext;
33
class sp_cache;
34
class Lex_input_stream;
35
class Rows_log_event;
unknown's avatar
unknown committed
36

37
enum enum_enable_or_disable { LEAVE_AS_IS, ENABLE, DISABLE };
38
enum enum_ha_read_modes { RFIRST, RNEXT, RPREV, RLAST, RKEY, RNEXT_SAME };
39
enum enum_duplicates { DUP_ERROR, DUP_REPLACE, DUP_UPDATE };
40 41
enum enum_delay_key_write { DELAY_KEY_WRITE_NONE, DELAY_KEY_WRITE_ON,
			    DELAY_KEY_WRITE_ALL };
42 43
enum enum_mark_columns
{ MARK_COLUMNS_NONE, MARK_COLUMNS_READ, MARK_COLUMNS_WRITE};
44

unknown's avatar
unknown committed
45
extern char internal_table_name[2];
46
extern char empty_c_string[1];
unknown's avatar
unknown committed
47
extern const char **errmesg;
unknown's avatar
unknown committed
48

49 50 51 52 53 54 55
#define TC_LOG_PAGE_SIZE   8192
#define TC_LOG_MIN_SIZE    (3*TC_LOG_PAGE_SIZE)

#define TC_HEURISTIC_RECOVER_COMMIT   1
#define TC_HEURISTIC_RECOVER_ROLLBACK 2
extern uint tc_heuristic_recover;

unknown's avatar
unknown committed
56 57 58 59 60 61 62 63 64
typedef struct st_user_var_events
{
  user_var_entry *user_var_event;
  char *value;
  ulong length;
  Item_result type;
  uint charset_number;
} BINLOG_USER_VAR_EVENT;

65 66 67
#define RP_LOCK_LOG_IS_ALREADY_LOCKED 1
#define RP_FORCE_ROTATE               2

68 69 70 71 72 73 74 75 76 77 78 79
/*
  The COPY_INFO structure is used by INSERT/REPLACE code.
  The schema of the row counting by the INSERT/INSERT ... ON DUPLICATE KEY
  UPDATE code:
    If a row is inserted then the copied variable is incremented.
    If a row is updated by the INSERT ... ON DUPLICATE KEY UPDATE and the
      new data differs from the old one then the copied and the updated
      variables are incremented.
    The touched variable is incremented if a row was touched by the update part
      of the INSERT ... ON DUPLICATE KEY UPDATE no matter whether the row
      was actually changed or not.
*/
unknown's avatar
unknown committed
80
typedef struct st_copy_info {
81 82 83 84
  ha_rows records; /* Number of processed records */
  ha_rows deleted; /* Number of deleted records */
  ha_rows updated; /* Number of updated records */
  ha_rows copied;  /* Number of copied records */
85
  ha_rows error_count;
86
  ha_rows touched; /* Number of touched records */
unknown's avatar
unknown committed
87
  enum enum_duplicates handle_duplicates;
88
  int escape_char, last_errno;
89 90
  bool ignore;
  /* for INSERT ... UPDATE */
91 92
  List<Item> *update_fields;
  List<Item> *update_values;
unknown's avatar
unknown committed
93
  /* for VIEW ... WITH CHECK OPTION */
unknown's avatar
unknown committed
94
  TABLE_LIST *view;
unknown's avatar
unknown committed
95 96 97
} COPY_INFO;


unknown's avatar
unknown committed
98
class Key_part_spec :public Sql_alloc {
unknown's avatar
unknown committed
99 100 101
public:
  const char *field_name;
  uint length;
unknown's avatar
unknown committed
102 103
  Key_part_spec(const char *name,uint len=0) :field_name(name), length(len) {}
  bool operator==(const Key_part_spec& other) const;
104
  /**
unknown's avatar
unknown committed
105
    Construct a copy of this Key_part_spec. field_name is copied
106 107 108 109 110 111 112
    by-pointer as it is known to never change. At the same time
    'length' may be reset in mysql_prepare_create_table, and this
    is why we supply it with a copy.

    @return If out of memory, 0 is returned and an error is set in
    THD.
  */
unknown's avatar
unknown committed
113 114
  Key_part_spec *clone(MEM_ROOT *mem_root) const
  { return new (mem_root) Key_part_spec(*this); }
unknown's avatar
unknown committed
115 116 117 118 119 120 121 122 123 124
};


class Alter_drop :public Sql_alloc {
public:
  enum drop_type {KEY, COLUMN };
  const char *name;
  enum drop_type type;
  Alter_drop(enum drop_type par_type,const char *par_name)
    :name(par_name), type(par_type) {}
125 126
  /**
    Used to make a clone of this object for ALTER/CREATE TABLE
unknown's avatar
unknown committed
127
    @sa comment for Key_part_spec::clone
128 129 130
  */
  Alter_drop *clone(MEM_ROOT *mem_root) const
    { return new (mem_root) Alter_drop(*this); }
unknown's avatar
unknown committed
131 132 133 134 135 136 137 138 139
};


class Alter_column :public Sql_alloc {
public:
  const char *name;
  Item *def;
  Alter_column(const char *par_name,Item *literal)
    :name(par_name), def(literal) {}
140 141
  /**
    Used to make a clone of this object for ALTER/CREATE TABLE
unknown's avatar
unknown committed
142
    @sa comment for Key_part_spec::clone
143 144 145
  */
  Alter_column *clone(MEM_ROOT *mem_root) const
    { return new (mem_root) Alter_column(*this); }
unknown's avatar
unknown committed
146 147 148 149 150
};


class Key :public Sql_alloc {
public:
151
  enum Keytype { PRIMARY, UNIQUE, MULTIPLE, FULLTEXT, SPATIAL, FOREIGN_KEY};
unknown's avatar
unknown committed
152
  enum Keytype type;
unknown's avatar
unknown committed
153
  KEY_CREATE_INFO key_create_info;
unknown's avatar
unknown committed
154
  List<Key_part_spec> columns;
155
  const char *name;
156
  bool generated;
unknown's avatar
unknown committed
157

158 159
  Key(enum Keytype type_par, const char *name_arg,
      KEY_CREATE_INFO *key_info_arg,
unknown's avatar
unknown committed
160
      bool generated_arg, List<Key_part_spec> &cols)
unknown's avatar
unknown committed
161 162
    :type(type_par), key_create_info(*key_info_arg), columns(cols),
    name(name_arg), generated(generated_arg)
163
  {}
164 165
  Key(const Key &rhs, MEM_ROOT *mem_root);
  virtual ~Key() {}
166
  /* Equality comparison of keys (ignoring name) */
167
  friend bool foreign_key_prefix(Key *a, Key *b);
168 169
  /**
    Used to make a clone of this object for ALTER/CREATE TABLE
unknown's avatar
unknown committed
170
    @sa comment for Key_part_spec::clone
171 172 173
  */
  virtual Key *clone(MEM_ROOT *mem_root) const
    { return new (mem_root) Key(*this, mem_root); }
unknown's avatar
unknown committed
174 175
};

176 177
class Table_ident;

unknown's avatar
unknown committed
178
class Foreign_key: public Key {
179 180 181 182 183 184 185
public:
  enum fk_match_opt { FK_MATCH_UNDEF, FK_MATCH_FULL,
		      FK_MATCH_PARTIAL, FK_MATCH_SIMPLE};
  enum fk_option { FK_OPTION_UNDEF, FK_OPTION_RESTRICT, FK_OPTION_CASCADE,
		   FK_OPTION_SET_NULL, FK_OPTION_NO_ACTION, FK_OPTION_DEFAULT};

  Table_ident *ref_table;
unknown's avatar
unknown committed
186
  List<Key_part_spec> ref_columns;
187
  uint delete_opt, update_opt, match_opt;
unknown's avatar
unknown committed
188 189
  Foreign_key(const char *name_arg, List<Key_part_spec> &cols,
	      Table_ident *table,   List<Key_part_spec> &ref_cols,
190
	      uint delete_opt_arg, uint update_opt_arg, uint match_opt_arg)
191
    :Key(FOREIGN_KEY, name_arg, &default_key_create_info, 0, cols),
192
    ref_table(table), ref_columns(ref_cols),
193 194 195
    delete_opt(delete_opt_arg), update_opt(update_opt_arg),
    match_opt(match_opt_arg)
  {}
unknown's avatar
unknown committed
196
  Foreign_key(const Foreign_key &rhs, MEM_ROOT *mem_root);
197 198
  /**
    Used to make a clone of this object for ALTER/CREATE TABLE
unknown's avatar
unknown committed
199
    @sa comment for Key_part_spec::clone
200 201
  */
  virtual Key *clone(MEM_ROOT *mem_root) const
unknown's avatar
unknown committed
202
  { return new (mem_root) Foreign_key(*this, mem_root); }
203
};
unknown's avatar
unknown committed
204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222

typedef struct st_mysql_lock
{
  TABLE **table;
  uint table_count,lock_count;
  THR_LOCK_DATA **locks;
} MYSQL_LOCK;


class LEX_COLUMN : public Sql_alloc
{
public:
  String column;
  uint rights;
  LEX_COLUMN (const String& x,const  uint& y ): column (x),rights (y) {}
};

#include "sql_lex.h"				/* Must be here */

223
class Delayed_insert;
unknown's avatar
unknown committed
224
class select_result;
225
class Time_zone;
unknown's avatar
unknown committed
226

227 228 229 230 231
#define THD_SENTRY_MAGIC 0xfeedd1ff
#define THD_SENTRY_GONE  0xdeadbeef

#define THD_CHECK_SENTRY(thd) DBUG_ASSERT(thd->dbug_sentry == THD_SENTRY_MAGIC)

232 233
struct system_variables
{
unknown's avatar
unknown committed
234 235 236 237 238 239 240 241 242 243 244 245 246 247
  /*
    How dynamically allocated system variables are handled:
    
    The global_system_variables and max_system_variables are "authoritative"
    They both should have the same 'version' and 'size'.
    When attempting to access a dynamic variable, if the session version
    is out of date, then the session version is updated and realloced if
    neccessary and bytes copied from global to make up for missing data.
  */ 
  ulong dynamic_variables_version;
  char* dynamic_variables_ptr;
  uint dynamic_variables_head;  /* largest valid variable offset */
  uint dynamic_variables_size;  /* how many bytes are in use */
  
unknown's avatar
unknown committed
248 249
  ulonglong myisam_max_extra_sort_file_size;
  ulonglong myisam_max_sort_file_size;
250 251
  ulonglong max_heap_table_size;
  ulonglong tmp_table_size;
252 253
  ha_rows select_limit;
  ha_rows max_join_size;
254
  ulong auto_increment_increment, auto_increment_offset;
unknown's avatar
unknown committed
255
  ulong bulk_insert_buff_size;
256 257
  ulong join_buff_size;
  ulong long_query_time;
unknown's avatar
unknown committed
258
  ulong max_allowed_packet;
259
  ulong max_error_count;
unknown's avatar
unknown committed
260
  ulong max_length_for_sort_data;
261
  ulong max_sort_length;
262
  ulong max_tmp_tables;
263
  ulong max_insert_delayed_threads;
unknown's avatar
unknown committed
264
  ulong multi_range_count;
265
  ulong myisam_repair_threads;
unknown's avatar
unknown committed
266
  ulong myisam_sort_buff_size;
267
  ulong myisam_stats_method;
unknown's avatar
unknown committed
268
  ulong net_buffer_length;
269
  ulong net_interactive_timeout;
unknown's avatar
unknown committed
270
  ulong net_read_timeout;
271
  ulong net_retry_count;
272
  ulong net_wait_timeout;
unknown's avatar
unknown committed
273
  ulong net_write_timeout;
274 275
  ulong optimizer_prune_level;
  ulong optimizer_search_depth;
unknown's avatar
unknown committed
276
  ulong preload_buff_size;
unknown's avatar
unknown committed
277 278 279
  ulong query_cache_type;
  ulong read_buff_size;
  ulong read_rnd_buff_size;
unknown's avatar
unknown committed
280
  ulong div_precincrement;
281
  ulong sortbuff_size;
unknown's avatar
unknown committed
282
  ulong thread_handling;
unknown's avatar
unknown committed
283
  ulong tx_isolation;
unknown's avatar
Merge  
unknown committed
284
  ulong completion_type;
285
  /* Determines which non-standard SQL behaviour should be enabled */
286
  ulong sql_mode;
287
  ulong max_sp_recursion_depth;
unknown's avatar
VIEW  
unknown committed
288
  /* check of key presence in updatable view */
289
  ulong updatable_views_with_limit;
unknown's avatar
unknown committed
290
  ulong default_week_format;
291
  ulong max_seeks_for_key;
292 293 294 295 296
  ulong range_alloc_block_size;
  ulong query_alloc_block_size;
  ulong query_prealloc_size;
  ulong trans_alloc_block_size;
  ulong trans_prealloc_size;
297
  ulong log_warnings;
298
  ulong group_concat_max_len;
unknown's avatar
unknown committed
299 300 301 302
  ulong ndb_autoincrement_prefetch_sz;
  ulong ndb_index_stat_cache_entries;
  ulong ndb_index_stat_update_freq;
  ulong binlog_format; // binlog format for this thd (see enum_binlog_format)
unknown's avatar
unknown committed
303 304 305 306
  /*
    In slave thread we need to know in behalf of which
    thread the query is being run to replicate temp tables properly
  */
unknown's avatar
unknown committed
307
  my_thread_id pseudo_thread_id;
unknown's avatar
unknown committed
308

unknown's avatar
unknown committed
309 310
  my_bool low_priority_updates;
  my_bool new_mode;
311 312 313 314 315
  /* 
    compatibility option:
      - index usage hints (USE INDEX without a FOR clause) behave as in 5.0 
  */
  my_bool old_mode;
316
  my_bool query_cache_wlock_invalidate;
unknown's avatar
unknown committed
317
  my_bool engine_condition_pushdown;
unknown's avatar
unknown committed
318
  my_bool keep_files_on_create;
319
  my_bool ndb_force_send;
320
  my_bool ndb_use_copying_alter_table;
321 322
  my_bool ndb_use_exact_count;
  my_bool ndb_use_transactions;
323
  my_bool ndb_index_stat_enable;
324

unknown's avatar
unknown committed
325
  my_bool old_alter_table;
326
  my_bool old_passwords;
327

unknown's avatar
unknown committed
328
  plugin_ref table_plugin;
unknown's avatar
unknown committed
329

330
  /* Only charset part of these variables is sensible */
unknown's avatar
unknown committed
331
  CHARSET_INFO  *character_set_filesystem;
332
  CHARSET_INFO  *character_set_client;
333
  CHARSET_INFO  *character_set_results;
334

335 336 337
  /* Both charset and collation parts of these variables are important */
  CHARSET_INFO	*collation_server;
  CHARSET_INFO	*collation_database;
unknown's avatar
unknown committed
338
  CHARSET_INFO  *collation_connection;
339

unknown's avatar
unknown committed
340 341 342
  /* Locale Support */
  MY_LOCALE *lc_time_names;

343 344
  Time_zone *time_zone;

345
  /* DATE, DATETIME and MYSQL_TIME formats */
346 347 348
  DATE_TIME_FORMAT *date_format;
  DATE_TIME_FORMAT *datetime_format;
  DATE_TIME_FORMAT *time_format;
349
  my_bool sysdate_is_now;
350

unknown's avatar
unknown committed
351 352
};

353 354 355 356 357

/* per thread status variables */

typedef struct system_status_var
{
358 359
  ulonglong bytes_received;
  ulonglong bytes_sent;
360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375
  ulong com_other;
  ulong com_stat[(uint) SQLCOM_END];
  ulong created_tmp_disk_tables;
  ulong created_tmp_tables;
  ulong ha_commit_count;
  ulong ha_delete_count;
  ulong ha_read_first_count;
  ulong ha_read_last_count;
  ulong ha_read_key_count;
  ulong ha_read_next_count;
  ulong ha_read_prev_count;
  ulong ha_read_rnd_count;
  ulong ha_read_rnd_next_count;
  ulong ha_rollback_count;
  ulong ha_update_count;
  ulong ha_write_count;
376 377 378 379
  ulong ha_prepare_count;
  ulong ha_discover_count;
  ulong ha_savepoint_count;
  ulong ha_savepoint_rollback_count;
380 381 382 383 384 385 386 387 388 389 390 391

  /* KEY_CACHE parts. These are copies of the original */
  ulong key_blocks_changed;
  ulong key_blocks_used;
  ulong key_cache_r_requests;
  ulong key_cache_read;
  ulong key_cache_w_requests;
  ulong key_cache_write;
  /* END OF KEY_CACHE parts */

  ulong net_big_packet_count;
  ulong opened_tables;
unknown's avatar
unknown committed
392
  ulong opened_shares;
393 394 395 396 397 398 399 400 401 402
  ulong select_full_join_count;
  ulong select_full_range_join_count;
  ulong select_range_count;
  ulong select_range_check_count;
  ulong select_scan_count;
  ulong long_query_count;
  ulong filesort_merge_passes;
  ulong filesort_range_count;
  ulong filesort_rows;
  ulong filesort_scan_count;
403
  /* Prepared statements and binary protocol */
unknown's avatar
unknown committed
404 405 406 407 408 409
  ulong com_stmt_prepare;
  ulong com_stmt_execute;
  ulong com_stmt_send_long_data;
  ulong com_stmt_fetch;
  ulong com_stmt_reset;
  ulong com_stmt_close;
410

411 412 413 414
  /*
    Status variables which it does not make sense to add to
    global status variable counter
  */
415
  double last_query_cost;
416 417 418
} STATUS_VAR;

/*
419 420 421
  This is used for 'SHOW STATUS'. It must be updated to the last ulong
  variable in system_status_var which is makes sens to add to the global
  counter
422 423
*/

unknown's avatar
unknown committed
424
#define last_system_status_var com_stmt_close
425

426 427
#ifdef MYSQL_SERVER

428
void free_tmp_table(THD *thd, TABLE *entry);
429 430


unknown's avatar
unknown committed
431 432 433
/* The following macro is to make init of Query_arena simpler */
#ifndef DBUG_OFF
#define INIT_ARENA_DBUG_INFO is_backup_arena= 0
434 435
#else
#define INIT_ARENA_DBUG_INFO
unknown's avatar
unknown committed
436 437
#endif

unknown's avatar
unknown committed
438
class Query_arena
439 440 441 442 443 444 445
{
public:
  /*
    List of items created in the parser for this query. Every item puts
    itself to the list on creation (see Item::Item() for details))
  */
  Item *free_list;
unknown's avatar
unknown committed
446
  MEM_ROOT *mem_root;                   // Pointer to current memroot
unknown's avatar
unknown committed
447
#ifndef DBUG_OFF
448
  bool is_backup_arena; /* True if this arena is used for backup. */
unknown's avatar
unknown committed
449
#endif
450 451 452 453 454 455 456
  /*
    The states relfects three diffrent life cycles for three
    different types of statements:
    Prepared statement: INITIALIZED -> PREPARED -> EXECUTED.
    Stored procedure:   INITIALIZED_FOR_SP -> EXECUTED.
    Other statements:   CONVENTIONAL_EXECUTION never changes.
  */
unknown's avatar
unknown committed
457
  enum enum_state
458
  {
459 460
    INITIALIZED= 0, INITIALIZED_FOR_SP= 1, PREPARED= 2,
    CONVENTIONAL_EXECUTION= 3, EXECUTED= 4, ERROR= -1
461
  };
unknown's avatar
unknown committed
462

unknown's avatar
unknown committed
463
  enum_state state;
464 465 466 467 468 469 470

  /* We build without RTTI, so dynamic_cast can't be used. */
  enum Type
  {
    STATEMENT, PREPARED_STATEMENT, STORED_PROCEDURE
  };

471 472
  Query_arena(MEM_ROOT *mem_root_arg, enum enum_state state_arg) :
    free_list(0), mem_root(mem_root_arg), state(state_arg)
473
  { INIT_ARENA_DBUG_INFO; }
474
  /*
unknown's avatar
unknown committed
475 476
    This constructor is used only when Query_arena is created as
    backup storage for another instance of Query_arena.
477
  */
478 479
  Query_arena() { INIT_ARENA_DBUG_INFO; }

480
  virtual Type type() const;
unknown's avatar
unknown committed
481
  virtual ~Query_arena() {};
482

483
  inline bool is_stmt_prepare() const { return state == INITIALIZED; }
484 485
  inline bool is_first_sp_execute() const
  { return state == INITIALIZED_FOR_SP; }
486 487
  inline bool is_stmt_prepare_or_first_sp_execute() const
  { return (int)state < (int)PREPARED; }
unknown's avatar
unknown committed
488
  inline bool is_first_stmt_execute() const { return state == PREPARED; }
489 490
  inline bool is_stmt_execute() const
  { return state == PREPARED || state == EXECUTED; }
unknown's avatar
unknown committed
491
  inline bool is_conventional() const
unknown's avatar
unknown committed
492
  { return state == CONVENTIONAL_EXECUTION; }
493

494 495
  inline void* alloc(size_t size) { return alloc_root(mem_root,size); }
  inline void* calloc(size_t size)
496
  {
497
    void *ptr;
unknown's avatar
unknown committed
498
    if ((ptr=alloc_root(mem_root,size)))
499
      bzero(ptr, size);
500 501 502
    return ptr;
  }
  inline char *strdup(const char *str)
unknown's avatar
unknown committed
503
  { return strdup_root(mem_root,str); }
504
  inline char *strmake(const char *str, size_t size)
unknown's avatar
unknown committed
505
  { return strmake_root(mem_root,str,size); }
506
  inline void *memdup(const void *str, size_t size)
unknown's avatar
unknown committed
507
  { return memdup_root(mem_root,str,size); }
508
  inline void *memdup_w_gap(const void *str, size_t size, uint gap)
509
  {
510 511
    void *ptr;
    if ((ptr= alloc_root(mem_root,size+gap)))
512 513 514 515
      memcpy(ptr,str,size);
    return ptr;
  }

unknown's avatar
unknown committed
516
  void set_query_arena(Query_arena *set);
517 518

  void free_items();
519 520
  /* Close the active state associated with execution of this statement */
  virtual void cleanup_stmt();
521 522
};

523

524
class Server_side_cursor;
525

526 527 528 529
/**
  @class Statement
  @brief State of a single command executed against this connection.

530 531 532 533 534 535 536 537 538 539 540 541
  One connection can contain a lot of simultaneously running statements,
  some of which could be:
   - prepared, that is, contain placeholders,
   - opened as cursors. We maintain 1 to 1 relationship between
     statement and cursor - if user wants to create another cursor for his
     query, we create another statement for it. 
  To perform some action with statement we reset THD part to the state  of
  that statement, do the action, and then save back modified state from THD
  to the statement. It will be changed in near future, and Statement will
  be used explicitly.
*/

542
class Statement: public ilink, public Query_arena
543
{
544 545
  Statement(const Statement &rhs);              /* not implemented: */
  Statement &operator=(const Statement &rhs);   /* non-copyable */
546 547
public:
  /*
unknown's avatar
unknown committed
548
    Uniquely identifies each statement object in thread scope; change during
549
    statement lifetime. FIXME: must be const
550
  */
unknown's avatar
unknown committed
551
   ulong id;
552 553

  /*
554 555 556 557 558 559 560 561 562
    MARK_COLUMNS_NONE:  Means mark_used_colums is not set and no indicator to
                        handler of fields used is set
    MARK_COLUMNS_READ:  Means a bit in read set is set to inform handler
	                that the field is to be read. If field list contains
                        duplicates, then thd->dup_field is set to point
                        to the last found duplicate.
    MARK_COLUMNS_WRITE: Means a bit is set in write set to inform handler
			that it needs to update this field in write_row
                        and update_row.
563
  */
564
  enum enum_mark_columns mark_used_columns;
565

566
  LEX_STRING name; /* name for named prepared statements */
567 568 569 570 571
  LEX *lex;                                     // parse tree descriptor
  /*
    Points to the query associated with this statement. It's const, but
    we need to declare it char * because all table handlers are written
    in C and need to point to it.
572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588

    Note that (A) if we set query = NULL, we must at the same time set
    query_length = 0, and protect the whole operation with the
    LOCK_thread_count mutex. And (B) we are ONLY allowed to set query to a
    non-NULL value if its previous value is NULL. We do not need to protect
    operation (B) with any mutex. To avoid crashes in races, if we do not
    know that thd->query cannot change at the moment, one should print
    thd->query like this:
      (1) reserve the LOCK_thread_count mutex;
      (2) check if thd->query is NULL;
      (3) if not NULL, then print at most thd->query_length characters from
      it. We will see the query_length field as either 0, or the right value
      for it.
    Assuming that the write and read of an n-bit memory field in an n-bit
    computer is atomic, we can avoid races in the above way. 
    This printing is needed at least in SHOW PROCESSLIST and SHOW INNODB
    STATUS.
589 590 591
  */
  char *query;
  uint32 query_length;                          // current query length
592
  Server_side_cursor *cursor;
593

594 595
public:

unknown's avatar
unknown committed
596
  /* This constructor is called for backup statements */
597
  Statement() {}
598

599 600
  Statement(LEX *lex_arg, MEM_ROOT *mem_root_arg,
            enum enum_state state_arg, ulong id_arg);
601
  virtual ~Statement();
602 603 604

  /* Assign execution context (note: not all members) of given stmt to self */
  void set_statement(Statement *stmt);
605 606
  void set_n_backup_statement(Statement *stmt, Statement *backup);
  void restore_backup_statement(Statement *stmt, Statement *backup);
607 608
  /* return class type */
  virtual Type type() const;
609 610 611
};


612
/**
613 614 615 616 617
  Container for all statements created/used in a connection.
  Statements in Statement_map have unique Statement::id (guaranteed by id
  assignment in Statement::Statement)
  Non-empty statement names are unique too: attempt to insert a new statement
  with duplicate name causes older statement to be deleted
618

619 620
  Statements are auto-deleted when they are removed from the map and when the
  map is deleted.
621 622 623 624 625 626
*/

class Statement_map
{
public:
  Statement_map();
627

628
  int insert(THD *thd, Statement *statement);
629 630

  Statement *find_by_name(LEX_STRING *name)
631
  {
632
    Statement *stmt;
633
    stmt= (Statement*)hash_search(&names_hash, (uchar*)name->str,
634 635
                                  name->length);
    return stmt;
636
  }
637 638

  Statement *find(ulong id)
639
  {
640
    if (last_found_statement == 0 || id != last_found_statement->id)
641 642
    {
      Statement *stmt;
643
      stmt= (Statement *) hash_search(&st_hash, (uchar *) &id, sizeof(id));
644
      if (stmt && stmt->name.str)
645 646 647
        return NULL;
      last_found_statement= stmt;
    }
648
    return last_found_statement;
649
  }
650 651 652 653 654 655
  /*
    Close all cursors of this connection that use tables of a storage
    engine that has transaction-specific state and therefore can not
    survive COMMIT or ROLLBACK. Currently all but MyISAM cursors are closed.
  */
  void close_transient_cursors();
656
  void erase(Statement *statement);
657
  /* Erase all statements (calls Statement destructor) */
658 659
  void reset();
  ~Statement_map();
660 661
private:
  HASH st_hash;
662
  HASH names_hash;
663
  I_List<Statement> transient_cursor_list;
664
  Statement *last_found_statement;
665 666
};

667 668 669 670 671 672 673
struct st_savepoint {
  struct st_savepoint *prev;
  char                *name;
  uint                 length, nht;
};

enum xa_states {XA_NOTR=0, XA_ACTIVE, XA_IDLE, XA_PREPARED};
unknown's avatar
unknown committed
674
extern const char *xa_state_names[];
675

676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691
typedef struct st_xid_state {
  /* For now, this is only used to catch duplicated external xids */
  XID  xid;                           // transaction identifier
  enum xa_states xa_state;            // used by external XA only
  bool in_thd;
} XID_STATE;

extern pthread_mutex_t LOCK_xid_cache;
extern HASH xid_cache;
bool xid_cache_init(void);
void xid_cache_free(void);
XID_STATE *xid_cache_search(XID *xid);
bool xid_cache_insert(XID *xid, enum xa_states xa_state);
bool xid_cache_insert(XID_STATE *xid_state);
void xid_cache_delete(XID_STATE *xid_state);

692 693 694 695
/**
  @class Security_context
  @brief A set of THD members describing the current authenticated user.
*/
696

697 698
class Security_context {
public:
699
  Security_context() {}                       /* Remove gcc warning */
700 701 702 703
  /*
    host - host of the client
    user - user of the client, set to NULL until the user has been read from
    the connection
704
    priv_user - The user privilege we are using. May be "" for anonymous user.
705 706 707
    ip - client IP
  */
  char   *host, *user, *priv_user, *ip;
708
  /* The host privilege we are using */
709 710 711 712 713 714 715 716 717
  char   priv_host[MAX_HOSTNAME];
  /* points to host if host is available, otherwise points to ip */
  const char *host_or_ip;
  ulong master_access;                 /* Global privileges from mysql.user */
  ulong db_access;                     /* Privileges for current db */

  void init();
  void destroy();
  void skip_grants();
718
  inline char *priv_host_name()
719 720 721
  {
    return (*priv_host ? priv_host : (char *)"%");
  }
722 723
  
  bool set_user(char *user_arg);
724 725 726 727 728 729 730 731 732 733 734 735

#ifndef NO_EMBEDDED_ACCESS_CHECKS
  bool
  change_security_context(THD *thd,
                          LEX_STRING *definer_user,
                          LEX_STRING *definer_host,
                          LEX_STRING *db,
                          Security_context **backup);

  void
  restore_security_context(THD *thd, Security_context *backup);
#endif
736 737 738
};


739
/**
740 741 742 743 744 745 746 747 748 749
  A registry for item tree transformations performed during
  query optimization. We register only those changes which require
  a rollback to re-execute a prepared statement or stored procedure
  yet another time.
*/

struct Item_change_record;
typedef I_List<Item_change_record> Item_change_list;


750
/**
751 752 753 754 755 756 757 758
  Type of prelocked mode.
  See comment for THD::prelocked_mode for complete description.
*/

enum prelocked_mode_type {NON_PRELOCKED= 0, PRELOCKED= 1,
                          PRELOCKED_UNDER_LOCK_TABLES= 2};


759
/**
760
  Class that holds information about tables which were opened and locked
761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795
  by the thread. It is also used to save/restore this information in
  push_open_tables_state()/pop_open_tables_state().
*/

class Open_tables_state
{
public:
  /*
    open_tables - list of regular tables in use by this thread
    temporary_tables - list of temp tables in use by this thread
    handler_tables - list of tables that were opened with HANDLER OPEN
     and are still in use by this thread
  */
  TABLE *open_tables, *temporary_tables, *handler_tables, *derived_tables;
  /*
    During a MySQL session, one can lock tables in two modes: automatic
    or manual. In automatic mode all necessary tables are locked just before
    statement execution, and all acquired locks are stored in 'lock'
    member. Unlocking takes place automatically as well, when the
    statement ends.
    Manual mode comes into play when a user issues a 'LOCK TABLES'
    statement. In this mode the user can only use the locked tables.
    Trying to use any other tables will give an error. The locked tables are
    stored in 'locked_tables' member.  Manual locking is described in
    the 'LOCK_TABLES' chapter of the MySQL manual.
    See also lock_tables() for details.
  */
  MYSQL_LOCK *lock;
  /*
    Tables that were locked with explicit or implicit LOCK TABLES.
    (Implicit LOCK TABLES happens when we are prelocking tables for
     execution of statement which uses stored routines. See description
     THD::prelocked_mode for more info.)
  */
  MYSQL_LOCK *locked_tables;
796 797 798 799 800 801 802 803

  /*
    CREATE-SELECT keeps an extra lock for the table being
    created. This field is used to keep the extra lock available for
    lower level routines, which would otherwise miss that lock.
   */
  MYSQL_LOCK *extra_lock;

804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830
  /*
    prelocked_mode_type enum and prelocked_mode member are used for
    indicating whenever "prelocked mode" is on, and what type of
    "prelocked mode" is it.

    Prelocked mode is used for execution of queries which explicitly
    or implicitly (via views or triggers) use functions, thus may need
    some additional tables (mentioned in query table list) for their
    execution.

    First open_tables() call for such query will analyse all functions
    used by it and add all additional tables to table its list. It will
    also mark this query as requiring prelocking. After that lock_tables()
    will issue implicit LOCK TABLES for the whole table list and change
    thd::prelocked_mode to non-0. All queries called in functions invoked
    by the main query will use prelocked tables. Non-0 prelocked_mode
    will also surpress mentioned analysys in those queries thus saving
    cycles. Prelocked mode will be turned off once close_thread_tables()
    for the main query will be called.

    Note: Since not all "tables" present in table list are really locked
    thd::prelocked_mode does not imply thd::locked_tables.
  */
  prelocked_mode_type prelocked_mode;
  ulong	version;
  uint current_tablenr;

831 832 833 834 835 836 837 838 839
  enum enum_flags {
    BACKUPS_AVAIL = (1U << 0)     /* There are backups available */
  };

  /*
    Flags with information about the open tables state.
  */
  uint state_flags;

840 841 842 843
  /*
    This constructor serves for creation of Open_tables_state instances
    which are used as backup storage.
  */
844
  Open_tables_state() : state_flags(0U) { }
845 846

  Open_tables_state(ulong version_arg);
847 848 849 850 851 852 853 854 855

  void set_open_tables_state(Open_tables_state *state)
  {
    *this= *state;
  }

  void reset_open_tables_state()
  {
    open_tables= temporary_tables= handler_tables= derived_tables= 0;
856
    extra_lock= lock= locked_tables= 0;
857
    prelocked_mode= NON_PRELOCKED;
858
    state_flags= 0U;
859 860 861
  }
};

862 863 864 865
/**
  @class Sub_statement_state
  @brief Used to save context when executing a function or trigger
*/
866 867 868 869 870 871

/* Defines used for Sub_statement_state::in_sub_stmt */

#define SUB_STMT_TRIGGER 1
#define SUB_STMT_FUNCTION 2

872

873 874 875 876
class Sub_statement_state
{
public:
  ulonglong options;
877 878 879
  ulonglong first_successful_insert_id_in_prev_stmt;
  ulonglong first_successful_insert_id_in_cur_stmt, insert_id_for_cur_row;
  Discrete_interval auto_inc_interval_for_cur_row;
880 881 882 883
  ulonglong limit_found_rows;
  ha_rows    cuted_fields, sent_row_count, examined_row_count;
  ulong client_capabilities;
  uint in_sub_stmt;
884
  bool enable_slow_log;
unknown's avatar
unknown committed
885
  bool last_insert_id_used;
886
  my_bool no_send_ok;
887
  SAVEPOINT *savepoints;
888 889 890
};


891 892 893 894 895 896 897 898 899 900 901 902 903
/* Flags for the THD::system_thread variable */
enum enum_thread_type
{
  NON_SYSTEM_THREAD= 0,
  SYSTEM_THREAD_DELAYED_INSERT= 1,
  SYSTEM_THREAD_SLAVE_IO= 2,
  SYSTEM_THREAD_SLAVE_SQL= 4,
  SYSTEM_THREAD_NDBCLUSTER_BINLOG= 8,
  SYSTEM_THREAD_EVENT_SCHEDULER= 16,
  SYSTEM_THREAD_EVENT_WORKER= 32
};


unknown's avatar
unknown committed
904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946
/**
  This class represents the interface for internal error handlers.
  Internal error handlers are exception handlers used by the server
  implementation.
*/
class Internal_error_handler
{
protected:
  Internal_error_handler() {}
  virtual ~Internal_error_handler() {}

public:
  /**
    Handle an error condition.
    This method can be implemented by a subclass to achieve any of the
    following:
    - mask an error internally, prevent exposing it to the user,
    - mask an error and throw another one instead.
    When this method returns true, the error condition is considered
    'handled', and will not be propagated to upper layers.
    It is the responsability of the code installing an internal handler
    to then check for trapped conditions, and implement logic to recover
    from the anticipated conditions trapped during runtime.

    This mechanism is similar to C++ try/throw/catch:
    - 'try' correspond to <code>THD::push_internal_handler()</code>,
    - 'throw' correspond to <code>my_error()</code>,
    which invokes <code>my_message_sql()</code>,
    - 'catch' correspond to checking how/if an internal handler was invoked,
    before removing it from the exception stack with
    <code>THD::pop_internal_handler()</code>.

    @param sql_errno the error number
    @param level the error level
    @param thd the calling thread
    @return true if the error is handled
  */
  virtual bool handle_error(uint sql_errno,
                            MYSQL_ERROR::enum_warning_level level,
                            THD *thd) = 0;
};


947 948
/**
  @class THD
unknown's avatar
unknown committed
949 950 951
  For each client connection we create a separate thread with THD serving as
  a thread/connection descriptor
*/
952

953
class THD :public Statement,
954
           public Open_tables_state
unknown's avatar
unknown committed
955
{
unknown's avatar
unknown committed
956
public:
957 958 959
  /* Used to execute base64 coded binlog events in MySQL server */
  RELAY_LOG_INFO* rli_fake;

960 961 962 963 964 965 966 967
  /*
    Constant for THD::where initialization in the beginning of every query.

    It's needed because we do not save/restore THD::where normally during
    primary (non subselect) query execution.
  */
  static const char * const DEFAULT_WHERE;

968 969
#ifdef EMBEDDED_LIBRARY
  struct st_mysql  *mysql;
unknown's avatar
SCRUM  
unknown committed
970 971
  unsigned long	 client_stmt_id;
  unsigned long  client_param_count;
unknown's avatar
unknown committed
972
  struct st_mysql_bind *client_params;
unknown's avatar
unknown committed
973 974
  char *extra_data;
  ulong extra_length;
975 976 977 978 979
  struct st_mysql_data *cur_data;
  struct st_mysql_data *first_data;
  struct st_mysql_data **data_tail;
  void clear_data_list();
  struct st_mysql_data *alloc_new_dataset();
980 981 982 983 984 985
  /*
    In embedded server it points to the statement that is processed
    in the current query. We store some results directly in statement
    fields then.
  */
  struct st_mysql_stmt *current_stmt;
986
#endif
unknown's avatar
unknown committed
987
  NET	  net;				// client connection descriptor
988
  MEM_ROOT warn_root;			// For warnings and errors
989
  Protocol *protocol;			// Current protocol
unknown's avatar
unknown committed
990 991
  Protocol_text   protocol_text;	// Normal protocol
  Protocol_binary protocol_binary;	// Binary protocol
unknown's avatar
unknown committed
992 993
  HASH    user_vars;			// hash for user variables
  String  packet;			// dynamic buffer for network I/O
994
  String  convert_buffer;               // buffer for charset conversions
unknown's avatar
unknown committed
995 996 997
  struct  sockaddr_in remote;		// client socket address
  struct  rand_struct rand;		// used for authentication
  struct  system_variables variables;	// Changeable local variables
998
  struct  system_status_var status_var; // Per thread statistic vars
999
  struct  system_status_var *initial_status_var; /* used by show status */
1000 1001 1002 1003
  THR_LOCK_INFO lock_info;              // Locking info of this thread
  THR_LOCK_OWNER main_lock_id;          // To use for conventional queries
  THR_LOCK_OWNER *lock_id;              // If not main_lock_id, points to
                                        // the lock_id of a cursor.
1004
  pthread_mutex_t LOCK_delete;		// Locked before thd is deleted
1005
  /* all prepared statements and cursors of this connection */
1006
  Statement_map stmt_map;
unknown's avatar
unknown committed
1007 1008 1009 1010 1011 1012
  /*
    A pointer to the stack frame of handle_one_connection(),
    which is called first in the thread for handling a client
  */
  char	  *thread_stack;

1013 1014
  /*
    db - currently selected database
1015
    catalog - currently selected catalog
1016 1017 1018 1019 1020
    WARNING: some members of THD (currently 'db', 'catalog' and 'query')  are
    set and alloced by the slave SQL thread (for the THD of that thread); that
    thread is (and must remain, for now) the only responsible for freeing these
    3 members. If you add members here, and you add code to set them in
    replication, don't forget to free_them_and_set_them_to_0 in replication
1021 1022
    properly. For details see the 'err:' label of the handle_slave_sql()
    in sql/slave.cc.
1023
   */
1024
  char   *db, *catalog;
1025 1026
  Security_context main_security_ctx;
  Security_context *security_ctx;
1027

unknown's avatar
unknown committed
1028 1029
  /* remote (peer) port */
  uint16 peer_port;
1030 1031 1032 1033 1034
  /*
    Points to info-string that we show in SHOW PROCESSLIST
    You are supposed to update thd->proc_info only if you have coded
    a time-consuming piece that MySQL can get stuck in for a long time.
  */
unknown's avatar
unknown committed
1035
  const char *proc_info;
1036

1037
  ulong client_capabilities;		/* What the client supports */
1038
  ulong max_client_packet_length;
1039

unknown's avatar
unknown committed
1040
  HASH		handler_tables_hash;
unknown's avatar
unknown committed
1041 1042 1043 1044 1045
  /*
    One thread can hold up to one named user-level lock. This variable
    points to a lock object if the lock is present. See item_func.cc and
    chapter 'Miscellaneous functions', for functions GET_LOCK, RELEASE_LOCK. 
  */
1046
  User_level_lock *ull;
1047 1048
#ifndef DBUG_OFF
  uint dbug_sentry; // watch out for memory corruption
1049
#endif
unknown's avatar
unknown committed
1050
  struct st_my_thread_var *mysys_var;
1051
  /*
1052
    Type of current query: COM_STMT_PREPARE, COM_QUERY, etc. Set from
1053 1054 1055
    first byte of the packet in do_command()
  */
  enum enum_server_command command;
unknown's avatar
unknown committed
1056
  uint32     server_id;
unknown's avatar
unknown committed
1057
  uint32     file_id;			// for LOAD DATA INFILE
1058 1059 1060 1061 1062
  /*
    Used in error messages to tell user in what part of MySQL we found an
    error. E. g. when where= "having clause", if fix_fields() fails, user
    will know that the error was in having clause.
  */
unknown's avatar
unknown committed
1063
  const char *where;
unknown's avatar
unknown committed
1064 1065
  time_t     start_time,time_after_lock,user_time;
  time_t     connect_time,thr_create_time; // track down slow pthread_create
unknown's avatar
unknown committed
1066
  thr_lock_type update_lock_default;
1067
  Delayed_insert *di;
1068

1069 1070
  /* <> 0 if we are inside of trigger or stored function. */
  uint in_sub_stmt;
1071

1072 1073
  /* container for handler's private per-connection data */
  void *ha_data[MAX_HA];
1074 1075

#ifndef MYSQL_CLIENT
1076 1077
  int binlog_setup_trx_data();

1078
  /*
1079
    Public interface to write RBR events to the binlog
1080
  */
1081
  void binlog_start_trans_and_stmt();
1082 1083
  int binlog_flush_transaction_cache();
  void binlog_set_stmt_begin();
1084
  int binlog_write_table_map(TABLE *table, bool is_transactional);
1085
  int binlog_write_row(TABLE* table, bool is_transactional,
1086 1087
                       MY_BITMAP const* cols, size_t colcnt,
                       const uchar *buf);
1088
  int binlog_delete_row(TABLE* table, bool is_transactional,
1089 1090
                        MY_BITMAP const* cols, size_t colcnt,
                        const uchar *buf);
1091
  int binlog_update_row(TABLE* table, bool is_transactional,
1092 1093
                        MY_BITMAP const* cols, size_t colcnt,
                        const uchar *old_data, const uchar *new_data);
1094 1095 1096 1097 1098 1099 1100 1101 1102

  void set_server_id(uint32 sid) { server_id = sid; }

  /*
    Member functions to handle pending event for row-level logging.
  */
  template <class RowsEventT> Rows_log_event*
    binlog_prepare_pending_rows_event(TABLE* table, uint32 serv_id,
                                      MY_BITMAP const* cols,
1103 1104
                                      size_t colcnt,
                                      size_t needed,
unknown's avatar
unknown committed
1105 1106
                                      bool is_transactional,
				      RowsEventT* hint);
1107 1108 1109 1110
  Rows_log_event* binlog_get_pending_rows_event() const;
  void            binlog_set_pending_rows_event(Rows_log_event* ev);
  int binlog_flush_pending_rows_event(bool stmt_end);

1111 1112
private:
  uint binlog_table_maps; // Number of table maps currently in the binlog
1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123

  enum enum_binlog_flag {
    BINLOG_FLAG_UNSAFE_STMT_PRINTED,
    BINLOG_FLAG_COUNT
  };

  /**
     Flags with per-thread information regarding the status of the
     binary log.
   */
  uint32 binlog_flags;
1124
public:
1125 1126 1127
  uint get_binlog_table_maps() const {
    return binlog_table_maps;
  }
1128 1129
#endif /* MYSQL_CLIENT */

1130 1131
public:

unknown's avatar
unknown committed
1132
  struct st_transactions {
1133
    SAVEPOINT *savepoints;
unknown's avatar
unknown committed
1134 1135
    THD_TRANS all;			// Trans since BEGIN WORK
    THD_TRANS stmt;			// Trans for current statement
1136
    bool on;                            // see ha_enable_transaction()
1137 1138
    XID  xid;                           // transaction identifier
    enum xa_states xa_state;            // used by external XA only
1139
    XID_STATE xid_state;
1140 1141
    Rows_log_event *m_pending_rows_event;

1142
    /*
1143
       Tables changed in transaction (that must be invalidated in query cache).
1144
       List contain only transactional tables, that not invalidated in query
1145 1146 1147 1148 1149 1150
       cache (instead of full list of changed in transaction tables).
    */
    CHANGED_TABLE_LIST* changed_tables;
    MEM_ROOT mem_root; // Transaction-life memory allocation pool
    void cleanup()
    {
1151 1152
      changed_tables= 0;
      savepoints= 0;
1153
#ifdef USING_TRANSACTIONS
1154
      free_root(&mem_root,MYF(MY_KEEP_PREALLOC));
1155
#endif
1156
    }
1157 1158
    st_transactions()
    {
1159
#ifdef USING_TRANSACTIONS
1160
      bzero((char*)this, sizeof(*this));
1161
      xid_state.xid.null();
1162
      init_sql_alloc(&mem_root, ALLOC_ROOT_MIN_BLOCK_SIZE, 0);
1163 1164
#else
      xid_state.xa_state= XA_NOTR;
1165
#endif
1166
    }
unknown's avatar
unknown committed
1167
  } transaction;
1168
  Field      *dup_field;
unknown's avatar
unknown committed
1169
#ifndef __WIN__
unknown's avatar
unknown committed
1170
  sigset_t signals;
unknown's avatar
unknown committed
1171
#endif
1172 1173
#ifdef SIGNAL_WITH_VIO_CLOSE
  Vio* active_vio;
1174
#endif
1175 1176 1177 1178
  /*
    This is to track items changed during execution of a prepared
    statement/stored procedure. It's created by
    register_item_tree_change() in memory root of THD, and freed in
unknown's avatar
unknown committed
1179 1180
    rollback_item_tree_changes(). For conventional execution it's always
    empty.
1181 1182 1183
  */
  Item_change_list change_list;

unknown's avatar
unknown committed
1184
  /*
unknown's avatar
unknown committed
1185 1186
    A permanent memory area of the statement. For conventional
    execution, the parsed tree and execution runtime reside in the same
unknown's avatar
unknown committed
1187
    memory root. In this case stmt_arena points to THD. In case of
unknown's avatar
unknown committed
1188
    a prepared statement or a stored procedure statement, thd->mem_root
unknown's avatar
unknown committed
1189
    conventionally points to runtime memory, and thd->stmt_arena
unknown's avatar
unknown committed
1190 1191 1192
    points to the memory of the PS/SP, where the parsed tree of the
    statement resides. Whenever you need to perform a permanent
    transformation of a parsed tree, you should allocate new memory in
unknown's avatar
unknown committed
1193 1194
    stmt_arena, to allow correct re-execution of PS/SP.
    Note: in the parser, stmt_arena == thd, even for PS/SP.
unknown's avatar
unknown committed
1195
  */
unknown's avatar
unknown committed
1196
  Query_arena *stmt_arena;
1197 1198
  /* Tells if LAST_INSERT_ID(#) was called for the current statement */
  bool arg_of_last_insert_id_function;
1199
  /*
1200 1201
    ALL OVER THIS FILE, "insert_id" means "*automatically generated* value for
    insertion into an auto_increment column".
1202 1203
  */
  /*
1204 1205 1206 1207 1208 1209
    This is the first autogenerated insert id which was *successfully*
    inserted by the previous statement (exactly, if the previous statement
    didn't successfully insert an autogenerated insert id, then it's the one
    of the statement before, etc).
    It can also be set by SET LAST_INSERT_ID=# or SELECT LAST_INSERT_ID(#).
    It is returned by LAST_INSERT_ID().
1210
  */
1211
  ulonglong  first_successful_insert_id_in_prev_stmt;
1212
  /*
1213 1214 1215 1216
    Variant of the above, used for storing in statement-based binlog. The
    difference is that the one above can change as the execution of a stored
    function progresses, while the one below is set once and then does not
    change (which is the value which statement-based binlog needs).
1217
  */
1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272
  ulonglong  first_successful_insert_id_in_prev_stmt_for_binlog;
  /*
    This is the first autogenerated insert id which was *successfully*
    inserted by the current statement. It is maintained only to set
    first_successful_insert_id_in_prev_stmt when statement ends.
  */
  ulonglong  first_successful_insert_id_in_cur_stmt;
  /*
    We follow this logic:
    - when stmt starts, first_successful_insert_id_in_prev_stmt contains the
    first insert id successfully inserted by the previous stmt.
    - as stmt makes progress, handler::insert_id_for_cur_row changes; every
    time get_auto_increment() is called, auto_inc_intervals_for_binlog is
    augmented with the reserved interval (if statement-based binlogging).
    - at first successful insertion of an autogenerated value,
    first_successful_insert_id_in_cur_stmt is set to
    handler::insert_id_for_cur_row.
    - when stmt goes to binlog, auto_inc_intervals_for_binlog is
    binlogged if non-empty.
    - when stmt ends, first_successful_insert_id_in_prev_stmt is set to
    first_successful_insert_id_in_cur_stmt.
  */
  /*
    stmt_depends_on_first_successful_insert_id_in_prev_stmt is set when
    LAST_INSERT_ID() is used by a statement.
    If it is set, first_successful_insert_id_in_prev_stmt_for_binlog will be
    stored in the statement-based binlog.
    This variable is CUMULATIVE along the execution of a stored function or
    trigger: if one substatement sets it to 1 it will stay 1 until the
    function/trigger ends, thus making sure that
    first_successful_insert_id_in_prev_stmt_for_binlog does not change anymore
    and is propagated to the caller for binlogging.
  */
  bool       stmt_depends_on_first_successful_insert_id_in_prev_stmt;
  /*
    List of auto_increment intervals reserved by the thread so far, for
    storage in the statement-based binlog.
    Note that its minimum is not first_successful_insert_id_in_cur_stmt:
    assuming a table with an autoinc column, and this happens:
    INSERT INTO ... VALUES(3);
    SET INSERT_ID=3; INSERT IGNORE ... VALUES (NULL);
    then the latter INSERT will insert no rows
    (first_successful_insert_id_in_cur_stmt == 0), but storing "INSERT_ID=3"
    in the binlog is still needed; the list's minimum will contain 3.
  */
  Discrete_intervals_list auto_inc_intervals_in_cur_stmt_for_binlog;
  /* Used by replication and SET INSERT_ID */
  Discrete_intervals_list auto_inc_intervals_forced;
  /*
    There is BUG#19630 where statement-based replication of stored
    functions/triggers with two auto_increment columns breaks.
    We however ensure that it works when there is 0 or 1 auto_increment
    column; our rules are
    a) on master, while executing a top statement involving substatements,
    first top- or sub- statement to generate auto_increment values wins the
1273 1274 1275
    exclusive right to see its values be written to binlog (the write
    will be done by the statement or its caller), and the losers won't see
    their values be written to binlog.
1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318
    b) on slave, while replicating a top statement involving substatements,
    first top- or sub- statement to need to read auto_increment values from
    the master's binlog wins the exclusive right to read them (so the losers
    won't read their values from binlog but instead generate on their own).
    a) implies that we mustn't backup/restore
    auto_inc_intervals_in_cur_stmt_for_binlog.
    b) implies that we mustn't backup/restore auto_inc_intervals_forced.

    If there are more than 1 auto_increment columns, then intervals for
    different columns may mix into the
    auto_inc_intervals_in_cur_stmt_for_binlog list, which is logically wrong,
    but there is no point in preventing this mixing by preventing intervals
    from the secondly inserted column to come into the list, as such
    prevention would be wrong too.
    What will happen in the case of
    INSERT INTO t1 (auto_inc) VALUES(NULL);
    where t1 has a trigger which inserts into an auto_inc column of t2, is
    that in binlog we'll store the interval of t1 and the interval of t2 (when
    we store intervals, soon), then in slave, t1 will use both intervals, t2
    will use none; if t1 inserts the same number of rows as on master,
    normally the 2nd interval will not be used by t1, which is fine. t2's
    values will be wrong if t2's internal auto_increment counter is different
    from what it was on master (which is likely). In 5.1, in mixed binlogging
    mode, row-based binlogging is used for such cases where two
    auto_increment columns are inserted.
  */
  inline void record_first_successful_insert_id_in_cur_stmt(ulonglong id)
  {
    if (first_successful_insert_id_in_cur_stmt == 0)
      first_successful_insert_id_in_cur_stmt= id;
  }
  inline ulonglong read_first_successful_insert_id_in_prev_stmt(void)
  {
    if (!stmt_depends_on_first_successful_insert_id_in_prev_stmt)
    {
      /* It's the first time we read it */
      first_successful_insert_id_in_prev_stmt_for_binlog=
        first_successful_insert_id_in_prev_stmt;
      stmt_depends_on_first_successful_insert_id_in_prev_stmt= 1;
    }
    return first_successful_insert_id_in_prev_stmt;
  }
  /*
1319
    Used by Intvar_log_event::do_apply_event() and by "SET INSERT_ID=#"
1320 1321 1322 1323 1324
    (mysqlbinlog). We'll soon add a variant which can take many intervals in
    argument.
  */
  inline void force_one_auto_inc_interval(ulonglong next_id)
  {
1325
    auto_inc_intervals_forced.empty(); // in case of multiple SET INSERT_ID
1326 1327 1328
    auto_inc_intervals_forced.append(next_id, ULONGLONG_MAX, 0);
  }

1329
  ulonglong  limit_found_rows;
1330 1331
  ulonglong  options;           /* Bitmap of states */
  longlong   row_count_func;	/* For the ROW_COUNT() function */
unknown's avatar
unknown committed
1332
  ha_rows    cuted_fields,
unknown's avatar
unknown committed
1333
             sent_row_count, examined_row_count;
unknown's avatar
unknown committed
1334 1335 1336 1337 1338 1339
  /*
    The set of those tables whose fields are referenced in all subqueries
    of the query.
    TODO: possibly this it is incorrect to have used tables in THD because
    with more than one subquery, it is not clear what does the field mean.
  */
unknown's avatar
unknown committed
1340
  table_map  used_tables;
1341
  USER_CONN *user_connect;
1342
  CHARSET_INFO *db_charset;
unknown's avatar
unknown committed
1343 1344 1345
  /*
    FIXME: this, and some other variables like 'count_cuted_fields'
    maybe should be statement/cursor local, that is, moved to Statement
1346 1347
    class. With current implementation warnings produced in each prepared
    statement/cursor settle here.
unknown's avatar
unknown committed
1348
  */
1349
  List	     <MYSQL_ERROR> warn_list;
1350
  uint	     warn_count[(uint) MYSQL_ERROR::WARN_LEVEL_END];
unknown's avatar
unknown committed
1351
  uint	     total_warn_count;
1352 1353 1354 1355 1356 1357 1358 1359
  /*
    Id of current query. Statement can be reused to execute several queries
    query_id is global in context of the whole MySQL server.
    ID is automatically generated from mutex-protected counter.
    It's used in handler code for various purposes: to check which columns
    from table are necessary for this select, to check if it's necessary to
    update auto-updatable fields (like auto_increment and timestamp).
  */
1360
  query_id_t query_id, warn_id;
unknown's avatar
unknown committed
1361
  ulong      col_access;
1362

1363 1364 1365
#ifdef ERROR_INJECT_SUPPORT
  ulong      error_inject_value;
#endif
1366 1367
  /* Statement id is thread-wide. This counter is used to generate ids */
  ulong      statement_id_counter;
1368
  ulong	     rand_saved_seed1, rand_saved_seed2;
1369
  ulong      row_count;  // Row counter, mainly for errors and warnings
unknown's avatar
unknown committed
1370 1371
  pthread_t  real_id;                           /* For debugging */
  my_thread_id  thread_id;
1372
  uint	     tmp_table, global_read_lock;
1373 1374
  uint	     server_status,open_options;
  enum enum_thread_type system_thread;
1375
  uint       db_length;
unknown's avatar
unknown committed
1376
  uint       select_number;             //number of select (used for EXPLAIN)
unknown's avatar
unknown committed
1377 1378
  /* variables.transaction_isolation is reset to this after each commit */
  enum_tx_isolation session_tx_isolation;
1379
  enum_check_fields count_cuted_fields;
1380 1381 1382

  DYNAMIC_ARRAY user_var_events;        /* For user variables replication */
  MEM_ROOT      *user_var_events_alloc; /* Allocate above array elements here */
1383

1384 1385 1386 1387 1388 1389 1390 1391
  enum killed_state
  {
    NOT_KILLED=0,
    KILL_BAD_DATA=1,
    KILL_CONNECTION=ER_SERVER_SHUTDOWN,
    KILL_QUERY=ER_QUERY_INTERRUPTED,
    KILLED_NO_VALUE      /* means neither of the states */
  };
1392 1393
  killed_state volatile killed;

1394
  /* scramble - random string sent to client on handshake */
unknown's avatar
unknown committed
1395
  char	     scramble[SCRAMBLE_LENGTH+1];
1396

1397
  bool       slave_thread, one_shot_set;
1398 1399
  /* tells if current statement should binlog row-based(1) or stmt-based(0) */
  bool       current_stmt_binlog_row_based;
1400
  bool	     locked, some_tables_deleted;
1401
  bool       last_cuted_field;
1402
  bool	     no_errors, password, is_fatal_error;
1403
  bool	     query_start_used, rand_used, time_zone_used;
1404 1405
  /* for IS NULL => = last_insert_id() fix in remove_eq_conds() */
  bool       substitute_null_with_insert_id;
1406
  bool	     in_lock_tables;
unknown's avatar
unknown committed
1407
  bool       query_error, bootstrap, cleanup_done;
unknown's avatar
unknown committed
1408
  bool	     tmp_table_used;
1409 1410 1411
  
  /**  is set if some thread specific value(s) used in a statement. */
  bool       thread_specific_used;
unknown's avatar
unknown committed
1412
  bool	     charset_is_system_charset, charset_is_collation_connection;
unknown's avatar
unknown committed
1413
  bool       charset_is_character_set_filesystem;
1414
  bool       enable_slow_log;   /* enable slow log for current statement */
1415 1416 1417 1418 1419
  struct {
    bool all:1;
    bool stmt:1;
  } no_trans_update;
  bool	     abort_on_warning;
unknown's avatar
Merge  
unknown committed
1420
  bool 	     got_warning;       /* Set on call to push_warning() */
1421
  bool	     no_warnings_for_error; /* no warnings on call to my_error() */
1422 1423
  /* set during loop of derived table processing */
  bool       derived_tables_processing;
1424 1425
  my_bool    tablespace_op;	/* This is TRUE in DISCARD/IMPORT TABLESPACE */

1426
  sp_rcontext *spcont;		// SP runtime context
1427 1428
  sp_cache   *sp_proc_cache;
  sp_cache   *sp_func_cache;
unknown's avatar
unknown committed
1429

unknown's avatar
unknown committed
1430 1431 1432 1433 1434
  /*
    If we do a purge of binary logs, log index info of the threads
    that are currently reading it needs to be adjusted. To do that
    each thread that is using LOG_INFO needs to adjust the pointer to it
  */
unknown's avatar
unknown committed
1435
  LOG_INFO*  current_linfo;
unknown's avatar
unknown committed
1436
  NET*       slave_net;			// network connection from slave -> m.
unknown's avatar
unknown committed
1437 1438 1439
  /* Used by the sys_var class to store temporary values */
  union
  {
1440 1441 1442 1443
    my_bool   my_bool_value;
    long      long_value;
    ulong     ulong_value;
    ulonglong ulonglong_value;
unknown's avatar
unknown committed
1444
  } sys_var_tmp;
1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463
  
  struct {
    /* 
      If true, mysql_bin_log::write(Log_event) call will not write events to 
      binlog, and maintain 2 below variables instead (use
      mysql_bin_log.start_union_events to turn this on)
    */
    bool do_union;
    /*
      If TRUE, at least one mysql_bin_log::write(Log_event) call has been
      made after last mysql_bin_log.start_union_events() call.
    */
    bool unioned_events;
    /*
      If TRUE, at least one mysql_bin_log::write(Log_event e), where 
      e.cache_stmt == TRUE call has been made after last 
      mysql_bin_log.start_union_events() call.
    */
    bool unioned_events_trans;
1464 1465 1466 1467 1468 1469
    
    /* 
      'queries' (actually SP statements) that run under inside this binlog
      union have thd->query_id >= first_query_id.
    */
    query_id_t first_query_id;
1470
  } binlog_evt_union;
1471 1472 1473 1474 1475 1476 1477 1478 1479 1480

  /**
    Character input stream consumed by the lexical analyser,
    used during parsing.
    Note that since the parser is not re-entrant, we keep only one input
    stream here. This member is valid only when executing code during parsing,
    and may point to invalid memory after that.
  */
  Lex_input_stream *m_lip;

unknown's avatar
unknown committed
1481
#ifdef WITH_PARTITION_STORAGE_ENGINE
unknown's avatar
unknown committed
1482
  partition_info *work_part_info;
unknown's avatar
unknown committed
1483
#endif
unknown's avatar
foo1  
unknown committed
1484

unknown's avatar
unknown committed
1485 1486
  THD();
  ~THD();
1487

unknown's avatar
unknown committed
1488
  void init(void);
1489 1490 1491 1492 1493 1494 1495 1496 1497 1498
  /*
    Initialize memory roots necessary for query processing and (!)
    pre-allocate memory for it. We can't do that in THD constructor because
    there are use cases (acl_init, delayed inserts, watcher threads,
    killing mysqld) where it's vital to not allocate excessive and not used
    memory. Note, that we still don't return error from init_for_queries():
    if preallocation fails, we should notice that at the first call to
    alloc_root. 
  */
  void init_for_queries();
unknown's avatar
unknown committed
1499
  void change_user(void);
unknown's avatar
unknown committed
1500
  void cleanup(void);
1501
  void cleanup_after_query();
unknown's avatar
unknown committed
1502
  bool store_globals();
1503 1504
#ifdef SIGNAL_WITH_VIO_CLOSE
  inline void set_active_vio(Vio* vio)
1505
  {
1506
    pthread_mutex_lock(&LOCK_delete);
1507
    active_vio = vio;
1508
    pthread_mutex_unlock(&LOCK_delete);
1509
  }
1510
  inline void clear_active_vio()
1511
  {
1512
    pthread_mutex_lock(&LOCK_delete);
1513
    active_vio = 0;
1514
    pthread_mutex_unlock(&LOCK_delete);
1515
  }
unknown's avatar
unknown committed
1516
  void close_active_vio();
1517
#endif
unknown's avatar
SCRUM  
unknown committed
1518
  void awake(THD::killed_state state_to_set);
unknown's avatar
unknown committed
1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545

#ifndef MYSQL_CLIENT
  enum enum_binlog_query_type {
    /*
      The query can be logged row-based or statement-based
    */
    ROW_QUERY_TYPE,
    
    /*
      The query has to be logged statement-based
    */
    STMT_QUERY_TYPE,
    
    /*
      The query represents a change to a table in the "mysql"
      database and is currently mapped to ROW_QUERY_TYPE.
    */
    MYSQL_QUERY_TYPE,
    QUERY_TYPE_COUNT
  };
  
  int binlog_query(enum_binlog_query_type qtype,
                   char const *query, ulong query_len,
                   bool is_trans, bool suppress_use,
                   THD::killed_state killed_err_arg= THD::KILLED_NO_VALUE);
#endif

1546 1547
  /*
    For enter_cond() / exit_cond() to work the mutex must be got before
1548 1549
    enter_cond(); this mutex is then released by exit_cond().
    Usage must be: lock mutex; enter_cond(); your code; exit_cond().
1550
  */
unknown's avatar
unknown committed
1551 1552 1553 1554
  inline const char* enter_cond(pthread_cond_t *cond, pthread_mutex_t* mutex,
			  const char* msg)
  {
    const char* old_msg = proc_info;
1555
    safe_mutex_assert_owner(mutex);
unknown's avatar
unknown committed
1556 1557 1558 1559 1560 1561 1562
    mysys_var->current_mutex = mutex;
    mysys_var->current_cond = cond;
    proc_info = msg;
    return old_msg;
  }
  inline void exit_cond(const char* old_msg)
  {
unknown's avatar
unknown committed
1563 1564 1565 1566 1567 1568 1569
    /*
      Putting the mutex unlock in exit_cond() ensures that
      mysys_var->current_mutex is always unlocked _before_ mysys_var->mutex is
      locked (if that would not be the case, you'll get a deadlock if someone
      does a THD::awake() on you).
    */
    pthread_mutex_unlock(mysys_var->current_mutex);
unknown's avatar
unknown committed
1570 1571 1572 1573 1574 1575
    pthread_mutex_lock(&mysys_var->mutex);
    mysys_var->current_mutex = 0;
    mysys_var->current_cond = 0;
    proc_info = old_msg;
    pthread_mutex_unlock(&mysys_var->mutex);
  }
1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591

  static inline void safe_time(time_t *t)
  {
    /**
       Wrapper around time() which retries on error (-1)

       @details
       This is needed because, despite the documentation, time() may fail
       in some circumstances.  Here we retry time() until it succeeds, and
       log the failure so that performance problems related to this can be
       identified.
    */
    while(unlikely(time(t) == ((time_t) -1)))
      sql_print_information("time() failed with %d", errno);
  }

unknown's avatar
unknown committed
1592
  inline time_t query_start() { query_start_used=1; return start_time; }
1593 1594
  inline void	set_time()    { if (user_time) start_time=time_after_lock=user_time; else { safe_time(&start_time); time_after_lock= start_time; }}
  inline void	end_time()    { safe_time(&start_time); }
unknown's avatar
unknown committed
1595
  inline void	set_time(time_t t) { time_after_lock=start_time=user_time=t; }
1596
  inline void	lock_time()   { safe_time(&time_after_lock); }
1597 1598 1599
  inline ulonglong found_rows(void)
  {
    return limit_found_rows;
1600
  }
1601 1602
  inline bool active_transaction()
  {
1603 1604
#ifdef USING_TRANSACTIONS
    return server_status & SERVER_STATUS_IN_TRANS;
1605 1606 1607
#else
    return 0;
#endif
1608
  }
unknown's avatar
unknown committed
1609 1610
  inline bool fill_derived_tables()
  {
unknown's avatar
unknown committed
1611
    return !stmt_arena->is_stmt_prepare() && !lex->only_view_structure();
unknown's avatar
unknown committed
1612
  }
1613 1614 1615 1616
  inline bool fill_information_schema_tables()
  {
    return !stmt_arena->is_stmt_prepare();
  }
1617
  inline void* trans_alloc(unsigned int size)
unknown's avatar
unknown committed
1618
  {
1619 1620
    return alloc_root(&transaction.mem_root,size);
  }
1621

1622 1623 1624 1625
  LEX_STRING *make_lex_string(LEX_STRING *lex_str,
                              const char* str, uint length,
                              bool allocate_lex_string);

1626 1627 1628
  bool convert_string(LEX_STRING *to, CHARSET_INFO *to_cs,
		      const char *from, uint from_length,
		      CHARSET_INFO *from_cs);
1629 1630 1631

  bool convert_string(String *s, CHARSET_INFO *from_cs, CHARSET_INFO *to_cs);

1632
  void add_changed_table(TABLE *table);
unknown's avatar
unknown committed
1633 1634
  void add_changed_table(const char *key, long key_length);
  CHANGED_TABLE_LIST * changed_table_dup(const char *key, long key_length);
unknown's avatar
unknown committed
1635
  int send_explain_fields(select_result *result);
1636
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
1637 1638
  inline void clear_error()
  {
1639
    DBUG_ENTER("clear_error");
unknown's avatar
unknown committed
1640 1641 1642
    net.last_error[0]= 0;
    net.last_errno= 0;
    net.report_error= 0;
unknown's avatar
unknown committed
1643
    query_error= 0;
1644
    DBUG_VOID_RETURN;
unknown's avatar
unknown committed
1645
  }
1646
  inline bool vio_ok() const { return net.vio != 0; }
1647 1648
#else
  void clear_error();
1649
  inline bool vio_ok() const { return true; }
1650
#endif
1651 1652 1653
  inline void fatal_error()
  {
    is_fatal_error= 1;
unknown's avatar
unknown committed
1654
    net.report_error= 1;
unknown's avatar
unknown committed
1655
    DBUG_PRINT("error",("Fatal error set"));
1656
  }
1657
  inline CHARSET_INFO *charset() { return variables.character_set_client; }
unknown's avatar
unknown committed
1658
  void update_charset();
1659

unknown's avatar
unknown committed
1660
  inline Query_arena *activate_stmt_arena_if_needed(Query_arena *backup)
unknown's avatar
unknown committed
1661 1662
  {
    /*
unknown's avatar
unknown committed
1663 1664
      Use the persistent arena if we are in a prepared statement or a stored
      procedure statement and we have not already changed to use this arena.
unknown's avatar
unknown committed
1665
    */
unknown's avatar
unknown committed
1666
    if (!stmt_arena->is_conventional() && mem_root != stmt_arena->mem_root)
unknown's avatar
unknown committed
1667
    {
unknown's avatar
unknown committed
1668 1669
      set_n_backup_active_arena(stmt_arena, backup);
      return stmt_arena;
unknown's avatar
unknown committed
1670 1671 1672 1673
    }
    return 0;
  }

1674
  void change_item_tree(Item **place, Item *new_value)
1675
  {
1676
    /* TODO: check for OOM condition here */
unknown's avatar
unknown committed
1677
    if (!stmt_arena->is_conventional())
unknown's avatar
unknown committed
1678
      nocheck_register_item_tree_change(place, *place, mem_root);
1679
    *place= new_value;
1680 1681
  }
  void nocheck_register_item_tree_change(Item **place, Item *old_value,
1682
                                         MEM_ROOT *runtime_memroot);
1683
  void rollback_item_tree_changes();
1684 1685 1686 1687 1688 1689

  /*
    Cleanup statement parse state (parse tree, lex) and execution
    state after execution of a non-prepared SQL statement.
  */
  void end_statement();
1690 1691
  inline int killed_errno() const
  {
1692 1693
    killed_state killed_val; /* to cache the volatile 'killed' */
    return (killed_val= killed) != KILL_BAD_DATA ? killed_val : 0;
1694 1695 1696
  }
  inline void send_kill_message() const
  {
unknown's avatar
unknown committed
1697
    int err= killed_errno();
1698 1699
    if (err)
      my_message(err, ER(err), MYF(0));
1700
  }
unknown's avatar
unknown committed
1701 1702 1703 1704
  /* return TRUE if we will abort query if we make a warning now */
  inline bool really_abort_on_warning()
  {
    return (abort_on_warning &&
1705
            (!no_trans_update.stmt ||
unknown's avatar
unknown committed
1706 1707
             (variables.sql_mode & MODE_STRICT_ALL_TABLES)));
  }
1708
  void set_status_var_init();
1709
  bool is_context_analysis_only()
unknown's avatar
unknown committed
1710
    { return stmt_arena->is_stmt_prepare() || lex->view_prepare_mode; }
1711 1712
  void reset_n_backup_open_tables_state(Open_tables_state *backup);
  void restore_backup_open_tables_state(Open_tables_state *backup);
1713 1714
  void reset_sub_statement_state(Sub_statement_state *backup, uint new_state);
  void restore_sub_statement_state(Sub_statement_state *backup);
unknown's avatar
unknown committed
1715 1716
  void set_n_backup_active_arena(Query_arena *set, Query_arena *backup);
  void restore_active_arena(Query_arena *set, Query_arena *backup);
1717

1718 1719
  inline void set_current_stmt_binlog_row_based_if_mixed()
  {
unknown's avatar
unknown committed
1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730
    /*
      If in a stored/function trigger, the caller should already have done the
      change. We test in_sub_stmt to prevent introducing bugs where people
      wouldn't ensure that, and would switch to row-based mode in the middle
      of executing a stored function/trigger (which is too late, see also
      reset_current_stmt_binlog_row_based()); this condition will make their
      tests fail and so force them to propagate the
      lex->binlog_row_based_if_mixed upwards to the caller.
    */
    if ((variables.binlog_format == BINLOG_FORMAT_MIXED) &&
        (in_sub_stmt == 0))
1731
      current_stmt_binlog_row_based= TRUE;
unknown's avatar
unknown committed
1732 1733 1734
  }
  inline void set_current_stmt_binlog_row_based()
  {
1735
    current_stmt_binlog_row_based= TRUE;
1736
  }
1737 1738
  inline void clear_current_stmt_binlog_row_based()
  {
1739
    current_stmt_binlog_row_based= FALSE;
1740
  }
1741 1742
  inline void reset_current_stmt_binlog_row_based()
  {
unknown's avatar
unknown committed
1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756
    /*
      If there are temporary tables, don't reset back to
      statement-based. Indeed it could be that:
      CREATE TEMPORARY TABLE t SELECT UUID(); # row-based
      # and row-based does not store updates to temp tables
      # in the binlog.
      INSERT INTO u SELECT * FROM t; # stmt-based
      and then the INSERT will fail as data inserted into t was not logged.
      So we continue with row-based until the temp table is dropped.
      If we are in a stored function or trigger, we mustn't reset in the
      middle of its execution (as the binary logging way of a stored function
      or trigger is decided when it starts executing, depending for example on
      the caller (for a stored function: if caller is SELECT or
      INSERT/UPDATE/DELETE...).
1757 1758

      Don't reset binlog format for NDB binlog injector thread.
unknown's avatar
unknown committed
1759
    */
1760 1761
    if ((temporary_tables == NULL) && (in_sub_stmt == 0) &&
        (system_thread != SYSTEM_THREAD_NDBCLUSTER_BINLOG))
unknown's avatar
unknown committed
1762 1763 1764 1765
    {
      current_stmt_binlog_row_based= 
        test(variables.binlog_format == BINLOG_FORMAT_ROW);
    }
1766
  }
unknown's avatar
unknown committed
1767 1768 1769

  /*
    Initialize the current database from a NULL-terminated string with length
1770 1771 1772
    If we run out of memory, we free the current database and return TRUE.
    This way the user will notice the error as there will be no current
    database selected (in addition to the error message set by malloc).
unknown's avatar
unknown committed
1773
  */
1774
  bool set_db(const char *new_db, size_t new_db_len)
unknown's avatar
unknown committed
1775
  {
1776 1777 1778 1779
    /* Do not reallocate memory if current chunk is big enough. */
    if (db && new_db && db_length >= new_db_len)
      memcpy(db, new_db, new_db_len+1);
    else
unknown's avatar
unknown committed
1780
    {
unknown's avatar
unknown committed
1781 1782
      x_free(db);
      db= new_db ? my_strndup(new_db, new_db_len, MYF(MY_WME)) : NULL;
unknown's avatar
unknown committed
1783
    }
1784 1785
    db_length= db ? new_db_len : 0;
    return new_db && !db;
unknown's avatar
unknown committed
1786
  }
1787
  void reset_db(char *new_db, size_t new_db_len)
unknown's avatar
unknown committed
1788 1789 1790 1791 1792 1793 1794 1795 1796
  {
    db= new_db;
    db_length= new_db_len;
  }
  /*
    Copy the current database to the argument. Use the current arena to
    allocate memory for a deep copy: current database may be freed after
    a statement is parsed but before it's executed.
  */
1797
  bool copy_db_to(char **p_db, size_t *p_db_length)
unknown's avatar
unknown committed
1798 1799 1800 1801 1802 1803 1804
  {
    if (db == NULL)
    {
      my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
      return TRUE;
    }
    *p_db= strmake(db, db_length);
1805
    *p_db_length= db_length;
unknown's avatar
unknown committed
1806 1807
    return FALSE;
  }
unknown's avatar
unknown committed
1808
  thd_scheduler scheduler;
unknown's avatar
unknown committed
1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833

public:
  /**
    Add an internal error handler to the thread execution context.
    @param handler the exception handler to add
  */
  void push_internal_handler(Internal_error_handler *handler);

  /**
    Handle an error condition.
    @param sql_errno the error number
    @param level the error level
    @return true if the error is handled
  */
  virtual bool handle_error(uint sql_errno,
                            MYSQL_ERROR::enum_warning_level level);

  /**
    Remove the error handler last pushed.
  */
  void pop_internal_handler();

private:
  /** The current internal error handler for this thread, or NULL. */
  Internal_error_handler *m_internal_handler;
1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849
  /**
    The lex to hold the parsed tree of conventional (non-prepared) queries.
    Whereas for prepared and stored procedure statements we use an own lex
    instance for each new query, for conventional statements we reuse
    the same lex. (@see mysql_parse for details).
  */
  LEX main_lex;
  /**
    This memory root is used for two purposes:
    - for conventional queries, to allocate structures stored in main_lex
    during parsing, and allocate runtime data (execution plan, etc.)
    during execution.
    - for prepared queries, only to allocate runtime data. The parsed
    tree itself is reused between executions and thus is stored elsewhere.
  */
  MEM_ROOT main_mem_root;
unknown's avatar
unknown committed
1850 1851
};

1852

1853
#define tmp_disable_binlog(A)       \
1854
  {ulonglong tmp_disable_binlog__save_options= (A)->options; \
1855
  (A)->options&= ~OPTION_BIN_LOG
1856

1857
#define reenable_binlog(A)   (A)->options= tmp_disable_binlog__save_options;}
1858

1859

unknown's avatar
unknown committed
1860
/*
1861
  Used to hold information about file and file structure in exchange
unknown's avatar
unknown committed
1862
  via non-DB file (...INTO OUTFILE..., ...LOAD DATA...)
1863
  XXX: We never call destructor for objects of this class.
unknown's avatar
unknown committed
1864
*/
1865

unknown's avatar
unknown committed
1866 1867 1868 1869 1870 1871 1872
class sql_exchange :public Sql_alloc
{
public:
  char *file_name;
  String *field_term,*enclosed,*line_term,*line_start,*escaped;
  bool opt_enclosed;
  bool dumpfile;
1873
  ulong skip_lines;
1874
  CHARSET_INFO *cs;
unknown's avatar
unknown committed
1875 1876 1877 1878 1879 1880
  sql_exchange(char *name,bool dumpfile_flag);
};

#include "log_event.h"

/*
1881
  This is used to get result from a select
unknown's avatar
unknown committed
1882 1883
*/

unknown's avatar
unknown committed
1884 1885
class JOIN;

unknown's avatar
unknown committed
1886 1887 1888
class select_result :public Sql_alloc {
protected:
  THD *thd;
1889
  SELECT_LEX_UNIT *unit;
unknown's avatar
unknown committed
1890 1891 1892
public:
  select_result();
  virtual ~select_result() {};
1893 1894 1895 1896 1897
  virtual int prepare(List<Item> &list, SELECT_LEX_UNIT *u)
  {
    unit= u;
    return 0;
  }
1898
  virtual int prepare2(void) { return 0; }
1899 1900 1901 1902 1903 1904 1905
  /*
    Because of peculiarities of prepared statements protocol
    we need to know number of columns in the result set (if
    there is a result set) apart from sending columns metadata.
  */
  virtual uint field_count(List<Item> &fields) const
  { return fields.elements; }
1906
  virtual bool send_fields(List<Item> &list, uint flags)=0;
unknown's avatar
unknown committed
1907
  virtual bool send_data(List<Item> &items)=0;
unknown's avatar
unknown committed
1908
  virtual bool initialize_tables (JOIN *join=0) { return 0; }
1909
  virtual void send_error(uint errcode,const char *err);
unknown's avatar
unknown committed
1910
  virtual bool send_eof()=0;
1911 1912 1913 1914 1915 1916 1917 1918
  /**
    Check if this query returns a result set and therefore is allowed in
    cursors and set an error message if it is not the case.

    @retval FALSE     success
    @retval TRUE      error, an error message is set
  */
  virtual bool check_simple_select() const;
unknown's avatar
unknown committed
1919
  virtual void abort() {}
1920 1921 1922 1923 1924
  /*
    Cleanup instance of this class for next execution of a prepared
    statement/stored procedure.
  */
  virtual void cleanup();
1925
  void set_thd(THD *thd_arg) { thd= thd_arg; }
1926 1927 1928 1929 1930
#ifdef EMBEDDED_LIBRARY
  virtual void begin_dataset() {}
#else
  void begin_dataset() {}
#endif
unknown's avatar
unknown committed
1931 1932 1933
};


1934 1935 1936 1937 1938 1939 1940 1941 1942
/*
  Base class for select_result descendands which intercept and
  transform result set rows. As the rows are not sent to the client,
  sending of result set metadata should be suppressed as well.
*/

class select_result_interceptor: public select_result
{
public:
1943
  select_result_interceptor() {}              /* Remove gcc warning */
1944 1945 1946 1947 1948
  uint field_count(List<Item> &fields) const { return 0; }
  bool send_fields(List<Item> &fields, uint flag) { return FALSE; }
};


unknown's avatar
unknown committed
1949
class select_send :public select_result {
1950
  int status;
unknown's avatar
unknown committed
1951
public:
1952
  select_send() :status(0) {}
1953
  bool send_fields(List<Item> &list, uint flags);
unknown's avatar
unknown committed
1954 1955
  bool send_data(List<Item> &items);
  bool send_eof();
1956
  virtual bool check_simple_select() const { return FALSE; }
1957
  void abort();
unknown's avatar
unknown committed
1958 1959 1960
};


1961
class select_to_file :public select_result_interceptor {
1962
protected:
unknown's avatar
unknown committed
1963 1964 1965 1966
  sql_exchange *exchange;
  File file;
  IO_CACHE cache;
  ha_rows row_count;
1967 1968 1969 1970 1971 1972 1973
  char path[FN_REFLEN];

public:
  select_to_file(sql_exchange *ex) :exchange(ex), file(-1),row_count(0L)
  { path[0]=0; }
  ~select_to_file();
  void send_error(uint errcode,const char *err);
1974 1975
  bool send_eof();
  void cleanup();
1976 1977 1978
};


unknown's avatar
unknown committed
1979 1980 1981
#define ESCAPE_CHARS "ntrb0ZN" // keep synchronous with READ_INFO::unescape


unknown's avatar
unknown committed
1982 1983 1984 1985 1986 1987
/*
 List of all possible characters of a numeric value text representation.
*/
#define NUMERIC_CHARS ".0123456789e+-"


1988
class select_export :public select_to_file {
unknown's avatar
unknown committed
1989 1990
  uint field_term_length;
  int field_sep_char,escape_char,line_sep_char;
unknown's avatar
unknown committed
1991 1992 1993 1994 1995 1996
  /*
    The is_ambiguous_field_sep field is true if a value of the field_sep_char
    field is one of the 'n', 't', 'r' etc characters
    (see the READ_INFO::unescape method and the ESCAPE_CHARS constant value).
  */
  bool is_ambiguous_field_sep;
unknown's avatar
unknown committed
1997 1998 1999 2000 2001 2002
  /*
    The is_unsafe_field_sep field is true if a value of the field_sep_char
    field is one of the '0'..'9', '+', '-', '.' and 'e' characters
    (see the NUMERIC_CHARS constant value).
  */
  bool is_unsafe_field_sep;
unknown's avatar
unknown committed
2003 2004
  bool fixed_row_size;
public:
2005
  select_export(sql_exchange *ex) :select_to_file(ex) {}
unknown's avatar
unknown committed
2006
  ~select_export();
2007
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
2008 2009 2010
  bool send_data(List<Item> &items);
};

unknown's avatar
unknown committed
2011

2012
class select_dump :public select_to_file {
unknown's avatar
unknown committed
2013
public:
2014
  select_dump(sql_exchange *ex) :select_to_file(ex) {}
2015
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
2016 2017
  bool send_data(List<Item> &items);
};
unknown's avatar
unknown committed
2018 2019


2020
class select_insert :public select_result_interceptor {
unknown's avatar
unknown committed
2021
 public:
unknown's avatar
VIEW  
unknown committed
2022
  TABLE_LIST *table_list;
unknown's avatar
unknown committed
2023 2024
  TABLE *table;
  List<Item> *fields;
2025
  ulonglong autoinc_value_of_last_inserted_row; // autogenerated or not
unknown's avatar
unknown committed
2026
  COPY_INFO info;
unknown's avatar
VIEW  
unknown committed
2027
  bool insert_into_view;
unknown's avatar
unknown committed
2028

unknown's avatar
unknown committed
2029 2030
  select_insert(TABLE_LIST *table_list_par,
		TABLE *table_par, List<Item> *fields_par,
unknown's avatar
unknown committed
2031
		List<Item> *update_fields, List<Item> *update_values,
2032
		enum_duplicates duplic, bool ignore);
unknown's avatar
unknown committed
2033
  ~select_insert();
2034
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
2035
  int prepare2(void);
unknown's avatar
unknown committed
2036
  bool send_data(List<Item> &items);
unknown's avatar
unknown committed
2037
  virtual void store_values(List<Item> &values);
2038
  virtual bool can_rollback_data() { return 0; }
unknown's avatar
unknown committed
2039 2040
  void send_error(uint errcode,const char *err);
  bool send_eof();
2041
  void abort();
2042 2043
  /* not implemented: select_insert is never re-used in prepared statements */
  void cleanup();
unknown's avatar
unknown committed
2044 2045
};

unknown's avatar
unknown committed
2046

unknown's avatar
unknown committed
2047 2048
class select_create: public select_insert {
  ORDER *group;
unknown's avatar
VIEW  
unknown committed
2049
  TABLE_LIST *create_table;
unknown's avatar
unknown committed
2050
  HA_CREATE_INFO *create_info;
2051
  TABLE_LIST *select_tables;
2052
  Alter_info *alter_info;
unknown's avatar
unknown committed
2053 2054
  Field **field;
public:
unknown's avatar
unknown committed
2055
  select_create (TABLE_LIST *table_arg,
unknown's avatar
VIEW  
unknown committed
2056
		 HA_CREATE_INFO *create_info_par,
2057
                 Alter_info *alter_info_arg,
2058 2059
		 List<Item> &select_fields,enum_duplicates duplic, bool ignore,
                 TABLE_LIST *select_tables_arg)
2060
    :select_insert (NULL, NULL, &select_fields, 0, 0, duplic, ignore),
2061
    create_table(table_arg),
2062 2063
    create_info(create_info_par),
    select_tables(select_tables_arg),
2064
    alter_info(alter_info_arg)
unknown's avatar
unknown committed
2065
    {}
2066
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
2067

2068
  void binlog_show_create_table(TABLE **tables, uint count);
unknown's avatar
unknown committed
2069
  void store_values(List<Item> &values);
2070
  void send_error(uint errcode,const char *err);
unknown's avatar
unknown committed
2071 2072
  bool send_eof();
  void abort();
2073 2074
  virtual bool can_rollback_data() { return 1; }

2075
  // Needed for access from local class MY_HOOKS in prepare(), since thd is proteted.
2076 2077
  const THD *get_thd(void) { return thd; }
  const HA_CREATE_INFO *get_create_info() { return create_info; };
unknown's avatar
unknown committed
2078 2079
};

2080 2081
#include <myisam.h>

unknown's avatar
unknown committed
2082 2083 2084 2085 2086
/* 
  Param to create temporary tables when doing SELECT:s 
  NOTE
    This structure is copied using memcpy as a part of JOIN.
*/
2087 2088 2089

class TMP_TABLE_PARAM :public Sql_alloc
{
2090 2091 2092 2093 2094 2095
private:
  /* Prevent use of these (not safe because of lists and copy_field) */
  TMP_TABLE_PARAM(const TMP_TABLE_PARAM &);
  void operator=(TMP_TABLE_PARAM &);

public:
2096 2097 2098 2099
  List<Item> copy_funcs;
  List<Item> save_copy_funcs;
  Copy_field *copy_field, *copy_field_end;
  Copy_field *save_copy_field, *save_copy_field_end;
2100
  uchar	    *group_buff;
2101 2102 2103 2104 2105 2106 2107 2108 2109
  Item	    **items_to_copy;			/* Fields in tmp table */
  MI_COLUMNDEF *recinfo,*start_recinfo;
  KEY *keyinfo;
  ha_rows end_write_records;
  uint	field_count,sum_func_count,func_count;
  uint  hidden_field_count;
  uint	group_parts,group_length,group_null_parts;
  uint	quick_group;
  bool  using_indirect_summary_function;
2110 2111
  /* If >0 convert all blob fields to varchar(convert_blob_length) */
  uint  convert_blob_length; 
unknown's avatar
unknown committed
2112
  CHARSET_INFO *table_charset; 
2113
  bool schema_table;
2114 2115 2116 2117 2118 2119 2120
  /*
    True if GROUP BY and its aggregate functions are already computed
    by a table access method (e.g. by loose index scan). In this case
    query execution should not perform aggregation and should treat
    aggregate functions as normal functions.
  */
  bool precomputed_group_by;
2121
  bool force_copy_fields;
2122 2123

  TMP_TABLE_PARAM()
unknown's avatar
unknown committed
2124
    :copy_field(0), group_parts(0),
unknown's avatar
unknown committed
2125
     group_length(0), group_null_parts(0), convert_blob_length(0),
unknown's avatar
unknown committed
2126
     schema_table(0), precomputed_group_by(0), force_copy_fields(0)
2127 2128 2129 2130 2131
  {}
  ~TMP_TABLE_PARAM()
  {
    cleanup();
  }
2132
  void init(void);
2133 2134 2135 2136 2137
  inline void cleanup(void)
  {
    if (copy_field)				/* Fix for Intel compiler */
    {
      delete [] copy_field;
2138
      save_copy_field= copy_field= 0;
2139 2140 2141 2142
    }
  }
};

2143 2144
class select_union :public select_result_interceptor
{
2145
  TMP_TABLE_PARAM tmp_table_param;
2146 2147
public:
  TABLE *table;
unknown's avatar
unknown committed
2148

2149
  select_union() :table(0) {}
2150
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
2151 2152 2153
  bool send_data(List<Item> &items);
  bool send_eof();
  bool flush();
2154 2155 2156 2157

  bool create_result_table(THD *thd, List<Item> *column_types,
                           bool is_distinct, ulonglong options,
                           const char *alias);
unknown's avatar
unknown committed
2158 2159
};

unknown's avatar
unknown committed
2160
/* Base subselect interface class */
2161
class select_subselect :public select_result_interceptor
2162
{
unknown's avatar
unknown committed
2163
protected:
2164 2165 2166
  Item_subselect *item;
public:
  select_subselect(Item_subselect *item);
unknown's avatar
unknown committed
2167
  bool send_data(List<Item> &items)=0;
2168 2169 2170
  bool send_eof() { return 0; };
};

unknown's avatar
unknown committed
2171
/* Single value subselect interface class */
unknown's avatar
unknown committed
2172
class select_singlerow_subselect :public select_subselect
unknown's avatar
unknown committed
2173 2174
{
public:
2175 2176 2177
  select_singlerow_subselect(Item_subselect *item_arg)
    :select_subselect(item_arg)
  {}
unknown's avatar
unknown committed
2178 2179 2180
  bool send_data(List<Item> &items);
};

2181 2182 2183 2184 2185 2186 2187
/* used in independent ALL/ANY optimisation */
class select_max_min_finder_subselect :public select_subselect
{
  Item_cache *cache;
  bool (select_max_min_finder_subselect::*op)();
  bool fmax;
public:
2188 2189
  select_max_min_finder_subselect(Item_subselect *item_arg, bool mx)
    :select_subselect(item_arg), cache(0), fmax(mx)
2190
  {}
unknown's avatar
Merge  
unknown committed
2191
  void cleanup();
2192 2193 2194
  bool send_data(List<Item> &items);
  bool cmp_real();
  bool cmp_int();
unknown's avatar
Merge  
unknown committed
2195
  bool cmp_decimal();
2196 2197 2198
  bool cmp_str();
};

unknown's avatar
unknown committed
2199 2200 2201 2202
/* EXISTS subselect interface class */
class select_exists_subselect :public select_subselect
{
public:
2203 2204
  select_exists_subselect(Item_subselect *item_arg)
    :select_subselect(item_arg){}
unknown's avatar
unknown committed
2205 2206 2207
  bool send_data(List<Item> &items);
};

unknown's avatar
unknown committed
2208 2209 2210 2211 2212 2213
/* Structs used when sorting */

typedef struct st_sort_field {
  Field *field;				/* Field to sort */
  Item	*item;				/* Item if not sorting fields */
  uint	 length;			/* Length of sort field */
2214
  uint   suffix_length;                 /* Length suffix (0-4) */
unknown's avatar
unknown committed
2215
  Item_result result_type;		/* Type of item */
2216 2217
  bool reverse;				/* if descending sort */
  bool need_strxnfrm;			/* If we have to use strxnfrm() */
unknown's avatar
unknown committed
2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230
} SORT_FIELD;


typedef struct st_sort_buffer {
  uint index;					/* 0 or 1 */
  uint sort_orders;
  uint change_pos;				/* If sort-fields changed */
  char **buff;
  SORT_FIELD *sortorder;
} SORT_BUFFER;

/* Structure for db & table in sql_yacc */

2231 2232
class Table_ident :public Sql_alloc
{
unknown's avatar
unknown committed
2233
public:
unknown's avatar
unknown committed
2234 2235
  LEX_STRING db;
  LEX_STRING table;
unknown's avatar
unknown committed
2236
  SELECT_LEX_UNIT *sel;
unknown's avatar
unknown committed
2237 2238
  inline Table_ident(THD *thd, LEX_STRING db_arg, LEX_STRING table_arg,
		     bool force)
unknown's avatar
unknown committed
2239
    :table(table_arg), sel((SELECT_LEX_UNIT *)0)
unknown's avatar
unknown committed
2240
  {
unknown's avatar
unknown committed
2241
    if (!force && (thd->client_capabilities & CLIENT_NO_SCHEMA))
unknown's avatar
unknown committed
2242 2243 2244 2245
      db.str=0;
    else
      db= db_arg;
  }
unknown's avatar
unknown committed
2246 2247 2248 2249 2250
  inline Table_ident(LEX_STRING table_arg) 
    :table(table_arg), sel((SELECT_LEX_UNIT *)0)
  {
    db.str=0;
  }
2251 2252 2253 2254 2255 2256
  /*
    This constructor is used only for the case when we create a derived
    table. A derived table has no name and doesn't belong to any database.
    Later, if there was an alias specified for the table, it will be set
    by add_table_to_list.
  */
unknown's avatar
foo1  
unknown committed
2257
  inline Table_ident(SELECT_LEX_UNIT *s) : sel(s)
unknown's avatar
unknown committed
2258
  {
unknown's avatar
unknown committed
2259
    /* We must have a table name here as this is used with add_table_to_list */
2260 2261 2262 2263
    db.str= empty_c_string;                    /* a subject to casedn_str */
    db.length= 0;
    table.str= internal_table_name;
    table.length=1;
unknown's avatar
unknown committed
2264
  }
2265
  bool is_derived_table() const { return test(sel); }
unknown's avatar
unknown committed
2266
  inline void change_db(char *db_name)
unknown's avatar
unknown committed
2267 2268 2269
  {
    db.str= db_name; db.length= (uint) strlen(db_name);
  }
unknown's avatar
unknown committed
2270 2271 2272 2273 2274 2275
};

// this is needed for user_vars hash
class user_var_entry
{
 public:
2276
  user_var_entry() {}                         /* Remove gcc warning */
unknown's avatar
unknown committed
2277 2278
  LEX_STRING name;
  char *value;
2279 2280
  ulong length;
  query_id_t update_query_id, used_query_id;
unknown's avatar
unknown committed
2281
  Item_result type;
2282
  bool unsigned_flag;
2283

unknown's avatar
Merge  
unknown committed
2284
  double val_real(my_bool *null_value);
2285 2286
  longlong val_int(my_bool *null_value);
  String *val_str(my_bool *null_value, String *str, uint decimals);
unknown's avatar
Merge  
unknown committed
2287
  my_decimal *val_decimal(my_bool *null_value, my_decimal *result);
2288
  DTCollation collation;
unknown's avatar
unknown committed
2289 2290
};

2291 2292 2293 2294 2295 2296 2297
/*
   Unique -- class for unique (removing of duplicates). 
   Puts all values to the TREE. If the tree becomes too big,
   it's dumped to the file. User can request sorted values, or
   just iterate through them. In the last case tree merging is performed in
   memory simultaneously with iteration, so it should be ~2-3x faster.
 */
2298 2299 2300 2301

class Unique :public Sql_alloc
{
  DYNAMIC_ARRAY file_ptrs;
2302 2303
  ulong max_elements;
  ulonglong max_in_memory_size;
2304 2305
  IO_CACHE file;
  TREE tree;
2306
  uchar *record_pointers;
2307
  bool flush();
2308
  uint size;
2309 2310 2311

public:
  ulong elements;
2312
  Unique(qsort_cmp2 comp_func, void *comp_func_fixed_arg,
2313
	 uint size_arg, ulonglong max_in_memory_size_arg);
2314
  ~Unique();
2315
  ulong elements_in_tree() { return tree.elements_in_tree; }
2316
  inline bool unique_add(void *ptr)
2317
  {
unknown's avatar
Merge  
unknown committed
2318
    DBUG_ENTER("unique_add");
unknown's avatar
unknown committed
2319
    DBUG_PRINT("info", ("tree %u - %lu", tree.elements_in_tree, max_elements));
2320
    if (tree.elements_in_tree > max_elements && flush())
unknown's avatar
Merge  
unknown committed
2321 2322
      DBUG_RETURN(1);
    DBUG_RETURN(!tree_insert(&tree, ptr, 0, tree.custom_arg));
2323 2324 2325
  }

  bool get(TABLE *table);
2326
  static double get_use_cost(uint *buffer, uint nkeys, uint key_size, 
2327
                             ulonglong max_in_memory_size);
2328
  inline static int get_cost_calc_buff_size(ulong nkeys, uint key_size, 
2329
                                            ulonglong max_in_memory_size)
2330
  {
2331
    register ulonglong max_elems_in_tree=
2332
      (1 + max_in_memory_size / ALIGN_SIZE(sizeof(TREE_ELEMENT)+key_size));
2333
    return (int) (sizeof(uint)*(1 + nkeys/max_elems_in_tree));
2334 2335
  }

2336 2337 2338
  void reset();
  bool walk(tree_walk_action action, void *walk_action_arg);

2339 2340
  friend int unique_write_to_file(uchar* key, element_count count, Unique *unique);
  friend int unique_write_to_ptrs(uchar* key, element_count count, Unique *unique);
2341
};
2342

unknown's avatar
unknown committed
2343

2344
class multi_delete :public select_result_interceptor
unknown's avatar
unknown committed
2345 2346
{
  TABLE_LIST *delete_tables, *table_being_deleted;
unknown's avatar
unknown committed
2347
  Unique **tempfiles;
2348
  ha_rows deleted, found;
unknown's avatar
unknown committed
2349 2350
  uint num_of_tables;
  int error;
2351 2352 2353 2354 2355 2356
  bool do_delete;
  /* True if at least one table we delete from is transactional */
  bool transactional_tables;
  /* True if at least one table we delete from is not transactional */
  bool normal_tables;
  bool delete_while_scanning;
2357

unknown's avatar
unknown committed
2358
public:
2359
  multi_delete(TABLE_LIST *dt, uint num_of_tables);
unknown's avatar
unknown committed
2360 2361 2362 2363 2364
  ~multi_delete();
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
  bool send_data(List<Item> &items);
  bool initialize_tables (JOIN *join);
  void send_error(uint errcode,const char *err);
2365
  int  do_deletes();
unknown's avatar
unknown committed
2366 2367 2368
  bool send_eof();
};

2369

2370
class multi_update :public select_result_interceptor
unknown's avatar
unknown committed
2371
{
2372 2373 2374
  TABLE_LIST *all_tables; /* query/update command tables */
  TABLE_LIST *leaves;     /* list of leves of join table tree */
  TABLE_LIST *update_tables, *table_being_updated;
unknown's avatar
unknown committed
2375
  TABLE **tmp_tables, *main_table, *table_to_update;
unknown's avatar
unknown committed
2376 2377 2378 2379 2380
  TMP_TABLE_PARAM *tmp_table_param;
  ha_rows updated, found;
  List <Item> *fields, *values;
  List <Item> **fields_for_table, **values_for_table;
  uint table_count;
unknown's avatar
unknown committed
2381 2382 2383 2384 2385
  /*
   List of tables referenced in the CHECK OPTION condition of
   the updated view excluding the updated table. 
  */
  List <TABLE> unupdated_check_opt_tables;
unknown's avatar
unknown committed
2386 2387
  Copy_field *copy_field;
  enum enum_duplicates handle_duplicates;
2388 2389 2390 2391
  bool do_update, trans_safe;
  /* True if the update operation has made a change in a transactional table */
  bool transactional_tables;
  bool ignore;
unknown's avatar
unknown committed
2392 2393

public:
2394
  multi_update(TABLE_LIST *ut, TABLE_LIST *leaves_list,
2395
	       List<Item> *fields, List<Item> *values,
2396
	       enum_duplicates handle_duplicates, bool ignore);
unknown's avatar
unknown committed
2397
  ~multi_update();
unknown's avatar
unknown committed
2398
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
2399 2400 2401 2402 2403 2404
  bool send_data(List<Item> &items);
  bool initialize_tables (JOIN *join);
  void send_error(uint errcode,const char *err);
  int  do_updates (bool from_send_error);
  bool send_eof();
};
2405

unknown's avatar
unknown committed
2406 2407 2408
class my_var : public Sql_alloc  {
public:
  LEX_STRING s;
unknown's avatar
unknown committed
2409
#ifndef DBUG_OFF
2410 2411 2412 2413
  /*
    Routine to which this Item_splocal belongs. Used for checking if correct
    runtime context is used for variable handling.
  */
2414
  sp_head *sp;
2415
#endif
unknown's avatar
unknown committed
2416 2417
  bool local;
  uint offset;
2418 2419 2420 2421
  enum_field_types type;
  my_var (LEX_STRING& j, bool i, uint o, enum_field_types t)
    :s(j), local(i), offset(o), type(t)
  {}
unknown's avatar
unknown committed
2422 2423
  ~my_var() {}
};
2424

2425
class select_dumpvar :public select_result_interceptor {
unknown's avatar
unknown committed
2426 2427
  ha_rows row_count;
public:
unknown's avatar
unknown committed
2428
  List<my_var> var_list;
2429
  select_dumpvar()  { var_list.empty(); row_count= 0;}
unknown's avatar
unknown committed
2430
  ~select_dumpvar() {}
2431
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
2432 2433
  bool send_data(List<Item> &items);
  bool send_eof();
2434
  virtual bool check_simple_select() const;
2435
  void cleanup();
unknown's avatar
unknown committed
2436
};
2437

2438 2439 2440 2441 2442 2443 2444
/* Bits in sql_command_flags */

#define CF_CHANGES_DATA		1
#define CF_HAS_ROW_COUNT	2
#define CF_STATUS_COMMAND	4
#define CF_SHOW_TABLE_COMMAND	8

2445 2446 2447
/* Functions in sql_class.cc */

void add_to_status(STATUS_VAR *to_var, STATUS_VAR *from_var);
2448 2449
void add_diff_to_status(STATUS_VAR *to_var, STATUS_VAR *from_var,
                        STATUS_VAR *dec_var);
2450
#endif /* MYSQL_SERVER */