sql_class.h 70.7 KB
Newer Older
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1
/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3 4 5 6
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
7

bk@work.mysql.com's avatar
bk@work.mysql.com committed
8 9 10 11
   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.
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
12

bk@work.mysql.com's avatar
bk@work.mysql.com committed
13 14 15 16 17 18 19
   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 */

20
#ifdef USE_PRAGMA_INTERFACE
bk@work.mysql.com's avatar
bk@work.mysql.com committed
21 22 23
#pragma interface			/* gcc class implementation */
#endif

24 25 26
#include "log.h"
#include "rpl_rli.h"
#include "rpl_tblmap.h"
27

bk@work.mysql.com's avatar
bk@work.mysql.com committed
28 29
class Query_log_event;
class Load_log_event;
30
class Slave_log_event;
31
class sp_rcontext;
32
class sp_cache;
33
class Rows_log_event;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
34

35
enum enum_enable_or_disable { LEAVE_AS_IS, ENABLE, DISABLE };
36
enum enum_ha_read_modes { RFIRST, RNEXT, RPREV, RLAST, RKEY, RNEXT_SAME };
37
enum enum_duplicates { DUP_ERROR, DUP_REPLACE, DUP_UPDATE };
38 39
enum enum_delay_key_write { DELAY_KEY_WRITE_NONE, DELAY_KEY_WRITE_ON,
			    DELAY_KEY_WRITE_ALL };
40 41 42 43
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};
44

45
extern char internal_table_name[2];
46
extern char empty_c_string[1];
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
47
extern const char **errmesg;
48

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

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

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

65 66 67
#define RP_LOCK_LOG_IS_ALREADY_LOCKED 1
#define RP_FORCE_ROTATE               2

bk@work.mysql.com's avatar
bk@work.mysql.com committed
68 69 70
typedef struct st_copy_info {
  ha_rows records;
  ha_rows deleted;
vva@eagle.mysql.r18.ru's avatar
vva@eagle.mysql.r18.ru committed
71
  ha_rows updated;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
72
  ha_rows copied;
73
  ha_rows error_count;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
74
  enum enum_duplicates handle_duplicates;
75
  int escape_char, last_errno;
76 77
  bool ignore;
  /* for INSERT ... UPDATE */
78 79
  List<Item> *update_fields;
  List<Item> *update_values;
monty@mysql.com's avatar
monty@mysql.com committed
80
  /* for VIEW ... WITH CHECK OPTION */
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
81
  TABLE_LIST *view;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
82 83 84 85 86 87 88 89
} COPY_INFO;


class key_part_spec :public Sql_alloc {
public:
  const char *field_name;
  uint length;
  key_part_spec(const char *name,uint len=0) :field_name(name), length(len) {}
90
  bool operator==(const key_part_spec& other) const;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
91 92 93 94 95 96 97 98 99 100 101 102 103 104 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) {}
};


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) {}
};


class Key :public Sql_alloc {
public:
115
  enum Keytype { PRIMARY, UNIQUE, MULTIPLE, FULLTEXT, SPATIAL, FOREIGN_KEY};
bk@work.mysql.com's avatar
bk@work.mysql.com committed
116
  enum Keytype type;
117
  KEY_CREATE_INFO key_create_info;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
118
  List<key_part_spec> columns;
119
  const char *name;
120
  bool generated;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
121

122 123 124
  Key(enum Keytype type_par, const char *name_arg,
      KEY_CREATE_INFO *key_info_arg,
      bool generated_arg, List<key_part_spec> &cols)
125 126
    :type(type_par), key_create_info(*key_info_arg), columns(cols),
    name(name_arg), generated(generated_arg)
127
  {}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
128
  ~Key() {}
129
  /* Equality comparison of keys (ignoring name) */
130
  friend bool foreign_key_prefix(Key *a, Key *b);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
131 132
};

133 134 135 136 137 138 139 140 141 142 143 144 145 146 147
class Table_ident;

class foreign_key: public Key {
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;
  List<key_part_spec> ref_columns;
  uint delete_opt, update_opt, match_opt;
  foreign_key(const char *name_arg, List<key_part_spec> &cols,
	      Table_ident *table,   List<key_part_spec> &ref_cols,
	      uint delete_opt_arg, uint update_opt_arg, uint match_opt_arg)
148
    :Key(FOREIGN_KEY, name_arg, &default_key_create_info, 0, cols),
149 150 151 152 153
    ref_table(table), ref_columns(cols),
    delete_opt(delete_opt_arg), update_opt(update_opt_arg),
    match_opt(match_opt_arg)
  {}
};
bk@work.mysql.com's avatar
bk@work.mysql.com committed
154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173

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

class delayed_insert;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
174
class select_result;
175
class Time_zone;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
176

177 178 179 180 181
#define THD_SENTRY_MAGIC 0xfeedd1ff
#define THD_SENTRY_GONE  0xdeadbeef

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

182 183
struct system_variables
{
184 185
  ulonglong myisam_max_extra_sort_file_size;
  ulonglong myisam_max_sort_file_size;
186 187
  ulonglong max_heap_table_size;
  ulonglong tmp_table_size;
188 189
  ha_rows select_limit;
  ha_rows max_join_size;
190
  ulong auto_increment_increment, auto_increment_offset;
191
  ulong bulk_insert_buff_size;
192 193
  ulong join_buff_size;
  ulong long_query_time;
194
  ulong max_allowed_packet;
195
  ulong max_error_count;
igor@hundin.mysql.fi's avatar
igor@hundin.mysql.fi committed
196
  ulong max_length_for_sort_data;
197
  ulong max_sort_length;
198
  ulong max_tmp_tables;
199
  ulong max_insert_delayed_threads;
ingo@mysql.com's avatar
ingo@mysql.com committed
200
  ulong multi_range_count;
201
  ulong myisam_repair_threads;
202
  ulong myisam_sort_buff_size;
203
  ulong myisam_stats_method;
204
  ulong net_buffer_length;
205
  ulong net_interactive_timeout;
206
  ulong net_read_timeout;
207
  ulong net_retry_count;
208
  ulong net_wait_timeout;
209
  ulong net_write_timeout;
210 211
  ulong optimizer_prune_level;
  ulong optimizer_search_depth;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
212
  ulong preload_buff_size;
213 214 215
  ulong query_cache_type;
  ulong read_buff_size;
  ulong read_rnd_buff_size;
216
  ulong div_precincrement;
217
  ulong sortbuff_size;
218
  handlerton *table_type;
219
  ulong tx_isolation;
mskold@mysql.com's avatar
Merge  
mskold@mysql.com committed
220
  ulong completion_type;
221
  /* Determines which non-standard SQL behaviour should be enabled */
222
  ulong sql_mode;
223
  ulong max_sp_recursion_depth;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
224
  /* check of key presence in updatable view */
225
  ulong updatable_views_with_limit;
226
  ulong default_week_format;
227
  ulong max_seeks_for_key;
228 229 230 231 232
  ulong range_alloc_block_size;
  ulong query_alloc_block_size;
  ulong query_prealloc_size;
  ulong trans_alloc_block_size;
  ulong trans_prealloc_size;
233
  ulong log_warnings;
234
  ulong group_concat_max_len;
235 236 237 238 239 240
  /*
    In slave thread we need to know in behalf of which
    thread the query is being run to replicate temp tables properly
  */
  ulong pseudo_thread_id;

241 242
  my_bool low_priority_updates;
  my_bool new_mode;
243
  my_bool query_cache_wlock_invalidate;
mskold@mysql.com's avatar
mskold@mysql.com committed
244
  my_bool engine_condition_pushdown;
245
  my_bool innodb_table_locks;
246
  my_bool innodb_support_xa;
247
  my_bool ndb_force_send;
248
  my_bool ndb_use_copying_alter_table;
249 250
  my_bool ndb_use_exact_count;
  my_bool ndb_use_transactions;
251
  my_bool ndb_index_stat_enable;
252
  ulong ndb_autoincrement_prefetch_sz;
253 254
  ulong ndb_index_stat_cache_entries;
  ulong ndb_index_stat_update_freq;
255 256
  ulong binlog_format; // binlog format for this thd (see enum_binlog_format)

257
  my_bool old_alter_table;
258
  my_bool old_passwords;
259

260
  /* Only charset part of these variables is sensible */
261
  CHARSET_INFO  *character_set_filesystem;
262
  CHARSET_INFO  *character_set_client;
263
  CHARSET_INFO  *character_set_results;
264

265 266 267
  /* Both charset and collation parts of these variables are important */
  CHARSET_INFO	*collation_server;
  CHARSET_INFO	*collation_database;
268
  CHARSET_INFO  *collation_connection;
269

bar@mysql.com's avatar
bar@mysql.com committed
270 271 272
  /* Locale Support */
  MY_LOCALE *lc_time_names;

273 274
  Time_zone *time_zone;

275 276 277 278
  /* DATE, DATETIME and TIME formats */
  DATE_TIME_FORMAT *date_format;
  DATE_TIME_FORMAT *datetime_format;
  DATE_TIME_FORMAT *time_format;
279
  my_bool sysdate_is_now;
280 281
};

282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304

/* per thread status variables */

typedef struct system_status_var
{
  ulong bytes_received;
  ulong bytes_sent;
  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;
305 306 307 308
  ulong ha_prepare_count;
  ulong ha_discover_count;
  ulong ha_savepoint_count;
  ulong ha_savepoint_rollback_count;
309 310 311 312 313 314 315 316 317 318 319 320

  /* 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;
321
  ulong opened_shares;
322 323 324 325 326 327 328 329 330 331
  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;
332
  /* Prepared statements and binary protocol */
333 334 335 336 337 338
  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;
339

340 341 342 343
  /*
    Status variables which it does not make sense to add to
    global status variable counter
  */
344
  double last_query_cost;
345 346 347
} STATUS_VAR;

/*
348 349 350
  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
351 352
*/

konstantin@mysql.com's avatar
konstantin@mysql.com committed
353
#define last_system_status_var com_stmt_close
354

355 356
#ifdef MYSQL_SERVER

357
void free_tmp_table(THD *thd, TABLE *entry);
358 359


360 361 362
/* The following macro is to make init of Query_arena simpler */
#ifndef DBUG_OFF
#define INIT_ARENA_DBUG_INFO is_backup_arena= 0
363 364
#else
#define INIT_ARENA_DBUG_INFO
365 366
#endif

serg@serg.mylan's avatar
serg@serg.mylan committed
367
class Query_arena
368 369 370 371 372 373 374
{
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;
375
  MEM_ROOT *mem_root;                   // Pointer to current memroot
monty@mysql.com's avatar
monty@mysql.com committed
376
#ifndef DBUG_OFF
377
  bool is_backup_arena; /* True if this arena is used for backup. */
monty@mysql.com's avatar
monty@mysql.com committed
378
#endif
serg@serg.mylan's avatar
serg@serg.mylan committed
379
  enum enum_state
380
  {
381 382
    INITIALIZED= 0, INITIALIZED_FOR_SP= 1, PREPARED= 2,
    CONVENTIONAL_EXECUTION= 3, EXECUTED= 4, ERROR= -1
383
  };
serg@serg.mylan's avatar
serg@serg.mylan committed
384

385
  enum_state state;
386 387 388 389 390 391 392

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

393 394
  Query_arena(MEM_ROOT *mem_root_arg, enum enum_state state_arg) :
    free_list(0), mem_root(mem_root_arg), state(state_arg)
395
  { INIT_ARENA_DBUG_INFO; }
396
  /*
serg@serg.mylan's avatar
serg@serg.mylan committed
397 398
    This constructor is used only when Query_arena is created as
    backup storage for another instance of Query_arena.
399
  */
400 401
  Query_arena() { INIT_ARENA_DBUG_INFO; }

402
  virtual Type type() const;
serg@serg.mylan's avatar
serg@serg.mylan committed
403
  virtual ~Query_arena() {};
404

405
  inline bool is_stmt_prepare() const { return state == INITIALIZED; }
406 407
  inline bool is_first_sp_execute() const
  { return state == INITIALIZED_FOR_SP; }
408 409
  inline bool is_stmt_prepare_or_first_sp_execute() const
  { return (int)state < (int)PREPARED; }
410
  inline bool is_first_stmt_execute() const { return state == PREPARED; }
411 412
  inline bool is_stmt_execute() const
  { return state == PREPARED || state == EXECUTED; }
monty@mysql.com's avatar
monty@mysql.com committed
413
  inline bool is_conventional() const
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
414
  { return state == CONVENTIONAL_EXECUTION; }
415

416
  inline gptr alloc(unsigned int size) { return alloc_root(mem_root,size); }
417 418 419
  inline gptr calloc(unsigned int size)
  {
    gptr ptr;
420
    if ((ptr=alloc_root(mem_root,size)))
421 422 423 424
      bzero((char*) ptr,size);
    return ptr;
  }
  inline char *strdup(const char *str)
425
  { return strdup_root(mem_root,str); }
426
  inline char *strmake(const char *str, uint size)
427
  { return strmake_root(mem_root,str,size); }
428 429 430 431 432 433
  inline bool LEX_STRING_make(LEX_STRING *lex_str, const char *str, uint size)
  {
    return ((lex_str->str= 
             strmake_root(mem_root, str, (lex_str->length= size)))) == 0;
  }

434
  inline char *memdup(const char *str, uint size)
435
  { return memdup_root(mem_root,str,size); }
436 437 438
  inline char *memdup_w_gap(const char *str, uint size, uint gap)
  {
    gptr ptr;
439
    if ((ptr=alloc_root(mem_root,size+gap)))
440 441 442 443
      memcpy(ptr,str,size);
    return ptr;
  }

konstantin@mysql.com's avatar
konstantin@mysql.com committed
444
  void set_query_arena(Query_arena *set);
445 446

  void free_items();
447 448
  /* Close the active state associated with execution of this statement */
  virtual void cleanup_stmt();
449 450
};

451

452
class Server_side_cursor;
453

454 455 456 457 458 459 460 461 462 463 464 465 466 467
/*
  State of a single command executed against this connection.
  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.
*/

468
class Statement: public ilink, public Query_arena
469
{
470 471
  Statement(const Statement &rhs);              /* not implemented: */
  Statement &operator=(const Statement &rhs);   /* non-copyable */
472
public:
473 474
  /* FIXME: these must be protected */
  MEM_ROOT main_mem_root;
475
  LEX     main_lex;
476

477
  /*
konstantin@oak.local's avatar
konstantin@oak.local committed
478
    Uniquely identifies each statement object in thread scope; change during
479
    statement lifetime. FIXME: must be const
480
  */
konstantin@oak.local's avatar
konstantin@oak.local committed
481
   ulong id;
482 483

  /*
484 485 486 487 488 489 490 491 492
    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.
493
  */
494
  enum enum_mark_columns mark_used_columns;
495

496
  LEX_STRING name; /* name for named prepared statements */
497 498 499 500 501
  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.
502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518

    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.
519 520 521
  */
  char *query;
  uint32 query_length;                          // current query length
522
  Server_side_cursor *cursor;
523

524 525
public:

526 527
  /* This constructor is called for backup statements */
  Statement() { clear_alloc_root(&main_mem_root); }
528

529 530
  Statement(enum enum_state state_arg, ulong id_arg,
            ulong alloc_block_size, ulong prealloc_size);
531
  virtual ~Statement();
532 533 534

  /* Assign execution context (note: not all members) of given stmt to self */
  void set_statement(Statement *stmt);
535 536
  void set_n_backup_statement(Statement *stmt, Statement *backup);
  void restore_backup_statement(Statement *stmt, Statement *backup);
537 538
  /* return class type */
  virtual Type type() const;
539 540 541 542
};


/*
543 544 545 546 547
  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
548

549 550
  Statements are auto-deleted when they are removed from the map and when the
  map is deleted.
551 552 553 554 555 556
*/

class Statement_map
{
public:
  Statement_map();
557

558
  int insert(THD *thd, Statement *statement);
559 560

  Statement *find_by_name(LEX_STRING *name)
561
  {
562 563 564 565
    Statement *stmt;
    stmt= (Statement*)hash_search(&names_hash, (byte*)name->str,
                                  name->length);
    return stmt;
566
  }
567 568

  Statement *find(ulong id)
569
  {
570
    if (last_found_statement == 0 || id != last_found_statement->id)
571 572 573
    {
      Statement *stmt;
      stmt= (Statement *) hash_search(&st_hash, (byte *) &id, sizeof(id));
574
      if (stmt && stmt->name.str)
575 576 577
        return NULL;
      last_found_statement= stmt;
    }
578
    return last_found_statement;
579
  }
580 581 582 583 584 585
  /*
    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();
586
  void erase(Statement *statement);
587
  /* Erase all statements (calls Statement destructor) */
588 589
  void reset();
  ~Statement_map();
590 591
private:
  HASH st_hash;
592
  HASH names_hash;
593
  I_List<Statement> transient_cursor_list;
594
  Statement *last_found_statement;
595 596
};

597 598 599 600 601 602 603
struct st_savepoint {
  struct st_savepoint *prev;
  char                *name;
  uint                 length, nht;
};

enum xa_states {XA_NOTR=0, XA_ACTIVE, XA_IDLE, XA_PREPARED};
604
extern const char *xa_state_names[];
605

606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621
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);

622

623 624
class Security_context {
public:
625
  Security_context() {}                       /* Remove gcc warning */
626 627 628 629
  /*
    host - host of the client
    user - user of the client, set to NULL until the user has been read from
    the connection
630
    priv_user - The user privilege we are using. May be "" for anonymous user.
631 632 633
    ip - client IP
  */
  char   *host, *user, *priv_user, *ip;
634
  /* The host privilege we are using */
635 636 637 638 639 640 641 642 643
  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();
644
  inline char *priv_host_name()
645 646 647
  {
    return (*priv_host ? priv_host : (char *)"%");
  }
648 649
  
  bool set_user(char *user_arg);
650 651 652
};


653 654 655 656 657 658 659 660 661 662 663
/*
  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;


664 665 666 667 668 669 670 671 672
/*
  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};


673
/*
674
  Class that holds information about tables which were opened and locked
675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709
  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;
710 711 712 713 714 715 716 717

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

718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744
  /*
    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;

745 746 747 748 749 750 751 752 753
  enum enum_flags {
    BACKUPS_AVAIL = (1U << 0)     /* There are backups available */
  };

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

754 755 756 757
  /*
    This constructor serves for creation of Open_tables_state instances
    which are used as backup storage.
  */
758
  Open_tables_state() : state_flags(0U) { }
759 760

  Open_tables_state(ulong version_arg);
761 762 763 764 765 766 767 768 769

  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;
770
    extra_lock= lock= locked_tables= 0;
771
    prelocked_mode= NON_PRELOCKED;
772
    state_flags= 0U;
773 774 775 776
  }
};


777 778 779 780 781 782 783 784 785 786 787
/* class to save context when executing a function or trigger */

/* Defines used for Sub_statement_state::in_sub_stmt */

#define SUB_STMT_TRIGGER 1
#define SUB_STMT_FUNCTION 2

class Sub_statement_state
{
public:
  ulonglong options;
788 789 790
  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;
791 792 793 794
  ulonglong limit_found_rows;
  ha_rows    cuted_fields, sent_row_count, examined_row_count;
  ulong client_capabilities;
  uint in_sub_stmt;
795
  bool enable_slow_log;
ramil@mysql.com's avatar
ramil@mysql.com committed
796
  bool last_insert_id_used;
797
  my_bool no_send_ok;
798
  SAVEPOINT *savepoints;
799 800 801
};


802 803 804 805 806 807 808 809 810 811 812 813 814
/* 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
};


815 816 817 818
/*
  For each client connection we create a separate thread with THD serving as
  a thread/connection descriptor
*/
819

820
class THD :public Statement,
821
           public Open_tables_state
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
822
{
bk@work.mysql.com's avatar
bk@work.mysql.com committed
823
public:
824 825 826
  /* Used to execute base64 coded binlog events in MySQL server */
  RELAY_LOG_INFO* rli_fake;

827 828 829 830 831 832 833 834
  /*
    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;

835 836
#ifdef EMBEDDED_LIBRARY
  struct st_mysql  *mysql;
hf@deer.(none)'s avatar
SCRUM  
hf@deer.(none) committed
837 838
  unsigned long	 client_stmt_id;
  unsigned long  client_param_count;
hf@deer.(none)'s avatar
hf@deer.(none) committed
839
  struct st_mysql_bind *client_params;
hf@deer.(none)'s avatar
hf@deer.(none) committed
840 841
  char *extra_data;
  ulong extra_length;
842 843 844 845 846
  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();
847 848 849 850 851 852
  /*
    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;
853
#endif
854
  NET	  net;				// client connection descriptor
855
  MEM_ROOT warn_root;			// For warnings and errors
856 857 858
  Protocol *protocol;			// Current protocol
  Protocol_simple protocol_simple;	// Normal protocol
  Protocol_prep protocol_prep;		// Binary protocol
859 860
  HASH    user_vars;			// hash for user variables
  String  packet;			// dynamic buffer for network I/O
861
  String  convert_buffer;               // buffer for charset conversions
862 863 864
  struct  sockaddr_in remote;		// client socket address
  struct  rand_struct rand;		// used for authentication
  struct  system_variables variables;	// Changeable local variables
865
  struct  system_status_var status_var; // Per thread statistic vars
866
  struct  system_status_var *initial_status_var; /* used by show status */
867 868 869 870
  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.
871
  pthread_mutex_t LOCK_delete;		// Locked before thd is deleted
872
  /* all prepared statements and cursors of this connection */
873
  Statement_map stmt_map;
874 875 876 877 878 879
  /*
    A pointer to the stack frame of handle_one_connection(),
    which is called first in the thread for handling a client
  */
  char	  *thread_stack;

880 881
  /*
    db - currently selected database
882
    catalog - currently selected catalog
883 884 885 886 887
    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
888 889
    properly. For details see the 'err:' label of the handle_slave_sql()
    in sql/slave.cc.
890
   */
891
  char   *db, *catalog;
892 893
  Security_context main_security_ctx;
  Security_context *security_ctx;
894

895 896
  /* remote (peer) port */
  uint16 peer_port;
897 898 899 900 901
  /*
    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.
  */
902
  const char *proc_info;
903

904
  ulong client_capabilities;		/* What the client supports */
905
  ulong max_client_packet_length;
906

907
  HASH		handler_tables_hash;
908 909 910 911 912
  /*
    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. 
  */
913
  User_level_lock *ull;
914 915
#ifndef DBUG_OFF
  uint dbug_sentry; // watch out for memory corruption
916
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com committed
917
  struct st_my_thread_var *mysys_var;
918
  /*
919
    Type of current query: COM_STMT_PREPARE, COM_QUERY, etc. Set from
920 921 922
    first byte of the packet in do_command()
  */
  enum enum_server_command command;
923
  uint32     server_id;
924
  uint32     file_id;			// for LOAD DATA INFILE
925 926 927 928 929
  /*
    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.
  */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
930
  const char *where;
931 932
  time_t     start_time,time_after_lock,user_time;
  time_t     connect_time,thr_create_time; // track down slow pthread_create
bk@work.mysql.com's avatar
bk@work.mysql.com committed
933 934
  thr_lock_type update_lock_default;
  delayed_insert *di;
935

936 937
  /* <> 0 if we are inside of trigger or stored function. */
  uint in_sub_stmt;
938

939 940
  /* container for handler's private per-connection data */
  void *ha_data[MAX_HA];
941 942

#ifndef MYSQL_CLIENT
943 944 945
  int binlog_setup_trx_data();

#ifdef HAVE_ROW_BASED_REPLICATION
946 947

  /*
948
    Public interface to write RBR events to the binlog
949
  */
950
  void binlog_start_trans_and_stmt();
951
  int binlog_write_table_map(TABLE *table, bool is_transactional);
952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971
  int binlog_write_row(TABLE* table, bool is_transactional,
                       MY_BITMAP const* cols, my_size_t colcnt,
                       const byte *buf);
  int binlog_delete_row(TABLE* table, bool is_transactional,
                        MY_BITMAP const* cols, my_size_t colcnt,
                        const byte *buf);
  int binlog_update_row(TABLE* table, bool is_transactional,
                        MY_BITMAP const* cols, my_size_t colcnt,
                        const byte *old_data, const byte *new_data);

  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,
                                      my_size_t colcnt,
                                      my_size_t needed,
972 973
                                      bool is_transactional,
				      RowsEventT* hint);
974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993
  Rows_log_event* binlog_get_pending_rows_event() const;
  void            binlog_set_pending_rows_event(Rows_log_event* ev);
  
  my_size_t max_row_length_blob(TABLE* table, const byte *data) const;
  my_size_t max_row_length(TABLE* table, const byte *data) const
  {
    TABLE_SHARE *table_s= table->s;
    my_size_t length= table_s->reclength + 2 * table_s->fields;
    if (table_s->blob_fields == 0)
      return length;

    return (length+max_row_length_blob(table,data));
  }

  my_size_t pack_row(TABLE* table, MY_BITMAP const* cols, byte *row_data,
                     const byte *data) const;

  int binlog_flush_pending_rows_event(bool stmt_end);
  void binlog_delete_pending_rows_event();

994 995 996
private:
  uint binlog_table_maps; // Number of table maps currently in the binlog
public:
997 998 999
  uint get_binlog_table_maps() const {
    return binlog_table_maps;
  }
1000
#endif /* HAVE_ROW_BASED_REPLICATION */
1001 1002
#endif /* MYSQL_CLIENT */

1003
#ifndef MYSQL_CLIENT
1004
public:
1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030
  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);
#endif

public:

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1031
  struct st_transactions {
1032
    SAVEPOINT *savepoints;
1033 1034
    THD_TRANS all;			// Trans since BEGIN WORK
    THD_TRANS stmt;			// Trans for current statement
1035
    bool on;                            // see ha_enable_transaction()
1036 1037
    XID  xid;                           // transaction identifier
    enum xa_states xa_state;            // used by external XA only
1038
    XID_STATE xid_state;
1039 1040 1041 1042
#ifdef HAVE_ROW_BASED_REPLICATION
    Rows_log_event *m_pending_rows_event;
#endif

1043
    /*
1044
       Tables changed in transaction (that must be invalidated in query cache).
1045
       List contain only transactional tables, that not invalidated in query
1046 1047 1048 1049 1050 1051
       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()
    {
1052 1053
      changed_tables= 0;
      savepoints= 0;
1054
#ifdef USING_TRANSACTIONS
1055
      free_root(&mem_root,MYF(MY_KEEP_PREALLOC));
1056
#endif
1057
    }
1058 1059
    st_transactions()
    {
1060
#ifdef USING_TRANSACTIONS
1061
      bzero((char*)this, sizeof(*this));
1062
      xid_state.xid.null();
1063
      init_sql_alloc(&mem_root, ALLOC_ROOT_MIN_BLOCK_SIZE, 0);
1064 1065
#else
      xid_state.xa_state= XA_NOTR;
1066
#endif
1067
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1068
  } transaction;
1069
  Field      *dup_field;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1070 1071 1072
#ifndef __WIN__
  sigset_t signals,block_signals;
#endif
1073 1074
#ifdef SIGNAL_WITH_VIO_CLOSE
  Vio* active_vio;
1075
#endif
1076 1077 1078 1079
  /*
    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
konstantin@mysql.com's avatar
konstantin@mysql.com committed
1080 1081
    rollback_item_tree_changes(). For conventional execution it's always
    empty.
1082 1083 1084
  */
  Item_change_list change_list;

1085
  /*
konstantin@mysql.com's avatar
konstantin@mysql.com committed
1086 1087
    A permanent memory area of the statement. For conventional
    execution, the parsed tree and execution runtime reside in the same
konstantin@mysql.com's avatar
konstantin@mysql.com committed
1088
    memory root. In this case stmt_arena points to THD. In case of
konstantin@mysql.com's avatar
konstantin@mysql.com committed
1089
    a prepared statement or a stored procedure statement, thd->mem_root
konstantin@mysql.com's avatar
konstantin@mysql.com committed
1090
    conventionally points to runtime memory, and thd->stmt_arena
konstantin@mysql.com's avatar
konstantin@mysql.com committed
1091 1092 1093
    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
konstantin@mysql.com's avatar
konstantin@mysql.com committed
1094 1095
    stmt_arena, to allow correct re-execution of PS/SP.
    Note: in the parser, stmt_arena == thd, even for PS/SP.
1096
  */
konstantin@mysql.com's avatar
konstantin@mysql.com committed
1097
  Query_arena *stmt_arena;
1098 1099
  /* Tells if LAST_INSERT_ID(#) was called for the current statement */
  bool arg_of_last_insert_id_function;
1100
  /*
1101 1102
    ALL OVER THIS FILE, "insert_id" means "*automatically generated* value for
    insertion into an auto_increment column".
1103 1104
  */
  /*
1105 1106 1107 1108 1109 1110
    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().
1111
  */
1112
  ulonglong  first_successful_insert_id_in_prev_stmt;
1113
  /*
1114 1115 1116 1117
    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).
1118
  */
1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173
  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
1174 1175 1176
    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.
1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225
    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;
  }
  /*
    Used by Intvar_log_event::exec_event() and by "SET INSERT_ID=#"
    (mysqlbinlog). We'll soon add a variant which can take many intervals in
    argument.
  */
  inline void force_one_auto_inc_interval(ulonglong next_id)
  {
1226
    auto_inc_intervals_forced.empty(); // in case of multiple SET INSERT_ID
1227 1228 1229
    auto_inc_intervals_forced.append(next_id, ULONGLONG_MAX, 0);
  }

1230
  ulonglong  limit_found_rows;
1231 1232
  ulonglong  options;           /* Bitmap of states */
  longlong   row_count_func;	/* For the ROW_COUNT() function */
1233
  ha_rows    cuted_fields,
1234
             sent_row_count, examined_row_count;
1235 1236 1237 1238 1239 1240
  /*
    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.
  */
1241
  table_map  used_tables;
1242
  USER_CONN *user_connect;
1243
  CHARSET_INFO *db_charset;
konstantin@oak.local's avatar
konstantin@oak.local committed
1244 1245 1246
  /*
    FIXME: this, and some other variables like 'count_cuted_fields'
    maybe should be statement/cursor local, that is, moved to Statement
1247 1248
    class. With current implementation warnings produced in each prepared
    statement/cursor settle here.
konstantin@oak.local's avatar
konstantin@oak.local committed
1249
  */
1250
  List	     <MYSQL_ERROR> warn_list;
1251
  uint	     warn_count[(uint) MYSQL_ERROR::WARN_LEVEL_END];
1252
  uint	     total_warn_count;
1253 1254 1255 1256 1257 1258 1259 1260
  /*
    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).
  */
1261
  query_id_t query_id, warn_id;
1262
  ulong      thread_id, col_access;
1263

1264 1265 1266
#ifdef ERROR_INJECT_SUPPORT
  ulong      error_inject_value;
#endif
1267 1268
  /* Statement id is thread-wide. This counter is used to generate ids */
  ulong      statement_id_counter;
1269
  ulong	     rand_saved_seed1, rand_saved_seed2;
1270
  ulong      row_count;  // Row counter, mainly for errors and warnings
1271
  long	     dbug_thread_id;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1272
  pthread_t  real_id;
1273
  uint	     tmp_table, global_read_lock;
1274 1275
  uint	     server_status,open_options;
  enum enum_thread_type system_thread;
1276
  uint       db_length;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1277
  uint       select_number;             //number of select (used for EXPLAIN)
1278 1279
  /* variables.transaction_isolation is reset to this after each commit */
  enum_tx_isolation session_tx_isolation;
1280
  enum_check_fields count_cuted_fields;
1281 1282 1283

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

1285
  enum killed_state { NOT_KILLED=0, KILL_BAD_DATA=1, KILL_CONNECTION=ER_SERVER_SHUTDOWN, KILL_QUERY=ER_QUERY_INTERRUPTED };
1286 1287
  killed_state volatile killed;

1288
  /* scramble - random string sent to client on handshake */
1289
  char	     scramble[SCRAMBLE_LENGTH+1];
1290

1291
  bool       slave_thread, one_shot_set;
1292 1293
  /* tells if current statement should binlog row-based(1) or stmt-based(0) */
  bool       current_stmt_binlog_row_based;
1294
  bool	     locked, some_tables_deleted;
1295
  bool       last_cuted_field;
1296
  bool	     no_errors, password, is_fatal_error;
1297
  bool	     query_start_used, rand_used, time_zone_used;
1298 1299
  /* for IS NULL => = last_insert_id() fix in remove_eq_conds() */
  bool       substitute_null_with_insert_id;
1300
  bool	     in_lock_tables;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1301
  bool       query_error, bootstrap, cleanup_done;
1302
  bool	     tmp_table_used;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1303
  bool	     charset_is_system_charset, charset_is_collation_connection;
1304
  bool       charset_is_character_set_filesystem;
1305
  bool       enable_slow_log;   /* enable slow log for current statement */
1306
  bool	     no_trans_update, abort_on_warning;
mskold@mysql.com's avatar
Merge  
mskold@mysql.com committed
1307
  bool 	     got_warning;       /* Set on call to push_warning() */
1308
  bool	     no_warnings_for_error; /* no warnings on call to my_error() */
1309 1310
  /* set during loop of derived table processing */
  bool       derived_tables_processing;
1311 1312
  my_bool    tablespace_op;	/* This is TRUE in DISCARD/IMPORT TABLESPACE */

1313
  sp_rcontext *spcont;		// SP runtime context
1314 1315
  sp_cache   *sp_proc_cache;
  sp_cache   *sp_func_cache;
1316

1317 1318 1319 1320 1321
  /*
    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
  */
1322
  LOG_INFO*  current_linfo;
1323
  NET*       slave_net;			// network connection from slave -> m.
1324 1325 1326
  /* Used by the sys_var class to store temporary values */
  union
  {
1327 1328 1329 1330
    my_bool   my_bool_value;
    long      long_value;
    ulong     ulong_value;
    ulonglong ulonglong_value;
1331
  } sys_var_tmp;
1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350
  
  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;
1351 1352 1353 1354 1355 1356
    
    /* 
      'queries' (actually SP statements) that run under inside this binlog
      union have thd->query_id >= first_query_id.
    */
    query_id_t first_query_id;
1357
  } binlog_evt_union;
holyfoot@vva.(none)'s avatar
holyfoot@vva.(none) committed
1358
#ifdef WITH_PARTITION_STORAGE_ENGINE
1359
  partition_info *work_part_info;
holyfoot@vva.(none)'s avatar
holyfoot@vva.(none) committed
1360
#endif
1361
  
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1362 1363
  THD();
  ~THD();
1364

1365
  void init(void);
1366 1367 1368 1369 1370 1371 1372 1373 1374 1375
  /*
    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();
1376
  void change_user(void);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1377
  void cleanup(void);
1378
  void cleanup_after_query();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1379
  bool store_globals();
1380 1381
#ifdef SIGNAL_WITH_VIO_CLOSE
  inline void set_active_vio(Vio* vio)
1382
  {
1383
    pthread_mutex_lock(&LOCK_delete);
1384
    active_vio = vio;
1385
    pthread_mutex_unlock(&LOCK_delete);
1386
  }
1387
  inline void clear_active_vio()
1388
  {
1389
    pthread_mutex_lock(&LOCK_delete);
1390
    active_vio = 0;
1391
    pthread_mutex_unlock(&LOCK_delete);
1392
  }
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1393
  void close_active_vio();
1394
#endif
hf@genie.(none)'s avatar
SCRUM  
hf@genie.(none) committed
1395
  void awake(THD::killed_state state_to_set);
1396 1397
  /*
    For enter_cond() / exit_cond() to work the mutex must be got before
1398 1399
    enter_cond(); this mutex is then released by exit_cond().
    Usage must be: lock mutex; enter_cond(); your code; exit_cond().
1400
  */
1401 1402 1403 1404
  inline const char* enter_cond(pthread_cond_t *cond, pthread_mutex_t* mutex,
			  const char* msg)
  {
    const char* old_msg = proc_info;
1405
    safe_mutex_assert_owner(mutex);
1406 1407 1408 1409 1410 1411 1412
    mysys_var->current_mutex = mutex;
    mysys_var->current_cond = cond;
    proc_info = msg;
    return old_msg;
  }
  inline void exit_cond(const char* old_msg)
  {
guilhem@mysql.com's avatar
guilhem@mysql.com committed
1413 1414 1415 1416 1417 1418 1419
    /*
      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);
1420 1421 1422 1423 1424 1425
    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);
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1426
  inline time_t query_start() { query_start_used=1; return start_time; }
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1427
  inline void	set_time()    { if (user_time) start_time=time_after_lock=user_time; else time_after_lock=time(&start_time); }
1428
  inline void	end_time()    { time(&start_time); }
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1429
  inline void	set_time(time_t t) { time_after_lock=start_time=user_time=t; }
1430
  inline void	lock_time()   { time(&time_after_lock); }
1431 1432 1433
  inline ulonglong found_rows(void)
  {
    return limit_found_rows;
1434
  }
1435 1436
  inline bool active_transaction()
  {
1437 1438
#ifdef USING_TRANSACTIONS
    return server_status & SERVER_STATUS_IN_TRANS;
1439 1440 1441
#else
    return 0;
#endif
1442
  }
1443 1444
  inline bool fill_derived_tables()
  {
konstantin@mysql.com's avatar
konstantin@mysql.com committed
1445
    return !stmt_arena->is_stmt_prepare() && !lex->only_view_structure();
1446
  }
1447 1448 1449 1450
  inline bool fill_information_schema_tables()
  {
    return !stmt_arena->is_stmt_prepare();
  }
1451 1452
  inline gptr trans_alloc(unsigned int size)
  {
1453 1454
    return alloc_root(&transaction.mem_root,size);
  }
1455 1456 1457 1458

  bool convert_string(LEX_STRING *to, CHARSET_INFO *to_cs,
		      const char *from, uint from_length,
		      CHARSET_INFO *from_cs);
1459 1460 1461

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

1462
  void add_changed_table(TABLE *table);
1463 1464
  void add_changed_table(const char *key, long key_length);
  CHANGED_TABLE_LIST * changed_table_dup(const char *key, long key_length);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1465
  int send_explain_fields(select_result *result);
1466
#ifndef EMBEDDED_LIBRARY
1467 1468
  inline void clear_error()
  {
1469
    DBUG_ENTER("clear_error");
1470 1471 1472
    net.last_error[0]= 0;
    net.last_errno= 0;
    net.report_error= 0;
1473
    query_error= 0;
1474
    DBUG_VOID_RETURN;
1475
  }
1476
  inline bool vio_ok() const { return net.vio != 0; }
1477 1478
#else
  void clear_error();
1479
  inline bool vio_ok() const { return true; }
1480
#endif
1481 1482 1483
  inline void fatal_error()
  {
    is_fatal_error= 1;
serg@serg.mylan's avatar
serg@serg.mylan committed
1484
    net.report_error= 1;
1485
    DBUG_PRINT("error",("Fatal error set"));
1486
  }
1487
  inline CHARSET_INFO *charset() { return variables.character_set_client; }
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1488
  void update_charset();
1489

konstantin@mysql.com's avatar
konstantin@mysql.com committed
1490
  inline Query_arena *activate_stmt_arena_if_needed(Query_arena *backup)
1491 1492
  {
    /*
konstantin@mysql.com's avatar
konstantin@mysql.com committed
1493 1494
      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.
1495
    */
konstantin@mysql.com's avatar
konstantin@mysql.com committed
1496
    if (!stmt_arena->is_conventional() && mem_root != stmt_arena->mem_root)
1497
    {
konstantin@mysql.com's avatar
konstantin@mysql.com committed
1498 1499
      set_n_backup_active_arena(stmt_arena, backup);
      return stmt_arena;
1500 1501 1502 1503
    }
    return 0;
  }

1504
  void change_item_tree(Item **place, Item *new_value)
1505
  {
1506
    /* TODO: check for OOM condition here */
konstantin@mysql.com's avatar
konstantin@mysql.com committed
1507
    if (!stmt_arena->is_conventional())
1508
      nocheck_register_item_tree_change(place, *place, mem_root);
1509
    *place= new_value;
1510 1511
  }
  void nocheck_register_item_tree_change(Item **place, Item *old_value,
1512
                                         MEM_ROOT *runtime_memroot);
1513
  void rollback_item_tree_changes();
1514 1515 1516 1517 1518 1519

  /*
    Cleanup statement parse state (parse tree, lex) and execution
    state after execution of a non-prepared SQL statement.
  */
  void end_statement();
1520 1521
  inline int killed_errno() const
  {
1522
    return killed != KILL_BAD_DATA ? killed : 0;
1523 1524 1525
  }
  inline void send_kill_message() const
  {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1526
    int err= killed_errno();
1527 1528
    if (err)
      my_message(err, ER(err), MYF(0));
1529
  }
1530 1531 1532 1533 1534 1535 1536
  /* return TRUE if we will abort query if we make a warning now */
  inline bool really_abort_on_warning()
  {
    return (abort_on_warning &&
            (!no_trans_update ||
             (variables.sql_mode & MODE_STRICT_ALL_TABLES)));
  }
1537
  void set_status_var_init();
1538
  bool is_context_analysis_only()
konstantin@mysql.com's avatar
konstantin@mysql.com committed
1539
    { return stmt_arena->is_stmt_prepare() || lex->view_prepare_mode; }
1540 1541
  void reset_n_backup_open_tables_state(Open_tables_state *backup);
  void restore_backup_open_tables_state(Open_tables_state *backup);
1542 1543
  void reset_sub_statement_state(Sub_statement_state *backup, uint new_state);
  void restore_sub_statement_state(Sub_statement_state *backup);
konstantin@mysql.com's avatar
konstantin@mysql.com committed
1544 1545
  void set_n_backup_active_arena(Query_arena *set, Query_arena *backup);
  void restore_active_arena(Query_arena *set, Query_arena *backup);
1546 1547
  inline void set_current_stmt_binlog_row_based_if_mixed()
  {
1548
#ifdef HAVE_ROW_BASED_REPLICATION
1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559
    /*
      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))
1560
      current_stmt_binlog_row_based= TRUE;
1561
#endif
1562 1563 1564
  }
  inline void set_current_stmt_binlog_row_based()
  {
1565
#ifdef HAVE_ROW_BASED_REPLICATION
1566
    current_stmt_binlog_row_based= TRUE;
1567
#endif
1568
  }
1569 1570
  inline void clear_current_stmt_binlog_row_based()
  {
1571
#ifdef HAVE_ROW_BASED_REPLICATION
1572
    current_stmt_binlog_row_based= FALSE;
1573
#endif
1574
  }
1575 1576
  inline void reset_current_stmt_binlog_row_based()
  {
1577
#ifdef HAVE_ROW_BASED_REPLICATION
1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591
    /*
      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...).
1592 1593

      Don't reset binlog format for NDB binlog injector thread.
1594
    */
1595 1596
    if ((temporary_tables == NULL) && (in_sub_stmt == 0) &&
        (system_thread != SYSTEM_THREAD_NDBCLUSTER_BINLOG))
1597 1598 1599 1600
    {
      current_stmt_binlog_row_based= 
        test(variables.binlog_format == BINLOG_FORMAT_ROW);
    }
1601 1602 1603
#else
    current_stmt_binlog_row_based= FALSE;
#endif
1604
  }
1605 1606 1607

  /*
    Initialize the current database from a NULL-terminated string with length
1608 1609 1610
    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).
1611
  */
1612
  bool set_db(const char *new_db, uint new_db_len)
1613
  {
1614 1615 1616 1617
    /* 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
1618
    {
kostja@bodhi.local's avatar
kostja@bodhi.local committed
1619 1620
      x_free(db);
      db= new_db ? my_strndup(new_db, new_db_len, MYF(MY_WME)) : NULL;
1621
    }
1622 1623
    db_length= db ? new_db_len : 0;
    return new_db && !db;
1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642
  }
  void reset_db(char *new_db, uint new_db_len)
  {
    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.
  */
  bool copy_db_to(char **p_db, uint *p_db_length)
  {
    if (db == NULL)
    {
      my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
      return TRUE;
    }
    *p_db= strmake(db, db_length);
1643
    *p_db_length= db_length;
1644 1645
    return FALSE;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1646 1647
};

1648

1649
#define tmp_disable_binlog(A)       \
1650
  {ulonglong tmp_disable_binlog__save_options= (A)->options; \
1651
  (A)->options&= ~OPTION_BIN_LOG
1652

1653
#define reenable_binlog(A)   (A)->options= tmp_disable_binlog__save_options;}
1654

1655

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1656 1657 1658
/*
  Used to hold information about file and file structure in exchainge 
  via non-DB file (...INTO OUTFILE..., ...LOAD DATA...)
1659
  XXX: We never call destructor for objects of this class.
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1660
*/
1661

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1662 1663 1664 1665 1666 1667 1668
class sql_exchange :public Sql_alloc
{
public:
  char *file_name;
  String *field_term,*enclosed,*line_term,*line_start,*escaped;
  bool opt_enclosed;
  bool dumpfile;
1669
  ulong skip_lines;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1670 1671 1672 1673 1674 1675
  sql_exchange(char *name,bool dumpfile_flag);
};

#include "log_event.h"

/*
1676
  This is used to get result from a select
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1677 1678
*/

1679 1680
class JOIN;

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1681 1682 1683
class select_result :public Sql_alloc {
protected:
  THD *thd;
1684
  SELECT_LEX_UNIT *unit;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1685 1686 1687
public:
  select_result();
  virtual ~select_result() {};
1688 1689 1690 1691 1692
  virtual int prepare(List<Item> &list, SELECT_LEX_UNIT *u)
  {
    unit= u;
    return 0;
  }
1693
  virtual int prepare2(void) { return 0; }
1694 1695 1696 1697 1698 1699 1700
  /*
    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; }
1701
  virtual bool send_fields(List<Item> &list, uint flags)=0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1702
  virtual bool send_data(List<Item> &items)=0;
1703
  virtual bool initialize_tables (JOIN *join=0) { return 0; }
1704
  virtual void send_error(uint errcode,const char *err);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1705
  virtual bool send_eof()=0;
1706 1707 1708 1709 1710 1711 1712 1713
  /**
    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;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1714
  virtual void abort() {}
1715 1716 1717 1718 1719
  /*
    Cleanup instance of this class for next execution of a prepared
    statement/stored procedure.
  */
  virtual void cleanup();
1720
  void set_thd(THD *thd_arg) { thd= thd_arg; }
1721 1722 1723 1724 1725
#ifdef EMBEDDED_LIBRARY
  virtual void begin_dataset() {}
#else
  void begin_dataset() {}
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1726 1727 1728
};


1729 1730 1731 1732 1733 1734 1735 1736 1737
/*
  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:
1738
  select_result_interceptor() {}              /* Remove gcc warning */
1739 1740 1741 1742 1743
  uint field_count(List<Item> &fields) const { return 0; }
  bool send_fields(List<Item> &fields, uint flag) { return FALSE; }
};


bk@work.mysql.com's avatar
bk@work.mysql.com committed
1744
class select_send :public select_result {
1745
  int status;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1746
public:
1747
  select_send() :status(0) {}
1748
  bool send_fields(List<Item> &list, uint flags);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1749 1750
  bool send_data(List<Item> &items);
  bool send_eof();
1751
  virtual bool check_simple_select() const { return FALSE; }
1752
  void abort();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1753 1754 1755
};


1756
class select_to_file :public select_result_interceptor {
1757
protected:
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1758 1759 1760 1761
  sql_exchange *exchange;
  File file;
  IO_CACHE cache;
  ha_rows row_count;
1762 1763 1764 1765 1766 1767 1768
  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);
1769 1770
  bool send_eof();
  void cleanup();
1771 1772 1773 1774
};


class select_export :public select_to_file {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1775 1776 1777 1778
  uint field_term_length;
  int field_sep_char,escape_char,line_sep_char;
  bool fixed_row_size;
public:
1779
  select_export(sql_exchange *ex) :select_to_file(ex) {}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1780
  ~select_export();
1781
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1782 1783 1784
  bool send_data(List<Item> &items);
};

monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
1785

1786
class select_dump :public select_to_file {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1787
public:
1788
  select_dump(sql_exchange *ex) :select_to_file(ex) {}
1789
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1790 1791
  bool send_data(List<Item> &items);
};
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
1792 1793


1794
class select_insert :public select_result_interceptor {
1795
 public:
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1796
  TABLE_LIST *table_list;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1797 1798
  TABLE *table;
  List<Item> *fields;
1799
  ulonglong autoinc_value_of_last_inserted_row; // autogenerated or not
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1800
  COPY_INFO info;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1801
  bool insert_into_view;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1802

monty@mishka.local's avatar
monty@mishka.local committed
1803 1804
  select_insert(TABLE_LIST *table_list_par,
		TABLE *table_par, List<Item> *fields_par,
1805
		List<Item> *update_fields, List<Item> *update_values,
1806
		enum_duplicates duplic, bool ignore);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1807
  ~select_insert();
1808
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
1809
  int prepare2(void);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1810
  bool send_data(List<Item> &items);
serg@serg.mylan's avatar
serg@serg.mylan committed
1811
  virtual void store_values(List<Item> &values);
1812
  virtual bool can_rollback_data() { return 0; }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1813 1814
  void send_error(uint errcode,const char *err);
  bool send_eof();
1815 1816
  /* not implemented: select_insert is never re-used in prepared statements */
  void cleanup();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1817 1818
};

monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
1819

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1820 1821
class select_create: public select_insert {
  ORDER *group;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1822
  TABLE_LIST *create_table;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1823 1824 1825 1826 1827
  List<create_field> *extra_fields;
  List<Key> *keys;
  HA_CREATE_INFO *create_info;
  Field **field;
public:
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1828 1829 1830 1831
  select_create (TABLE_LIST *table,
		 HA_CREATE_INFO *create_info_par,
		 List<create_field> &fields_par,
		 List<Key> &keys_par,
1832
		 List<Item> &select_fields,enum_duplicates duplic, bool ignore)
1833 1834
    :select_insert (NULL, NULL, &select_fields, 0, 0, duplic, ignore),
    create_table(table), extra_fields(&fields_par),keys(&keys_par),
lars@mysql.com's avatar
lars@mysql.com committed
1835
    create_info(create_info_par)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1836
    {}
1837
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
1838

1839
  void binlog_show_create_table(TABLE **tables, uint count);
serg@serg.mylan's avatar
serg@serg.mylan committed
1840
  void store_values(List<Item> &values);
1841
  void send_error(uint errcode,const char *err);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1842 1843
  bool send_eof();
  void abort();
1844 1845
  virtual bool can_rollback_data() { return 1; }

1846
  // Needed for access from local class MY_HOOKS in prepare(), since thd is proteted.
1847 1848
  const THD *get_thd(void) { return thd; }
  const HA_CREATE_INFO *get_create_info() { return create_info; };
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1849 1850
};

1851 1852
#include <myisam.h>

sergefp@mysql.com's avatar
sergefp@mysql.com committed
1853 1854 1855 1856 1857
/* 
  Param to create temporary tables when doing SELECT:s 
  NOTE
    This structure is copied using memcpy as a part of JOIN.
*/
1858 1859 1860

class TMP_TABLE_PARAM :public Sql_alloc
{
1861 1862 1863 1864 1865 1866
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:
1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880
  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;
  byte	    *group_buff;
  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;
1881 1882
  /* If >0 convert all blob fields to varchar(convert_blob_length) */
  uint  convert_blob_length; 
1883
  CHARSET_INFO *table_charset; 
1884
  bool schema_table;
1885 1886 1887 1888 1889 1890 1891
  /*
    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;
1892
  bool force_copy_fields;
1893 1894

  TMP_TABLE_PARAM()
sergefp@mysql.com's avatar
sergefp@mysql.com committed
1895
    :copy_field(0), group_parts(0),
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
1896
     group_length(0), group_null_parts(0), convert_blob_length(0),
evgen@sunlight.local's avatar
evgen@sunlight.local committed
1897
     schema_table(0), precomputed_group_by(0), force_copy_fields(0)
1898 1899 1900 1901 1902
  {}
  ~TMP_TABLE_PARAM()
  {
    cleanup();
  }
1903
  void init(void);
1904 1905 1906 1907 1908
  inline void cleanup(void)
  {
    if (copy_field)				/* Fix for Intel compiler */
    {
      delete [] copy_field;
1909
      save_copy_field= copy_field= 0;
1910 1911 1912 1913
    }
  }
};

1914 1915
class select_union :public select_result_interceptor
{
1916
  TMP_TABLE_PARAM tmp_table_param;
1917 1918
public:
  TABLE *table;
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
1919

1920
  select_union() :table(0) {}
1921
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
1922 1923 1924
  bool send_data(List<Item> &items);
  bool send_eof();
  bool flush();
1925 1926 1927 1928

  bool create_result_table(THD *thd, List<Item> *column_types,
                           bool is_distinct, ulonglong options,
                           const char *alias);
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
1929 1930
};

1931
/* Base subselect interface class */
1932
class select_subselect :public select_result_interceptor
1933
{
1934
protected:
1935 1936 1937
  Item_subselect *item;
public:
  select_subselect(Item_subselect *item);
1938
  bool send_data(List<Item> &items)=0;
1939 1940 1941
  bool send_eof() { return 0; };
};

1942
/* Single value subselect interface class */
1943
class select_singlerow_subselect :public select_subselect
1944 1945
{
public:
1946
  select_singlerow_subselect(Item_subselect *item):select_subselect(item){}
1947 1948 1949
  bool send_data(List<Item> &items);
};

1950 1951 1952 1953 1954 1955 1956 1957 1958 1959
/* 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:
  select_max_min_finder_subselect(Item_subselect *item, bool mx)
    :select_subselect(item), cache(0), fmax(mx)
  {}
mskold@mysql.com's avatar
Merge  
mskold@mysql.com committed
1960
  void cleanup();
1961 1962 1963
  bool send_data(List<Item> &items);
  bool cmp_real();
  bool cmp_int();
mskold@mysql.com's avatar
Merge  
mskold@mysql.com committed
1964
  bool cmp_decimal();
1965 1966 1967
  bool cmp_str();
};

1968 1969 1970 1971 1972 1973 1974 1975
/* EXISTS subselect interface class */
class select_exists_subselect :public select_subselect
{
public:
  select_exists_subselect(Item_subselect *item):select_subselect(item){}
  bool send_data(List<Item> &items);
};

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1976 1977 1978 1979 1980 1981
/* 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 */
1982
  uint   suffix_length;                 /* Length suffix (0-4) */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1983
  Item_result result_type;		/* Type of item */
1984 1985
  bool reverse;				/* if descending sort */
  bool need_strxnfrm;			/* If we have to use strxnfrm() */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998
} 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 */

1999 2000
class Table_ident :public Sql_alloc
{
2001
public:
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2002 2003
  LEX_STRING db;
  LEX_STRING table;
2004
  SELECT_LEX_UNIT *sel;
2005 2006
  inline Table_ident(THD *thd, LEX_STRING db_arg, LEX_STRING table_arg,
		     bool force)
2007
    :table(table_arg), sel((SELECT_LEX_UNIT *)0)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2008
  {
2009
    if (!force && (thd->client_capabilities & CLIENT_NO_SCHEMA))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2010 2011 2012 2013
      db.str=0;
    else
      db= db_arg;
  }
2014 2015 2016 2017 2018
  inline Table_ident(LEX_STRING table_arg) 
    :table(table_arg), sel((SELECT_LEX_UNIT *)0)
  {
    db.str=0;
  }
2019 2020 2021 2022 2023 2024
  /*
    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.
  */
grog@mysql.com[grog]'s avatar
foo1  
grog@mysql.com[grog] committed
2025
  inline Table_ident(SELECT_LEX_UNIT *s) : sel(s)
2026
  {
2027
    /* We must have a table name here as this is used with add_table_to_list */
2028 2029 2030 2031
    db.str= empty_c_string;                    /* a subject to casedn_str */
    db.length= 0;
    table.str= internal_table_name;
    table.length=1;
2032
  }
2033
  bool is_derived_table() const { return test(sel); }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2034
  inline void change_db(char *db_name)
2035 2036 2037
  {
    db.str= db_name; db.length= (uint) strlen(db_name);
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2038 2039 2040 2041 2042 2043
};

// this is needed for user_vars hash
class user_var_entry
{
 public:
2044
  user_var_entry() {}                         /* Remove gcc warning */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2045 2046
  LEX_STRING name;
  char *value;
2047 2048
  ulong length;
  query_id_t update_query_id, used_query_id;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2049
  Item_result type;
2050
  bool unsigned_flag;
2051

mskold@mysql.com's avatar
Merge  
mskold@mysql.com committed
2052
  double val_real(my_bool *null_value);
2053 2054
  longlong val_int(my_bool *null_value);
  String *val_str(my_bool *null_value, String *str, uint decimals);
mskold@mysql.com's avatar
Merge  
mskold@mysql.com committed
2055
  my_decimal *val_decimal(my_bool *null_value, my_decimal *result);
2056
  DTCollation collation;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2057 2058
};

2059 2060 2061 2062 2063 2064 2065
/*
   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.
 */
2066 2067 2068 2069

class Unique :public Sql_alloc
{
  DYNAMIC_ARRAY file_ptrs;
2070 2071
  ulong max_elements;
  ulonglong max_in_memory_size;
2072 2073
  IO_CACHE file;
  TREE tree;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2074
  byte *record_pointers;
2075
  bool flush();
2076
  uint size;
2077 2078 2079

public:
  ulong elements;
2080
  Unique(qsort_cmp2 comp_func, void *comp_func_fixed_arg,
2081
	 uint size_arg, ulonglong max_in_memory_size_arg);
2082
  ~Unique();
2083
  ulong elements_in_tree() { return tree.elements_in_tree; }
2084
  inline bool unique_add(void *ptr)
2085
  {
mskold@mysql.com's avatar
Merge  
mskold@mysql.com committed
2086
    DBUG_ENTER("unique_add");
2087
    DBUG_PRINT("info", ("tree %u - %lu", tree.elements_in_tree, max_elements));
2088
    if (tree.elements_in_tree > max_elements && flush())
mskold@mysql.com's avatar
Merge  
mskold@mysql.com committed
2089 2090
      DBUG_RETURN(1);
    DBUG_RETURN(!tree_insert(&tree, ptr, 0, tree.custom_arg));
2091 2092 2093
  }

  bool get(TABLE *table);
2094
  static double get_use_cost(uint *buffer, uint nkeys, uint key_size, 
2095
                             ulonglong max_in_memory_size);
2096
  inline static int get_cost_calc_buff_size(ulong nkeys, uint key_size, 
2097
                                            ulonglong max_in_memory_size)
2098
  {
2099
    register ulonglong max_elems_in_tree=
2100
      (1 + max_in_memory_size / ALIGN_SIZE(sizeof(TREE_ELEMENT)+key_size));
2101
    return (int) (sizeof(uint)*(1 + nkeys/max_elems_in_tree));
2102 2103
  }

2104 2105 2106
  void reset();
  bool walk(tree_walk_action action, void *walk_action_arg);

2107 2108
  friend int unique_write_to_file(gptr key, element_count count, Unique *unique);
  friend int unique_write_to_ptrs(gptr key, element_count count, Unique *unique);
2109
};
2110

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2111

2112
class multi_delete :public select_result_interceptor
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2113 2114
{
  TABLE_LIST *delete_tables, *table_being_deleted;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2115
  Unique **tempfiles;
2116
  ha_rows deleted, found;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2117 2118
  uint num_of_tables;
  int error;
2119 2120 2121 2122 2123 2124
  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;
2125

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2126
public:
2127
  multi_delete(TABLE_LIST *dt, uint num_of_tables);
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2128 2129 2130 2131 2132
  ~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);
2133
  int  do_deletes();
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2134 2135 2136
  bool send_eof();
};

2137

2138
class multi_update :public select_result_interceptor
2139
{
2140 2141 2142
  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;
2143
  TABLE **tmp_tables, *main_table, *table_to_update;
2144 2145 2146 2147 2148 2149 2150
  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;
  Copy_field *copy_field;
  enum enum_duplicates handle_duplicates;
2151 2152 2153 2154
  bool do_update, trans_safe;
  /* True if the update operation has made a change in a transactional table */
  bool transactional_tables;
  bool ignore;
2155 2156

public:
2157
  multi_update(TABLE_LIST *ut, TABLE_LIST *leaves_list,
2158
	       List<Item> *fields, List<Item> *values,
2159
	       enum_duplicates handle_duplicates, bool ignore);
2160
  ~multi_update();
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2161
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
2162 2163 2164 2165 2166 2167
  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();
};
2168

2169 2170 2171
class my_var : public Sql_alloc  {
public:
  LEX_STRING s;
2172
#ifndef DBUG_OFF
2173 2174 2175 2176
  /*
    Routine to which this Item_splocal belongs. Used for checking if correct
    runtime context is used for variable handling.
  */
2177
  sp_head *sp;
2178
#endif
2179 2180
  bool local;
  uint offset;
2181 2182 2183 2184
  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)
  {}
2185 2186
  ~my_var() {}
};
2187

2188
class select_dumpvar :public select_result_interceptor {
Sinisa@sinisa.nasamreza.org's avatar
Sinisa@sinisa.nasamreza.org committed
2189 2190
  ha_rows row_count;
public:
2191
  List<my_var> var_list;
2192
  List<Item_func_set_user_var> vars;
2193 2194
  List<Item_splocal> local_vars;
  select_dumpvar(void)  { var_list.empty(); local_vars.empty(); vars.empty(); row_count=0;}
Sinisa@sinisa.nasamreza.org's avatar
Sinisa@sinisa.nasamreza.org committed
2195
  ~select_dumpvar() {}
2196
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
Sinisa@sinisa.nasamreza.org's avatar
Sinisa@sinisa.nasamreza.org committed
2197 2198
  bool send_data(List<Item> &items);
  bool send_eof();
2199
  virtual bool check_simple_select() const;
2200
  void cleanup();
Sinisa@sinisa.nasamreza.org's avatar
Sinisa@sinisa.nasamreza.org committed
2201
};
2202

2203 2204 2205 2206 2207 2208 2209
/* 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

2210 2211 2212
/* Functions in sql_class.cc */

void add_to_status(STATUS_VAR *to_var, STATUS_VAR *from_var);
2213 2214
void add_diff_to_status(STATUS_VAR *to_var, STATUS_VAR *from_var,
                        STATUS_VAR *dec_var);
2215
#endif /* MYSQL_SERVER */