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

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

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

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


/* Classes in mysql */

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

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

unknown's avatar
unknown committed
26
/**
27
  An interface that is used to take an action when
unknown's avatar
unknown committed
28 29 30 31 32 33 34 35 36 37 38
  the locking module notices that a table version has changed
  since the last execution. "Table" here may refer to any kind of
  table -- a base table, a temporary table, a view or an
  information schema table.

  When we open and lock tables for execution of a prepared
  statement, we must verify that they did not change
  since statement prepare. If some table did change, the statement
  parse tree *may* be no longer valid, e.g. in case it contains
  optimizations that depend on table metadata.

39
  This class provides an interface (a method) that is
unknown's avatar
unknown committed
40
  invoked when such a situation takes place.
41 42
  The implementation of the method simply reports an error, but
  the exact details depend on the nature of the SQL statement.
unknown's avatar
unknown committed
43 44

  At most 1 instance of this class is active at a time, in which
45
  case THD::m_reprepare_observer is not NULL.
unknown's avatar
unknown committed
46

47
  @sa check_and_update_table_version() for details of the
unknown's avatar
unknown committed
48 49
  version tracking algorithm 

50
  @sa Open_tables_state::m_reprepare_observer for the life cycle
unknown's avatar
unknown committed
51 52 53
  of metadata observers.
*/

54
class Reprepare_observer
unknown's avatar
unknown committed
55 56 57 58 59 60 61 62
{
public:
  /**
    Check if a change of metadata is OK. In future
    the signature of this method may be extended to accept the old
    and the new versions, but since currently the check is very
    simple, we only need the THD to report an error.
  */
63 64 65 66 67
  bool report_error(THD *thd);
  bool is_invalidated() const { return m_invalidated; }
  void reset_reprepare_observer() { m_invalidated= FALSE; }
private:
  bool m_invalidated;
unknown's avatar
unknown committed
68 69 70
};


71
class Relay_log_info;
72

unknown's avatar
unknown committed
73 74
class Query_log_event;
class Load_log_event;
75
class Slave_log_event;
76
class sp_rcontext;
77
class sp_cache;
78
class Lex_input_stream;
79
class Rows_log_event;
unknown's avatar
unknown committed
80

81
enum enum_enable_or_disable { LEAVE_AS_IS, ENABLE, DISABLE };
82
enum enum_ha_read_modes { RFIRST, RNEXT, RPREV, RLAST, RKEY, RNEXT_SAME };
83
enum enum_duplicates { DUP_ERROR, DUP_REPLACE, DUP_UPDATE };
84 85
enum enum_delay_key_write { DELAY_KEY_WRITE_NONE, DELAY_KEY_WRITE_ON,
			    DELAY_KEY_WRITE_ALL };
86 87 88
enum enum_slave_exec_mode { SLAVE_EXEC_MODE_STRICT,
                            SLAVE_EXEC_MODE_IDEMPOTENT,
                            SLAVE_EXEC_MODE_LAST_BIT};
89 90
enum enum_mark_columns
{ MARK_COLUMNS_NONE, MARK_COLUMNS_READ, MARK_COLUMNS_WRITE};
91

unknown's avatar
unknown committed
92
extern char internal_table_name[2];
93
extern char empty_c_string[1];
unknown's avatar
unknown committed
94
extern const char **errmesg;
unknown's avatar
unknown committed
95

96 97 98 99 100 101 102
#define TC_LOG_PAGE_SIZE   8192
#define TC_LOG_MIN_SIZE    (3*TC_LOG_PAGE_SIZE)

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

unknown's avatar
unknown committed
103 104 105 106 107 108 109 110 111
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;

112 113 114
#define RP_LOCK_LOG_IS_ALREADY_LOCKED 1
#define RP_FORCE_ROTATE               2

115 116 117 118 119 120 121 122 123 124 125 126
/*
  The COPY_INFO structure is used by INSERT/REPLACE code.
  The schema of the row counting by the INSERT/INSERT ... ON DUPLICATE KEY
  UPDATE code:
    If a row is inserted then the copied variable is incremented.
    If a row is updated by the INSERT ... ON DUPLICATE KEY UPDATE and the
      new data differs from the old one then the copied and the updated
      variables are incremented.
    The touched variable is incremented if a row was touched by the update part
      of the INSERT ... ON DUPLICATE KEY UPDATE no matter whether the row
      was actually changed or not.
*/
unknown's avatar
unknown committed
127
typedef struct st_copy_info {
unknown's avatar
unknown committed
128 129 130 131
  ha_rows records; /**< Number of processed records */
  ha_rows deleted; /**< Number of deleted records */
  ha_rows updated; /**< Number of updated records */
  ha_rows copied;  /**< Number of copied records */
132
  ha_rows error_count;
133
  ha_rows touched; /* Number of touched records */
unknown's avatar
unknown committed
134
  enum enum_duplicates handle_duplicates;
135
  int escape_char, last_errno;
136 137
  bool ignore;
  /* for INSERT ... UPDATE */
138 139
  List<Item> *update_fields;
  List<Item> *update_values;
unknown's avatar
unknown committed
140
  /* for VIEW ... WITH CHECK OPTION */
unknown's avatar
unknown committed
141
  TABLE_LIST *view;
unknown's avatar
unknown committed
142 143 144
} COPY_INFO;


unknown's avatar
unknown committed
145
class Key_part_spec :public Sql_alloc {
unknown's avatar
unknown committed
146 147 148
public:
  const char *field_name;
  uint length;
unknown's avatar
unknown committed
149 150
  Key_part_spec(const char *name,uint len=0) :field_name(name), length(len) {}
  bool operator==(const Key_part_spec& other) const;
151
  /**
unknown's avatar
unknown committed
152
    Construct a copy of this Key_part_spec. field_name is copied
153 154 155 156 157 158 159
    by-pointer as it is known to never change. At the same time
    'length' may be reset in mysql_prepare_create_table, and this
    is why we supply it with a copy.

    @return If out of memory, 0 is returned and an error is set in
    THD.
  */
unknown's avatar
unknown committed
160 161
  Key_part_spec *clone(MEM_ROOT *mem_root) const
  { return new (mem_root) Key_part_spec(*this); }
unknown's avatar
unknown committed
162 163 164 165 166 167 168 169 170 171
};


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) {}
172 173
  /**
    Used to make a clone of this object for ALTER/CREATE TABLE
unknown's avatar
unknown committed
174
    @sa comment for Key_part_spec::clone
175 176 177
  */
  Alter_drop *clone(MEM_ROOT *mem_root) const
    { return new (mem_root) Alter_drop(*this); }
unknown's avatar
unknown committed
178 179 180 181 182 183 184 185 186
};


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) {}
187 188
  /**
    Used to make a clone of this object for ALTER/CREATE TABLE
unknown's avatar
unknown committed
189
    @sa comment for Key_part_spec::clone
190 191 192
  */
  Alter_column *clone(MEM_ROOT *mem_root) const
    { return new (mem_root) Alter_column(*this); }
unknown's avatar
unknown committed
193 194 195 196 197
};


class Key :public Sql_alloc {
public:
198
  enum Keytype { PRIMARY, UNIQUE, MULTIPLE, FULLTEXT, SPATIAL, FOREIGN_KEY};
unknown's avatar
unknown committed
199
  enum Keytype type;
unknown's avatar
unknown committed
200
  KEY_CREATE_INFO key_create_info;
unknown's avatar
unknown committed
201
  List<Key_part_spec> columns;
202
  const char *name;
203
  bool generated;
unknown's avatar
unknown committed
204

205 206
  Key(enum Keytype type_par, const char *name_arg,
      KEY_CREATE_INFO *key_info_arg,
unknown's avatar
unknown committed
207
      bool generated_arg, List<Key_part_spec> &cols)
unknown's avatar
unknown committed
208 209
    :type(type_par), key_create_info(*key_info_arg), columns(cols),
    name(name_arg), generated(generated_arg)
210
  {}
211 212
  Key(const Key &rhs, MEM_ROOT *mem_root);
  virtual ~Key() {}
213
  /* Equality comparison of keys (ignoring name) */
214
  friend bool foreign_key_prefix(Key *a, Key *b);
215 216
  /**
    Used to make a clone of this object for ALTER/CREATE TABLE
unknown's avatar
unknown committed
217
    @sa comment for Key_part_spec::clone
218 219 220
  */
  virtual Key *clone(MEM_ROOT *mem_root) const
    { return new (mem_root) Key(*this, mem_root); }
unknown's avatar
unknown committed
221 222
};

223 224
class Table_ident;

unknown's avatar
unknown committed
225
class Foreign_key: public Key {
226 227 228 229 230 231 232
public:
  enum fk_match_opt { FK_MATCH_UNDEF, FK_MATCH_FULL,
		      FK_MATCH_PARTIAL, FK_MATCH_SIMPLE};
  enum fk_option { FK_OPTION_UNDEF, FK_OPTION_RESTRICT, FK_OPTION_CASCADE,
		   FK_OPTION_SET_NULL, FK_OPTION_NO_ACTION, FK_OPTION_DEFAULT};

  Table_ident *ref_table;
unknown's avatar
unknown committed
233
  List<Key_part_spec> ref_columns;
234
  uint delete_opt, update_opt, match_opt;
unknown's avatar
unknown committed
235 236
  Foreign_key(const char *name_arg, List<Key_part_spec> &cols,
	      Table_ident *table,   List<Key_part_spec> &ref_cols,
237
	      uint delete_opt_arg, uint update_opt_arg, uint match_opt_arg)
238
    :Key(FOREIGN_KEY, name_arg, &default_key_create_info, 0, cols),
239
    ref_table(table), ref_columns(ref_cols),
240 241 242
    delete_opt(delete_opt_arg), update_opt(update_opt_arg),
    match_opt(match_opt_arg)
  {}
unknown's avatar
unknown committed
243
  Foreign_key(const Foreign_key &rhs, MEM_ROOT *mem_root);
244 245
  /**
    Used to make a clone of this object for ALTER/CREATE TABLE
unknown's avatar
unknown committed
246
    @sa comment for Key_part_spec::clone
247 248
  */
  virtual Key *clone(MEM_ROOT *mem_root) const
unknown's avatar
unknown committed
249
  { return new (mem_root) Foreign_key(*this, mem_root); }
250
};
unknown's avatar
unknown committed
251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269

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

270
class Delayed_insert;
unknown's avatar
unknown committed
271
class select_result;
272
class Time_zone;
unknown's avatar
unknown committed
273

274 275 276 277 278
#define THD_SENTRY_MAGIC 0xfeedd1ff
#define THD_SENTRY_GONE  0xdeadbeef

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

279 280
struct system_variables
{
unknown's avatar
unknown committed
281 282 283 284 285 286 287 288 289 290 291 292 293 294
  /*
    How dynamically allocated system variables are handled:
    
    The global_system_variables and max_system_variables are "authoritative"
    They both should have the same 'version' and 'size'.
    When attempting to access a dynamic variable, if the session version
    is out of date, then the session version is updated and realloced if
    neccessary and bytes copied from global to make up for missing data.
  */ 
  ulong dynamic_variables_version;
  char* dynamic_variables_ptr;
  uint dynamic_variables_head;  /* largest valid variable offset */
  uint dynamic_variables_size;  /* how many bytes are in use */
  
unknown's avatar
unknown committed
295 296
  ulonglong myisam_max_extra_sort_file_size;
  ulonglong myisam_max_sort_file_size;
297 298
  ulonglong max_heap_table_size;
  ulonglong tmp_table_size;
299
  ulonglong long_query_time;
300 301
  ha_rows select_limit;
  ha_rows max_join_size;
302
  ulong auto_increment_increment, auto_increment_offset;
unknown's avatar
unknown committed
303
  ulong bulk_insert_buff_size;
304
  ulong join_buff_size;
unknown's avatar
unknown committed
305
  ulong max_allowed_packet;
306
  ulong max_error_count;
unknown's avatar
unknown committed
307
  ulong max_length_for_sort_data;
308
  ulong max_sort_length;
309
  ulong max_tmp_tables;
310
  ulong max_insert_delayed_threads;
311
  ulong min_examined_row_limit;
unknown's avatar
unknown committed
312
  ulong multi_range_count;
313
  ulong myisam_repair_threads;
unknown's avatar
unknown committed
314
  ulong myisam_sort_buff_size;
315
  ulong myisam_stats_method;
unknown's avatar
unknown committed
316
  ulong net_buffer_length;
317
  ulong net_interactive_timeout;
unknown's avatar
unknown committed
318
  ulong net_read_timeout;
319
  ulong net_retry_count;
320
  ulong net_wait_timeout;
unknown's avatar
unknown committed
321
  ulong net_write_timeout;
322 323
  ulong optimizer_prune_level;
  ulong optimizer_search_depth;
unknown's avatar
unknown committed
324
  ulong preload_buff_size;
325
  ulong profiling_history_size;
unknown's avatar
unknown committed
326 327 328
  ulong query_cache_type;
  ulong read_buff_size;
  ulong read_rnd_buff_size;
unknown's avatar
unknown committed
329
  ulong div_precincrement;
330
  ulong sortbuff_size;
unknown's avatar
unknown committed
331
  ulong thread_handling;
unknown's avatar
unknown committed
332
  ulong tx_isolation;
unknown's avatar
Merge  
unknown committed
333
  ulong completion_type;
334
  /* Determines which non-standard SQL behaviour should be enabled */
335
  ulong sql_mode;
336
  ulong max_sp_recursion_depth;
unknown's avatar
VIEW  
unknown committed
337
  /* check of key presence in updatable view */
338
  ulong updatable_views_with_limit;
unknown's avatar
unknown committed
339
  ulong default_week_format;
340
  ulong max_seeks_for_key;
341 342 343 344 345
  ulong range_alloc_block_size;
  ulong query_alloc_block_size;
  ulong query_prealloc_size;
  ulong trans_alloc_block_size;
  ulong trans_prealloc_size;
346
  ulong log_warnings;
347
  ulong group_concat_max_len;
unknown's avatar
unknown committed
348 349 350 351
  ulong ndb_autoincrement_prefetch_sz;
  ulong ndb_index_stat_cache_entries;
  ulong ndb_index_stat_update_freq;
  ulong binlog_format; // binlog format for this thd (see enum_binlog_format)
unknown's avatar
unknown committed
352 353 354 355
  /*
    In slave thread we need to know in behalf of which
    thread the query is being run to replicate temp tables properly
  */
unknown's avatar
unknown committed
356
  my_thread_id pseudo_thread_id;
unknown's avatar
unknown committed
357

unknown's avatar
unknown committed
358 359
  my_bool low_priority_updates;
  my_bool new_mode;
360 361 362 363 364
  /* 
    compatibility option:
      - index usage hints (USE INDEX without a FOR clause) behave as in 5.0 
  */
  my_bool old_mode;
365
  my_bool query_cache_wlock_invalidate;
unknown's avatar
unknown committed
366
  my_bool engine_condition_pushdown;
unknown's avatar
unknown committed
367
  my_bool keep_files_on_create;
368
  my_bool ndb_force_send;
369
  my_bool ndb_use_copying_alter_table;
370 371
  my_bool ndb_use_exact_count;
  my_bool ndb_use_transactions;
372
  my_bool ndb_index_stat_enable;
373

unknown's avatar
unknown committed
374
  my_bool old_alter_table;
375
  my_bool old_passwords;
376

unknown's avatar
unknown committed
377
  plugin_ref table_plugin;
unknown's avatar
unknown committed
378

379
  /* Only charset part of these variables is sensible */
unknown's avatar
unknown committed
380
  CHARSET_INFO  *character_set_filesystem;
381
  CHARSET_INFO  *character_set_client;
382
  CHARSET_INFO  *character_set_results;
383

384 385 386
  /* Both charset and collation parts of these variables are important */
  CHARSET_INFO	*collation_server;
  CHARSET_INFO	*collation_database;
unknown's avatar
unknown committed
387
  CHARSET_INFO  *collation_connection;
388

unknown's avatar
unknown committed
389 390 391
  /* Locale Support */
  MY_LOCALE *lc_time_names;

392 393
  Time_zone *time_zone;

394
  /* DATE, DATETIME and MYSQL_TIME formats */
395 396 397
  DATE_TIME_FORMAT *date_format;
  DATE_TIME_FORMAT *datetime_format;
  DATE_TIME_FORMAT *time_format;
398
  my_bool sysdate_is_now;
399

unknown's avatar
unknown committed
400 401
};

402 403 404 405 406

/* per thread status variables */

typedef struct system_status_var
{
407 408
  ulonglong bytes_received;
  ulonglong bytes_sent;
409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424
  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;
425 426 427 428
  ulong ha_prepare_count;
  ulong ha_discover_count;
  ulong ha_savepoint_count;
  ulong ha_savepoint_rollback_count;
429 430 431 432 433 434 435 436 437 438 439 440

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

  ulong net_big_packet_count;
  ulong opened_tables;
unknown's avatar
unknown committed
441
  ulong opened_shares;
442 443 444 445 446 447 448 449 450 451
  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;
452
  /* Prepared statements and binary protocol */
unknown's avatar
unknown committed
453
  ulong com_stmt_prepare;
unknown's avatar
unknown committed
454
  ulong com_stmt_reprepare;
unknown's avatar
unknown committed
455 456 457 458 459
  ulong com_stmt_execute;
  ulong com_stmt_send_long_data;
  ulong com_stmt_fetch;
  ulong com_stmt_reset;
  ulong com_stmt_close;
460

461 462 463 464
  /*
    Status variables which it does not make sense to add to
    global status variable counter
  */
465
  double last_query_cost;
466 467 468
} STATUS_VAR;

/*
469 470 471
  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
472 473
*/

unknown's avatar
unknown committed
474
#define last_system_status_var com_stmt_close
475

unknown's avatar
unknown committed
476 477
void mark_transaction_to_rollback(THD *thd, bool all);

478 479
#ifdef MYSQL_SERVER

480
void free_tmp_table(THD *thd, TABLE *entry);
481 482


unknown's avatar
unknown committed
483 484
/* The following macro is to make init of Query_arena simpler */
#ifndef DBUG_OFF
unknown's avatar
unknown committed
485
#define INIT_ARENA_DBUG_INFO is_backup_arena= 0; is_reprepared= FALSE;
486 487
#else
#define INIT_ARENA_DBUG_INFO
unknown's avatar
unknown committed
488 489
#endif

unknown's avatar
unknown committed
490
class Query_arena
491 492 493 494 495 496 497
{
public:
  /*
    List of items created in the parser for this query. Every item puts
    itself to the list on creation (see Item::Item() for details))
  */
  Item *free_list;
unknown's avatar
unknown committed
498
  MEM_ROOT *mem_root;                   // Pointer to current memroot
unknown's avatar
unknown committed
499
#ifndef DBUG_OFF
500
  bool is_backup_arena; /* True if this arena is used for backup. */
unknown's avatar
unknown committed
501
  bool is_reprepared;
unknown's avatar
unknown committed
502
#endif
503 504 505 506 507 508 509
  /*
    The states relfects three diffrent life cycles for three
    different types of statements:
    Prepared statement: INITIALIZED -> PREPARED -> EXECUTED.
    Stored procedure:   INITIALIZED_FOR_SP -> EXECUTED.
    Other statements:   CONVENTIONAL_EXECUTION never changes.
  */
unknown's avatar
unknown committed
510
  enum enum_state
511
  {
512 513
    INITIALIZED= 0, INITIALIZED_FOR_SP= 1, PREPARED= 2,
    CONVENTIONAL_EXECUTION= 3, EXECUTED= 4, ERROR= -1
514
  };
unknown's avatar
unknown committed
515

unknown's avatar
unknown committed
516
  enum_state state;
517 518 519 520 521 522 523

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

524 525
  Query_arena(MEM_ROOT *mem_root_arg, enum enum_state state_arg) :
    free_list(0), mem_root(mem_root_arg), state(state_arg)
526
  { INIT_ARENA_DBUG_INFO; }
527
  /*
unknown's avatar
unknown committed
528 529
    This constructor is used only when Query_arena is created as
    backup storage for another instance of Query_arena.
530
  */
531 532
  Query_arena() { INIT_ARENA_DBUG_INFO; }

533
  virtual Type type() const;
unknown's avatar
unknown committed
534
  virtual ~Query_arena() {};
535

536
  inline bool is_stmt_prepare() const { return state == INITIALIZED; }
537 538
  inline bool is_first_sp_execute() const
  { return state == INITIALIZED_FOR_SP; }
539 540
  inline bool is_stmt_prepare_or_first_sp_execute() const
  { return (int)state < (int)PREPARED; }
unknown's avatar
unknown committed
541
  inline bool is_first_stmt_execute() const { return state == PREPARED; }
542 543
  inline bool is_stmt_execute() const
  { return state == PREPARED || state == EXECUTED; }
unknown's avatar
unknown committed
544
  inline bool is_conventional() const
unknown's avatar
unknown committed
545
  { return state == CONVENTIONAL_EXECUTION; }
546

547 548
  inline void* alloc(size_t size) { return alloc_root(mem_root,size); }
  inline void* calloc(size_t size)
549
  {
550
    void *ptr;
unknown's avatar
unknown committed
551
    if ((ptr=alloc_root(mem_root,size)))
552
      bzero(ptr, size);
553 554 555
    return ptr;
  }
  inline char *strdup(const char *str)
unknown's avatar
unknown committed
556
  { return strdup_root(mem_root,str); }
557
  inline char *strmake(const char *str, size_t size)
unknown's avatar
unknown committed
558
  { return strmake_root(mem_root,str,size); }
559
  inline void *memdup(const void *str, size_t size)
unknown's avatar
unknown committed
560
  { return memdup_root(mem_root,str,size); }
561
  inline void *memdup_w_gap(const void *str, size_t size, uint gap)
562
  {
563 564
    void *ptr;
    if ((ptr= alloc_root(mem_root,size+gap)))
565 566 567 568
      memcpy(ptr,str,size);
    return ptr;
  }

unknown's avatar
unknown committed
569
  void set_query_arena(Query_arena *set);
570 571

  void free_items();
572 573
  /* Close the active state associated with execution of this statement */
  virtual void cleanup_stmt();
574 575
};

576

577
class Server_side_cursor;
578

579 580 581 582
/**
  @class Statement
  @brief State of a single command executed against this connection.

583 584 585 586 587 588 589 590 591 592 593 594
  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.
*/

595
class Statement: public ilink, public Query_arena
596
{
597 598
  Statement(const Statement &rhs);              /* not implemented: */
  Statement &operator=(const Statement &rhs);   /* non-copyable */
599 600
public:
  /*
unknown's avatar
unknown committed
601
    Uniquely identifies each statement object in thread scope; change during
602
    statement lifetime. FIXME: must be const
603
  */
unknown's avatar
unknown committed
604
   ulong id;
605 606

  /*
607 608 609 610 611 612 613 614 615
    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.
616
  */
617
  enum enum_mark_columns mark_used_columns;
618

619
  LEX_STRING name; /* name for named prepared statements */
620 621 622 623 624
  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.
625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641

    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.
642 643 644
  */
  char *query;
  uint32 query_length;                          // current query length
645
  Server_side_cursor *cursor;
646

647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662
  /**
    Name of the current (default) database.

    If there is the current (default) database, "db" contains its name. If
    there is no current (default) database, "db" is NULL and "db_length" is
    0. In other words, "db", "db_length" must either be NULL, or contain a
    valid database name.

    @note this attribute is 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 this member.
  */

  char *db;
  uint db_length;

663 664
public:

unknown's avatar
unknown committed
665
  /* This constructor is called for backup statements */
666
  Statement() {}
667

668 669
  Statement(LEX *lex_arg, MEM_ROOT *mem_root_arg,
            enum enum_state state_arg, ulong id_arg);
670
  virtual ~Statement();
671 672 673

  /* Assign execution context (note: not all members) of given stmt to self */
  void set_statement(Statement *stmt);
674 675
  void set_n_backup_statement(Statement *stmt, Statement *backup);
  void restore_backup_statement(Statement *stmt, Statement *backup);
676 677
  /* return class type */
  virtual Type type() const;
678 679 680
};


681
/**
682 683 684 685 686
  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
687

688 689
  Statements are auto-deleted when they are removed from the map and when the
  map is deleted.
690 691 692 693 694 695
*/

class Statement_map
{
public:
  Statement_map();
696

697
  int insert(THD *thd, Statement *statement);
698 699

  Statement *find_by_name(LEX_STRING *name)
700
  {
701
    Statement *stmt;
702
    stmt= (Statement*)hash_search(&names_hash, (uchar*)name->str,
703 704
                                  name->length);
    return stmt;
705
  }
706 707

  Statement *find(ulong id)
708
  {
709
    if (last_found_statement == 0 || id != last_found_statement->id)
710 711
    {
      Statement *stmt;
712
      stmt= (Statement *) hash_search(&st_hash, (uchar *) &id, sizeof(id));
713
      if (stmt && stmt->name.str)
714 715 716
        return NULL;
      last_found_statement= stmt;
    }
717
    return last_found_statement;
718
  }
719 720 721 722 723 724
  /*
    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();
725
  void erase(Statement *statement);
726
  /* Erase all statements (calls Statement destructor) */
727 728
  void reset();
  ~Statement_map();
729 730
private:
  HASH st_hash;
731
  HASH names_hash;
732
  I_List<Statement> transient_cursor_list;
733
  Statement *last_found_statement;
734 735
};

736 737 738
struct st_savepoint {
  struct st_savepoint *prev;
  char                *name;
739 740
  uint                 length;
  Ha_trx_info         *ha_list;
741 742 743
};

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

746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761
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);

762 763 764 765
/**
  @class Security_context
  @brief A set of THD members describing the current authenticated user.
*/
766

767 768
class Security_context {
public:
769
  Security_context() {}                       /* Remove gcc warning */
770 771 772 773
  /*
    host - host of the client
    user - user of the client, set to NULL until the user has been read from
    the connection
774
    priv_user - The user privilege we are using. May be "" for anonymous user.
775 776 777
    ip - client IP
  */
  char   *host, *user, *priv_user, *ip;
778
  /* The host privilege we are using */
779 780 781 782 783 784 785 786 787
  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();
788
  inline char *priv_host_name()
789 790 791
  {
    return (*priv_host ? priv_host : (char *)"%");
  }
792 793
  
  bool set_user(char *user_arg);
794 795 796 797 798 799 800 801 802 803 804 805

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

  void
  restore_security_context(THD *thd, Security_context *backup);
#endif
806 807 808
};


809
/**
810 811 812 813 814 815 816 817 818 819
  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;


820
/**
821 822 823 824 825 826 827 828
  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};


829
/**
830
  Class that holds information about tables which were opened and locked
831 832 833 834 835 836 837
  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:
unknown's avatar
unknown committed
838 839 840 841 842 843 844 845 846 847
  /**
    As part of class THD, this member is set during execution
    of a prepared statement. When it is set, it is used
    by the locking subsystem to report a change in table metadata.

    When Open_tables_state part of THD is reset to open
    a system or INFORMATION_SCHEMA table, the member is cleared
    to avoid spurious ER_NEED_REPREPARE errors -- system and
    INFORMATION_SCHEMA tables are not subject to metadata version
    tracking.
848
    @sa check_and_update_table_version()
unknown's avatar
unknown committed
849
  */
850
  Reprepare_observer *m_reprepare_observer;
unknown's avatar
unknown committed
851

852 853 854 855 856 857 858 859 860 861 862
  /**
    List of regular tables in use by this thread. Contains temporary and
    base tables that were opened with @see open_tables().
  */
  TABLE *open_tables;
  /**
    List of temporary tables used by this thread. Contains user-level
    temporary tables, created with CREATE TEMPORARY TABLE, and
    internal temporary tables, created, e.g., to resolve a SELECT,
    or for an intermediate table used in ALTER.
    XXX Why are internal temporary tables added to this list?
863
  */
864 865 866 867
  TABLE *temporary_tables;
  /**
    List of tables that were opened with HANDLER OPEN and are
    still in use by this thread.
868
  */
869 870
  TABLE *handler_tables;
  TABLE *derived_tables;
871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891
  /*
    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;
892 893 894 895 896 897 898 899

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

900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926
  /*
    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;

927 928 929 930 931 932 933 934 935
  enum enum_flags {
    BACKUPS_AVAIL = (1U << 0)     /* There are backups available */
  };

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

936 937 938 939
  /*
    This constructor serves for creation of Open_tables_state instances
    which are used as backup storage.
  */
940
  Open_tables_state() : state_flags(0U) { }
941 942

  Open_tables_state(ulong version_arg);
943 944 945 946 947 948 949 950 951

  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;
952
    extra_lock= lock= locked_tables= 0;
953
    prelocked_mode= NON_PRELOCKED;
954
    state_flags= 0U;
955
    m_reprepare_observer= NULL;
956 957 958
  }
};

959 960 961 962
/**
  @class Sub_statement_state
  @brief Used to save context when executing a function or trigger
*/
963 964 965 966 967 968

/* Defines used for Sub_statement_state::in_sub_stmt */

#define SUB_STMT_TRIGGER 1
#define SUB_STMT_FUNCTION 2

969

970 971 972 973
class Sub_statement_state
{
public:
  ulonglong options;
974 975 976
  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;
977
  Discrete_intervals_list auto_inc_intervals_forced;
978 979 980 981
  ulonglong limit_found_rows;
  ha_rows    cuted_fields, sent_row_count, examined_row_count;
  ulong client_capabilities;
  uint in_sub_stmt;
982
  bool enable_slow_log;
unknown's avatar
unknown committed
983
  bool last_insert_id_used;
984
  SAVEPOINT *savepoints;
985 986 987
};


988 989 990 991 992 993 994 995 996 997 998 999 1000
/* Flags for the THD::system_thread variable */
enum enum_thread_type
{
  NON_SYSTEM_THREAD= 0,
  SYSTEM_THREAD_DELAYED_INSERT= 1,
  SYSTEM_THREAD_SLAVE_IO= 2,
  SYSTEM_THREAD_SLAVE_SQL= 4,
  SYSTEM_THREAD_NDBCLUSTER_BINLOG= 8,
  SYSTEM_THREAD_EVENT_SCHEDULER= 16,
  SYSTEM_THREAD_EVENT_WORKER= 32
};


unknown's avatar
unknown committed
1001 1002 1003 1004 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 1031 1032 1033 1034 1035 1036 1037 1038
/**
  This class represents the interface for internal error handlers.
  Internal error handlers are exception handlers used by the server
  implementation.
*/
class Internal_error_handler
{
protected:
  Internal_error_handler() {}
  virtual ~Internal_error_handler() {}

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

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

    @param sql_errno the error number
    @param level the error level
    @param thd the calling thread
    @return true if the error is handled
  */
  virtual bool handle_error(uint sql_errno,
1039
                            const char *message,
unknown's avatar
unknown committed
1040 1041 1042 1043 1044
                            MYSQL_ERROR::enum_warning_level level,
                            THD *thd) = 0;
};


1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058
/**
  Stores status of the currently executed statement.
  Cleared at the beginning of the statement, and then
  can hold either OK, ERROR, or EOF status.
  Can not be assigned twice per statement.
*/

class Diagnostics_area
{
public:
  enum enum_diagnostics_status
  {
    /** The area is cleared at start of a statement. */
    DA_EMPTY= 0,
1059
    /** Set whenever one calls my_ok(). */
1060
    DA_OK,
1061
    /** Set whenever one calls my_eof(). */
1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073
    DA_EOF,
    /** Set whenever one calls my_error() or my_message(). */
    DA_ERROR,
    /** Set in case of a custom response, such as one from COM_STMT_PREPARE. */
    DA_DISABLED
  };
  /** True if status information is sent to the client. */
  bool is_sent;
  /** Set to make set_error_status after set_{ok,eof}_status possible. */
  bool can_overwrite_status;

  void set_ok_status(THD *thd, ha_rows affected_rows_arg,
1074
                     ulonglong last_insert_id_arg,
1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104
                     const char *message);
  void set_eof_status(THD *thd);
  void set_error_status(THD *thd, uint sql_errno_arg, const char *message_arg);

  void disable_status();

  void reset_diagnostics_area();

  bool is_set() const { return m_status != DA_EMPTY; }
  bool is_error() const { return m_status == DA_ERROR; }
  bool is_eof() const { return m_status == DA_EOF; }
  bool is_ok() const { return m_status == DA_OK; }
  bool is_disabled() const { return m_status == DA_DISABLED; }
  enum_diagnostics_status status() const { return m_status; }

  const char *message() const
  { DBUG_ASSERT(m_status == DA_ERROR || m_status == DA_OK); return m_message; }

  uint sql_errno() const
  { DBUG_ASSERT(m_status == DA_ERROR); return m_sql_errno; }

  uint server_status() const
  {
    DBUG_ASSERT(m_status == DA_OK || m_status == DA_EOF);
    return m_server_status;
  }

  ha_rows affected_rows() const
  { DBUG_ASSERT(m_status == DA_OK); return m_affected_rows; }

1105
  ulonglong last_insert_id() const
1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128
  { DBUG_ASSERT(m_status == DA_OK); return m_last_insert_id; }

  uint total_warn_count() const
  {
    DBUG_ASSERT(m_status == DA_OK || m_status == DA_EOF);
    return m_total_warn_count;
  }

  Diagnostics_area() { reset_diagnostics_area(); }

private:
  /** Message buffer. Can be used by OK or ERROR status. */
  char m_message[MYSQL_ERRMSG_SIZE];
  /**
    SQL error number. One of ER_ codes from share/errmsg.txt.
    Set by set_error_status.
  */
  uint m_sql_errno;

  /**
    Copied from thd->server_status when the diagnostics area is assigned.
    We need this member as some places in the code use the following pattern:
    thd->server_status|= ...
1129
    my_eof(thd);
1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150
    thd->server_status&= ~...
    Assigned by OK, EOF or ERROR.
  */
  uint m_server_status;
  /**
    The number of rows affected by the last statement. This is
    semantically close to thd->row_count_func, but has a different
    life cycle. thd->row_count_func stores the value returned by
    function ROW_COUNT() and is cleared only by statements that
    update its value, such as INSERT, UPDATE, DELETE and few others.
    This member is cleared at the beginning of the next statement.

    We could possibly merge the two, but life cycle of thd->row_count_func
    can not be changed.
  */
  ha_rows    m_affected_rows;
  /**
    Similarly to the previous member, this is a replacement of
    thd->first_successful_insert_id_in_prev_stmt, which is used
    to implement LAST_INSERT_ID().
  */
1151
  ulonglong   m_last_insert_id;
1152 1153 1154 1155 1156 1157 1158 1159 1160 1161
  /** The total number of warnings. */
  uint	     m_total_warn_count;
  enum_diagnostics_status m_status;
  /**
    @todo: the following THD members belong here:
    - warn_list, warn_count,
  */
};


1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188
/**
  Storage engine specific thread local data.
*/

struct Ha_data
{
  /**
    Storage engine specific thread local data.
    Lifetime: one user connection.
  */
  void *ha_ptr;
  /**
    0: Life time: one statement within a transaction. If @@autocommit is
    on, also represents the entire transaction.
    @sa trans_register_ha()

    1: Life time: one transaction within a connection.
    If the storage engine does not participate in a transaction,
    this should not be used.
    @sa trans_register_ha()
  */
  Ha_trx_info ha_info[2];

  Ha_data() :ha_ptr(NULL) {}
};


1189 1190
/**
  @class THD
unknown's avatar
unknown committed
1191 1192 1193
  For each client connection we create a separate thread with THD serving as
  a thread/connection descriptor
*/
1194

1195
class THD :public Statement,
1196
           public Open_tables_state
unknown's avatar
unknown committed
1197
{
unknown's avatar
unknown committed
1198
public:
1199
  /* Used to execute base64 coded binlog events in MySQL server */
1200
  Relay_log_info* rli_fake;
1201

1202 1203 1204 1205 1206 1207 1208 1209
  /*
    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;

1210 1211
#ifdef EMBEDDED_LIBRARY
  struct st_mysql  *mysql;
unknown's avatar
SCRUM  
unknown committed
1212 1213
  unsigned long	 client_stmt_id;
  unsigned long  client_param_count;
unknown's avatar
unknown committed
1214
  struct st_mysql_bind *client_params;
unknown's avatar
unknown committed
1215 1216
  char *extra_data;
  ulong extra_length;
1217 1218 1219 1220 1221
  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();
1222 1223 1224 1225 1226 1227
  /*
    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;
1228
#endif
unknown's avatar
unknown committed
1229
  NET	  net;				// client connection descriptor
1230
  MEM_ROOT warn_root;			// For warnings and errors
1231
  Protocol *protocol;			// Current protocol
unknown's avatar
unknown committed
1232 1233
  Protocol_text   protocol_text;	// Normal protocol
  Protocol_binary protocol_binary;	// Binary protocol
unknown's avatar
unknown committed
1234 1235
  HASH    user_vars;			// hash for user variables
  String  packet;			// dynamic buffer for network I/O
1236
  String  convert_buffer;               // buffer for charset conversions
unknown's avatar
unknown committed
1237 1238 1239
  struct  sockaddr_in remote;		// client socket address
  struct  rand_struct rand;		// used for authentication
  struct  system_variables variables;	// Changeable local variables
1240
  struct  system_status_var status_var; // Per thread statistic vars
1241
  struct  system_status_var *initial_status_var; /* used by show status */
1242 1243 1244 1245
  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.
1246
  pthread_mutex_t LOCK_delete;		// Locked before thd is deleted
1247
  /* all prepared statements and cursors of this connection */
1248
  Statement_map stmt_map;
unknown's avatar
unknown committed
1249 1250 1251 1252 1253 1254
  /*
    A pointer to the stack frame of handle_one_connection(),
    which is called first in the thread for handling a client
  */
  char	  *thread_stack;

1255 1256 1257 1258 1259
  /**
    Currently selected catalog.
  */
  char *catalog;

unknown's avatar
unknown committed
1260 1261 1262
  /**
    @note
    Some members of THD (currently 'Statement::db',
1263 1264 1265 1266 1267 1268
    '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 properly. For details see
    the 'err:' label of the handle_slave_sql() in sql/slave.cc.
unknown's avatar
unknown committed
1269 1270

    @see handle_slave_sql
1271 1272
  */

1273 1274
  Security_context main_security_ctx;
  Security_context *security_ctx;
1275

1276 1277 1278 1279
  /*
    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.
1280 1281 1282

    Set it using the  thd_proc_info(THD *thread, const char *message)
    macro/function.
1283
  */
unknown's avatar
unknown committed
1284
  const char *proc_info;
1285

1286 1287 1288 1289 1290 1291 1292 1293
  /*
    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.
  */
  const char *where;

  double tmp_double_value;                    /* Used in set_var.cc */
1294
  ulong client_capabilities;		/* What the client supports */
1295
  ulong max_client_packet_length;
1296

unknown's avatar
unknown committed
1297
  HASH		handler_tables_hash;
unknown's avatar
unknown committed
1298 1299 1300 1301 1302
  /*
    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. 
  */
1303
  User_level_lock *ull;
1304 1305
#ifndef DBUG_OFF
  uint dbug_sentry; // watch out for memory corruption
1306
#endif
unknown's avatar
unknown committed
1307
  struct st_my_thread_var *mysys_var;
1308
  /*
1309
    Type of current query: COM_STMT_PREPARE, COM_QUERY, etc. Set from
1310 1311 1312
    first byte of the packet in do_command()
  */
  enum enum_server_command command;
unknown's avatar
unknown committed
1313
  uint32     server_id;
unknown's avatar
unknown committed
1314
  uint32     file_id;			// for LOAD DATA INFILE
1315 1316 1317 1318 1319 1320
  /* remote (peer) port */
  uint16 peer_port;
  time_t     start_time, user_time;
  ulonglong  connect_utime, thr_create_utime; // track down slow pthread_create
  ulonglong  start_utime, utime_after_lock;
  
unknown's avatar
unknown committed
1321
  thr_lock_type update_lock_default;
1322
  Delayed_insert *di;
1323

1324 1325
  /* <> 0 if we are inside of trigger or stored function. */
  uint in_sub_stmt;
1326

1327
  /* container for handler's private per-connection data */
1328
  Ha_data ha_data[MAX_HA];
1329 1330

#ifndef MYSQL_CLIENT
1331 1332
  int binlog_setup_trx_data();

1333
  /*
1334
    Public interface to write RBR events to the binlog
1335
  */
1336
  void binlog_start_trans_and_stmt();
1337
  void binlog_set_stmt_begin();
1338
  int binlog_write_table_map(TABLE *table, bool is_transactional);
1339
  int binlog_write_row(TABLE* table, bool is_transactional,
1340 1341
                       MY_BITMAP const* cols, size_t colcnt,
                       const uchar *buf);
1342
  int binlog_delete_row(TABLE* table, bool is_transactional,
1343 1344
                        MY_BITMAP const* cols, size_t colcnt,
                        const uchar *buf);
1345
  int binlog_update_row(TABLE* table, bool is_transactional,
1346 1347
                        MY_BITMAP const* cols, size_t colcnt,
                        const uchar *old_data, const uchar *new_data);
1348 1349 1350 1351 1352 1353 1354 1355 1356

  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,
1357 1358
                                      size_t colcnt,
                                      size_t needed,
unknown's avatar
unknown committed
1359 1360
                                      bool is_transactional,
				      RowsEventT* hint);
1361 1362 1363 1364
  Rows_log_event* binlog_get_pending_rows_event() const;
  void            binlog_set_pending_rows_event(Rows_log_event* ev);
  int binlog_flush_pending_rows_event(bool stmt_end);

1365 1366
private:
  uint binlog_table_maps; // Number of table maps currently in the binlog
1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377

  enum enum_binlog_flag {
    BINLOG_FLAG_UNSAFE_STMT_PRINTED,
    BINLOG_FLAG_COUNT
  };

  /**
     Flags with per-thread information regarding the status of the
     binary log.
   */
  uint32 binlog_flags;
1378
public:
1379 1380 1381
  uint get_binlog_table_maps() const {
    return binlog_table_maps;
  }
1382 1383
#endif /* MYSQL_CLIENT */

1384 1385
public:

unknown's avatar
unknown committed
1386
  struct st_transactions {
1387
    SAVEPOINT *savepoints;
unknown's avatar
unknown committed
1388 1389
    THD_TRANS all;			// Trans since BEGIN WORK
    THD_TRANS stmt;			// Trans for current statement
1390
    bool on;                            // see ha_enable_transaction()
1391
    XID_STATE xid_state;
1392 1393
    Rows_log_event *m_pending_rows_event;

1394
    /*
1395
       Tables changed in transaction (that must be invalidated in query cache).
1396
       List contain only transactional tables, that not invalidated in query
1397 1398 1399 1400 1401 1402
       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()
    {
1403 1404
      changed_tables= 0;
      savepoints= 0;
1405
#ifdef USING_TRANSACTIONS
1406
      free_root(&mem_root,MYF(MY_KEEP_PREALLOC));
1407
#endif
1408
    }
1409 1410
    st_transactions()
    {
1411
#ifdef USING_TRANSACTIONS
1412
      bzero((char*)this, sizeof(*this));
1413
      xid_state.xid.null();
1414
      init_sql_alloc(&mem_root, ALLOC_ROOT_MIN_BLOCK_SIZE, 0);
1415 1416
#else
      xid_state.xa_state= XA_NOTR;
1417
#endif
1418
    }
unknown's avatar
unknown committed
1419
  } transaction;
1420
  Field      *dup_field;
unknown's avatar
unknown committed
1421
#ifndef __WIN__
unknown's avatar
unknown committed
1422
  sigset_t signals;
unknown's avatar
unknown committed
1423
#endif
1424 1425
#ifdef SIGNAL_WITH_VIO_CLOSE
  Vio* active_vio;
1426
#endif
1427 1428 1429 1430
  /*
    This is to track items changed during execution of a prepared
    statement/stored procedure. It's created by
    register_item_tree_change() in memory root of THD, and freed in
unknown's avatar
unknown committed
1431 1432
    rollback_item_tree_changes(). For conventional execution it's always
    empty.
1433 1434 1435
  */
  Item_change_list change_list;

unknown's avatar
unknown committed
1436
  /*
unknown's avatar
unknown committed
1437 1438
    A permanent memory area of the statement. For conventional
    execution, the parsed tree and execution runtime reside in the same
unknown's avatar
unknown committed
1439
    memory root. In this case stmt_arena points to THD. In case of
unknown's avatar
unknown committed
1440
    a prepared statement or a stored procedure statement, thd->mem_root
unknown's avatar
unknown committed
1441
    conventionally points to runtime memory, and thd->stmt_arena
unknown's avatar
unknown committed
1442 1443 1444
    points to the memory of the PS/SP, where the parsed tree of the
    statement resides. Whenever you need to perform a permanent
    transformation of a parsed tree, you should allocate new memory in
unknown's avatar
unknown committed
1445 1446
    stmt_arena, to allow correct re-execution of PS/SP.
    Note: in the parser, stmt_arena == thd, even for PS/SP.
unknown's avatar
unknown committed
1447
  */
unknown's avatar
unknown committed
1448
  Query_arena *stmt_arena;
1449 1450
  /* Tells if LAST_INSERT_ID(#) was called for the current statement */
  bool arg_of_last_insert_id_function;
1451
  /*
1452 1453
    ALL OVER THIS FILE, "insert_id" means "*automatically generated* value for
    insertion into an auto_increment column".
1454 1455
  */
  /*
1456 1457 1458 1459 1460 1461
    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().
1462
  */
1463
  ulonglong  first_successful_insert_id_in_prev_stmt;
1464
  /*
1465 1466 1467 1468
    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).
1469
  */
1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480
  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.
1481 1482 1483 1484
    - as stmt makes progress, handler::insert_id_for_cur_row changes;
    every time get_auto_increment() is called,
    auto_inc_intervals_in_cur_stmt_for_binlog is augmented with the
    reserved interval (if statement-based binlogging).
1485 1486 1487
    - at first successful insertion of an autogenerated value,
    first_successful_insert_id_in_cur_stmt is set to
    handler::insert_id_for_cur_row.
1488 1489 1490
    - when stmt goes to binlog,
    auto_inc_intervals_in_cur_stmt_for_binlog is binlogged if
    non-empty.
1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526
    - 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
1527 1528 1529
    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.
1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555
    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.
  */
1556
  inline void record_first_successful_insert_id_in_cur_stmt(ulonglong id_arg)
1557 1558
  {
    if (first_successful_insert_id_in_cur_stmt == 0)
1559
      first_successful_insert_id_in_cur_stmt= id_arg;
1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572
  }
  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;
  }
  /*
1573
    Used by Intvar_log_event::do_apply_event() and by "SET INSERT_ID=#"
1574 1575 1576 1577 1578
    (mysqlbinlog). We'll soon add a variant which can take many intervals in
    argument.
  */
  inline void force_one_auto_inc_interval(ulonglong next_id)
  {
1579
    auto_inc_intervals_forced.empty(); // in case of multiple SET INSERT_ID
1580 1581 1582
    auto_inc_intervals_forced.append(next_id, ULONGLONG_MAX, 0);
  }

1583
  ulonglong  limit_found_rows;
1584
  ulonglong  options;           /* Bitmap of states */
1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598
  longlong   row_count_func;    /* For the ROW_COUNT() function */
  ha_rows    cuted_fields;

  /*
    number of rows we actually sent to the client, including "synthetic"
    rows in ROLLUP etc.
  */
  ha_rows    sent_row_count;

  /*
    number of rows we read, sent or not, including in create_sort_index()
  */
  ha_rows    examined_row_count;

unknown's avatar
unknown committed
1599 1600 1601 1602 1603 1604
  /*
    The set of those tables whose fields are referenced in all subqueries
    of the query.
    TODO: possibly this it is incorrect to have used tables in THD because
    with more than one subquery, it is not clear what does the field mean.
  */
unknown's avatar
unknown committed
1605
  table_map  used_tables;
1606
  USER_CONN *user_connect;
1607
  CHARSET_INFO *db_charset;
unknown's avatar
unknown committed
1608 1609 1610
  /*
    FIXME: this, and some other variables like 'count_cuted_fields'
    maybe should be statement/cursor local, that is, moved to Statement
1611 1612
    class. With current implementation warnings produced in each prepared
    statement/cursor settle here.
unknown's avatar
unknown committed
1613
  */
1614
  List	     <MYSQL_ERROR> warn_list;
1615
  uint	     warn_count[(uint) MYSQL_ERROR::WARN_LEVEL_END];
unknown's avatar
unknown committed
1616
  uint	     total_warn_count;
1617
  Diagnostics_area main_da;
1618
#if defined(ENABLED_PROFILING) && defined(COMMUNITY_SERVER)
unknown's avatar
unknown committed
1619
  PROFILING  profiling;
1620
#endif
unknown's avatar
unknown committed
1621

1622 1623 1624 1625 1626 1627 1628 1629
  /*
    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).
  */
1630
  query_id_t query_id, warn_id;
unknown's avatar
unknown committed
1631
  ulong      col_access;
1632

1633 1634 1635
#ifdef ERROR_INJECT_SUPPORT
  ulong      error_inject_value;
#endif
1636 1637
  /* Statement id is thread-wide. This counter is used to generate ids */
  ulong      statement_id_counter;
1638
  ulong	     rand_saved_seed1, rand_saved_seed2;
1639 1640 1641 1642 1643
  /*
    Row counter, mainly for errors and warnings. Not increased in
    create_sort_index(); may differ from examined_row_count.
  */
  ulong      row_count;
unknown's avatar
unknown committed
1644 1645
  pthread_t  real_id;                           /* For debugging */
  my_thread_id  thread_id;
1646
  uint	     tmp_table, global_read_lock;
1647 1648
  uint	     server_status,open_options;
  enum enum_thread_type system_thread;
unknown's avatar
unknown committed
1649
  uint       select_number;             //number of select (used for EXPLAIN)
unknown's avatar
unknown committed
1650 1651
  /* variables.transaction_isolation is reset to this after each commit */
  enum_tx_isolation session_tx_isolation;
1652
  enum_check_fields count_cuted_fields;
1653 1654 1655

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

1657 1658 1659 1660 1661 1662 1663 1664
  enum killed_state
  {
    NOT_KILLED=0,
    KILL_BAD_DATA=1,
    KILL_CONNECTION=ER_SERVER_SHUTDOWN,
    KILL_QUERY=ER_QUERY_INTERRUPTED,
    KILLED_NO_VALUE      /* means neither of the states */
  };
1665 1666
  killed_state volatile killed;

1667
  /* scramble - random string sent to client on handshake */
unknown's avatar
unknown committed
1668
  char	     scramble[SCRAMBLE_LENGTH+1];
1669

1670
  bool       slave_thread, one_shot_set;
1671 1672
  /* tells if current statement should binlog row-based(1) or stmt-based(0) */
  bool       current_stmt_binlog_row_based;
1673
  bool	     locked, some_tables_deleted;
1674
  bool       last_cuted_field;
1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701
  bool	     no_errors, password;
  /**
    Set to TRUE if execution of the current compound statement
    can not continue. In particular, disables activation of
    CONTINUE or EXIT handlers of stored routines.
    Reset in the end of processing of the current user request, in
    @see mysql_reset_thd_for_next_command().
  */
  bool is_fatal_error;
  /**
    Set by a storage engine to request the entire
    transaction (that possibly spans multiple engines) to
    rollback. Reset in ha_rollback.
  */
  bool       transaction_rollback_request;
  /**
    TRUE if we are in a sub-statement and the current error can
    not be safely recovered until we left the sub-statement mode.
    In particular, disables activation of CONTINUE and EXIT
    handlers inside sub-statements. E.g. if it is a deadlock
    error and requires a transaction-wide rollback, this flag is
    raised (traditionally, MySQL first has to close all the reads
    via @see handler::ha_index_or_rnd_end() and only then perform
    the rollback).
    Reset to FALSE when we leave the sub-statement mode.
  */
  bool       is_fatal_sub_stmt_error;
1702
  bool	     query_start_used, rand_used, time_zone_used;
1703 1704
  /* for IS NULL => = last_insert_id() fix in remove_eq_conds() */
  bool       substitute_null_with_insert_id;
1705
  bool	     in_lock_tables;
1706 1707
  /**
    True if a slave error. Causes the slave to stop. Not the same
1708
    as the statement execution error (is_error()), since
1709 1710 1711 1712 1713
    a statement may be expected to return an error, e.g. because
    it returned an error on master, and this is OK on the slave.
  */
  bool       is_slave_error;
  bool       bootstrap, cleanup_done;
1714 1715 1716
  
  /**  is set if some thread specific value(s) used in a statement. */
  bool       thread_specific_used;
unknown's avatar
unknown committed
1717
  bool	     charset_is_system_charset, charset_is_collation_connection;
unknown's avatar
unknown committed
1718
  bool       charset_is_character_set_filesystem;
1719
  bool       enable_slow_log;   /* enable slow log for current statement */
1720
  bool	     abort_on_warning;
unknown's avatar
Merge  
unknown committed
1721
  bool 	     got_warning;       /* Set on call to push_warning() */
1722
  bool	     no_warnings_for_error; /* no warnings on call to my_error() */
1723 1724
  /* set during loop of derived table processing */
  bool       derived_tables_processing;
1725 1726
  my_bool    tablespace_op;	/* This is TRUE in DISCARD/IMPORT TABLESPACE */

1727
  sp_rcontext *spcont;		// SP runtime context
1728 1729
  sp_cache   *sp_proc_cache;
  sp_cache   *sp_func_cache;
unknown's avatar
unknown committed
1730

unknown's avatar
unknown committed
1731 1732 1733 1734 1735
  /*
    If we do a purge of binary logs, log index info of the threads
    that are currently reading it needs to be adjusted. To do that
    each thread that is using LOG_INFO needs to adjust the pointer to it
  */
unknown's avatar
unknown committed
1736
  LOG_INFO*  current_linfo;
unknown's avatar
unknown committed
1737
  NET*       slave_net;			// network connection from slave -> m.
unknown's avatar
unknown committed
1738 1739 1740
  /* Used by the sys_var class to store temporary values */
  union
  {
1741 1742 1743 1744
    my_bool   my_bool_value;
    long      long_value;
    ulong     ulong_value;
    ulonglong ulonglong_value;
unknown's avatar
unknown committed
1745
  } sys_var_tmp;
1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764
  
  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;
1765 1766 1767 1768 1769 1770
    
    /* 
      'queries' (actually SP statements) that run under inside this binlog
      union have thd->query_id >= first_query_id.
    */
    query_id_t first_query_id;
1771
  } binlog_evt_union;
1772 1773 1774 1775 1776 1777 1778 1779 1780 1781

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

unknown's avatar
unknown committed
1782
#ifdef WITH_PARTITION_STORAGE_ENGINE
unknown's avatar
unknown committed
1783
  partition_info *work_part_info;
unknown's avatar
unknown committed
1784
#endif
unknown's avatar
foo1  
unknown committed
1785

unknown's avatar
unknown committed
1786 1787
  THD();
  ~THD();
1788

unknown's avatar
unknown committed
1789
  void init(void);
1790 1791 1792 1793 1794 1795 1796 1797 1798 1799
  /*
    Initialize memory roots necessary for query processing and (!)
    pre-allocate memory for it. We can't do that in THD constructor because
    there are use cases (acl_init, delayed inserts, watcher threads,
    killing mysqld) where it's vital to not allocate excessive and not used
    memory. Note, that we still don't return error from init_for_queries():
    if preallocation fails, we should notice that at the first call to
    alloc_root. 
  */
  void init_for_queries();
unknown's avatar
unknown committed
1800
  void change_user(void);
unknown's avatar
unknown committed
1801
  void cleanup(void);
1802
  void cleanup_after_query();
unknown's avatar
unknown committed
1803
  bool store_globals();
1804 1805
#ifdef SIGNAL_WITH_VIO_CLOSE
  inline void set_active_vio(Vio* vio)
1806
  {
1807
    pthread_mutex_lock(&LOCK_delete);
1808
    active_vio = vio;
1809
    pthread_mutex_unlock(&LOCK_delete);
1810
  }
1811
  inline void clear_active_vio()
1812
  {
1813
    pthread_mutex_lock(&LOCK_delete);
1814
    active_vio = 0;
1815
    pthread_mutex_unlock(&LOCK_delete);
1816
  }
unknown's avatar
unknown committed
1817
  void close_active_vio();
1818
#endif
unknown's avatar
SCRUM  
unknown committed
1819
  void awake(THD::killed_state state_to_set);
unknown's avatar
unknown committed
1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846

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

1847 1848
  /*
    For enter_cond() / exit_cond() to work the mutex must be got before
1849 1850
    enter_cond(); this mutex is then released by exit_cond().
    Usage must be: lock mutex; enter_cond(); your code; exit_cond().
1851
  */
unknown's avatar
unknown committed
1852 1853 1854 1855
  inline const char* enter_cond(pthread_cond_t *cond, pthread_mutex_t* mutex,
			  const char* msg)
  {
    const char* old_msg = proc_info;
1856
    safe_mutex_assert_owner(mutex);
unknown's avatar
unknown committed
1857 1858 1859 1860 1861 1862 1863
    mysys_var->current_mutex = mutex;
    mysys_var->current_cond = cond;
    proc_info = msg;
    return old_msg;
  }
  inline void exit_cond(const char* old_msg)
  {
unknown's avatar
unknown committed
1864 1865 1866 1867 1868 1869 1870
    /*
      Putting the mutex unlock in exit_cond() ensures that
      mysys_var->current_mutex is always unlocked _before_ mysys_var->mutex is
      locked (if that would not be the case, you'll get a deadlock if someone
      does a THD::awake() on you).
    */
    pthread_mutex_unlock(mysys_var->current_mutex);
unknown's avatar
unknown committed
1871 1872 1873 1874 1875 1876
    pthread_mutex_lock(&mysys_var->mutex);
    mysys_var->current_mutex = 0;
    mysys_var->current_cond = 0;
    proc_info = old_msg;
    pthread_mutex_unlock(&mysys_var->mutex);
  }
unknown's avatar
unknown committed
1877
  inline time_t query_start() { query_start_used=1; return start_time; }
1878
  inline void set_time()
1879
  {
1880 1881 1882 1883 1884 1885 1886
    if (user_time)
    {
      start_time= user_time;
      start_utime= utime_after_lock= my_micro_time();
    }
    else
      start_utime= utime_after_lock= my_micro_time_and_time(&start_time);
1887
  }
1888 1889 1890 1891 1892 1893 1894 1895
  inline void	set_current_time()    { start_time= my_time(MY_WME); }
  inline void	set_time(time_t t)
  {
    start_time= user_time= t;
    start_utime= utime_after_lock= my_micro_time();
  }
  void set_time_after_lock()  { utime_after_lock= my_micro_time(); }
  ulonglong current_utime()  { return my_micro_time(); }
1896 1897 1898
  inline ulonglong found_rows(void)
  {
    return limit_found_rows;
1899
  }
1900 1901
  inline bool active_transaction()
  {
1902 1903
#ifdef USING_TRANSACTIONS
    return server_status & SERVER_STATUS_IN_TRANS;
1904 1905 1906
#else
    return 0;
#endif
1907
  }
unknown's avatar
unknown committed
1908 1909
  inline bool fill_derived_tables()
  {
unknown's avatar
unknown committed
1910
    return !stmt_arena->is_stmt_prepare() && !lex->only_view_structure();
unknown's avatar
unknown committed
1911
  }
1912 1913 1914 1915
  inline bool fill_information_schema_tables()
  {
    return !stmt_arena->is_stmt_prepare();
  }
1916
  inline void* trans_alloc(unsigned int size)
unknown's avatar
unknown committed
1917
  {
1918 1919
    return alloc_root(&transaction.mem_root,size);
  }
1920

1921 1922 1923 1924
  LEX_STRING *make_lex_string(LEX_STRING *lex_str,
                              const char* str, uint length,
                              bool allocate_lex_string);

1925 1926 1927
  bool convert_string(LEX_STRING *to, CHARSET_INFO *to_cs,
		      const char *from, uint from_length,
		      CHARSET_INFO *from_cs);
1928 1929 1930

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

1931
  void add_changed_table(TABLE *table);
unknown's avatar
unknown committed
1932 1933
  void add_changed_table(const char *key, long key_length);
  CHANGED_TABLE_LIST * changed_table_dup(const char *key, long key_length);
unknown's avatar
unknown committed
1934
  int send_explain_fields(select_result *result);
1935
#ifndef EMBEDDED_LIBRARY
1936 1937 1938 1939 1940 1941 1942
  /**
    Clear the current error, if any.
    We do not clear is_fatal_error or is_fatal_sub_stmt_error since we
    assume this is never called if the fatal error is set.
    @todo: To silence an error, one should use Internal_error_handler
    mechanism. In future this function will be removed.
  */
unknown's avatar
unknown committed
1943 1944
  inline void clear_error()
  {
1945
    DBUG_ENTER("clear_error");
1946 1947
    if (main_da.is_error())
      main_da.reset_diagnostics_area();
1948
    is_slave_error= 0;
1949
    DBUG_VOID_RETURN;
unknown's avatar
unknown committed
1950
  }
1951
  inline bool vio_ok() const { return net.vio != 0; }
1952 1953
#else
  void clear_error();
1954
  inline bool vio_ok() const { return true; }
1955
#endif
1956 1957 1958 1959 1960
  /**
    Mark the current error as fatal. Warning: this does not
    set any error, it sets a property of the error, so must be
    followed or prefixed with my_error().
  */
1961 1962 1963
  inline void fatal_error()
  {
    is_fatal_error= 1;
unknown's avatar
unknown committed
1964
    DBUG_PRINT("error",("Fatal error set"));
1965
  }
1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978
  /**
    TRUE if there is an error in the error stack.

    Please use this method instead of direct access to
    net.report_error.

    If TRUE, the current (sub)-statement should be aborted.
    The main difference between this member and is_fatal_error
    is that a fatal error can not be handled by a stored
    procedure continue handler, whereas a normal error can.

    To raise this flag, use my_error().
  */
1979
  inline bool is_error() const { return main_da.is_error(); }
1980
  inline CHARSET_INFO *charset() { return variables.character_set_client; }
unknown's avatar
unknown committed
1981
  void update_charset();
1982

unknown's avatar
unknown committed
1983
  inline Query_arena *activate_stmt_arena_if_needed(Query_arena *backup)
unknown's avatar
unknown committed
1984 1985
  {
    /*
unknown's avatar
unknown committed
1986 1987
      Use the persistent arena if we are in a prepared statement or a stored
      procedure statement and we have not already changed to use this arena.
unknown's avatar
unknown committed
1988
    */
unknown's avatar
unknown committed
1989
    if (!stmt_arena->is_conventional() && mem_root != stmt_arena->mem_root)
unknown's avatar
unknown committed
1990
    {
unknown's avatar
unknown committed
1991 1992
      set_n_backup_active_arena(stmt_arena, backup);
      return stmt_arena;
unknown's avatar
unknown committed
1993 1994 1995 1996
    }
    return 0;
  }

1997
  void change_item_tree(Item **place, Item *new_value)
1998
  {
1999
    /* TODO: check for OOM condition here */
unknown's avatar
unknown committed
2000
    if (!stmt_arena->is_conventional())
unknown's avatar
unknown committed
2001
      nocheck_register_item_tree_change(place, *place, mem_root);
2002
    *place= new_value;
2003 2004
  }
  void nocheck_register_item_tree_change(Item **place, Item *old_value,
2005
                                         MEM_ROOT *runtime_memroot);
2006
  void rollback_item_tree_changes();
2007 2008 2009 2010 2011 2012

  /*
    Cleanup statement parse state (parse tree, lex) and execution
    state after execution of a non-prepared SQL statement.
  */
  void end_statement();
2013 2014
  inline int killed_errno() const
  {
2015 2016
    killed_state killed_val; /* to cache the volatile 'killed' */
    return (killed_val= killed) != KILL_BAD_DATA ? killed_val : 0;
2017 2018 2019
  }
  inline void send_kill_message() const
  {
unknown's avatar
unknown committed
2020
    int err= killed_errno();
2021 2022
    if (err)
      my_message(err, ER(err), MYF(0));
2023
  }
unknown's avatar
unknown committed
2024 2025 2026 2027
  /* return TRUE if we will abort query if we make a warning now */
  inline bool really_abort_on_warning()
  {
    return (abort_on_warning &&
unknown's avatar
unknown committed
2028
            (!transaction.stmt.modified_non_trans_table ||
unknown's avatar
unknown committed
2029 2030
             (variables.sql_mode & MODE_STRICT_ALL_TABLES)));
  }
2031
  void set_status_var_init();
2032
  bool is_context_analysis_only()
unknown's avatar
unknown committed
2033
    { return stmt_arena->is_stmt_prepare() || lex->view_prepare_mode; }
2034 2035
  void reset_n_backup_open_tables_state(Open_tables_state *backup);
  void restore_backup_open_tables_state(Open_tables_state *backup);
2036 2037
  void reset_sub_statement_state(Sub_statement_state *backup, uint new_state);
  void restore_sub_statement_state(Sub_statement_state *backup);
unknown's avatar
unknown committed
2038 2039
  void set_n_backup_active_arena(Query_arena *set, Query_arena *backup);
  void restore_active_arena(Query_arena *set, Query_arena *backup);
2040

2041 2042
  inline void set_current_stmt_binlog_row_based_if_mixed()
  {
unknown's avatar
unknown committed
2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053
    /*
      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))
2054
      current_stmt_binlog_row_based= TRUE;
unknown's avatar
unknown committed
2055 2056 2057
  }
  inline void set_current_stmt_binlog_row_based()
  {
2058
    current_stmt_binlog_row_based= TRUE;
2059
  }
2060 2061
  inline void clear_current_stmt_binlog_row_based()
  {
2062
    current_stmt_binlog_row_based= FALSE;
2063
  }
2064 2065
  inline void reset_current_stmt_binlog_row_based()
  {
unknown's avatar
unknown committed
2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079
    /*
      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...).
2080 2081

      Don't reset binlog format for NDB binlog injector thread.
unknown's avatar
unknown committed
2082
    */
2083 2084
    if ((temporary_tables == NULL) && (in_sub_stmt == 0) &&
        (system_thread != SYSTEM_THREAD_NDBCLUSTER_BINLOG))
unknown's avatar
unknown committed
2085 2086 2087 2088
    {
      current_stmt_binlog_row_based= 
        test(variables.binlog_format == BINLOG_FORMAT_ROW);
    }
2089
  }
unknown's avatar
unknown committed
2090

2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102
  /**
    Set the current database; use deep copy of C-string.

    @param new_db     a pointer to the new database name.
    @param new_db_len length of the new database name.

    Initialize the current database from a NULL-terminated string with
    length. 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).

2103 2104 2105 2106
    @note This operation just sets {db, db_length}. Switching the current
    database usually involves other actions, like switching other database
    attributes including security context. In the future, this operation
    will be made private and more convenient interface will be provided.
2107 2108 2109 2110

    @return Operation status
      @retval FALSE Success
      @retval TRUE  Out-of-memory error
unknown's avatar
unknown committed
2111
  */
2112
  bool set_db(const char *new_db, size_t new_db_len)
unknown's avatar
unknown committed
2113
  {
2114 2115 2116 2117
    /* Do not reallocate memory if current chunk is big enough. */
    if (db && new_db && db_length >= new_db_len)
      memcpy(db, new_db, new_db_len+1);
    else
unknown's avatar
unknown committed
2118
    {
unknown's avatar
unknown committed
2119 2120
      x_free(db);
      db= new_db ? my_strndup(new_db, new_db_len, MYF(MY_WME)) : NULL;
unknown's avatar
unknown committed
2121
    }
2122 2123
    db_length= db ? new_db_len : 0;
    return new_db && !db;
unknown's avatar
unknown committed
2124
  }
2125 2126 2127 2128 2129 2130 2131

  /**
    Set the current database; use shallow copy of C-string.

    @param new_db     a pointer to the new database name.
    @param new_db_len length of the new database name.

2132 2133 2134 2135
    @note This operation just sets {db, db_length}. Switching the current
    database usually involves other actions, like switching other database
    attributes including security context. In the future, this operation
    will be made private and more convenient interface will be provided.
2136
  */
2137
  void reset_db(char *new_db, size_t new_db_len)
unknown's avatar
unknown committed
2138 2139 2140 2141 2142 2143 2144 2145 2146
  {
    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.
  */
2147
  bool copy_db_to(char **p_db, size_t *p_db_length)
unknown's avatar
unknown committed
2148 2149 2150 2151 2152 2153 2154
  {
    if (db == NULL)
    {
      my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
      return TRUE;
    }
    *p_db= strmake(db, db_length);
2155
    *p_db_length= db_length;
unknown's avatar
unknown committed
2156 2157
    return FALSE;
  }
unknown's avatar
unknown committed
2158
  thd_scheduler scheduler;
unknown's avatar
unknown committed
2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172

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

  /**
    Handle an error condition.
    @param sql_errno the error number
    @param level the error level
    @return true if the error is handled
  */
2173
  virtual bool handle_error(uint sql_errno, const char *message,
unknown's avatar
unknown committed
2174 2175 2176 2177 2178 2179 2180 2181 2182 2183
                            MYSQL_ERROR::enum_warning_level level);

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

private:
  /** The current internal error handler for this thread, or NULL. */
  Internal_error_handler *m_internal_handler;
2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199
  /**
    The lex to hold the parsed tree of conventional (non-prepared) queries.
    Whereas for prepared and stored procedure statements we use an own lex
    instance for each new query, for conventional statements we reuse
    the same lex. (@see mysql_parse for details).
  */
  LEX main_lex;
  /**
    This memory root is used for two purposes:
    - for conventional queries, to allocate structures stored in main_lex
    during parsing, and allocate runtime data (execution plan, etc.)
    during execution.
    - for prepared queries, only to allocate runtime data. The parsed
    tree itself is reused between executions and thus is stored elsewhere.
  */
  MEM_ROOT main_mem_root;
unknown's avatar
unknown committed
2200 2201
};

2202

2203 2204 2205
/** A short cut for thd->main_da.set_ok_status(). */

inline void
2206
my_ok(THD *thd, ha_rows affected_rows= 0, ulonglong id= 0,
2207 2208 2209 2210 2211 2212 2213 2214 2215
        const char *message= NULL)
{
  thd->main_da.set_ok_status(thd, affected_rows, id, message);
}


/** A short cut for thd->main_da.set_eof_status(). */

inline void
2216
my_eof(THD *thd)
2217 2218 2219 2220
{
  thd->main_da.set_eof_status(thd);
}

2221
#define tmp_disable_binlog(A)       \
2222
  {ulonglong tmp_disable_binlog__save_options= (A)->options; \
2223
  (A)->options&= ~OPTION_BIN_LOG
2224

2225
#define reenable_binlog(A)   (A)->options= tmp_disable_binlog__save_options;}
2226

2227

unknown's avatar
unknown committed
2228
/*
2229
  Used to hold information about file and file structure in exchange
unknown's avatar
unknown committed
2230
  via non-DB file (...INTO OUTFILE..., ...LOAD DATA...)
2231
  XXX: We never call destructor for objects of this class.
unknown's avatar
unknown committed
2232
*/
2233

unknown's avatar
unknown committed
2234 2235 2236 2237 2238 2239 2240
class sql_exchange :public Sql_alloc
{
public:
  char *file_name;
  String *field_term,*enclosed,*line_term,*line_start,*escaped;
  bool opt_enclosed;
  bool dumpfile;
2241
  ulong skip_lines;
2242
  CHARSET_INFO *cs;
unknown's avatar
unknown committed
2243 2244 2245 2246 2247 2248
  sql_exchange(char *name,bool dumpfile_flag);
};

#include "log_event.h"

/*
2249
  This is used to get result from a select
unknown's avatar
unknown committed
2250 2251
*/

unknown's avatar
unknown committed
2252 2253
class JOIN;

unknown's avatar
unknown committed
2254 2255 2256
class select_result :public Sql_alloc {
protected:
  THD *thd;
2257
  SELECT_LEX_UNIT *unit;
2258
  uint nest_level;
unknown's avatar
unknown committed
2259 2260 2261
public:
  select_result();
  virtual ~select_result() {};
2262 2263 2264 2265 2266
  virtual int prepare(List<Item> &list, SELECT_LEX_UNIT *u)
  {
    unit= u;
    return 0;
  }
2267
  virtual int prepare2(void) { return 0; }
2268 2269 2270 2271 2272 2273 2274
  /*
    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; }
2275
  virtual bool send_fields(List<Item> &list, uint flags)=0;
unknown's avatar
unknown committed
2276
  virtual bool send_data(List<Item> &items)=0;
unknown's avatar
unknown committed
2277
  virtual bool initialize_tables (JOIN *join=0) { return 0; }
2278
  virtual void send_error(uint errcode,const char *err);
unknown's avatar
unknown committed
2279
  virtual bool send_eof()=0;
2280 2281 2282 2283 2284 2285 2286 2287
  /**
    Check if this query returns a result set and therefore is allowed in
    cursors and set an error message if it is not the case.

    @retval FALSE     success
    @retval TRUE      error, an error message is set
  */
  virtual bool check_simple_select() const;
unknown's avatar
unknown committed
2288
  virtual void abort() {}
2289 2290 2291 2292 2293
  /*
    Cleanup instance of this class for next execution of a prepared
    statement/stored procedure.
  */
  virtual void cleanup();
2294
  void set_thd(THD *thd_arg) { thd= thd_arg; }
2295 2296 2297 2298 2299 2300
  /**
     The nest level, if supported. 
     @return
     -1 if nest level is undefined, otherwise a positive integer.
   */
  int get_nest_level() { return nest_level; }
2301 2302 2303 2304 2305
#ifdef EMBEDDED_LIBRARY
  virtual void begin_dataset() {}
#else
  void begin_dataset() {}
#endif
unknown's avatar
unknown committed
2306 2307 2308
};


2309 2310 2311 2312 2313 2314 2315 2316 2317
/*
  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:
2318
  select_result_interceptor() {}              /* Remove gcc warning */
2319 2320 2321 2322 2323
  uint field_count(List<Item> &fields) const { return 0; }
  bool send_fields(List<Item> &fields, uint flag) { return FALSE; }
};


unknown's avatar
unknown committed
2324
class select_send :public select_result {
2325 2326 2327 2328 2329 2330
  /**
    True if we have sent result set metadata to the client.
    In this case the client always expects us to end the result
    set with an eof or error packet
  */
  bool is_result_set_started;
unknown's avatar
unknown committed
2331
public:
2332
  select_send() :is_result_set_started(FALSE) {}
2333
  bool send_fields(List<Item> &list, uint flags);
unknown's avatar
unknown committed
2334 2335
  bool send_data(List<Item> &items);
  bool send_eof();
2336
  virtual bool check_simple_select() const { return FALSE; }
2337
  void abort();
2338
  virtual void cleanup();
unknown's avatar
unknown committed
2339 2340 2341
};


2342
class select_to_file :public select_result_interceptor {
2343
protected:
unknown's avatar
unknown committed
2344 2345 2346 2347
  sql_exchange *exchange;
  File file;
  IO_CACHE cache;
  ha_rows row_count;
2348 2349 2350 2351 2352 2353 2354
  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);
2355 2356
  bool send_eof();
  void cleanup();
2357 2358 2359
};


unknown's avatar
unknown committed
2360 2361 2362
#define ESCAPE_CHARS "ntrb0ZN" // keep synchronous with READ_INFO::unescape


unknown's avatar
unknown committed
2363 2364 2365 2366 2367 2368
/*
 List of all possible characters of a numeric value text representation.
*/
#define NUMERIC_CHARS ".0123456789e+-"


2369
class select_export :public select_to_file {
unknown's avatar
unknown committed
2370 2371
  uint field_term_length;
  int field_sep_char,escape_char,line_sep_char;
2372
  int field_term_char; // first char of FIELDS TERMINATED BY or MAX_INT
unknown's avatar
unknown committed
2373 2374 2375 2376 2377 2378
  /*
    The is_ambiguous_field_sep field is true if a value of the field_sep_char
    field is one of the 'n', 't', 'r' etc characters
    (see the READ_INFO::unescape method and the ESCAPE_CHARS constant value).
  */
  bool is_ambiguous_field_sep;
2379 2380 2381 2382 2383 2384
  /*
     The is_ambiguous_field_term is true if field_sep_char contains the first
     char of the FIELDS TERMINATED BY (ENCLOSED BY is empty), and items can
     contain this character.
  */
  bool is_ambiguous_field_term;
unknown's avatar
unknown committed
2385 2386 2387 2388 2389 2390
  /*
    The is_unsafe_field_sep field is true if a value of the field_sep_char
    field is one of the '0'..'9', '+', '-', '.' and 'e' characters
    (see the NUMERIC_CHARS constant value).
  */
  bool is_unsafe_field_sep;
unknown's avatar
unknown committed
2391 2392
  bool fixed_row_size;
public:
2393
  select_export(sql_exchange *ex) :select_to_file(ex) {}
2394 2395 2396 2397 2398 2399 2400 2401
  /**
     Creates a select_export to represent INTO OUTFILE <filename> with a
     defined level of subquery nesting.
   */
  select_export(sql_exchange *ex, uint nest_level_arg) :select_to_file(ex) 
  {
    nest_level= nest_level_arg;
  }
unknown's avatar
unknown committed
2402
  ~select_export();
2403
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
2404 2405 2406
  bool send_data(List<Item> &items);
};

unknown's avatar
unknown committed
2407

2408
class select_dump :public select_to_file {
unknown's avatar
unknown committed
2409
public:
2410
  select_dump(sql_exchange *ex) :select_to_file(ex) {}
2411 2412 2413 2414 2415 2416 2417 2418 2419
  /**
     Creates a select_export to represent INTO DUMPFILE <filename> with a
     defined level of subquery nesting.
   */  
  select_dump(sql_exchange *ex, uint nest_level_arg) : 
    select_to_file(ex) 
  {
    nest_level= nest_level_arg;
  }
2420
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
2421 2422
  bool send_data(List<Item> &items);
};
unknown's avatar
unknown committed
2423 2424


2425
class select_insert :public select_result_interceptor {
unknown's avatar
unknown committed
2426
 public:
unknown's avatar
VIEW  
unknown committed
2427
  TABLE_LIST *table_list;
unknown's avatar
unknown committed
2428 2429
  TABLE *table;
  List<Item> *fields;
2430
  ulonglong autoinc_value_of_last_inserted_row; // autogenerated or not
unknown's avatar
unknown committed
2431
  COPY_INFO info;
unknown's avatar
VIEW  
unknown committed
2432
  bool insert_into_view;
unknown's avatar
unknown committed
2433 2434
  select_insert(TABLE_LIST *table_list_par,
		TABLE *table_par, List<Item> *fields_par,
unknown's avatar
unknown committed
2435
		List<Item> *update_fields, List<Item> *update_values,
2436
		enum_duplicates duplic, bool ignore);
unknown's avatar
unknown committed
2437
  ~select_insert();
2438
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
2439
  virtual int prepare2(void);
unknown's avatar
unknown committed
2440
  bool send_data(List<Item> &items);
unknown's avatar
unknown committed
2441
  virtual void store_values(List<Item> &values);
2442
  virtual bool can_rollback_data() { return 0; }
unknown's avatar
unknown committed
2443 2444
  void send_error(uint errcode,const char *err);
  bool send_eof();
2445
  void abort();
2446 2447
  /* not implemented: select_insert is never re-used in prepared statements */
  void cleanup();
unknown's avatar
unknown committed
2448 2449
};

unknown's avatar
unknown committed
2450

unknown's avatar
unknown committed
2451 2452
class select_create: public select_insert {
  ORDER *group;
unknown's avatar
VIEW  
unknown committed
2453
  TABLE_LIST *create_table;
unknown's avatar
unknown committed
2454
  HA_CREATE_INFO *create_info;
2455
  TABLE_LIST *select_tables;
2456
  Alter_info *alter_info;
unknown's avatar
unknown committed
2457
  Field **field;
2458 2459 2460 2461
  /* lock data for tmp table */
  MYSQL_LOCK *m_lock;
  /* m_lock or thd->extra_lock */
  MYSQL_LOCK **m_plock;
unknown's avatar
unknown committed
2462
public:
unknown's avatar
unknown committed
2463
  select_create (TABLE_LIST *table_arg,
unknown's avatar
VIEW  
unknown committed
2464
		 HA_CREATE_INFO *create_info_par,
2465
                 Alter_info *alter_info_arg,
2466 2467
		 List<Item> &select_fields,enum_duplicates duplic, bool ignore,
                 TABLE_LIST *select_tables_arg)
2468
    :select_insert (NULL, NULL, &select_fields, 0, 0, duplic, ignore),
2469
    create_table(table_arg),
2470 2471
    create_info(create_info_par),
    select_tables(select_tables_arg),
2472 2473
    alter_info(alter_info_arg),
    m_plock(NULL)
unknown's avatar
unknown committed
2474
    {}
2475
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
2476

2477
  void binlog_show_create_table(TABLE **tables, uint count);
unknown's avatar
unknown committed
2478
  void store_values(List<Item> &values);
2479
  void send_error(uint errcode,const char *err);
unknown's avatar
unknown committed
2480 2481
  bool send_eof();
  void abort();
2482 2483
  virtual bool can_rollback_data() { return 1; }

2484
  // Needed for access from local class MY_HOOKS in prepare(), since thd is proteted.
2485 2486
  const THD *get_thd(void) { return thd; }
  const HA_CREATE_INFO *get_create_info() { return create_info; };
2487
  int prepare2(void) { return 0; }
unknown's avatar
unknown committed
2488 2489
};

2490 2491
#include <myisam.h>

unknown's avatar
unknown committed
2492 2493 2494 2495 2496
/* 
  Param to create temporary tables when doing SELECT:s 
  NOTE
    This structure is copied using memcpy as a part of JOIN.
*/
2497 2498 2499

class TMP_TABLE_PARAM :public Sql_alloc
{
2500 2501 2502 2503 2504 2505
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:
2506 2507 2508 2509
  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;
2510
  uchar	    *group_buff;
2511 2512 2513 2514 2515 2516 2517 2518 2519
  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;
2520 2521
  /* If >0 convert all blob fields to varchar(convert_blob_length) */
  uint  convert_blob_length; 
unknown's avatar
unknown committed
2522
  CHARSET_INFO *table_charset; 
2523
  bool schema_table;
2524 2525 2526 2527 2528 2529 2530
  /*
    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;
2531
  bool force_copy_fields;
2532 2533

  TMP_TABLE_PARAM()
unknown's avatar
unknown committed
2534
    :copy_field(0), group_parts(0),
unknown's avatar
unknown committed
2535
     group_length(0), group_null_parts(0), convert_blob_length(0),
unknown's avatar
unknown committed
2536
     schema_table(0), precomputed_group_by(0), force_copy_fields(0)
2537 2538 2539 2540 2541
  {}
  ~TMP_TABLE_PARAM()
  {
    cleanup();
  }
2542
  void init(void);
2543 2544 2545 2546 2547
  inline void cleanup(void)
  {
    if (copy_field)				/* Fix for Intel compiler */
    {
      delete [] copy_field;
2548
      save_copy_field= copy_field= 0;
2549 2550 2551 2552
    }
  }
};

2553 2554
class select_union :public select_result_interceptor
{
2555
  TMP_TABLE_PARAM tmp_table_param;
2556 2557
public:
  TABLE *table;
unknown's avatar
unknown committed
2558

2559
  select_union() :table(0) {}
2560
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
2561 2562 2563
  bool send_data(List<Item> &items);
  bool send_eof();
  bool flush();
2564 2565 2566 2567

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

unknown's avatar
unknown committed
2570
/* Base subselect interface class */
2571
class select_subselect :public select_result_interceptor
2572
{
unknown's avatar
unknown committed
2573
protected:
2574 2575 2576
  Item_subselect *item;
public:
  select_subselect(Item_subselect *item);
unknown's avatar
unknown committed
2577
  bool send_data(List<Item> &items)=0;
2578 2579 2580
  bool send_eof() { return 0; };
};

unknown's avatar
unknown committed
2581
/* Single value subselect interface class */
unknown's avatar
unknown committed
2582
class select_singlerow_subselect :public select_subselect
unknown's avatar
unknown committed
2583 2584
{
public:
2585 2586 2587
  select_singlerow_subselect(Item_subselect *item_arg)
    :select_subselect(item_arg)
  {}
unknown's avatar
unknown committed
2588 2589 2590
  bool send_data(List<Item> &items);
};

2591 2592 2593 2594 2595 2596 2597
/* 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:
2598 2599
  select_max_min_finder_subselect(Item_subselect *item_arg, bool mx)
    :select_subselect(item_arg), cache(0), fmax(mx)
2600
  {}
unknown's avatar
Merge  
unknown committed
2601
  void cleanup();
2602 2603 2604
  bool send_data(List<Item> &items);
  bool cmp_real();
  bool cmp_int();
unknown's avatar
Merge  
unknown committed
2605
  bool cmp_decimal();
2606 2607 2608
  bool cmp_str();
};

unknown's avatar
unknown committed
2609 2610 2611 2612
/* EXISTS subselect interface class */
class select_exists_subselect :public select_subselect
{
public:
2613 2614
  select_exists_subselect(Item_subselect *item_arg)
    :select_subselect(item_arg){}
unknown's avatar
unknown committed
2615 2616 2617
  bool send_data(List<Item> &items);
};

unknown's avatar
unknown committed
2618 2619 2620 2621 2622 2623
/* 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 */
2624
  uint   suffix_length;                 /* Length suffix (0-4) */
unknown's avatar
unknown committed
2625
  Item_result result_type;		/* Type of item */
2626 2627
  bool reverse;				/* if descending sort */
  bool need_strxnfrm;			/* If we have to use strxnfrm() */
unknown's avatar
unknown committed
2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640
} 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 */

2641 2642
class Table_ident :public Sql_alloc
{
unknown's avatar
unknown committed
2643
public:
unknown's avatar
unknown committed
2644 2645
  LEX_STRING db;
  LEX_STRING table;
unknown's avatar
unknown committed
2646
  SELECT_LEX_UNIT *sel;
unknown's avatar
unknown committed
2647 2648
  inline Table_ident(THD *thd, LEX_STRING db_arg, LEX_STRING table_arg,
		     bool force)
unknown's avatar
unknown committed
2649
    :table(table_arg), sel((SELECT_LEX_UNIT *)0)
unknown's avatar
unknown committed
2650
  {
unknown's avatar
unknown committed
2651
    if (!force && (thd->client_capabilities & CLIENT_NO_SCHEMA))
unknown's avatar
unknown committed
2652 2653 2654 2655
      db.str=0;
    else
      db= db_arg;
  }
unknown's avatar
unknown committed
2656 2657 2658 2659 2660
  inline Table_ident(LEX_STRING table_arg) 
    :table(table_arg), sel((SELECT_LEX_UNIT *)0)
  {
    db.str=0;
  }
2661 2662 2663 2664 2665 2666
  /*
    This constructor is used only for the case when we create a derived
    table. A derived table has no name and doesn't belong to any database.
    Later, if there was an alias specified for the table, it will be set
    by add_table_to_list.
  */
unknown's avatar
foo1  
unknown committed
2667
  inline Table_ident(SELECT_LEX_UNIT *s) : sel(s)
unknown's avatar
unknown committed
2668
  {
unknown's avatar
unknown committed
2669
    /* We must have a table name here as this is used with add_table_to_list */
2670 2671 2672 2673
    db.str= empty_c_string;                    /* a subject to casedn_str */
    db.length= 0;
    table.str= internal_table_name;
    table.length=1;
unknown's avatar
unknown committed
2674
  }
2675
  bool is_derived_table() const { return test(sel); }
unknown's avatar
unknown committed
2676
  inline void change_db(char *db_name)
unknown's avatar
unknown committed
2677 2678 2679
  {
    db.str= db_name; db.length= (uint) strlen(db_name);
  }
unknown's avatar
unknown committed
2680 2681 2682 2683 2684 2685
};

// this is needed for user_vars hash
class user_var_entry
{
 public:
2686
  user_var_entry() {}                         /* Remove gcc warning */
unknown's avatar
unknown committed
2687 2688
  LEX_STRING name;
  char *value;
2689 2690
  ulong length;
  query_id_t update_query_id, used_query_id;
unknown's avatar
unknown committed
2691
  Item_result type;
2692
  bool unsigned_flag;
2693

unknown's avatar
Merge  
unknown committed
2694
  double val_real(my_bool *null_value);
2695
  longlong val_int(my_bool *null_value) const;
2696
  String *val_str(my_bool *null_value, String *str, uint decimals);
unknown's avatar
Merge  
unknown committed
2697
  my_decimal *val_decimal(my_bool *null_value, my_decimal *result);
2698
  DTCollation collation;
unknown's avatar
unknown committed
2699 2700
};

2701 2702 2703 2704 2705 2706 2707
/*
   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.
 */
2708 2709 2710 2711

class Unique :public Sql_alloc
{
  DYNAMIC_ARRAY file_ptrs;
2712 2713
  ulong max_elements;
  ulonglong max_in_memory_size;
2714 2715
  IO_CACHE file;
  TREE tree;
2716
  uchar *record_pointers;
2717
  bool flush();
2718
  uint size;
2719 2720 2721

public:
  ulong elements;
2722
  Unique(qsort_cmp2 comp_func, void *comp_func_fixed_arg,
2723
	 uint size_arg, ulonglong max_in_memory_size_arg);
2724
  ~Unique();
2725
  ulong elements_in_tree() { return tree.elements_in_tree; }
2726
  inline bool unique_add(void *ptr)
2727
  {
unknown's avatar
Merge  
unknown committed
2728
    DBUG_ENTER("unique_add");
unknown's avatar
unknown committed
2729
    DBUG_PRINT("info", ("tree %u - %lu", tree.elements_in_tree, max_elements));
2730
    if (tree.elements_in_tree > max_elements && flush())
unknown's avatar
Merge  
unknown committed
2731 2732
      DBUG_RETURN(1);
    DBUG_RETURN(!tree_insert(&tree, ptr, 0, tree.custom_arg));
2733 2734 2735
  }

  bool get(TABLE *table);
2736
  static double get_use_cost(uint *buffer, uint nkeys, uint key_size, 
2737
                             ulonglong max_in_memory_size);
2738
  inline static int get_cost_calc_buff_size(ulong nkeys, uint key_size, 
2739
                                            ulonglong max_in_memory_size)
2740
  {
2741
    register ulonglong max_elems_in_tree=
2742
      (1 + max_in_memory_size / ALIGN_SIZE(sizeof(TREE_ELEMENT)+key_size));
2743
    return (int) (sizeof(uint)*(1 + nkeys/max_elems_in_tree));
2744 2745
  }

2746 2747 2748
  void reset();
  bool walk(tree_walk_action action, void *walk_action_arg);

2749 2750
  friend int unique_write_to_file(uchar* key, element_count count, Unique *unique);
  friend int unique_write_to_ptrs(uchar* key, element_count count, Unique *unique);
2751
};
2752

unknown's avatar
unknown committed
2753

2754
class multi_delete :public select_result_interceptor
unknown's avatar
unknown committed
2755 2756
{
  TABLE_LIST *delete_tables, *table_being_deleted;
unknown's avatar
unknown committed
2757
  Unique **tempfiles;
2758
  ha_rows deleted, found;
unknown's avatar
unknown committed
2759 2760
  uint num_of_tables;
  int error;
2761 2762 2763 2764 2765 2766
  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;
2767 2768 2769 2770 2771
  /*
     error handling (rollback and binlogging) can happen in send_eof()
     so that afterward send_error() needs to find out that.
  */
  bool error_handled;
2772

unknown's avatar
unknown committed
2773
public:
2774
  multi_delete(TABLE_LIST *dt, uint num_of_tables);
unknown's avatar
unknown committed
2775 2776 2777 2778 2779
  ~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);
2780
  int  do_deletes();
unknown's avatar
unknown committed
2781
  bool send_eof();
2782
  virtual void abort();
unknown's avatar
unknown committed
2783 2784
};

2785

2786
class multi_update :public select_result_interceptor
unknown's avatar
unknown committed
2787
{
2788 2789 2790
  TABLE_LIST *all_tables; /* query/update command tables */
  TABLE_LIST *leaves;     /* list of leves of join table tree */
  TABLE_LIST *update_tables, *table_being_updated;
unknown's avatar
unknown committed
2791
  TABLE **tmp_tables, *main_table, *table_to_update;
unknown's avatar
unknown committed
2792 2793 2794 2795 2796
  TMP_TABLE_PARAM *tmp_table_param;
  ha_rows updated, found;
  List <Item> *fields, *values;
  List <Item> **fields_for_table, **values_for_table;
  uint table_count;
unknown's avatar
unknown committed
2797 2798 2799 2800 2801
  /*
   List of tables referenced in the CHECK OPTION condition of
   the updated view excluding the updated table. 
  */
  List <TABLE> unupdated_check_opt_tables;
unknown's avatar
unknown committed
2802 2803
  Copy_field *copy_field;
  enum enum_duplicates handle_duplicates;
2804 2805 2806 2807
  bool do_update, trans_safe;
  /* True if the update operation has made a change in a transactional table */
  bool transactional_tables;
  bool ignore;
2808 2809 2810 2811 2812
  /* 
     error handling (rollback and binlogging) can happen in send_eof()
     so that afterward send_error() needs to find out that.
  */
  bool error_handled;
unknown's avatar
unknown committed
2813 2814

public:
2815
  multi_update(TABLE_LIST *ut, TABLE_LIST *leaves_list,
2816
	       List<Item> *fields, List<Item> *values,
2817
	       enum_duplicates handle_duplicates, bool ignore);
unknown's avatar
unknown committed
2818
  ~multi_update();
unknown's avatar
unknown committed
2819
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
2820 2821 2822
  bool send_data(List<Item> &items);
  bool initialize_tables (JOIN *join);
  void send_error(uint errcode,const char *err);
2823
  int  do_updates();
unknown's avatar
unknown committed
2824
  bool send_eof();
2825
  virtual void abort();
unknown's avatar
unknown committed
2826
};
2827

unknown's avatar
unknown committed
2828 2829 2830
class my_var : public Sql_alloc  {
public:
  LEX_STRING s;
unknown's avatar
unknown committed
2831
#ifndef DBUG_OFF
2832 2833 2834 2835
  /*
    Routine to which this Item_splocal belongs. Used for checking if correct
    runtime context is used for variable handling.
  */
2836
  sp_head *sp;
2837
#endif
unknown's avatar
unknown committed
2838 2839
  bool local;
  uint offset;
2840 2841 2842 2843
  enum_field_types type;
  my_var (LEX_STRING& j, bool i, uint o, enum_field_types t)
    :s(j), local(i), offset(o), type(t)
  {}
unknown's avatar
unknown committed
2844 2845
  ~my_var() {}
};
2846

2847
class select_dumpvar :public select_result_interceptor {
unknown's avatar
unknown committed
2848 2849
  ha_rows row_count;
public:
unknown's avatar
unknown committed
2850
  List<my_var> var_list;
2851
  select_dumpvar()  { var_list.empty(); row_count= 0;}
2852 2853 2854 2855 2856 2857 2858 2859 2860 2861
  /**
     Creates a select_dumpvar to represent INTO <variable> with a defined 
     level of subquery nesting.
   */
  select_dumpvar(uint nest_level_arg)
  {
    var_list.empty();
    row_count= 0;
    nest_level= nest_level_arg;
  }
unknown's avatar
unknown committed
2862
  ~select_dumpvar() {}
2863
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
2864 2865
  bool send_data(List<Item> &items);
  bool send_eof();
2866
  virtual bool check_simple_select() const;
2867
  void cleanup();
unknown's avatar
unknown committed
2868
};
2869

2870 2871 2872 2873 2874 2875
/* 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
2876
#define CF_WRITE_LOGS_COMMAND  16
2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889
/**
  Must be set for SQL statements that may contain
  Item expressions and/or use joins and tables.
  Indicates that the parse tree of such statement may
  contain rule-based optimizations that depend on metadata
  (i.e. number of columns in a table), and consequently
  that the statement must be re-prepared whenever
  referenced metadata changes. Must not be set for
  statements that themselves change metadata, e.g. RENAME,
  ALTER and other DDL, since otherwise will trigger constant
  reprepare. Consequently, complex item expressions and
  joins are currently prohibited in these statements.
*/
unknown's avatar
unknown committed
2890
#define CF_REEXECUTION_FRAGILE 32
2891

2892 2893 2894
/* Functions in sql_class.cc */

void add_to_status(STATUS_VAR *to_var, STATUS_VAR *from_var);
2895

2896 2897
void add_diff_to_status(STATUS_VAR *to_var, STATUS_VAR *from_var,
                        STATUS_VAR *dec_var);
2898 2899
void mark_transaction_to_rollback(THD *thd, bool all);

2900
#endif /* MYSQL_SERVER */