sql_class.h 76.4 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 44 45
enum enum_check_fields
{ CHECK_FIELD_IGNORE, CHECK_FIELD_WARN, CHECK_FIELD_ERROR_FOR_NULL };
enum enum_mark_columns
{ MARK_COLUMNS_NONE, MARK_COLUMNS_READ, MARK_COLUMNS_WRITE};
46

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

51 52 53 54 55 56 57
#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
58 59 60 61 62 63 64 65 66
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;

67 68 69
#define RP_LOCK_LOG_IS_ALREADY_LOCKED 1
#define RP_FORCE_ROTATE               2

unknown's avatar
unknown committed
70 71 72
typedef struct st_copy_info {
  ha_rows records;
  ha_rows deleted;
unknown's avatar
unknown committed
73
  ha_rows updated;
unknown's avatar
unknown committed
74
  ha_rows copied;
75
  ha_rows error_count;
76
  ha_rows touched; /* Number of touched records */
unknown's avatar
unknown committed
77
  enum enum_duplicates handle_duplicates;
78
  int escape_char, last_errno;
79 80
  bool ignore;
  /* for INSERT ... UPDATE */
81 82
  List<Item> *update_fields;
  List<Item> *update_values;
unknown's avatar
unknown committed
83
  /* for VIEW ... WITH CHECK OPTION */
unknown's avatar
unknown committed
84
  TABLE_LIST *view;
unknown's avatar
unknown committed
85 86 87
} COPY_INFO;


unknown's avatar
unknown committed
88
class Key_part_spec :public Sql_alloc {
unknown's avatar
unknown committed
89 90 91
public:
  const char *field_name;
  uint length;
unknown's avatar
unknown committed
92 93
  Key_part_spec(const char *name,uint len=0) :field_name(name), length(len) {}
  bool operator==(const Key_part_spec& other) const;
94
  /**
unknown's avatar
unknown committed
95
    Construct a copy of this Key_part_spec. field_name is copied
96 97 98 99 100 101 102
    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
103 104
  Key_part_spec *clone(MEM_ROOT *mem_root) const
  { return new (mem_root) Key_part_spec(*this); }
unknown's avatar
unknown committed
105 106 107 108 109 110 111 112 113 114
};


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) {}
115 116
  /**
    Used to make a clone of this object for ALTER/CREATE TABLE
unknown's avatar
unknown committed
117
    @sa comment for Key_part_spec::clone
118 119 120
  */
  Alter_drop *clone(MEM_ROOT *mem_root) const
    { return new (mem_root) Alter_drop(*this); }
unknown's avatar
unknown committed
121 122 123 124 125 126 127 128 129
};


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) {}
130 131
  /**
    Used to make a clone of this object for ALTER/CREATE TABLE
unknown's avatar
unknown committed
132
    @sa comment for Key_part_spec::clone
133 134 135
  */
  Alter_column *clone(MEM_ROOT *mem_root) const
    { return new (mem_root) Alter_column(*this); }
unknown's avatar
unknown committed
136 137 138 139 140
};


class Key :public Sql_alloc {
public:
141
  enum Keytype { PRIMARY, UNIQUE, MULTIPLE, FULLTEXT, SPATIAL, FOREIGN_KEY};
unknown's avatar
unknown committed
142
  enum Keytype type;
unknown's avatar
unknown committed
143
  KEY_CREATE_INFO key_create_info;
unknown's avatar
unknown committed
144
  List<Key_part_spec> columns;
145
  const char *name;
146
  bool generated;
unknown's avatar
unknown committed
147

148 149
  Key(enum Keytype type_par, const char *name_arg,
      KEY_CREATE_INFO *key_info_arg,
unknown's avatar
unknown committed
150
      bool generated_arg, List<Key_part_spec> &cols)
unknown's avatar
unknown committed
151 152
    :type(type_par), key_create_info(*key_info_arg), columns(cols),
    name(name_arg), generated(generated_arg)
153
  {}
154 155
  Key(const Key &rhs, MEM_ROOT *mem_root);
  virtual ~Key() {}
156
  /* Equality comparison of keys (ignoring name) */
157
  friend bool foreign_key_prefix(Key *a, Key *b);
158 159
  /**
    Used to make a clone of this object for ALTER/CREATE TABLE
unknown's avatar
unknown committed
160
    @sa comment for Key_part_spec::clone
161 162 163
  */
  virtual Key *clone(MEM_ROOT *mem_root) const
    { return new (mem_root) Key(*this, mem_root); }
unknown's avatar
unknown committed
164 165
};

166 167
class Table_ident;

unknown's avatar
unknown committed
168
class Foreign_key: public Key {
169 170 171 172 173 174 175
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
176
  List<Key_part_spec> ref_columns;
177
  uint delete_opt, update_opt, match_opt;
unknown's avatar
unknown committed
178 179
  Foreign_key(const char *name_arg, List<Key_part_spec> &cols,
	      Table_ident *table,   List<Key_part_spec> &ref_cols,
180
	      uint delete_opt_arg, uint update_opt_arg, uint match_opt_arg)
181
    :Key(FOREIGN_KEY, name_arg, &default_key_create_info, 0, cols),
182 183 184 185
    ref_table(table), ref_columns(cols),
    delete_opt(delete_opt_arg), update_opt(update_opt_arg),
    match_opt(match_opt_arg)
  {}
unknown's avatar
unknown committed
186
  Foreign_key(const Foreign_key &rhs, MEM_ROOT *mem_root);
187 188
  /**
    Used to make a clone of this object for ALTER/CREATE TABLE
unknown's avatar
unknown committed
189
    @sa comment for Key_part_spec::clone
190 191
  */
  virtual Key *clone(MEM_ROOT *mem_root) const
unknown's avatar
unknown committed
192
  { return new (mem_root) Foreign_key(*this, mem_root); }
193
};
unknown's avatar
unknown committed
194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212

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 */

213
class Delayed_insert;
unknown's avatar
unknown committed
214
class select_result;
215
class Time_zone;
unknown's avatar
unknown committed
216

217 218 219 220 221
#define THD_SENTRY_MAGIC 0xfeedd1ff
#define THD_SENTRY_GONE  0xdeadbeef

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

222 223
struct system_variables
{
unknown's avatar
unknown committed
224 225 226 227 228 229 230 231 232 233 234 235 236 237
  /*
    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
238 239
  ulonglong myisam_max_extra_sort_file_size;
  ulonglong myisam_max_sort_file_size;
240 241
  ulonglong max_heap_table_size;
  ulonglong tmp_table_size;
242 243
  ha_rows select_limit;
  ha_rows max_join_size;
244
  ulong auto_increment_increment, auto_increment_offset;
unknown's avatar
unknown committed
245
  ulong bulk_insert_buff_size;
246 247
  ulong join_buff_size;
  ulong long_query_time;
unknown's avatar
unknown committed
248
  ulong max_allowed_packet;
249
  ulong max_error_count;
unknown's avatar
unknown committed
250
  ulong max_length_for_sort_data;
251
  ulong max_sort_length;
252
  ulong max_tmp_tables;
253
  ulong max_insert_delayed_threads;
unknown's avatar
unknown committed
254
  ulong multi_range_count;
255
  ulong myisam_repair_threads;
unknown's avatar
unknown committed
256
  ulong myisam_sort_buff_size;
257
  ulong myisam_stats_method;
unknown's avatar
unknown committed
258
  ulong net_buffer_length;
259
  ulong net_interactive_timeout;
unknown's avatar
unknown committed
260
  ulong net_read_timeout;
261
  ulong net_retry_count;
262
  ulong net_wait_timeout;
unknown's avatar
unknown committed
263
  ulong net_write_timeout;
264 265
  ulong optimizer_prune_level;
  ulong optimizer_search_depth;
unknown's avatar
unknown committed
266
  ulong preload_buff_size;
unknown's avatar
unknown committed
267 268 269
  ulong query_cache_type;
  ulong read_buff_size;
  ulong read_rnd_buff_size;
unknown's avatar
unknown committed
270
  ulong div_precincrement;
271
  ulong sortbuff_size;
unknown's avatar
unknown committed
272
  ulong thread_handling;
unknown's avatar
unknown committed
273
  ulong tx_isolation;
unknown's avatar
Merge  
unknown committed
274
  ulong completion_type;
275
  /* Determines which non-standard SQL behaviour should be enabled */
276
  ulong sql_mode;
277
  ulong max_sp_recursion_depth;
unknown's avatar
VIEW  
unknown committed
278
  /* check of key presence in updatable view */
279
  ulong updatable_views_with_limit;
unknown's avatar
unknown committed
280
  ulong default_week_format;
281
  ulong max_seeks_for_key;
282 283 284 285 286
  ulong range_alloc_block_size;
  ulong query_alloc_block_size;
  ulong query_prealloc_size;
  ulong trans_alloc_block_size;
  ulong trans_prealloc_size;
287
  ulong log_warnings;
288
  ulong group_concat_max_len;
unknown's avatar
unknown committed
289 290 291 292
  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
293 294 295 296
  /*
    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
297
  my_thread_id pseudo_thread_id;
unknown's avatar
unknown committed
298

unknown's avatar
unknown committed
299 300
  my_bool low_priority_updates;
  my_bool new_mode;
301 302 303 304 305
  /* 
    compatibility option:
      - index usage hints (USE INDEX without a FOR clause) behave as in 5.0 
  */
  my_bool old_mode;
306
  my_bool query_cache_wlock_invalidate;
unknown's avatar
unknown committed
307
  my_bool engine_condition_pushdown;
308
  my_bool ndb_force_send;
309
  my_bool ndb_use_copying_alter_table;
310 311
  my_bool ndb_use_exact_count;
  my_bool ndb_use_transactions;
312
  my_bool ndb_index_stat_enable;
313

unknown's avatar
unknown committed
314
  my_bool old_alter_table;
315
  my_bool old_passwords;
316

unknown's avatar
unknown committed
317
  plugin_ref table_plugin;
unknown's avatar
unknown committed
318

319
  /* Only charset part of these variables is sensible */
unknown's avatar
unknown committed
320
  CHARSET_INFO  *character_set_filesystem;
321
  CHARSET_INFO  *character_set_client;
322
  CHARSET_INFO  *character_set_results;
323

324 325 326
  /* Both charset and collation parts of these variables are important */
  CHARSET_INFO	*collation_server;
  CHARSET_INFO	*collation_database;
unknown's avatar
unknown committed
327
  CHARSET_INFO  *collation_connection;
328

unknown's avatar
unknown committed
329 330 331
  /* Locale Support */
  MY_LOCALE *lc_time_names;

332 333
  Time_zone *time_zone;

334
  /* DATE, DATETIME and MYSQL_TIME formats */
335 336 337
  DATE_TIME_FORMAT *date_format;
  DATE_TIME_FORMAT *datetime_format;
  DATE_TIME_FORMAT *time_format;
338
  my_bool sysdate_is_now;
339

unknown's avatar
unknown committed
340 341
};

342 343 344 345 346

/* per thread status variables */

typedef struct system_status_var
{
347 348
  ulonglong bytes_received;
  ulonglong bytes_sent;
349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364
  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;
365 366 367 368
  ulong ha_prepare_count;
  ulong ha_discover_count;
  ulong ha_savepoint_count;
  ulong ha_savepoint_rollback_count;
369 370 371 372 373 374 375 376 377 378 379 380

  /* 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
381
  ulong opened_shares;
382 383 384 385 386 387 388 389 390 391
  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;
392
  /* Prepared statements and binary protocol */
unknown's avatar
unknown committed
393 394 395 396 397 398
  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;
399

400 401 402 403
  /*
    Status variables which it does not make sense to add to
    global status variable counter
  */
404
  double last_query_cost;
405 406 407
} STATUS_VAR;

/*
408 409 410
  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
411 412
*/

unknown's avatar
unknown committed
413
#define last_system_status_var com_stmt_close
414

415 416
#ifdef MYSQL_SERVER

417
void free_tmp_table(THD *thd, TABLE *entry);
418 419


unknown's avatar
unknown committed
420 421 422
/* The following macro is to make init of Query_arena simpler */
#ifndef DBUG_OFF
#define INIT_ARENA_DBUG_INFO is_backup_arena= 0
423 424
#else
#define INIT_ARENA_DBUG_INFO
unknown's avatar
unknown committed
425 426
#endif

unknown's avatar
unknown committed
427
class Query_arena
428 429 430 431 432 433 434
{
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
435
  MEM_ROOT *mem_root;                   // Pointer to current memroot
unknown's avatar
unknown committed
436
#ifndef DBUG_OFF
437
  bool is_backup_arena; /* True if this arena is used for backup. */
unknown's avatar
unknown committed
438
#endif
unknown's avatar
unknown committed
439
  enum enum_state
440
  {
441 442
    INITIALIZED= 0, INITIALIZED_FOR_SP= 1, PREPARED= 2,
    CONVENTIONAL_EXECUTION= 3, EXECUTED= 4, ERROR= -1
443
  };
unknown's avatar
unknown committed
444

unknown's avatar
unknown committed
445
  enum_state state;
446 447 448 449 450 451 452

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

453 454
  Query_arena(MEM_ROOT *mem_root_arg, enum enum_state state_arg) :
    free_list(0), mem_root(mem_root_arg), state(state_arg)
455
  { INIT_ARENA_DBUG_INFO; }
456
  /*
unknown's avatar
unknown committed
457 458
    This constructor is used only when Query_arena is created as
    backup storage for another instance of Query_arena.
459
  */
460 461
  Query_arena() { INIT_ARENA_DBUG_INFO; }

462
  virtual Type type() const;
unknown's avatar
unknown committed
463
  virtual ~Query_arena() {};
464

465
  inline bool is_stmt_prepare() const { return state == INITIALIZED; }
466 467
  inline bool is_first_sp_execute() const
  { return state == INITIALIZED_FOR_SP; }
468 469
  inline bool is_stmt_prepare_or_first_sp_execute() const
  { return (int)state < (int)PREPARED; }
unknown's avatar
unknown committed
470
  inline bool is_first_stmt_execute() const { return state == PREPARED; }
471 472
  inline bool is_stmt_execute() const
  { return state == PREPARED || state == EXECUTED; }
unknown's avatar
unknown committed
473
  inline bool is_conventional() const
unknown's avatar
unknown committed
474
  { return state == CONVENTIONAL_EXECUTION; }
475

476 477
  inline void* alloc(size_t size) { return alloc_root(mem_root,size); }
  inline void* calloc(size_t size)
478
  {
479
    void *ptr;
unknown's avatar
unknown committed
480
    if ((ptr=alloc_root(mem_root,size)))
481
      bzero(ptr, size);
482 483 484
    return ptr;
  }
  inline char *strdup(const char *str)
unknown's avatar
unknown committed
485
  { return strdup_root(mem_root,str); }
486
  inline char *strmake(const char *str, size_t size)
unknown's avatar
unknown committed
487
  { return strmake_root(mem_root,str,size); }
488 489
  inline bool LEX_STRING_make(LEX_STRING *lex_str, const char *str,
                              size_t size)
490 491 492 493 494
  {
    return ((lex_str->str= 
             strmake_root(mem_root, str, (lex_str->length= size)))) == 0;
  }

495
  inline void *memdup(const void *str, size_t size)
unknown's avatar
unknown committed
496
  { return memdup_root(mem_root,str,size); }
497
  inline void *memdup_w_gap(const void *str, size_t size, uint gap)
498
  {
499 500
    void *ptr;
    if ((ptr= alloc_root(mem_root,size+gap)))
501 502 503 504
      memcpy(ptr,str,size);
    return ptr;
  }

unknown's avatar
unknown committed
505
  void set_query_arena(Query_arena *set);
506 507

  void free_items();
508 509
  /* Close the active state associated with execution of this statement */
  virtual void cleanup_stmt();
510 511
};

512

513
class Server_side_cursor;
514

515 516 517 518
/**
  @class Statement
  @brief State of a single command executed against this connection.

519 520 521 522 523 524 525 526 527 528 529 530
  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.
*/

531
class Statement: public ilink, public Query_arena
532
{
533 534
  Statement(const Statement &rhs);              /* not implemented: */
  Statement &operator=(const Statement &rhs);   /* non-copyable */
535 536
public:
  /*
unknown's avatar
unknown committed
537
    Uniquely identifies each statement object in thread scope; change during
538
    statement lifetime. FIXME: must be const
539
  */
unknown's avatar
unknown committed
540
   ulong id;
541 542

  /*
543 544 545 546 547 548 549 550 551
    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.
552
  */
553
  enum enum_mark_columns mark_used_columns;
554

555
  LEX_STRING name; /* name for named prepared statements */
556 557 558 559 560
  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.
561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577

    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.
578 579 580
  */
  char *query;
  uint32 query_length;                          // current query length
581
  Server_side_cursor *cursor;
582

583 584
public:

unknown's avatar
unknown committed
585
  /* This constructor is called for backup statements */
586
  Statement() {}
587

588 589
  Statement(LEX *lex_arg, MEM_ROOT *mem_root_arg,
            enum enum_state state_arg, ulong id_arg);
590
  virtual ~Statement();
591 592 593

  /* Assign execution context (note: not all members) of given stmt to self */
  void set_statement(Statement *stmt);
594 595
  void set_n_backup_statement(Statement *stmt, Statement *backup);
  void restore_backup_statement(Statement *stmt, Statement *backup);
596 597
  /* return class type */
  virtual Type type() const;
598 599 600
};


601
/**
602 603 604 605 606
  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
607

608 609
  Statements are auto-deleted when they are removed from the map and when the
  map is deleted.
610 611 612 613 614 615
*/

class Statement_map
{
public:
  Statement_map();
616

617
  int insert(THD *thd, Statement *statement);
618 619

  Statement *find_by_name(LEX_STRING *name)
620
  {
621
    Statement *stmt;
622
    stmt= (Statement*)hash_search(&names_hash, (uchar*)name->str,
623 624
                                  name->length);
    return stmt;
625
  }
626 627

  Statement *find(ulong id)
628
  {
629
    if (last_found_statement == 0 || id != last_found_statement->id)
630 631
    {
      Statement *stmt;
632
      stmt= (Statement *) hash_search(&st_hash, (uchar *) &id, sizeof(id));
633
      if (stmt && stmt->name.str)
634 635 636
        return NULL;
      last_found_statement= stmt;
    }
637
    return last_found_statement;
638
  }
639 640 641 642 643 644
  /*
    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();
645
  void erase(Statement *statement);
646
  /* Erase all statements (calls Statement destructor) */
647 648
  void reset();
  ~Statement_map();
649 650
private:
  HASH st_hash;
651
  HASH names_hash;
652
  I_List<Statement> transient_cursor_list;
653
  Statement *last_found_statement;
654 655
};

656 657 658 659 660 661 662
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
663
extern const char *xa_state_names[];
664

665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680
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);

681 682 683 684
/**
  @class Security_context
  @brief A set of THD members describing the current authenticated user.
*/
685

686 687
class Security_context {
public:
688
  Security_context() {}                       /* Remove gcc warning */
689 690 691 692
  /*
    host - host of the client
    user - user of the client, set to NULL until the user has been read from
    the connection
693
    priv_user - The user privilege we are using. May be "" for anonymous user.
694 695 696
    ip - client IP
  */
  char   *host, *user, *priv_user, *ip;
697
  /* The host privilege we are using */
698 699 700 701 702 703 704 705 706
  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();
707
  inline char *priv_host_name()
708 709 710
  {
    return (*priv_host ? priv_host : (char *)"%");
  }
711 712
  
  bool set_user(char *user_arg);
713 714 715 716 717 718 719 720 721 722 723 724

#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
725 726 727
};


728
/**
729 730 731 732 733 734 735 736 737 738
  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;


739
/**
740 741 742 743 744 745 746 747
  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};


748
/**
749
  Class that holds information about tables which were opened and locked
750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784
  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;
785 786 787 788 789 790 791 792

  /*
    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;

793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819
  /*
    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;

820 821 822 823 824 825 826 827 828
  enum enum_flags {
    BACKUPS_AVAIL = (1U << 0)     /* There are backups available */
  };

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

829 830 831 832
  /*
    This constructor serves for creation of Open_tables_state instances
    which are used as backup storage.
  */
833
  Open_tables_state() : state_flags(0U) { }
834 835

  Open_tables_state(ulong version_arg);
836 837 838 839 840 841 842 843 844

  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;
845
    extra_lock= lock= locked_tables= 0;
846
    prelocked_mode= NON_PRELOCKED;
847
    state_flags= 0U;
848 849 850
  }
};

851 852 853 854
/**
  @class Sub_statement_state
  @brief Used to save context when executing a function or trigger
*/
855 856 857 858 859 860

/* Defines used for Sub_statement_state::in_sub_stmt */

#define SUB_STMT_TRIGGER 1
#define SUB_STMT_FUNCTION 2

861

862 863 864 865
class Sub_statement_state
{
public:
  ulonglong options;
866 867 868
  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;
869 870 871 872
  ulonglong limit_found_rows;
  ha_rows    cuted_fields, sent_row_count, examined_row_count;
  ulong client_capabilities;
  uint in_sub_stmt;
873
  bool enable_slow_log;
unknown's avatar
unknown committed
874
  bool last_insert_id_used;
875
  my_bool no_send_ok;
876
  SAVEPOINT *savepoints;
877 878 879
};


880 881 882 883 884 885 886 887 888 889 890 891 892
/* 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
893 894 895 896 897 898 899 900 901 902 903 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
/**
  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;
};


936 937
/**
  @class THD
unknown's avatar
unknown committed
938 939 940
  For each client connection we create a separate thread with THD serving as
  a thread/connection descriptor
*/
941

942
class THD :public Statement,
943
           public Open_tables_state
unknown's avatar
unknown committed
944
{
unknown's avatar
unknown committed
945
public:
946 947 948
  /* Used to execute base64 coded binlog events in MySQL server */
  RELAY_LOG_INFO* rli_fake;

949 950 951 952 953 954 955 956
  /*
    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;

957 958
#ifdef EMBEDDED_LIBRARY
  struct st_mysql  *mysql;
unknown's avatar
SCRUM  
unknown committed
959 960
  unsigned long	 client_stmt_id;
  unsigned long  client_param_count;
unknown's avatar
unknown committed
961
  struct st_mysql_bind *client_params;
unknown's avatar
unknown committed
962 963
  char *extra_data;
  ulong extra_length;
964 965 966 967 968
  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();
969 970 971 972 973 974
  /*
    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;
975
#endif
unknown's avatar
unknown committed
976
  NET	  net;				// client connection descriptor
977
  MEM_ROOT warn_root;			// For warnings and errors
978
  Protocol *protocol;			// Current protocol
unknown's avatar
unknown committed
979 980
  Protocol_text   protocol_text;	// Normal protocol
  Protocol_binary protocol_binary;	// Binary protocol
unknown's avatar
unknown committed
981 982
  HASH    user_vars;			// hash for user variables
  String  packet;			// dynamic buffer for network I/O
983
  String  convert_buffer;               // buffer for charset conversions
unknown's avatar
unknown committed
984 985 986
  struct  sockaddr_in remote;		// client socket address
  struct  rand_struct rand;		// used for authentication
  struct  system_variables variables;	// Changeable local variables
987
  struct  system_status_var status_var; // Per thread statistic vars
988
  struct  system_status_var *initial_status_var; /* used by show status */
989 990 991 992
  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.
993
  pthread_mutex_t LOCK_delete;		// Locked before thd is deleted
994
  /* all prepared statements and cursors of this connection */
995
  Statement_map stmt_map;
unknown's avatar
unknown committed
996 997 998 999 1000 1001
  /*
    A pointer to the stack frame of handle_one_connection(),
    which is called first in the thread for handling a client
  */
  char	  *thread_stack;

1002 1003
  /*
    db - currently selected database
1004
    catalog - currently selected catalog
1005 1006 1007 1008 1009
    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
1010 1011
    properly. For details see the 'err:' label of the handle_slave_sql()
    in sql/slave.cc.
1012
   */
1013
  char   *db, *catalog;
1014 1015
  Security_context main_security_ctx;
  Security_context *security_ctx;
1016

unknown's avatar
unknown committed
1017 1018
  /* remote (peer) port */
  uint16 peer_port;
1019 1020 1021 1022 1023
  /*
    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
1024
  const char *proc_info;
1025

1026
  ulong client_capabilities;		/* What the client supports */
1027
  ulong max_client_packet_length;
1028

unknown's avatar
unknown committed
1029
  HASH		handler_tables_hash;
unknown's avatar
unknown committed
1030 1031 1032 1033 1034
  /*
    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. 
  */
1035
  User_level_lock *ull;
1036 1037
#ifndef DBUG_OFF
  uint dbug_sentry; // watch out for memory corruption
1038
#endif
unknown's avatar
unknown committed
1039
  struct st_my_thread_var *mysys_var;
1040
  /*
1041
    Type of current query: COM_STMT_PREPARE, COM_QUERY, etc. Set from
1042 1043 1044
    first byte of the packet in do_command()
  */
  enum enum_server_command command;
unknown's avatar
unknown committed
1045
  uint32     server_id;
unknown's avatar
unknown committed
1046
  uint32     file_id;			// for LOAD DATA INFILE
1047 1048 1049 1050 1051
  /*
    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
1052
  const char *where;
unknown's avatar
unknown committed
1053 1054
  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
1055
  thr_lock_type update_lock_default;
1056
  Delayed_insert *di;
1057

1058 1059
  /* <> 0 if we are inside of trigger or stored function. */
  uint in_sub_stmt;
1060

1061 1062
  /* container for handler's private per-connection data */
  void *ha_data[MAX_HA];
1063 1064

#ifndef MYSQL_CLIENT
1065 1066
  int binlog_setup_trx_data();

1067
  /*
1068
    Public interface to write RBR events to the binlog
1069
  */
1070
  void binlog_start_trans_and_stmt();
1071 1072
  int binlog_flush_transaction_cache();
  void binlog_set_stmt_begin();
1073
  int binlog_write_table_map(TABLE *table, bool is_transactional);
1074
  int binlog_write_row(TABLE* table, bool is_transactional,
1075 1076
                       MY_BITMAP const* cols, size_t colcnt,
                       const uchar *buf);
1077
  int binlog_delete_row(TABLE* table, bool is_transactional,
1078 1079
                        MY_BITMAP const* cols, size_t colcnt,
                        const uchar *buf);
1080
  int binlog_update_row(TABLE* table, bool is_transactional,
1081 1082
                        MY_BITMAP const* cols, size_t colcnt,
                        const uchar *old_data, const uchar *new_data);
1083 1084 1085 1086 1087 1088 1089 1090 1091

  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,
1092 1093
                                      size_t colcnt,
                                      size_t needed,
unknown's avatar
unknown committed
1094 1095
                                      bool is_transactional,
				      RowsEventT* hint);
1096 1097 1098 1099 1100
  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);
  void binlog_delete_pending_rows_event();

1101 1102
private:
  uint binlog_table_maps; // Number of table maps currently in the binlog
1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113

  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;
1114
public:
1115 1116 1117
  uint get_binlog_table_maps() const {
    return binlog_table_maps;
  }
1118 1119
#endif /* MYSQL_CLIENT */

1120 1121
public:

unknown's avatar
unknown committed
1122
  struct st_transactions {
1123
    SAVEPOINT *savepoints;
unknown's avatar
unknown committed
1124 1125
    THD_TRANS all;			// Trans since BEGIN WORK
    THD_TRANS stmt;			// Trans for current statement
1126
    bool on;                            // see ha_enable_transaction()
1127 1128
    XID  xid;                           // transaction identifier
    enum xa_states xa_state;            // used by external XA only
1129
    XID_STATE xid_state;
1130 1131
    Rows_log_event *m_pending_rows_event;

1132
    /*
1133
       Tables changed in transaction (that must be invalidated in query cache).
1134
       List contain only transactional tables, that not invalidated in query
1135 1136 1137 1138 1139 1140
       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()
    {
1141 1142
      changed_tables= 0;
      savepoints= 0;
1143
#ifdef USING_TRANSACTIONS
1144
      free_root(&mem_root,MYF(MY_KEEP_PREALLOC));
1145
#endif
1146
    }
1147 1148
    st_transactions()
    {
1149
#ifdef USING_TRANSACTIONS
1150
      bzero((char*)this, sizeof(*this));
1151
      xid_state.xid.null();
1152
      init_sql_alloc(&mem_root, ALLOC_ROOT_MIN_BLOCK_SIZE, 0);
1153 1154
#else
      xid_state.xa_state= XA_NOTR;
1155
#endif
1156
    }
unknown's avatar
unknown committed
1157
  } transaction;
1158
  Field      *dup_field;
unknown's avatar
unknown committed
1159
#ifndef __WIN__
unknown's avatar
unknown committed
1160
  sigset_t signals;
unknown's avatar
unknown committed
1161
#endif
1162 1163
#ifdef SIGNAL_WITH_VIO_CLOSE
  Vio* active_vio;
1164
#endif
1165 1166 1167 1168
  /*
    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
1169 1170
    rollback_item_tree_changes(). For conventional execution it's always
    empty.
1171 1172 1173
  */
  Item_change_list change_list;

unknown's avatar
unknown committed
1174
  /*
unknown's avatar
unknown committed
1175 1176
    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
1177
    memory root. In this case stmt_arena points to THD. In case of
unknown's avatar
unknown committed
1178
    a prepared statement or a stored procedure statement, thd->mem_root
unknown's avatar
unknown committed
1179
    conventionally points to runtime memory, and thd->stmt_arena
unknown's avatar
unknown committed
1180 1181 1182
    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
1183 1184
    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
1185
  */
unknown's avatar
unknown committed
1186
  Query_arena *stmt_arena;
1187 1188
  /* Tells if LAST_INSERT_ID(#) was called for the current statement */
  bool arg_of_last_insert_id_function;
1189
  /*
1190 1191
    ALL OVER THIS FILE, "insert_id" means "*automatically generated* value for
    insertion into an auto_increment column".
1192 1193
  */
  /*
1194 1195 1196 1197 1198 1199
    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().
1200
  */
1201
  ulonglong  first_successful_insert_id_in_prev_stmt;
1202
  /*
1203 1204 1205 1206
    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).
1207
  */
1208 1209 1210 1211 1212 1213 1214 1215 1216 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
  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
1263 1264 1265
    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.
1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 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
    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;
  }
  /*
1309
    Used by Intvar_log_event::do_apply_event() and by "SET INSERT_ID=#"
1310 1311 1312 1313 1314
    (mysqlbinlog). We'll soon add a variant which can take many intervals in
    argument.
  */
  inline void force_one_auto_inc_interval(ulonglong next_id)
  {
1315
    auto_inc_intervals_forced.empty(); // in case of multiple SET INSERT_ID
1316 1317 1318
    auto_inc_intervals_forced.append(next_id, ULONGLONG_MAX, 0);
  }

1319
  ulonglong  limit_found_rows;
1320 1321
  ulonglong  options;           /* Bitmap of states */
  longlong   row_count_func;	/* For the ROW_COUNT() function */
unknown's avatar
unknown committed
1322
  ha_rows    cuted_fields,
unknown's avatar
unknown committed
1323
             sent_row_count, examined_row_count;
unknown's avatar
unknown committed
1324 1325 1326 1327 1328 1329
  /*
    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
1330
  table_map  used_tables;
1331
  USER_CONN *user_connect;
1332
  CHARSET_INFO *db_charset;
unknown's avatar
unknown committed
1333 1334 1335
  /*
    FIXME: this, and some other variables like 'count_cuted_fields'
    maybe should be statement/cursor local, that is, moved to Statement
1336 1337
    class. With current implementation warnings produced in each prepared
    statement/cursor settle here.
unknown's avatar
unknown committed
1338
  */
1339
  List	     <MYSQL_ERROR> warn_list;
1340
  uint	     warn_count[(uint) MYSQL_ERROR::WARN_LEVEL_END];
unknown's avatar
unknown committed
1341
  uint	     total_warn_count;
1342 1343 1344 1345 1346 1347 1348 1349
  /*
    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).
  */
1350
  query_id_t query_id, warn_id;
unknown's avatar
unknown committed
1351
  ulong      col_access;
1352

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

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

1374 1375 1376 1377 1378 1379 1380 1381
  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 */
  };
1382 1383
  killed_state volatile killed;

1384
  /* scramble - random string sent to client on handshake */
unknown's avatar
unknown committed
1385
  char	     scramble[SCRAMBLE_LENGTH+1];
1386

1387
  bool       slave_thread, one_shot_set;
1388 1389
  /* tells if current statement should binlog row-based(1) or stmt-based(0) */
  bool       current_stmt_binlog_row_based;
1390
  bool	     locked, some_tables_deleted;
1391
  bool       last_cuted_field;
1392
  bool	     no_errors, password, is_fatal_error;
1393
  bool	     query_start_used, rand_used, time_zone_used;
1394 1395
  /* for IS NULL => = last_insert_id() fix in remove_eq_conds() */
  bool       substitute_null_with_insert_id;
1396
  bool	     in_lock_tables;
unknown's avatar
unknown committed
1397
  bool       query_error, bootstrap, cleanup_done;
unknown's avatar
unknown committed
1398
  bool	     tmp_table_used;
unknown's avatar
unknown committed
1399
  bool	     charset_is_system_charset, charset_is_collation_connection;
unknown's avatar
unknown committed
1400
  bool       charset_is_character_set_filesystem;
1401
  bool       enable_slow_log;   /* enable slow log for current statement */
1402 1403 1404 1405 1406
  struct {
    bool all:1;
    bool stmt:1;
  } no_trans_update;
  bool	     abort_on_warning;
unknown's avatar
Merge  
unknown committed
1407
  bool 	     got_warning;       /* Set on call to push_warning() */
1408
  bool	     no_warnings_for_error; /* no warnings on call to my_error() */
1409 1410
  /* set during loop of derived table processing */
  bool       derived_tables_processing;
1411 1412
  my_bool    tablespace_op;	/* This is TRUE in DISCARD/IMPORT TABLESPACE */

1413
  sp_rcontext *spcont;		// SP runtime context
1414 1415
  sp_cache   *sp_proc_cache;
  sp_cache   *sp_func_cache;
unknown's avatar
unknown committed
1416

unknown's avatar
unknown committed
1417 1418 1419 1420 1421
  /*
    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
1422
  LOG_INFO*  current_linfo;
unknown's avatar
unknown committed
1423
  NET*       slave_net;			// network connection from slave -> m.
unknown's avatar
unknown committed
1424 1425 1426
  /* Used by the sys_var class to store temporary values */
  union
  {
1427 1428 1429 1430
    my_bool   my_bool_value;
    long      long_value;
    ulong     ulong_value;
    ulonglong ulonglong_value;
unknown's avatar
unknown committed
1431
  } sys_var_tmp;
1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450
  
  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;
1451 1452 1453 1454 1455 1456
    
    /* 
      'queries' (actually SP statements) that run under inside this binlog
      union have thd->query_id >= first_query_id.
    */
    query_id_t first_query_id;
1457
  } binlog_evt_union;
1458 1459 1460 1461 1462 1463 1464 1465 1466 1467

  /**
    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
1468
#ifdef WITH_PARTITION_STORAGE_ENGINE
unknown's avatar
unknown committed
1469
  partition_info *work_part_info;
unknown's avatar
unknown committed
1470
#endif
unknown's avatar
foo1  
unknown committed
1471

unknown's avatar
unknown committed
1472 1473
  THD();
  ~THD();
1474

unknown's avatar
unknown committed
1475
  void init(void);
1476 1477 1478 1479 1480 1481 1482 1483 1484 1485
  /*
    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
1486
  void change_user(void);
unknown's avatar
unknown committed
1487
  void cleanup(void);
1488
  void cleanup_after_query();
unknown's avatar
unknown committed
1489
  bool store_globals();
1490 1491
#ifdef SIGNAL_WITH_VIO_CLOSE
  inline void set_active_vio(Vio* vio)
1492
  {
1493
    pthread_mutex_lock(&LOCK_delete);
1494
    active_vio = vio;
1495
    pthread_mutex_unlock(&LOCK_delete);
1496
  }
1497
  inline void clear_active_vio()
1498
  {
1499
    pthread_mutex_lock(&LOCK_delete);
1500
    active_vio = 0;
1501
    pthread_mutex_unlock(&LOCK_delete);
1502
  }
unknown's avatar
unknown committed
1503
  void close_active_vio();
1504
#endif
unknown's avatar
SCRUM  
unknown committed
1505
  void awake(THD::killed_state state_to_set);
unknown's avatar
unknown committed
1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532

#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

1533 1534
  /*
    For enter_cond() / exit_cond() to work the mutex must be got before
1535 1536
    enter_cond(); this mutex is then released by exit_cond().
    Usage must be: lock mutex; enter_cond(); your code; exit_cond().
1537
  */
unknown's avatar
unknown committed
1538 1539 1540 1541
  inline const char* enter_cond(pthread_cond_t *cond, pthread_mutex_t* mutex,
			  const char* msg)
  {
    const char* old_msg = proc_info;
1542
    safe_mutex_assert_owner(mutex);
unknown's avatar
unknown committed
1543 1544 1545 1546 1547 1548 1549
    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
1550 1551 1552 1553 1554 1555 1556
    /*
      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
1557 1558 1559 1560 1561 1562
    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);
  }
unknown's avatar
unknown committed
1563
  inline time_t query_start() { query_start_used=1; return start_time; }
unknown's avatar
unknown committed
1564
  inline void	set_time()    { if (user_time) start_time=time_after_lock=user_time; else time_after_lock=time(&start_time); }
1565
  inline void	end_time()    { time(&start_time); }
unknown's avatar
unknown committed
1566
  inline void	set_time(time_t t) { time_after_lock=start_time=user_time=t; }
1567
  inline void	lock_time()   { time(&time_after_lock); }
1568 1569 1570
  inline ulonglong found_rows(void)
  {
    return limit_found_rows;
1571
  }
1572 1573
  inline bool active_transaction()
  {
1574 1575
#ifdef USING_TRANSACTIONS
    return server_status & SERVER_STATUS_IN_TRANS;
1576 1577 1578
#else
    return 0;
#endif
1579
  }
unknown's avatar
unknown committed
1580 1581
  inline bool fill_derived_tables()
  {
unknown's avatar
unknown committed
1582
    return !stmt_arena->is_stmt_prepare() && !lex->only_view_structure();
unknown's avatar
unknown committed
1583
  }
1584 1585 1586 1587
  inline bool fill_information_schema_tables()
  {
    return !stmt_arena->is_stmt_prepare();
  }
1588
  inline void* trans_alloc(unsigned int size)
unknown's avatar
unknown committed
1589
  {
1590 1591
    return alloc_root(&transaction.mem_root,size);
  }
1592 1593 1594 1595

  bool convert_string(LEX_STRING *to, CHARSET_INFO *to_cs,
		      const char *from, uint from_length,
		      CHARSET_INFO *from_cs);
1596 1597 1598

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

1599
  void add_changed_table(TABLE *table);
unknown's avatar
unknown committed
1600 1601
  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
1602
  int send_explain_fields(select_result *result);
1603
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
1604 1605
  inline void clear_error()
  {
1606
    DBUG_ENTER("clear_error");
unknown's avatar
unknown committed
1607 1608 1609
    net.last_error[0]= 0;
    net.last_errno= 0;
    net.report_error= 0;
unknown's avatar
unknown committed
1610
    query_error= 0;
1611
    DBUG_VOID_RETURN;
unknown's avatar
unknown committed
1612
  }
1613
  inline bool vio_ok() const { return net.vio != 0; }
1614 1615
#else
  void clear_error();
1616
  inline bool vio_ok() const { return true; }
1617
#endif
1618 1619 1620
  inline void fatal_error()
  {
    is_fatal_error= 1;
unknown's avatar
unknown committed
1621
    net.report_error= 1;
unknown's avatar
unknown committed
1622
    DBUG_PRINT("error",("Fatal error set"));
1623
  }
1624
  inline CHARSET_INFO *charset() { return variables.character_set_client; }
unknown's avatar
unknown committed
1625
  void update_charset();
1626

unknown's avatar
unknown committed
1627
  inline Query_arena *activate_stmt_arena_if_needed(Query_arena *backup)
unknown's avatar
unknown committed
1628 1629
  {
    /*
unknown's avatar
unknown committed
1630 1631
      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
1632
    */
unknown's avatar
unknown committed
1633
    if (!stmt_arena->is_conventional() && mem_root != stmt_arena->mem_root)
unknown's avatar
unknown committed
1634
    {
unknown's avatar
unknown committed
1635 1636
      set_n_backup_active_arena(stmt_arena, backup);
      return stmt_arena;
unknown's avatar
unknown committed
1637 1638 1639 1640
    }
    return 0;
  }

1641
  void change_item_tree(Item **place, Item *new_value)
1642
  {
1643
    /* TODO: check for OOM condition here */
unknown's avatar
unknown committed
1644
    if (!stmt_arena->is_conventional())
unknown's avatar
unknown committed
1645
      nocheck_register_item_tree_change(place, *place, mem_root);
1646
    *place= new_value;
1647 1648
  }
  void nocheck_register_item_tree_change(Item **place, Item *old_value,
1649
                                         MEM_ROOT *runtime_memroot);
1650
  void rollback_item_tree_changes();
1651 1652 1653 1654 1655 1656

  /*
    Cleanup statement parse state (parse tree, lex) and execution
    state after execution of a non-prepared SQL statement.
  */
  void end_statement();
1657 1658
  inline int killed_errno() const
  {
1659 1660
    killed_state killed_val; /* to cache the volatile 'killed' */
    return (killed_val= killed) != KILL_BAD_DATA ? killed_val : 0;
1661 1662 1663
  }
  inline void send_kill_message() const
  {
unknown's avatar
unknown committed
1664
    int err= killed_errno();
1665 1666
    if (err)
      my_message(err, ER(err), MYF(0));
1667
  }
unknown's avatar
unknown committed
1668 1669 1670 1671
  /* return TRUE if we will abort query if we make a warning now */
  inline bool really_abort_on_warning()
  {
    return (abort_on_warning &&
1672
            (!no_trans_update.stmt ||
unknown's avatar
unknown committed
1673 1674
             (variables.sql_mode & MODE_STRICT_ALL_TABLES)));
  }
1675
  void set_status_var_init();
1676
  bool is_context_analysis_only()
unknown's avatar
unknown committed
1677
    { return stmt_arena->is_stmt_prepare() || lex->view_prepare_mode; }
1678 1679
  void reset_n_backup_open_tables_state(Open_tables_state *backup);
  void restore_backup_open_tables_state(Open_tables_state *backup);
1680 1681
  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
1682 1683
  void set_n_backup_active_arena(Query_arena *set, Query_arena *backup);
  void restore_active_arena(Query_arena *set, Query_arena *backup);
1684

1685 1686
  inline void set_current_stmt_binlog_row_based_if_mixed()
  {
unknown's avatar
unknown committed
1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697
    /*
      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))
1698
      current_stmt_binlog_row_based= TRUE;
unknown's avatar
unknown committed
1699 1700 1701
  }
  inline void set_current_stmt_binlog_row_based()
  {
1702
    current_stmt_binlog_row_based= TRUE;
1703
  }
1704 1705
  inline void clear_current_stmt_binlog_row_based()
  {
1706
    current_stmt_binlog_row_based= FALSE;
1707
  }
1708 1709
  inline void reset_current_stmt_binlog_row_based()
  {
unknown's avatar
unknown committed
1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723
    /*
      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...).
1724 1725

      Don't reset binlog format for NDB binlog injector thread.
unknown's avatar
unknown committed
1726
    */
1727 1728
    if ((temporary_tables == NULL) && (in_sub_stmt == 0) &&
        (system_thread != SYSTEM_THREAD_NDBCLUSTER_BINLOG))
unknown's avatar
unknown committed
1729 1730 1731 1732
    {
      current_stmt_binlog_row_based= 
        test(variables.binlog_format == BINLOG_FORMAT_ROW);
    }
1733
  }
unknown's avatar
unknown committed
1734 1735 1736

  /*
    Initialize the current database from a NULL-terminated string with length
1737 1738 1739
    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
1740
  */
1741
  bool set_db(const char *new_db, size_t new_db_len)
unknown's avatar
unknown committed
1742
  {
1743 1744 1745 1746
    /* 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
1747
    {
unknown's avatar
unknown committed
1748 1749
      x_free(db);
      db= new_db ? my_strndup(new_db, new_db_len, MYF(MY_WME)) : NULL;
unknown's avatar
unknown committed
1750
    }
1751 1752
    db_length= db ? new_db_len : 0;
    return new_db && !db;
unknown's avatar
unknown committed
1753
  }
1754
  void reset_db(char *new_db, size_t new_db_len)
unknown's avatar
unknown committed
1755 1756 1757 1758 1759 1760 1761 1762 1763
  {
    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.
  */
1764
  bool copy_db_to(char **p_db, size_t *p_db_length)
unknown's avatar
unknown committed
1765 1766 1767 1768 1769 1770 1771
  {
    if (db == NULL)
    {
      my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
      return TRUE;
    }
    *p_db= strmake(db, db_length);
1772
    *p_db_length= db_length;
unknown's avatar
unknown committed
1773 1774
    return FALSE;
  }
unknown's avatar
unknown committed
1775
  thd_scheduler scheduler;
unknown's avatar
unknown committed
1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800

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;
1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816
  /**
    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
1817 1818
};

1819

1820
#define tmp_disable_binlog(A)       \
1821
  {ulonglong tmp_disable_binlog__save_options= (A)->options; \
1822
  (A)->options&= ~OPTION_BIN_LOG
1823

1824
#define reenable_binlog(A)   (A)->options= tmp_disable_binlog__save_options;}
1825

1826

unknown's avatar
unknown committed
1827
/*
1828
  Used to hold information about file and file structure in exchange
unknown's avatar
unknown committed
1829
  via non-DB file (...INTO OUTFILE..., ...LOAD DATA...)
1830
  XXX: We never call destructor for objects of this class.
unknown's avatar
unknown committed
1831
*/
1832

unknown's avatar
unknown committed
1833 1834 1835 1836 1837 1838 1839
class sql_exchange :public Sql_alloc
{
public:
  char *file_name;
  String *field_term,*enclosed,*line_term,*line_start,*escaped;
  bool opt_enclosed;
  bool dumpfile;
1840
  ulong skip_lines;
1841
  CHARSET_INFO *cs;
unknown's avatar
unknown committed
1842 1843 1844 1845 1846 1847
  sql_exchange(char *name,bool dumpfile_flag);
};

#include "log_event.h"

/*
1848
  This is used to get result from a select
unknown's avatar
unknown committed
1849 1850
*/

unknown's avatar
unknown committed
1851 1852
class JOIN;

unknown's avatar
unknown committed
1853 1854 1855
class select_result :public Sql_alloc {
protected:
  THD *thd;
1856
  SELECT_LEX_UNIT *unit;
unknown's avatar
unknown committed
1857 1858 1859
public:
  select_result();
  virtual ~select_result() {};
1860 1861 1862 1863 1864
  virtual int prepare(List<Item> &list, SELECT_LEX_UNIT *u)
  {
    unit= u;
    return 0;
  }
1865
  virtual int prepare2(void) { return 0; }
1866 1867 1868 1869 1870 1871 1872
  /*
    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; }
1873
  virtual bool send_fields(List<Item> &list, uint flags)=0;
unknown's avatar
unknown committed
1874
  virtual bool send_data(List<Item> &items)=0;
unknown's avatar
unknown committed
1875
  virtual bool initialize_tables (JOIN *join=0) { return 0; }
1876
  virtual void send_error(uint errcode,const char *err);
unknown's avatar
unknown committed
1877
  virtual bool send_eof()=0;
1878 1879 1880 1881 1882 1883 1884 1885
  /**
    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
1886
  virtual void abort() {}
1887 1888 1889 1890 1891
  /*
    Cleanup instance of this class for next execution of a prepared
    statement/stored procedure.
  */
  virtual void cleanup();
1892
  void set_thd(THD *thd_arg) { thd= thd_arg; }
1893 1894 1895 1896 1897
#ifdef EMBEDDED_LIBRARY
  virtual void begin_dataset() {}
#else
  void begin_dataset() {}
#endif
unknown's avatar
unknown committed
1898 1899 1900
};


1901 1902 1903 1904 1905 1906 1907 1908 1909
/*
  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:
1910
  select_result_interceptor() {}              /* Remove gcc warning */
1911 1912 1913 1914 1915
  uint field_count(List<Item> &fields) const { return 0; }
  bool send_fields(List<Item> &fields, uint flag) { return FALSE; }
};


unknown's avatar
unknown committed
1916
class select_send :public select_result {
1917
  int status;
unknown's avatar
unknown committed
1918
public:
1919
  select_send() :status(0) {}
1920
  bool send_fields(List<Item> &list, uint flags);
unknown's avatar
unknown committed
1921 1922
  bool send_data(List<Item> &items);
  bool send_eof();
1923
  virtual bool check_simple_select() const { return FALSE; }
1924
  void abort();
unknown's avatar
unknown committed
1925 1926 1927
};


1928
class select_to_file :public select_result_interceptor {
1929
protected:
unknown's avatar
unknown committed
1930 1931 1932 1933
  sql_exchange *exchange;
  File file;
  IO_CACHE cache;
  ha_rows row_count;
1934 1935 1936 1937 1938 1939 1940
  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);
1941 1942
  bool send_eof();
  void cleanup();
1943 1944 1945 1946
};


class select_export :public select_to_file {
unknown's avatar
unknown committed
1947 1948 1949 1950
  uint field_term_length;
  int field_sep_char,escape_char,line_sep_char;
  bool fixed_row_size;
public:
1951
  select_export(sql_exchange *ex) :select_to_file(ex) {}
unknown's avatar
unknown committed
1952
  ~select_export();
1953
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
1954 1955 1956
  bool send_data(List<Item> &items);
};

unknown's avatar
unknown committed
1957

1958
class select_dump :public select_to_file {
unknown's avatar
unknown committed
1959
public:
1960
  select_dump(sql_exchange *ex) :select_to_file(ex) {}
1961
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
1962 1963
  bool send_data(List<Item> &items);
};
unknown's avatar
unknown committed
1964 1965


1966
class select_insert :public select_result_interceptor {
unknown's avatar
unknown committed
1967
 public:
unknown's avatar
VIEW  
unknown committed
1968
  TABLE_LIST *table_list;
unknown's avatar
unknown committed
1969 1970
  TABLE *table;
  List<Item> *fields;
1971
  ulonglong autoinc_value_of_last_inserted_row; // autogenerated or not
unknown's avatar
unknown committed
1972
  COPY_INFO info;
unknown's avatar
VIEW  
unknown committed
1973
  bool insert_into_view;
unknown's avatar
unknown committed
1974

unknown's avatar
unknown committed
1975 1976
  select_insert(TABLE_LIST *table_list_par,
		TABLE *table_par, List<Item> *fields_par,
unknown's avatar
unknown committed
1977
		List<Item> *update_fields, List<Item> *update_values,
1978
		enum_duplicates duplic, bool ignore);
unknown's avatar
unknown committed
1979
  ~select_insert();
1980
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
1981
  int prepare2(void);
unknown's avatar
unknown committed
1982
  bool send_data(List<Item> &items);
unknown's avatar
unknown committed
1983
  virtual void store_values(List<Item> &values);
1984
  virtual bool can_rollback_data() { return 0; }
unknown's avatar
unknown committed
1985 1986
  void send_error(uint errcode,const char *err);
  bool send_eof();
1987 1988
  /* not implemented: select_insert is never re-used in prepared statements */
  void cleanup();
unknown's avatar
unknown committed
1989 1990
};

unknown's avatar
unknown committed
1991

unknown's avatar
unknown committed
1992 1993
class select_create: public select_insert {
  ORDER *group;
unknown's avatar
VIEW  
unknown committed
1994
  TABLE_LIST *create_table;
1995
  TABLE_LIST *select_tables;
unknown's avatar
unknown committed
1996
  HA_CREATE_INFO *create_info;
1997
  Alter_info *alter_info;
unknown's avatar
unknown committed
1998 1999
  Field **field;
public:
unknown's avatar
unknown committed
2000
  select_create (TABLE_LIST *table_arg,
unknown's avatar
VIEW  
unknown committed
2001
		 HA_CREATE_INFO *create_info_par,
2002
                 Alter_info *alter_info_arg,
2003 2004
		 List<Item> &select_fields,enum_duplicates duplic, bool ignore,
                 TABLE_LIST *select_tables_arg)
2005
    :select_insert (NULL, NULL, &select_fields, 0, 0, duplic, ignore),
2006
    create_table(table_arg),
2007 2008
    create_info(create_info_par),
    select_tables(select_tables_arg),
2009
    alter_info(alter_info_arg)
unknown's avatar
unknown committed
2010
    {}
2011
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
2012

2013
  void binlog_show_create_table(TABLE **tables, uint count);
unknown's avatar
unknown committed
2014
  void store_values(List<Item> &values);
2015
  void send_error(uint errcode,const char *err);
unknown's avatar
unknown committed
2016 2017
  bool send_eof();
  void abort();
2018 2019
  virtual bool can_rollback_data() { return 1; }

2020
  // Needed for access from local class MY_HOOKS in prepare(), since thd is proteted.
2021 2022
  const THD *get_thd(void) { return thd; }
  const HA_CREATE_INFO *get_create_info() { return create_info; };
unknown's avatar
unknown committed
2023 2024
};

2025 2026
#include <myisam.h>

unknown's avatar
unknown committed
2027 2028 2029 2030 2031
/* 
  Param to create temporary tables when doing SELECT:s 
  NOTE
    This structure is copied using memcpy as a part of JOIN.
*/
2032 2033 2034

class TMP_TABLE_PARAM :public Sql_alloc
{
2035 2036 2037 2038 2039 2040
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:
2041 2042 2043 2044
  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;
2045
  uchar	    *group_buff;
2046 2047 2048 2049 2050 2051 2052 2053 2054
  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;
2055 2056
  /* If >0 convert all blob fields to varchar(convert_blob_length) */
  uint  convert_blob_length; 
unknown's avatar
unknown committed
2057
  CHARSET_INFO *table_charset; 
2058
  bool schema_table;
2059 2060 2061 2062 2063 2064 2065
  /*
    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;
2066
  bool force_copy_fields;
2067 2068

  TMP_TABLE_PARAM()
unknown's avatar
unknown committed
2069
    :copy_field(0), group_parts(0),
unknown's avatar
unknown committed
2070
     group_length(0), group_null_parts(0), convert_blob_length(0),
unknown's avatar
unknown committed
2071
     schema_table(0), precomputed_group_by(0), force_copy_fields(0)
2072 2073 2074 2075 2076
  {}
  ~TMP_TABLE_PARAM()
  {
    cleanup();
  }
2077
  void init(void);
2078 2079 2080 2081 2082
  inline void cleanup(void)
  {
    if (copy_field)				/* Fix for Intel compiler */
    {
      delete [] copy_field;
2083
      save_copy_field= copy_field= 0;
2084 2085 2086 2087
    }
  }
};

2088 2089
class select_union :public select_result_interceptor
{
2090
  TMP_TABLE_PARAM tmp_table_param;
2091 2092
public:
  TABLE *table;
unknown's avatar
unknown committed
2093

2094
  select_union() :table(0) {}
2095
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
2096 2097 2098
  bool send_data(List<Item> &items);
  bool send_eof();
  bool flush();
2099 2100 2101 2102

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

unknown's avatar
unknown committed
2105
/* Base subselect interface class */
2106
class select_subselect :public select_result_interceptor
2107
{
unknown's avatar
unknown committed
2108
protected:
2109 2110 2111
  Item_subselect *item;
public:
  select_subselect(Item_subselect *item);
unknown's avatar
unknown committed
2112
  bool send_data(List<Item> &items)=0;
2113 2114 2115
  bool send_eof() { return 0; };
};

unknown's avatar
unknown committed
2116
/* Single value subselect interface class */
unknown's avatar
unknown committed
2117
class select_singlerow_subselect :public select_subselect
unknown's avatar
unknown committed
2118 2119
{
public:
2120 2121 2122
  select_singlerow_subselect(Item_subselect *item_arg)
    :select_subselect(item_arg)
  {}
unknown's avatar
unknown committed
2123 2124 2125
  bool send_data(List<Item> &items);
};

2126 2127 2128 2129 2130 2131 2132
/* 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:
2133 2134
  select_max_min_finder_subselect(Item_subselect *item_arg, bool mx)
    :select_subselect(item_arg), cache(0), fmax(mx)
2135
  {}
unknown's avatar
Merge  
unknown committed
2136
  void cleanup();
2137 2138 2139
  bool send_data(List<Item> &items);
  bool cmp_real();
  bool cmp_int();
unknown's avatar
Merge  
unknown committed
2140
  bool cmp_decimal();
2141 2142 2143
  bool cmp_str();
};

unknown's avatar
unknown committed
2144 2145 2146 2147
/* EXISTS subselect interface class */
class select_exists_subselect :public select_subselect
{
public:
2148 2149
  select_exists_subselect(Item_subselect *item_arg)
    :select_subselect(item_arg){}
unknown's avatar
unknown committed
2150 2151 2152
  bool send_data(List<Item> &items);
};

unknown's avatar
unknown committed
2153 2154 2155 2156 2157 2158
/* 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 */
2159
  uint   suffix_length;                 /* Length suffix (0-4) */
unknown's avatar
unknown committed
2160
  Item_result result_type;		/* Type of item */
2161 2162
  bool reverse;				/* if descending sort */
  bool need_strxnfrm;			/* If we have to use strxnfrm() */
unknown's avatar
unknown committed
2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175
} 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 */

2176 2177
class Table_ident :public Sql_alloc
{
unknown's avatar
unknown committed
2178
public:
unknown's avatar
unknown committed
2179 2180
  LEX_STRING db;
  LEX_STRING table;
unknown's avatar
unknown committed
2181
  SELECT_LEX_UNIT *sel;
unknown's avatar
unknown committed
2182 2183
  inline Table_ident(THD *thd, LEX_STRING db_arg, LEX_STRING table_arg,
		     bool force)
unknown's avatar
unknown committed
2184
    :table(table_arg), sel((SELECT_LEX_UNIT *)0)
unknown's avatar
unknown committed
2185
  {
unknown's avatar
unknown committed
2186
    if (!force && (thd->client_capabilities & CLIENT_NO_SCHEMA))
unknown's avatar
unknown committed
2187 2188 2189 2190
      db.str=0;
    else
      db= db_arg;
  }
unknown's avatar
unknown committed
2191 2192 2193 2194 2195
  inline Table_ident(LEX_STRING table_arg) 
    :table(table_arg), sel((SELECT_LEX_UNIT *)0)
  {
    db.str=0;
  }
2196 2197 2198 2199 2200 2201
  /*
    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
2202
  inline Table_ident(SELECT_LEX_UNIT *s) : sel(s)
unknown's avatar
unknown committed
2203
  {
unknown's avatar
unknown committed
2204
    /* We must have a table name here as this is used with add_table_to_list */
2205 2206 2207 2208
    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
2209
  }
2210
  bool is_derived_table() const { return test(sel); }
unknown's avatar
unknown committed
2211
  inline void change_db(char *db_name)
unknown's avatar
unknown committed
2212 2213 2214
  {
    db.str= db_name; db.length= (uint) strlen(db_name);
  }
unknown's avatar
unknown committed
2215 2216 2217 2218 2219 2220
};

// this is needed for user_vars hash
class user_var_entry
{
 public:
2221
  user_var_entry() {}                         /* Remove gcc warning */
unknown's avatar
unknown committed
2222 2223
  LEX_STRING name;
  char *value;
2224 2225
  ulong length;
  query_id_t update_query_id, used_query_id;
unknown's avatar
unknown committed
2226
  Item_result type;
2227
  bool unsigned_flag;
2228

unknown's avatar
Merge  
unknown committed
2229
  double val_real(my_bool *null_value);
2230 2231
  longlong val_int(my_bool *null_value);
  String *val_str(my_bool *null_value, String *str, uint decimals);
unknown's avatar
Merge  
unknown committed
2232
  my_decimal *val_decimal(my_bool *null_value, my_decimal *result);
2233
  DTCollation collation;
unknown's avatar
unknown committed
2234 2235
};

2236 2237 2238 2239 2240 2241 2242
/*
   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.
 */
2243 2244 2245 2246

class Unique :public Sql_alloc
{
  DYNAMIC_ARRAY file_ptrs;
2247 2248
  ulong max_elements;
  ulonglong max_in_memory_size;
2249 2250
  IO_CACHE file;
  TREE tree;
2251
  uchar *record_pointers;
2252
  bool flush();
2253
  uint size;
2254 2255 2256

public:
  ulong elements;
2257
  Unique(qsort_cmp2 comp_func, void *comp_func_fixed_arg,
2258
	 uint size_arg, ulonglong max_in_memory_size_arg);
2259
  ~Unique();
2260
  ulong elements_in_tree() { return tree.elements_in_tree; }
2261
  inline bool unique_add(void *ptr)
2262
  {
unknown's avatar
Merge  
unknown committed
2263
    DBUG_ENTER("unique_add");
unknown's avatar
unknown committed
2264
    DBUG_PRINT("info", ("tree %u - %lu", tree.elements_in_tree, max_elements));
2265
    if (tree.elements_in_tree > max_elements && flush())
unknown's avatar
Merge  
unknown committed
2266 2267
      DBUG_RETURN(1);
    DBUG_RETURN(!tree_insert(&tree, ptr, 0, tree.custom_arg));
2268 2269 2270
  }

  bool get(TABLE *table);
2271
  static double get_use_cost(uint *buffer, uint nkeys, uint key_size, 
2272
                             ulonglong max_in_memory_size);
2273
  inline static int get_cost_calc_buff_size(ulong nkeys, uint key_size, 
2274
                                            ulonglong max_in_memory_size)
2275
  {
2276
    register ulonglong max_elems_in_tree=
2277
      (1 + max_in_memory_size / ALIGN_SIZE(sizeof(TREE_ELEMENT)+key_size));
2278
    return (int) (sizeof(uint)*(1 + nkeys/max_elems_in_tree));
2279 2280
  }

2281 2282 2283
  void reset();
  bool walk(tree_walk_action action, void *walk_action_arg);

2284 2285
  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);
2286
};
2287

unknown's avatar
unknown committed
2288

2289
class multi_delete :public select_result_interceptor
unknown's avatar
unknown committed
2290 2291
{
  TABLE_LIST *delete_tables, *table_being_deleted;
unknown's avatar
unknown committed
2292
  Unique **tempfiles;
2293
  ha_rows deleted, found;
unknown's avatar
unknown committed
2294 2295
  uint num_of_tables;
  int error;
2296 2297 2298 2299 2300 2301
  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;
2302

unknown's avatar
unknown committed
2303
public:
2304
  multi_delete(TABLE_LIST *dt, uint num_of_tables);
unknown's avatar
unknown committed
2305 2306 2307 2308 2309
  ~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);
2310
  int  do_deletes();
unknown's avatar
unknown committed
2311 2312 2313
  bool send_eof();
};

2314

2315
class multi_update :public select_result_interceptor
unknown's avatar
unknown committed
2316
{
2317 2318 2319
  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
2320
  TABLE **tmp_tables, *main_table, *table_to_update;
unknown's avatar
unknown committed
2321 2322 2323 2324 2325
  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
2326 2327 2328 2329 2330
  /*
   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
2331 2332
  Copy_field *copy_field;
  enum enum_duplicates handle_duplicates;
2333 2334 2335 2336
  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
2337 2338

public:
2339
  multi_update(TABLE_LIST *ut, TABLE_LIST *leaves_list,
2340
	       List<Item> *fields, List<Item> *values,
2341
	       enum_duplicates handle_duplicates, bool ignore);
unknown's avatar
unknown committed
2342
  ~multi_update();
unknown's avatar
unknown committed
2343
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
2344 2345 2346 2347 2348 2349
  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();
};
2350

unknown's avatar
unknown committed
2351 2352 2353
class my_var : public Sql_alloc  {
public:
  LEX_STRING s;
unknown's avatar
unknown committed
2354
#ifndef DBUG_OFF
2355 2356 2357 2358
  /*
    Routine to which this Item_splocal belongs. Used for checking if correct
    runtime context is used for variable handling.
  */
2359
  sp_head *sp;
2360
#endif
unknown's avatar
unknown committed
2361 2362
  bool local;
  uint offset;
2363 2364 2365 2366
  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
2367 2368
  ~my_var() {}
};
2369

2370
class select_dumpvar :public select_result_interceptor {
unknown's avatar
unknown committed
2371 2372
  ha_rows row_count;
public:
unknown's avatar
unknown committed
2373
  List<my_var> var_list;
2374
  select_dumpvar()  { var_list.empty(); row_count= 0;}
unknown's avatar
unknown committed
2375
  ~select_dumpvar() {}
2376
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
2377 2378
  bool send_data(List<Item> &items);
  bool send_eof();
2379
  virtual bool check_simple_select() const;
2380
  void cleanup();
unknown's avatar
unknown committed
2381
};
2382

2383 2384 2385 2386 2387 2388 2389
/* 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

2390 2391 2392
/* Functions in sql_class.cc */

void add_to_status(STATUS_VAR *to_var, STATUS_VAR *from_var);
2393 2394
void add_diff_to_status(STATUS_VAR *to_var, STATUS_VAR *from_var,
                        STATUS_VAR *dec_var);
2395
#endif /* MYSQL_SERVER */