sql_class.h 61 KB
Newer Older
unknown's avatar
unknown committed
1
/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
unknown's avatar
unknown committed
2

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

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

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


/* Classes in mysql */

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

24 25
// TODO: create log.h and move all the log header stuff there

unknown's avatar
unknown committed
26 27
class Query_log_event;
class Load_log_event;
28
class Slave_log_event;
29
class Format_description_log_event;
30
class sp_rcontext;
31
class sp_cache;
unknown's avatar
unknown committed
32

33
enum enum_enable_or_disable { LEAVE_AS_IS, ENABLE, DISABLE };
34
enum enum_ha_read_modes { RFIRST, RNEXT, RPREV, RLAST, RKEY, RNEXT_SAME };
35
enum enum_duplicates { DUP_ERROR, DUP_REPLACE, DUP_UPDATE };
36
enum enum_log_type { LOG_CLOSED, LOG_TO_BE_OPENED, LOG_NORMAL, LOG_NEW, LOG_BIN};
37 38
enum enum_delay_key_write { DELAY_KEY_WRITE_NONE, DELAY_KEY_WRITE_ON,
			    DELAY_KEY_WRITE_ALL };
unknown's avatar
unknown committed
39

40 41 42
enum enum_check_fields { CHECK_FIELD_IGNORE, CHECK_FIELD_WARN,
			 CHECK_FIELD_ERROR_FOR_NULL };

unknown's avatar
unknown committed
43
extern char internal_table_name[2];
unknown's avatar
unknown committed
44
extern const char **errmesg;
unknown's avatar
unknown committed
45

46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78
#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;

/*
  Transaction Coordinator log - a base abstract class
  for two different implementations
*/
class TC_LOG
{
  public:
  int using_heuristic_recover();
  TC_LOG() {}
  virtual ~TC_LOG() {}

  virtual int open(const char *opt_name)=0;
  virtual void close()=0;
  virtual int log(THD *thd, my_xid xid)=0;
  virtual void unlog(ulong cookie, my_xid xid)=0;
};

class TC_LOG_DUMMY: public TC_LOG // use it to disable the logging
{
  public:
  int open(const char *opt_name)        { return 0; }
  void close()                          { }
  int log(THD *thd, my_xid xid)         { return 1; }
  void unlog(ulong cookie, my_xid xid)  { }
};

unknown's avatar
unknown committed
79
#ifdef HAVE_MMAP
80 81
class TC_LOG_MMAP: public TC_LOG
{
82
  public:                // only to keep Sun Forte on sol9x86 happy
83 84 85 86 87 88
  typedef enum {
    POOL,                 // page is in pool
    ERROR,                // last sync failed
    DIRTY                 // new xids added since last sync
  } PAGE_STATE;

89
  private:
90 91 92 93 94 95 96 97 98 99 100 101 102
  typedef struct st_page {
    struct st_page *next; // page a linked in a fifo queue
    my_xid *start, *end;  // usable area of a page
    my_xid *ptr;          // next xid will be written here
    int size, free;       // max and current number of free xid slots on the page
    int waiters;          // number of waiters on condition
    PAGE_STATE state;     // see above
    pthread_mutex_t lock; // to access page data or control structure
    pthread_cond_t  cond; // to wait for a sync
  } PAGE;

  char logname[FN_REFLEN];
  File fd;
unknown's avatar
unknown committed
103 104
  my_off_t file_length;
  uint npages, inited;
105
  uchar *data;
unknown's avatar
unknown committed
106 107 108 109 110 111 112
  struct st_page *pages, *syncing, *active, *pool, *pool_last;
  /*
    note that, e.g. LOCK_active is only used to protect
    'active' pointer, to protect the content of the active page
    one has to use active->lock.
    Same for LOCK_pool and LOCK_sync
  */
113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128
  pthread_mutex_t LOCK_active, LOCK_pool, LOCK_sync;
  pthread_cond_t COND_pool, COND_active;

  public:
  TC_LOG_MMAP(): inited(0) {}
  int open(const char *opt_name);
  void close();
  int log(THD *thd, my_xid xid);
  void unlog(ulong cookie, my_xid xid);
  int recover();

  private:
  void get_active_from_pool();
  int sync();
  int overflow();
};
unknown's avatar
unknown committed
129 130 131
#else
#define TC_LOG_MMAP TC_LOG_DUMMY
#endif
132 133 134 135 136

extern TC_LOG *tc_log;
extern TC_LOG_MMAP tc_log_mmap;
extern TC_LOG_DUMMY tc_log_dummy;

137
/* log info errors */
unknown's avatar
unknown committed
138 139 140 141
#define LOG_INFO_EOF -1
#define LOG_INFO_IO  -2
#define LOG_INFO_INVALID -3
#define LOG_INFO_SEEK -4
unknown's avatar
unknown committed
142 143 144
#define LOG_INFO_MEM -6
#define LOG_INFO_FATAL -7
#define LOG_INFO_IN_USE -8
unknown's avatar
unknown committed
145

146 147 148 149 150
/* bitmap to SQL_LOG::close() */
#define LOG_CLOSE_INDEX		1
#define LOG_CLOSE_TO_BE_OPENED	2
#define LOG_CLOSE_STOP_EVENT	4

151 152
struct st_relay_log_info;

unknown's avatar
unknown committed
153 154 155
typedef struct st_log_info
{
  char log_file_name[FN_REFLEN];
156
  my_off_t index_file_offset, index_file_start_offset;
unknown's avatar
unknown committed
157 158 159
  my_off_t pos;
  bool fatal; // if the purge happens to give us a negative offset
  pthread_mutex_t lock;
160
  st_log_info():fatal(0) { pthread_mutex_init(&lock, MY_MUTEX_INIT_FAST);}
unknown's avatar
unknown committed
161
  ~st_log_info() { pthread_mutex_destroy(&lock);}
unknown's avatar
unknown committed
162 163
} LOG_INFO;

unknown's avatar
unknown committed
164 165 166 167 168 169 170 171 172
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;

173 174 175
#define RP_LOCK_LOG_IS_ALREADY_LOCKED 1
#define RP_FORCE_ROTATE               2

unknown's avatar
unknown committed
176
class Log_event;
unknown's avatar
unknown committed
177

178 179 180 181 182 183 184 185 186 187 188 189
/*
  TODO split MYSQL_LOG into base MYSQL_LOG and
  MYSQL_QUERY_LOG, MYSQL_SLOW_LOG, MYSQL_BIN_LOG
  most of the code from MYSQL_LOG should be in the MYSQL_BIN_LOG
  only (TC_LOG included)

  TODO use mmap instead of IO_CACHE for binlog
  (mmap+fsync is two times faster than write+fsync)
*/

class MYSQL_LOG: public TC_LOG
{
unknown's avatar
unknown committed
190
 private:
unknown's avatar
unknown committed
191
  /* LOCK_log and LOCK_index are inited by init_pthread_objects() */
unknown's avatar
unknown committed
192
  pthread_mutex_t LOCK_log, LOCK_index;
unknown's avatar
unknown committed
193 194
  pthread_cond_t update_cond;
  ulonglong bytes_written;
unknown's avatar
unknown committed
195
  time_t last_time,query_start;
196
  IO_CACHE log_file;
197
  IO_CACHE index_file;
unknown's avatar
unknown committed
198 199 200
  char *name;
  char time_buff[20],db[NAME_LEN+1];
  char log_file_name[FN_REFLEN],index_file_name[FN_REFLEN];
unknown's avatar
unknown committed
201 202 203
  // current file sequence number for load data infile binary logging
  uint file_id;
  uint open_count;				// For replication
unknown's avatar
unknown committed
204 205
  volatile enum_log_type log_type;
  enum cache_type io_cache_type;
unknown's avatar
unknown committed
206
  bool write_error, inited;
207
  bool need_start_event;
208 209 210 211 212 213 214
  /*
    no_auto_events means we don't want any of these automatic events :
    Start/Rotate/Stop. That is, in 4.x when we rotate a relay log, we don't want
    a Rotate_log event to be written to the relay log. When we start a relay log
    etc. So in 4.x this is 1 for relay logs, 0 for binlogs.
    In 5.0 it's 0 for relay logs too!
  */
215 216
  bool no_auto_events;
  /*
217 218 219 220 221 222 223
     The max size before rotation (usable only if log_type == LOG_BIN: binary
     logs and relay logs).
     For a binlog, max_size should be max_binlog_size.
     For a relay log, it should be max_relay_log_size if this is non-zero,
     max_binlog_size otherwise.
     max_size is set in init(), and dynamically changed (when one does SET
     GLOBAL MAX_BINLOG_SIZE|MAX_RELAY_LOG_SIZE) by fix_max_binlog_size and
224
     fix_max_relay_log_size).
225 226
  */
  ulong max_size;
227 228 229 230

  ulong prepared_xids; /* for tc log - number of xids to remember */
  pthread_mutex_t LOCK_prep_xids;
  pthread_cond_t  COND_prep_xids;
231 232
  friend class Log_event;

unknown's avatar
unknown committed
233 234
public:
  MYSQL_LOG();
235 236 237 238 239
  /*
    note that there's no destructor ~MYSQL_LOG() !
    The reason is that we don't want it to be automatically called
    on exit() - but only during the correct shutdown process
  */
240

241 242 243 244 245 246 247
  int open(const char *opt_name);
  void close();
  int log(THD *thd, my_xid xid);
  void unlog(ulong cookie, my_xid xid);
  int recover(IO_CACHE *log, Format_description_log_event *fdle);

  /*
248 249 250 251 252 253 254 255 256 257
     These describe the log's format. This is used only for relay logs.
     _for_exec is used by the SQL thread, _for_queue by the I/O thread. It's
     necessary to have 2 distinct objects, because the I/O thread may be reading
     events in a different format from what the SQL thread is reading (consider
     the case of a master which has been upgraded from 5.0 to 5.1 without doing
     RESET MASTER, or from 4.x to 5.0).
  */
  Format_description_log_event *description_event_for_exec,
    *description_event_for_queue;

unknown's avatar
unknown committed
258
  void reset_bytes_written()
unknown's avatar
unknown committed
259 260 261
  {
    bytes_written = 0;
  }
unknown's avatar
unknown committed
262
  void harvest_bytes_written(ulonglong* counter)
unknown's avatar
unknown committed
263
  {
unknown's avatar
unknown committed
264
#ifndef DBUG_OFF
unknown's avatar
unknown committed
265
    char buf1[22],buf2[22];
266
#endif
unknown's avatar
unknown committed
267 268 269 270 271 272 273
    DBUG_ENTER("harvest_bytes_written");
    (*counter)+=bytes_written;
    DBUG_PRINT("info",("counter: %s  bytes_written: %s", llstr(*counter,buf1),
		       llstr(bytes_written,buf2)));
    bytes_written=0;
    DBUG_VOID_RETURN;
  }
274
  void set_max_size(ulong max_size_arg);
unknown's avatar
unknown committed
275
  void signal_update();
276
  void wait_for_update(THD* thd, bool master_or_slave);
277 278
  void set_need_start_event() { need_start_event = 1; }
  void init(enum_log_type log_type_arg,
279 280
	    enum cache_type io_cache_type_arg,
	    bool no_auto_events_arg, ulong max_size);
unknown's avatar
unknown committed
281
  void init_pthread_objects();
unknown's avatar
unknown committed
282
  void cleanup();
283 284 285
  bool open(const char *log_name,
            enum_log_type log_type,
            const char *new_name,
286
	    enum cache_type io_cache_type_arg,
287 288
	    bool no_auto_events_arg, ulong max_size,
            bool null_created);
289 290 291 292 293 294 295
  const char *generate_name(const char *log_name, const char *suffix,
                            bool strip_ext, char *buff);
  /* simplified open_xxx wrappers for the gigantic open above */
  bool open_query_log(const char *log_name)
  {
    char buf[FN_REFLEN];
    return open(generate_name(log_name, ".log", 0, buf),
unknown's avatar
unknown committed
296
                LOG_NORMAL, 0, WRITE_CACHE, 0, 0, 0);
297 298 299 300 301
  }
  bool open_slow_log(const char *log_name)
  {
    char buf[FN_REFLEN];
    return open(generate_name(log_name, "-slow.log", 0, buf),
unknown's avatar
unknown committed
302
                LOG_NORMAL, 0, WRITE_CACHE, 0, 0, 0);
303 304 305
  }
  bool open_index_file(const char *index_file_name_arg,
                       const char *log_name);
306
  void new_file(bool need_lock);
307 308
  bool write(THD *thd, enum enum_server_command command,
	     const char *format,...);
309
  bool write(THD *thd, const char *query, uint query_length,
310
	     time_t query_start=0);
311
  bool write(Log_event* event_info); // binary log write
312
  bool write(THD *thd, IO_CACHE *cache, Log_event *commit_event);
313

unknown's avatar
unknown committed
314 315 316 317
  /*
    v stands for vector
    invoked as appendv(buf1,len1,buf2,len2,...,bufn,lenn,0)
  */
318
  bool appendv(const char* buf,uint len,...);
319
  bool append(Log_event* ev);
320

unknown's avatar
unknown committed
321 322 323
  int generate_new_name(char *new_name,const char *old_name);
  void make_log_name(char* buf, const char* log_ident);
  bool is_active(const char* log_file_name);
324
  int update_log_index(LOG_INFO* linfo, bool need_update_threads);
325
  void rotate_and_purge(uint flags);
326
  bool flush_and_sync();
327
  int purge_logs(const char *to_log, bool included,
328 329 330
                 bool need_mutex, bool need_update_threads,
                 ulonglong *decrease_log_space);
  int purge_logs_before_date(time_t purge_time);
331
  int purge_first_log(struct st_relay_log_info* rli, bool included);
332
  bool reset_logs(THD* thd);
333
  void close(uint exiting);
unknown's avatar
unknown committed
334 335

  // iterating through the log index file
336
  int find_log_pos(LOG_INFO* linfo, const char* log_name,
337 338
		   bool need_mutex);
  int find_next_log(LOG_INFO* linfo, bool need_mutex);
unknown's avatar
unknown committed
339
  int get_current_log(LOG_INFO* linfo);
unknown's avatar
unknown committed
340
  uint next_file_id();
341
  inline bool is_open() { return log_type != LOG_CLOSED; }
unknown's avatar
unknown committed
342 343
  inline char* get_index_fname() { return index_file_name;}
  inline char* get_log_fname() { return log_file_name; }
344
  inline char* get_name() { return name; }
unknown's avatar
unknown committed
345 346 347 348 349
  inline pthread_mutex_t* get_log_lock() { return &LOCK_log; }
  inline IO_CACHE* get_log_file() { return &log_file; }

  inline void lock_index() { pthread_mutex_lock(&LOCK_index);}
  inline void unlock_index() { pthread_mutex_unlock(&LOCK_index);}
350
  inline IO_CACHE *get_index_file() { return &index_file;}
unknown's avatar
unknown committed
351
  inline uint32 get_open_count() { return open_count; }
unknown's avatar
unknown committed
352 353 354 355 356 357 358 359
};

/* character conversion tables */


typedef struct st_copy_info {
  ha_rows records;
  ha_rows deleted;
unknown's avatar
unknown committed
360
  ha_rows updated;
unknown's avatar
unknown committed
361
  ha_rows copied;
362
  ha_rows error_count;
unknown's avatar
unknown committed
363
  enum enum_duplicates handle_duplicates;
364
  int escape_char, last_errno;
365 366
  bool ignore;
  /* for INSERT ... UPDATE */
367 368
  List<Item> *update_fields;
  List<Item> *update_values;
unknown's avatar
unknown committed
369
  /* for VIEW ... WITH CHECK OPTION */
unknown's avatar
unknown committed
370
  TABLE_LIST *view;
unknown's avatar
unknown committed
371 372 373 374 375 376 377 378
} COPY_INFO;


class key_part_spec :public Sql_alloc {
public:
  const char *field_name;
  uint length;
  key_part_spec(const char *name,uint len=0) :field_name(name), length(len) {}
379
  bool operator==(const key_part_spec& other) const;
unknown's avatar
unknown committed
380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403
};


class Alter_drop :public Sql_alloc {
public:
  enum drop_type {KEY, COLUMN };
  const char *name;
  enum drop_type type;
  Alter_drop(enum drop_type par_type,const char *par_name)
    :name(par_name), type(par_type) {}
};


class Alter_column :public Sql_alloc {
public:
  const char *name;
  Item *def;
  Alter_column(const char *par_name,Item *literal)
    :name(par_name), def(literal) {}
};


class Key :public Sql_alloc {
public:
404
  enum Keytype { PRIMARY, UNIQUE, MULTIPLE, FULLTEXT, SPATIAL, FOREIGN_KEY};
unknown's avatar
unknown committed
405
  enum Keytype type;
406
  enum ha_key_alg algorithm;
unknown's avatar
unknown committed
407
  List<key_part_spec> columns;
408
  const char *name;
409
  bool generated;
unknown's avatar
unknown committed
410

411
  Key(enum Keytype type_par, const char *name_arg, enum ha_key_alg alg_par,
412 413 414
      bool generated_arg, List<key_part_spec> &cols)
    :type(type_par), algorithm(alg_par), columns(cols), name(name_arg),
    generated(generated_arg)
415
  {}
unknown's avatar
unknown committed
416
  ~Key() {}
417
  /* Equality comparison of keys (ignoring name) */
418
  friend bool foreign_key_prefix(Key *a, Key *b);
unknown's avatar
unknown committed
419 420
};

421 422 423 424 425 426 427 428 429 430 431 432 433 434 435
class Table_ident;

class foreign_key: public Key {
public:
  enum fk_match_opt { FK_MATCH_UNDEF, FK_MATCH_FULL,
		      FK_MATCH_PARTIAL, FK_MATCH_SIMPLE};
  enum fk_option { FK_OPTION_UNDEF, FK_OPTION_RESTRICT, FK_OPTION_CASCADE,
		   FK_OPTION_SET_NULL, FK_OPTION_NO_ACTION, FK_OPTION_DEFAULT};

  Table_ident *ref_table;
  List<key_part_spec> ref_columns;
  uint delete_opt, update_opt, match_opt;
  foreign_key(const char *name_arg, List<key_part_spec> &cols,
	      Table_ident *table,   List<key_part_spec> &ref_cols,
	      uint delete_opt_arg, uint update_opt_arg, uint match_opt_arg)
436
    :Key(FOREIGN_KEY, name_arg, HA_KEY_ALG_UNDEF, 0, cols),
437 438 439 440 441
    ref_table(table), ref_columns(cols),
    delete_opt(delete_opt_arg), update_opt(update_opt_arg),
    match_opt(match_opt_arg)
  {}
};
unknown's avatar
unknown committed
442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460

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

461 462
/* Needed to be able to have an I_List of char* strings in mysqld.cc. */

unknown's avatar
unknown committed
463 464 465 466 467 468 469 470
class i_string: public ilink
{
public:
  char* ptr;
  i_string():ptr(0) { }
  i_string(char* s) : ptr(s) {}
};

471
/* needed for linked list of two strings for replicate-rewrite-db */
unknown's avatar
unknown committed
472 473 474 475 476 477
class i_string_pair: public ilink
{
public:
  char* key;
  char* val;
  i_string_pair():key(0),val(0) { }
unknown's avatar
unknown committed
478
  i_string_pair(char* key_arg, char* val_arg) : key(key_arg),val(val_arg) {}
unknown's avatar
unknown committed
479 480 481
};


unknown's avatar
unknown committed
482
class delayed_insert;
unknown's avatar
unknown committed
483
class select_result;
unknown's avatar
unknown committed
484

485 486 487 488 489
#define THD_SENTRY_MAGIC 0xfeedd1ff
#define THD_SENTRY_GONE  0xdeadbeef

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

490 491
struct system_variables
{
unknown's avatar
unknown committed
492 493
  ulonglong myisam_max_extra_sort_file_size;
  ulonglong myisam_max_sort_file_size;
494 495
  ha_rows select_limit;
  ha_rows max_join_size;
496
  ulong auto_increment_increment, auto_increment_offset;
unknown's avatar
unknown committed
497
  ulong bulk_insert_buff_size;
498 499
  ulong join_buff_size;
  ulong long_query_time;
unknown's avatar
unknown committed
500
  ulong max_allowed_packet;
501
  ulong max_error_count;
502
  ulong max_heap_table_size;
unknown's avatar
unknown committed
503
  ulong max_length_for_sort_data;
504
  ulong max_sort_length;
505
  ulong max_tmp_tables;
506
  ulong max_insert_delayed_threads;
unknown's avatar
unknown committed
507
  ulong multi_range_count;
508
  ulong myisam_repair_threads;
unknown's avatar
unknown committed
509 510
  ulong myisam_sort_buff_size;
  ulong net_buffer_length;
511
  ulong net_interactive_timeout;
unknown's avatar
unknown committed
512
  ulong net_read_timeout;
513
  ulong net_retry_count;
514
  ulong net_wait_timeout;
unknown's avatar
unknown committed
515
  ulong net_write_timeout;
516 517
  ulong optimizer_prune_level;
  ulong optimizer_search_depth;
unknown's avatar
unknown committed
518
  ulong preload_buff_size;
unknown's avatar
unknown committed
519 520 521
  ulong query_cache_type;
  ulong read_buff_size;
  ulong read_rnd_buff_size;
unknown's avatar
unknown committed
522
  ulong div_precincrement;
523
  ulong sortbuff_size;
524
  ulong table_type;
525
  ulong tmp_table_size;
unknown's avatar
unknown committed
526
  ulong tx_isolation;
unknown's avatar
Merge  
unknown committed
527
  ulong completion_type;
528
  /* Determines which non-standard SQL behaviour should be enabled */
529
  ulong sql_mode;
unknown's avatar
VIEW  
unknown committed
530
  /* check of key presence in updatable view */
531
  ulong updatable_views_with_limit;
unknown's avatar
unknown committed
532
  ulong default_week_format;
533
  ulong max_seeks_for_key;
534 535 536 537 538
  ulong range_alloc_block_size;
  ulong query_alloc_block_size;
  ulong query_prealloc_size;
  ulong trans_alloc_block_size;
  ulong trans_prealloc_size;
539
  ulong log_warnings;
540
  ulong group_concat_max_len;
unknown's avatar
unknown committed
541 542 543 544 545 546
  /*
    In slave thread we need to know in behalf of which
    thread the query is being run to replicate temp tables properly
  */
  ulong pseudo_thread_id;

unknown's avatar
unknown committed
547 548
  my_bool low_priority_updates;
  my_bool new_mode;
549
  my_bool query_cache_wlock_invalidate;
unknown's avatar
unknown committed
550
  my_bool engine_condition_pushdown;
unknown's avatar
Merge  
unknown committed
551 552 553 554 555
#ifdef HAVE_REPLICATION
  ulong sync_replication;
  ulong sync_replication_slave_id;
  ulong sync_replication_timeout;
#endif /* HAVE_REPLICATION */
556
#ifdef HAVE_INNOBASE_DB
557
  my_bool innodb_table_locks;
558
  my_bool innodb_support_xa;
559
#endif /* HAVE_INNOBASE_DB */
560 561 562 563 564 565
#ifdef HAVE_NDBCLUSTER_DB
  ulong ndb_autoincrement_prefetch_sz;
  my_bool ndb_force_send;
  my_bool ndb_use_exact_count;
  my_bool ndb_use_transactions;
#endif /* HAVE_NDBCLUSTER_DB */
566
  my_bool old_passwords;
567
  
568
  /* Only charset part of these variables is sensible */
569 570
  CHARSET_INFO 	*character_set_client;
  CHARSET_INFO  *character_set_results;
571 572 573 574
  
  /* Both charset and collation parts of these variables are important */
  CHARSET_INFO	*collation_server;
  CHARSET_INFO	*collation_database;
unknown's avatar
unknown committed
575
  CHARSET_INFO  *collation_connection;
576

577 578
  Time_zone *time_zone;

579 580 581 582
  /* DATE, DATETIME and TIME formats */
  DATE_TIME_FORMAT *date_format;
  DATE_TIME_FORMAT *datetime_format;
  DATE_TIME_FORMAT *time_format;
unknown's avatar
unknown committed
583 584
};

585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607

/* per thread status variables */

typedef struct system_status_var
{
  ulong bytes_received;
  ulong bytes_sent;
  ulong com_other;
  ulong com_stat[(uint) SQLCOM_END];
  ulong created_tmp_disk_tables;
  ulong created_tmp_tables;
  ulong ha_commit_count;
  ulong ha_delete_count;
  ulong ha_read_first_count;
  ulong ha_read_last_count;
  ulong ha_read_key_count;
  ulong ha_read_next_count;
  ulong ha_read_prev_count;
  ulong ha_read_rnd_count;
  ulong ha_read_rnd_next_count;
  ulong ha_rollback_count;
  ulong ha_update_count;
  ulong ha_write_count;
608 609 610 611
  ulong ha_prepare_count;
  ulong ha_discover_count;
  ulong ha_savepoint_count;
  ulong ha_savepoint_rollback_count;
612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633

  /* 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;
  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;
unknown's avatar
unknown committed
634 635 636 637 638 639 640
  /* Ppepared statements and binary protocol */
  ulong com_stmt_prepare;
  ulong com_stmt_execute;
  ulong com_stmt_send_long_data;
  ulong com_stmt_fetch;
  ulong com_stmt_reset;
  ulong com_stmt_close;
641 642

  double last_query_cost;
643 644 645 646 647 648 649
} STATUS_VAR;

/*
  This is used for 'show status'. It must be updated to the last ulong
  variable in system_status_var
*/

unknown's avatar
unknown committed
650
#define last_system_status_var com_stmt_close
651 652


653
void free_tmp_table(THD *thd, TABLE *entry);
654 655


unknown's avatar
unknown committed
656 657 658 659 660 661 662 663
/* The following macro is to make init of Query_arena simpler */
#ifndef DBUG_OFF
#define INIT_ARENA_DBUG_INFO is_backup_arena= 0
#else 
#define INIT_ARENA_DBUG_INFO  
#endif


unknown's avatar
unknown committed
664
class Query_arena
665 666 667 668 669 670 671
{
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
672
  MEM_ROOT *mem_root;                   // Pointer to current memroot
unknown's avatar
unknown committed
673
#ifndef DBUG_OFF
674
  bool is_backup_arena; /* True if this arena is used for backup. */
unknown's avatar
unknown committed
675
#endif
unknown's avatar
unknown committed
676
  enum enum_state
677
  {
678 679
    INITIALIZED= 0, INITIALIZED_FOR_SP= 1, PREPARED= 2,
    CONVENTIONAL_EXECUTION= 3, EXECUTED= 4, ERROR= -1
680
  };
unknown's avatar
unknown committed
681

unknown's avatar
unknown committed
682
  enum_state state;
683 684 685 686 687 688 689

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

690 691
  Query_arena(MEM_ROOT *mem_root_arg, enum enum_state state_arg) :
    free_list(0), mem_root(mem_root_arg), state(state_arg)
692
  { INIT_ARENA_DBUG_INFO; }
693
  /*
unknown's avatar
unknown committed
694 695
    This constructor is used only when Query_arena is created as
    backup storage for another instance of Query_arena.
696
  */
697 698
  Query_arena() { INIT_ARENA_DBUG_INFO; }

699
  virtual Type type() const;
unknown's avatar
unknown committed
700
  virtual ~Query_arena() {};
701

702
  inline bool is_stmt_prepare() const { return state == INITIALIZED; }
703 704
  inline bool is_first_sp_execute() const
  { return state == INITIALIZED_FOR_SP; }
705 706
  inline bool is_stmt_prepare_or_first_sp_execute() const
  { return (int)state < (int)PREPARED; }
unknown's avatar
unknown committed
707
  inline bool is_first_stmt_execute() const { return state == PREPARED; }
708 709
  inline bool is_stmt_execute() const
  { return state == PREPARED || state == EXECUTED; }
unknown's avatar
unknown committed
710
  inline bool is_conventional() const
unknown's avatar
unknown committed
711
  { return state == CONVENTIONAL_EXECUTION; }
712

unknown's avatar
unknown committed
713
  inline gptr alloc(unsigned int size) { return alloc_root(mem_root,size); }
714 715 716
  inline gptr calloc(unsigned int size)
  {
    gptr ptr;
unknown's avatar
unknown committed
717
    if ((ptr=alloc_root(mem_root,size)))
718 719 720 721
      bzero((char*) ptr,size);
    return ptr;
  }
  inline char *strdup(const char *str)
unknown's avatar
unknown committed
722
  { return strdup_root(mem_root,str); }
723
  inline char *strmake(const char *str, uint size)
unknown's avatar
unknown committed
724
  { return strmake_root(mem_root,str,size); }
725
  inline char *memdup(const char *str, uint size)
unknown's avatar
unknown committed
726
  { return memdup_root(mem_root,str,size); }
727 728 729
  inline char *memdup_w_gap(const char *str, uint size, uint gap)
  {
    gptr ptr;
unknown's avatar
unknown committed
730
    if ((ptr=alloc_root(mem_root,size+gap)))
731 732 733 734
      memcpy(ptr,str,size);
    return ptr;
  }

unknown's avatar
unknown committed
735 736 737
  void set_n_backup_item_arena(Query_arena *set, Query_arena *backup);
  void restore_backup_item_arena(Query_arena *set, Query_arena *backup);
  void set_item_arena(Query_arena *set);
738 739

  void free_items();
740 741
};

742 743 744

class Cursor;

745 746 747 748 749 750 751 752 753 754 755 756 757 758
/*
  State of a single command executed against this connection.
  One connection can contain a lot of simultaneously running statements,
  some of which could be:
   - prepared, that is, contain placeholders,
   - opened as cursors. We maintain 1 to 1 relationship between
     statement and cursor - if user wants to create another cursor for his
     query, we create another statement for it. 
  To perform some action with statement we reset THD part to the state  of
  that statement, do the action, and then save back modified state from THD
  to the statement. It will be changed in near future, and Statement will
  be used explicitly.
*/

759
class Statement: public ilink, public Query_arena
760
{
761 762
  Statement(const Statement &rhs);              /* not implemented: */
  Statement &operator=(const Statement &rhs);   /* non-copyable */
763
public:
764 765
  /* FIXME: these must be protected */
  MEM_ROOT main_mem_root;
766
  LEX     main_lex;
unknown's avatar
unknown committed
767

768
  /*
unknown's avatar
unknown committed
769
    Uniquely identifies each statement object in thread scope; change during
770
    statement lifetime. FIXME: must be const
771
  */
unknown's avatar
unknown committed
772
   ulong id;
773 774

  /*
775
    - if set_query_id=1, we set field->query_id for all fields. In that case 
776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792
    field list can not contain duplicates.
  */
  bool set_query_id;
  /*
    This variable is used in post-parse stage to declare that sum-functions,
    or functions which have sense only if GROUP BY is present, are allowed.
    For example in queries
    SELECT MIN(i) FROM foo
    SELECT GROUP_CONCAT(a, b, MIN(i)) FROM ... GROUP BY ...
    MIN(i) have no sense.
    Though it's grammar-related issue, it's hard to catch it out during the
    parse stage because GROUP BY clause goes in the end of query. This
    variable is mainly used in setup_fields/fix_fields.
    See item_sum.cc for details.
  */
  bool allow_sum_func;

793
  LEX_STRING name; /* name for named prepared statements */
794 795 796 797 798
  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.
799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815

    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.
816 817 818
  */
  char *query;
  uint32 query_length;                          // current query length
819
  Cursor *cursor;
820

821 822
public:

unknown's avatar
unknown committed
823 824
  /* This constructor is called for backup statements */
  Statement() { clear_alloc_root(&main_mem_root); }
825

unknown's avatar
unknown committed
826 827
  Statement(enum enum_state state_arg, ulong id_arg,
            ulong alloc_block_size, ulong prealloc_size);
828
  virtual ~Statement();
829 830 831

  /* Assign execution context (note: not all members) of given stmt to self */
  void set_statement(Statement *stmt);
832 833
  void set_n_backup_statement(Statement *stmt, Statement *backup);
  void restore_backup_statement(Statement *stmt, Statement *backup);
834 835
  /* return class type */
  virtual Type type() const;
836 837
  /* Close the cursor open for this statement, if there is one */
  virtual void close_cursor();
838 839 840 841
};


/*
842 843 844 845 846
  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
847

848 849
  Statements are auto-deleted when they are removed from the map and when the
  map is deleted.
850 851 852 853 854 855
*/

class Statement_map
{
public:
  Statement_map();
856

857 858 859
  int insert(Statement *statement);

  Statement *find_by_name(LEX_STRING *name)
860
  {
861 862 863 864
    Statement *stmt;
    stmt= (Statement*)hash_search(&names_hash, (byte*)name->str,
                                  name->length);
    return stmt;
865
  }
866 867

  Statement *find(ulong id)
868
  {
869
    if (last_found_statement == 0 || id != last_found_statement->id)
870 871 872
    {
      Statement *stmt;
      stmt= (Statement *) hash_search(&st_hash, (byte *) &id, sizeof(id));
873
      if (stmt && stmt->name.str)
874 875 876
        return NULL;
      last_found_statement= stmt;
    }
877
    return last_found_statement;
878 879 880
  }
  void erase(Statement *statement)
  {
881 882
    if (statement == last_found_statement)
      last_found_statement= 0;
883 884 885 886
    if (statement->name.str)
    {
      hash_delete(&names_hash, (byte *) statement);  
    }
887 888
    hash_delete(&st_hash, (byte *) statement);
  }
889 890 891 892 893 894 895 896 897
  void add_transient_cursor(Statement *stmt)
  { transient_cursor_list.append(stmt); }
  void erase_transient_cursor(Statement *stmt) { stmt->unlink(); }
  /*
    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();
898 899 900
  /* Erase all statements (calls Statement destructor) */
  void reset()
  {
901 902
    my_hash_reset(&names_hash);
    my_hash_reset(&st_hash);
903
    transient_cursor_list.empty();
904 905
    last_found_statement= 0;
  }
906

907
  void destroy()
908
  {
909
    hash_free(&names_hash);
910
    hash_free(&st_hash);
911
  }
912 913
private:
  HASH st_hash;
914
  HASH names_hash;
915
  I_List<Statement> transient_cursor_list;
916
  Statement *last_found_statement;
917 918
};

919 920 921 922 923 924 925
struct st_savepoint {
  struct st_savepoint *prev;
  char                *name;
  uint                 length, nht;
};

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

928 929 930 931 932 933 934 935 936 937 938
/*
  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;


939 940 941 942 943 944 945 946 947
/*
  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};


948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 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
/*
  Class that holds information about tables which were open and locked
  by the thread. It is also used to save/restore this information in
  push_open_tables_state()/pop_open_tables_state().
*/

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

  Open_tables_state();

  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;
    lock= locked_tables= 0;
    prelocked_mode= NON_PRELOCKED;
  }
};


unknown's avatar
unknown committed
1028 1029 1030 1031
/*
  For each client connection we create a separate thread with THD serving as
  a thread/connection descriptor
*/
1032

1033
class THD :public Statement,
1034
           public Open_tables_state
unknown's avatar
unknown committed
1035
{
unknown's avatar
unknown committed
1036
public:
1037 1038
#ifdef EMBEDDED_LIBRARY
  struct st_mysql  *mysql;
unknown's avatar
SCRUM  
unknown committed
1039 1040 1041
  struct st_mysql_data *data;
  unsigned long	 client_stmt_id;
  unsigned long  client_param_count;
unknown's avatar
unknown committed
1042
  struct st_mysql_bind *client_params;
unknown's avatar
unknown committed
1043 1044
  char *extra_data;
  ulong extra_length;
unknown's avatar
unknown committed
1045
  String query_rest;
1046
#endif
unknown's avatar
unknown committed
1047
  NET	  net;				// client connection descriptor
1048
  MEM_ROOT warn_root;			// For warnings and errors
1049 1050 1051
  Protocol *protocol;			// Current protocol
  Protocol_simple protocol_simple;	// Normal protocol
  Protocol_prep protocol_prep;		// Binary protocol
unknown's avatar
unknown committed
1052 1053
  HASH    user_vars;			// hash for user variables
  String  packet;			// dynamic buffer for network I/O
1054
  String  convert_buffer;               // buffer for charset conversions
unknown's avatar
unknown committed
1055 1056 1057
  struct  sockaddr_in remote;		// client socket address
  struct  rand_struct rand;		// used for authentication
  struct  system_variables variables;	// Changeable local variables
1058
  struct  system_status_var status_var; // Per thread statistic vars
1059 1060 1061 1062
  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.
1063
  pthread_mutex_t LOCK_delete;		// Locked before thd is deleted
1064 1065
  /* all prepared statements and cursors of this connection */
  Statement_map stmt_map; 
unknown's avatar
unknown committed
1066 1067 1068 1069 1070 1071
  /*
    A pointer to the stack frame of handle_one_connection(),
    which is called first in the thread for handling a client
  */
  char	  *thread_stack;

1072 1073 1074 1075
  /*
    host - host of the client
    user - user of the client, set to NULL until the user has been read from
     the connection
1076
    priv_user - The user privilege we are using. May be '' for anonymous user.
1077
    db - currently selected database
1078
    catalog - currently selected catalog
1079
    ip - client IP
1080 1081 1082 1083 1084 1085 1086
    WARNING: some members of THD (currently 'db', 'catalog' and 'query')  are
    set and alloced by the slave SQL thread (for the THD of that thread); that
    thread is (and must remain, for now) the only responsible for freeing these
    3 members. If you add members here, and you add code to set them in
    replication, don't forget to free_them_and_set_them_to_0 in replication
    properly. For details see the 'err:' label of the pthread_handler_decl of
    the slave SQL thread, in sql/slave.cc.
1087
   */
1088
  char	  *host,*user,*priv_user,*db,*catalog,*ip;
1089
  char	  priv_host[MAX_HOSTNAME];
unknown's avatar
unknown committed
1090 1091
  /* remote (peer) port */
  uint16 peer_port;
1092 1093 1094 1095 1096
  /*
    Points to info-string that we show in SHOW PROCESSLIST
    You are supposed to update thd->proc_info only if you have coded
    a time-consuming piece that MySQL can get stuck in for a long time.
  */
unknown's avatar
unknown committed
1097 1098 1099
  const char *proc_info;
  /* points to host if host is available, otherwise points to ip */
  const char *host_or_ip;
1100

1101
  ulong client_capabilities;		/* What the client supports */
1102
  ulong max_client_packet_length;
unknown's avatar
unknown committed
1103 1104
  ulong master_access;			/* Global privileges from mysql.user */
  ulong db_access;			/* Privileges for current db */
1105

unknown's avatar
unknown committed
1106
  HASH		handler_tables_hash;
unknown's avatar
unknown committed
1107 1108 1109 1110 1111
  /*
    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. 
  */
1112
  User_level_lock *ull;
1113 1114
#ifndef DBUG_OFF
  uint dbug_sentry; // watch out for memory corruption
1115
#endif
unknown's avatar
unknown committed
1116
  struct st_my_thread_var *mysys_var;
1117
  /*
1118
    Type of current query: COM_STMT_PREPARE, COM_QUERY, etc. Set from
1119 1120 1121
    first byte of the packet in do_command()
  */
  enum enum_server_command command;
unknown's avatar
unknown committed
1122
  uint32     server_id;
unknown's avatar
unknown committed
1123
  uint32     file_id;			// for LOAD DATA INFILE
1124 1125 1126 1127 1128
  /*
    Used in error messages to tell user in what part of MySQL we found an
    error. E. g. when where= "having clause", if fix_fields() fails, user
    will know that the error was in having clause.
  */
unknown's avatar
unknown committed
1129
  const char *where;
unknown's avatar
unknown committed
1130 1131
  time_t     start_time,time_after_lock,user_time;
  time_t     connect_time,thr_create_time; // track down slow pthread_create
unknown's avatar
unknown committed
1132 1133
  thr_lock_type update_lock_default;
  delayed_insert *di;
unknown's avatar
unknown committed
1134
  my_bool    tablespace_op;	/* This is TRUE in DISCARD/IMPORT TABLESPACE */
1135 1136 1137 1138
  
  /* TRUE if we are inside of trigger or stored function. */
  bool in_sub_stmt;
  
1139 1140
  /* container for handler's private per-connection data */
  void *ha_data[MAX_HA];
unknown's avatar
unknown committed
1141
  struct st_transactions {
1142
    SAVEPOINT *savepoints;
unknown's avatar
unknown committed
1143 1144
    THD_TRANS all;			// Trans since BEGIN WORK
    THD_TRANS stmt;			// Trans for current statement
1145 1146 1147
    bool on;                            // see ha_enable_transaction()
    XID  xid;                           // transaction identifier
    enum xa_states xa_state;            // used by external XA only
1148
    /*
1149
       Tables changed in transaction (that must be invalidated in query cache).
1150
       List contain only transactional tables, that not invalidated in query
1151 1152 1153 1154 1155 1156
       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()
    {
1157 1158
      changed_tables= 0;
      savepoints= 0;
1159
#ifdef USING_TRANSACTIONS
1160
      free_root(&mem_root,MYF(MY_KEEP_PREALLOC));
1161
#endif
1162
    }
1163 1164 1165 1166 1167 1168 1169 1170
#ifdef USING_TRANSACTIONS
    st_transactions()
    {
      bzero((char*)this, sizeof(*this));
      xid.null();
      init_sql_alloc(&mem_root, ALLOC_ROOT_MIN_BLOCK_SIZE, 0);
    }
#endif
unknown's avatar
unknown committed
1171 1172 1173 1174 1175
  } transaction;
  Field      *dupp_field;
#ifndef __WIN__
  sigset_t signals,block_signals;
#endif
1176 1177
#ifdef SIGNAL_WITH_VIO_CLOSE
  Vio* active_vio;
1178
#endif
1179 1180 1181 1182
  /*
    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
1183 1184
    rollback_item_tree_changes(). For conventional execution it's always
    empty.
1185 1186 1187
  */
  Item_change_list change_list;

unknown's avatar
unknown committed
1188
  /*
unknown's avatar
unknown committed
1189 1190 1191 1192 1193 1194 1195 1196 1197 1198
    A permanent memory area of the statement. For conventional
    execution, the parsed tree and execution runtime reside in the same
    memory root. In this case current_arena points to THD. In case of
    a prepared statement or a stored procedure statement, thd->mem_root
    conventionally points to runtime memory, and thd->current_arena
    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
    current_arena, to allow correct re-execution of PS/SP.
    Note: in the parser, current_arena == thd, even for PS/SP.
unknown's avatar
unknown committed
1199
  */
unknown's avatar
unknown committed
1200
  Query_arena *current_arena;
1201 1202 1203 1204 1205
  /*
    next_insert_id is set on SET INSERT_ID= #. This is used as the next
    generated auto_increment value in handler.cc
  */
  ulonglong  next_insert_id;
1206 1207
  /* Remember last next_insert_id to reset it if something went wrong */
  ulonglong  prev_insert_id;
1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219
  /*
    The insert_id used for the last statement or set by SET LAST_INSERT_ID=#
    or SELECT LAST_INSERT_ID(#).  Used for binary log and returned by
    LAST_INSERT_ID()
  */
  ulonglong  last_insert_id;
  /*
    Set to the first value that LAST_INSERT_ID() returned for the last
    statement.  When this is set, last_insert_id_used is set to true.
  */
  ulonglong  current_insert_id;
  ulonglong  limit_found_rows;
unknown's avatar
unknown committed
1220
  ha_rows    cuted_fields,
unknown's avatar
unknown committed
1221
             sent_row_count, examined_row_count;
unknown's avatar
unknown committed
1222
  table_map  used_tables;
1223
  USER_CONN *user_connect;
1224
  CHARSET_INFO *db_charset;
unknown's avatar
unknown committed
1225 1226 1227
  /*
    FIXME: this, and some other variables like 'count_cuted_fields'
    maybe should be statement/cursor local, that is, moved to Statement
1228 1229
    class. With current implementation warnings produced in each prepared
    statement/cursor settle here.
unknown's avatar
unknown committed
1230
  */
1231
  List	     <MYSQL_ERROR> warn_list;
1232
  uint	     warn_count[(uint) MYSQL_ERROR::WARN_LEVEL_END];
unknown's avatar
unknown committed
1233
  uint	     total_warn_count;
1234
  List	     <Open_tables_state> open_state_list;
1235 1236 1237 1238 1239 1240 1241 1242
  /*
    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).
  */
1243
  query_id_t query_id, warn_id;
1244
  ulong	     options, thread_id, col_access;
1245 1246 1247

  /* Statement id is thread-wide. This counter is used to generate ids */
  ulong      statement_id_counter;
1248
  ulong	     rand_saved_seed1, rand_saved_seed2;
1249
  ulong      row_count;  // Row counter, mainly for errors and warnings
unknown's avatar
unknown committed
1250
  long	     dbug_thread_id;
unknown's avatar
unknown committed
1251
  pthread_t  real_id;
1252
  uint	     tmp_table, global_read_lock;
1253
  uint	     server_status,open_options,system_thread;
unknown's avatar
unknown committed
1254
  uint32     db_length;
unknown's avatar
unknown committed
1255
  uint       select_number;             //number of select (used for EXPLAIN)
unknown's avatar
unknown committed
1256 1257
  /* variables.transaction_isolation is reset to this after each commit */
  enum_tx_isolation session_tx_isolation;
1258
  enum_check_fields count_cuted_fields;
unknown's avatar
unknown committed
1259 1260
  /* for user variables replication*/
  DYNAMIC_ARRAY user_var_events;
1261

unknown's avatar
unknown committed
1262
  enum killed_state { NOT_KILLED=0, KILL_BAD_DATA=1, KILL_CONNECTION=ER_SERVER_SHUTDOWN, KILL_QUERY=ER_QUERY_INTERRUPTED };
1263 1264
  killed_state volatile killed;

1265
  /* scramble - random string sent to client on handshake */
unknown's avatar
unknown committed
1266
  char	     scramble[SCRAMBLE_LENGTH+1];
1267

1268
  bool       slave_thread, one_shot_set;
1269
  bool	     locked, some_tables_deleted;
1270
  bool       last_cuted_field;
1271
  bool	     no_errors, password, is_fatal_error;
1272 1273
  bool	     query_start_used, rand_used, time_zone_used;
  bool	     last_insert_id_used,insert_id_used, clear_next_insert_id;
1274
  bool	     in_lock_tables;
unknown's avatar
unknown committed
1275
  bool       query_error, bootstrap, cleanup_done;
unknown's avatar
unknown committed
1276
  bool	     tmp_table_used;
unknown's avatar
unknown committed
1277
  bool	     charset_is_system_charset, charset_is_collation_connection;
1278
  bool       enable_slow_log;   /* enable slow log for current statement */
unknown's avatar
unknown committed
1279
  bool	     no_trans_update, abort_on_warning;
unknown's avatar
Merge  
unknown committed
1280
  bool 	     got_warning;       /* Set on call to push_warning() */
1281
  bool	     no_warnings_for_error; /* no warnings on call to my_error() */
1282 1283
  /* set during loop of derived table processing */
  bool       derived_tables_processing;
1284
  longlong   row_count_func;	/* For the ROW_COUNT() function */
1285
  sp_rcontext *spcont;		// SP runtime context
1286 1287
  sp_cache   *sp_proc_cache;
  sp_cache   *sp_func_cache;
unknown's avatar
unknown committed
1288

unknown's avatar
unknown committed
1289 1290 1291 1292 1293
  /*
    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
1294
  LOG_INFO*  current_linfo;
unknown's avatar
unknown committed
1295
  NET*       slave_net;			// network connection from slave -> m.
unknown's avatar
unknown committed
1296 1297 1298 1299 1300 1301 1302
  /* Used by the sys_var class to store temporary values */
  union
  {
    my_bool my_bool_value;
    long    long_value;
  } sys_var_tmp;

unknown's avatar
unknown committed
1303 1304
  THD();
  ~THD();
1305

unknown's avatar
unknown committed
1306
  void init(void);
1307 1308 1309 1310 1311 1312 1313 1314 1315 1316
  /*
    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
1317
  void change_user(void);
unknown's avatar
unknown committed
1318
  void cleanup(void);
1319
  void cleanup_after_query();
unknown's avatar
unknown committed
1320
  bool store_globals();
1321 1322
#ifdef SIGNAL_WITH_VIO_CLOSE
  inline void set_active_vio(Vio* vio)
1323
  {
1324
    pthread_mutex_lock(&LOCK_delete);
1325
    active_vio = vio;
1326
    pthread_mutex_unlock(&LOCK_delete);
1327
  }
1328
  inline void clear_active_vio()
1329
  {
1330
    pthread_mutex_lock(&LOCK_delete);
1331
    active_vio = 0;
1332
    pthread_mutex_unlock(&LOCK_delete);
1333
  }
unknown's avatar
unknown committed
1334
  void close_active_vio();
1335
#endif
unknown's avatar
SCRUM  
unknown committed
1336
  void awake(THD::killed_state state_to_set);
1337 1338
  /*
    For enter_cond() / exit_cond() to work the mutex must be got before
1339 1340
    enter_cond(); this mutex is then released by exit_cond().
    Usage must be: lock mutex; enter_cond(); your code; exit_cond().
1341
  */
unknown's avatar
unknown committed
1342 1343 1344 1345
  inline const char* enter_cond(pthread_cond_t *cond, pthread_mutex_t* mutex,
			  const char* msg)
  {
    const char* old_msg = proc_info;
1346
    safe_mutex_assert_owner(mutex);
unknown's avatar
unknown committed
1347 1348 1349 1350 1351 1352 1353
    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
1354 1355 1356 1357 1358 1359 1360
    /*
      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
1361 1362 1363 1364 1365 1366
    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
1367
  inline time_t query_start() { query_start_used=1; return start_time; }
unknown's avatar
unknown committed
1368
  inline void	set_time()    { if (user_time) start_time=time_after_lock=user_time; else time_after_lock=time(&start_time); }
1369
  inline void	end_time()    { time(&start_time); }
unknown's avatar
unknown committed
1370
  inline void	set_time(time_t t) { time_after_lock=start_time=user_time=t; }
1371
  inline void	lock_time()   { time(&time_after_lock); }
1372 1373 1374 1375 1376
  inline void	insert_id(ulonglong id_arg)
  {
    last_insert_id= id_arg;
    insert_id_used=1;
  }
unknown's avatar
unknown committed
1377 1378 1379
  inline ulonglong insert_id(void)
  {
    if (!last_insert_id_used)
1380
    {
unknown's avatar
unknown committed
1381 1382 1383 1384 1385
      last_insert_id_used=1;
      current_insert_id=last_insert_id;
    }
    return last_insert_id;
  }
1386 1387 1388
  inline ulonglong found_rows(void)
  {
    return limit_found_rows;
1389
  }
1390 1391
  inline bool active_transaction()
  {
1392 1393
#ifdef USING_TRANSACTIONS
    return server_status & SERVER_STATUS_IN_TRANS;
1394 1395 1396
#else
    return 0;
#endif
1397
  }
unknown's avatar
unknown committed
1398 1399
  inline bool fill_derived_tables()
  {
1400
    return !current_arena->is_stmt_prepare() && !lex->only_view_structure();
unknown's avatar
unknown committed
1401 1402 1403
  }
  inline gptr trans_alloc(unsigned int size)
  {
1404 1405
    return alloc_root(&transaction.mem_root,size);
  }
1406 1407 1408 1409

  bool convert_string(LEX_STRING *to, CHARSET_INFO *to_cs,
		      const char *from, uint from_length,
		      CHARSET_INFO *from_cs);
1410 1411 1412

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

1413
  void add_changed_table(TABLE *table);
unknown's avatar
unknown committed
1414 1415
  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
1416
  int send_explain_fields(select_result *result);
1417
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
1418 1419 1420 1421 1422
  inline void clear_error()
  {
    net.last_error[0]= 0;
    net.last_errno= 0;
    net.report_error= 0;
unknown's avatar
unknown committed
1423
    query_error= 0;
unknown's avatar
unknown committed
1424
  }
1425
  inline bool vio_ok() const { return net.vio != 0; }
1426 1427
#else
  void clear_error();
1428
  inline bool vio_ok() const { return true; }
1429
#endif
1430 1431 1432
  inline void fatal_error()
  {
    is_fatal_error= 1;
unknown's avatar
unknown committed
1433
    net.report_error= 1;
unknown's avatar
unknown committed
1434
    DBUG_PRINT("error",("Fatal error set"));
1435
  }
1436
  inline CHARSET_INFO *charset() { return variables.character_set_client; }
unknown's avatar
unknown committed
1437
  void update_charset();
1438

unknown's avatar
unknown committed
1439
  inline Query_arena *change_arena_if_needed(Query_arena *backup)
unknown's avatar
unknown committed
1440 1441 1442 1443 1444
  {
    /*
      use new arena if we are in a prepared statements and we have not
      already changed to use this arena.
    */
unknown's avatar
unknown committed
1445
    if (!current_arena->is_conventional() &&
1446
        mem_root != current_arena->mem_root)
unknown's avatar
unknown committed
1447 1448 1449 1450 1451 1452 1453
    {
      set_n_backup_item_arena(current_arena, backup);
      return current_arena;
    }
    return 0;
  }

1454
  void change_item_tree(Item **place, Item *new_value)
1455
  {
1456
    /* TODO: check for OOM condition here */
unknown's avatar
unknown committed
1457
    if (!current_arena->is_conventional())
unknown's avatar
unknown committed
1458
      nocheck_register_item_tree_change(place, *place, mem_root);
1459
    *place= new_value;
1460 1461
  }
  void nocheck_register_item_tree_change(Item **place, Item *old_value,
1462
                                         MEM_ROOT *runtime_memroot);
1463
  void rollback_item_tree_changes();
1464 1465 1466 1467 1468 1469

  /*
    Cleanup statement parse state (parse tree, lex) and execution
    state after execution of a non-prepared SQL statement.
  */
  void end_statement();
1470 1471
  inline int killed_errno() const
  {
unknown's avatar
unknown committed
1472
    return killed != KILL_BAD_DATA ? killed : 0;
1473 1474 1475
  }
  inline void send_kill_message() const
  {
unknown's avatar
unknown committed
1476
    int err= killed_errno();
1477 1478
    if (err)
      my_message(err, ER(err), MYF(0));
1479
  }
unknown's avatar
unknown committed
1480 1481 1482 1483 1484 1485 1486
  /* return TRUE if we will abort query if we make a warning now */
  inline bool really_abort_on_warning()
  {
    return (abort_on_warning &&
            (!no_trans_update ||
             (variables.sql_mode & MODE_STRICT_ALL_TABLES)));
  }
1487
  void set_status_var_init();
1488 1489
  bool is_context_analysis_only()
    { return current_arena->is_stmt_prepare() || lex->view_prepare_mode; }
1490 1491
  bool push_open_tables_state();
  void pop_open_tables_state();
unknown's avatar
unknown committed
1492 1493
};

1494

1495
#define tmp_disable_binlog(A)       \
1496 1497
  {ulong tmp_disable_binlog__save_options= (A)->options; \
  (A)->options&= ~OPTION_BIN_LOG
1498

1499
#define reenable_binlog(A)   (A)->options= tmp_disable_binlog__save_options;}
1500

1501 1502 1503 1504 1505
/* Flags for the THD::system_thread (bitmap) variable */
#define SYSTEM_THREAD_DELAYED_INSERT 1
#define SYSTEM_THREAD_SLAVE_IO 2
#define SYSTEM_THREAD_SLAVE_SQL 4

unknown's avatar
unknown committed
1506 1507 1508
/*
  Used to hold information about file and file structure in exchainge 
  via non-DB file (...INTO OUTFILE..., ...LOAD DATA...)
1509
  XXX: We never call destructor for objects of this class.
unknown's avatar
unknown committed
1510
*/
1511

unknown's avatar
unknown committed
1512 1513 1514 1515 1516 1517 1518
class sql_exchange :public Sql_alloc
{
public:
  char *file_name;
  String *field_term,*enclosed,*line_term,*line_start,*escaped;
  bool opt_enclosed;
  bool dumpfile;
1519
  ulong skip_lines;
unknown's avatar
unknown committed
1520 1521 1522 1523 1524 1525
  sql_exchange(char *name,bool dumpfile_flag);
};

#include "log_event.h"

/*
1526
  This is used to get result from a select
unknown's avatar
unknown committed
1527 1528
*/

unknown's avatar
unknown committed
1529 1530
class JOIN;

unknown's avatar
unknown committed
1531 1532 1533
class select_result :public Sql_alloc {
protected:
  THD *thd;
1534
  SELECT_LEX_UNIT *unit;
unknown's avatar
unknown committed
1535 1536 1537
public:
  select_result();
  virtual ~select_result() {};
1538 1539 1540 1541 1542
  virtual int prepare(List<Item> &list, SELECT_LEX_UNIT *u)
  {
    unit= u;
    return 0;
  }
1543
  virtual int prepare2(void) { return 0; }
1544 1545 1546 1547 1548 1549 1550
  /*
    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; }
1551
  virtual bool send_fields(List<Item> &list, uint flags)=0;
unknown's avatar
unknown committed
1552
  virtual bool send_data(List<Item> &items)=0;
unknown's avatar
unknown committed
1553
  virtual bool initialize_tables (JOIN *join=0) { return 0; }
1554
  virtual void send_error(uint errcode,const char *err);
unknown's avatar
unknown committed
1555
  virtual bool send_eof()=0;
unknown's avatar
unknown committed
1556
  virtual bool simple_select() { return 0; }
unknown's avatar
unknown committed
1557
  virtual void abort() {}
1558 1559 1560 1561 1562
  /*
    Cleanup instance of this class for next execution of a prepared
    statement/stored procedure.
  */
  virtual void cleanup();
unknown's avatar
unknown committed
1563 1564 1565
};


1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579
/*
  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:
  uint field_count(List<Item> &fields) const { return 0; }
  bool send_fields(List<Item> &fields, uint flag) { return FALSE; }
};


unknown's avatar
unknown committed
1580 1581 1582
class select_send :public select_result {
public:
  select_send() {}
1583
  bool send_fields(List<Item> &list, uint flags);
unknown's avatar
unknown committed
1584 1585
  bool send_data(List<Item> &items);
  bool send_eof();
unknown's avatar
unknown committed
1586
  bool simple_select() { return 1; }
unknown's avatar
unknown committed
1587 1588 1589
};


1590
class select_to_file :public select_result_interceptor {
1591
protected:
unknown's avatar
unknown committed
1592 1593 1594 1595
  sql_exchange *exchange;
  File file;
  IO_CACHE cache;
  ha_rows row_count;
1596 1597 1598 1599 1600 1601 1602
  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);
1603 1604
  bool send_eof();
  void cleanup();
1605 1606 1607 1608
};


class select_export :public select_to_file {
unknown's avatar
unknown committed
1609 1610 1611 1612
  uint field_term_length;
  int field_sep_char,escape_char,line_sep_char;
  bool fixed_row_size;
public:
1613
  select_export(sql_exchange *ex) :select_to_file(ex) {}
unknown's avatar
unknown committed
1614
  ~select_export();
1615
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
1616 1617 1618
  bool send_data(List<Item> &items);
};

unknown's avatar
unknown committed
1619

1620
class select_dump :public select_to_file {
unknown's avatar
unknown committed
1621
public:
1622
  select_dump(sql_exchange *ex) :select_to_file(ex) {}
1623
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
1624 1625
  bool send_data(List<Item> &items);
};
unknown's avatar
unknown committed
1626 1627


1628
class select_insert :public select_result_interceptor {
unknown's avatar
unknown committed
1629
 public:
unknown's avatar
VIEW  
unknown committed
1630
  TABLE_LIST *table_list;
unknown's avatar
unknown committed
1631 1632 1633 1634
  TABLE *table;
  List<Item> *fields;
  ulonglong last_insert_id;
  COPY_INFO info;
unknown's avatar
VIEW  
unknown committed
1635
  bool insert_into_view;
unknown's avatar
unknown committed
1636

unknown's avatar
unknown committed
1637 1638
  select_insert(TABLE_LIST *table_list_par,
		TABLE *table_par, List<Item> *fields_par,
unknown's avatar
unknown committed
1639
		List<Item> *update_fields, List<Item> *update_values,
1640
		enum_duplicates duplic, bool ignore);
unknown's avatar
unknown committed
1641
  ~select_insert();
1642
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
1643
  int prepare2(void);
unknown's avatar
unknown committed
1644
  bool send_data(List<Item> &items);
unknown's avatar
unknown committed
1645
  virtual void store_values(List<Item> &values);
unknown's avatar
unknown committed
1646 1647
  void send_error(uint errcode,const char *err);
  bool send_eof();
1648 1649
  /* not implemented: select_insert is never re-used in prepared statements */
  void cleanup();
unknown's avatar
unknown committed
1650 1651
};

unknown's avatar
unknown committed
1652

unknown's avatar
unknown committed
1653 1654
class select_create: public select_insert {
  ORDER *group;
unknown's avatar
VIEW  
unknown committed
1655
  TABLE_LIST *create_table;
unknown's avatar
unknown committed
1656 1657 1658 1659 1660 1661
  List<create_field> *extra_fields;
  List<Key> *keys;
  HA_CREATE_INFO *create_info;
  MYSQL_LOCK *lock;
  Field **field;
public:
unknown's avatar
VIEW  
unknown committed
1662 1663 1664 1665
  select_create (TABLE_LIST *table,
		 HA_CREATE_INFO *create_info_par,
		 List<create_field> &fields_par,
		 List<Key> &keys_par,
1666 1667
		 List<Item> &select_fields,enum_duplicates duplic, bool ignore)
    :select_insert (NULL, NULL, &select_fields, 0, 0, duplic, ignore), create_table(table),
unknown's avatar
VIEW  
unknown committed
1668 1669
    extra_fields(&fields_par),keys(&keys_par), create_info(create_info_par),
    lock(0)
unknown's avatar
unknown committed
1670
    {}
1671
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
1672
  void store_values(List<Item> &values);
1673
  void send_error(uint errcode,const char *err);
unknown's avatar
unknown committed
1674 1675 1676 1677
  bool send_eof();
  void abort();
};

1678 1679
#include <myisam.h>

unknown's avatar
unknown committed
1680 1681 1682 1683 1684
/* 
  Param to create temporary tables when doing SELECT:s 
  NOTE
    This structure is copied using memcpy as a part of JOIN.
*/
1685 1686 1687

class TMP_TABLE_PARAM :public Sql_alloc
{
1688 1689 1690 1691 1692 1693
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:
1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707
  List<Item> copy_funcs;
  List<Item> save_copy_funcs;
  Copy_field *copy_field, *copy_field_end;
  Copy_field *save_copy_field, *save_copy_field_end;
  byte	    *group_buff;
  Item	    **items_to_copy;			/* Fields in tmp table */
  MI_COLUMNDEF *recinfo,*start_recinfo;
  KEY *keyinfo;
  ha_rows end_write_records;
  uint	field_count,sum_func_count,func_count;
  uint  hidden_field_count;
  uint	group_parts,group_length,group_null_parts;
  uint	quick_group;
  bool  using_indirect_summary_function;
1708 1709
  /* If >0 convert all blob fields to varchar(convert_blob_length) */
  uint  convert_blob_length; 
unknown's avatar
unknown committed
1710
  CHARSET_INFO *table_charset; 
1711
  bool schema_table;
1712 1713

  TMP_TABLE_PARAM()
unknown's avatar
unknown committed
1714
    :copy_field(0), group_parts(0),
unknown's avatar
unknown committed
1715 1716
     group_length(0), group_null_parts(0), convert_blob_length(0),
     schema_table(0)
1717 1718 1719 1720 1721
  {}
  ~TMP_TABLE_PARAM()
  {
    cleanup();
  }
1722
  void init(void);
1723 1724 1725 1726 1727
  inline void cleanup(void)
  {
    if (copy_field)				/* Fix for Intel compiler */
    {
      delete [] copy_field;
1728
      save_copy_field= copy_field= 0;
1729 1730 1731 1732
    }
  }
};

1733
class select_union :public select_result_interceptor {
unknown's avatar
unknown committed
1734 1735
 public:
  TABLE *table;
1736
  TMP_TABLE_PARAM tmp_table_param;
unknown's avatar
unknown committed
1737 1738 1739

  select_union(TABLE *table_par);
  ~select_union();
1740
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
1741 1742 1743
  bool send_data(List<Item> &items);
  bool send_eof();
  bool flush();
1744
  void set_table(TABLE *tbl) { table= tbl; }
unknown's avatar
unknown committed
1745 1746
};

unknown's avatar
unknown committed
1747
/* Base subselect interface class */
1748
class select_subselect :public select_result_interceptor
1749
{
unknown's avatar
unknown committed
1750
protected:
1751 1752 1753
  Item_subselect *item;
public:
  select_subselect(Item_subselect *item);
unknown's avatar
unknown committed
1754
  bool send_data(List<Item> &items)=0;
1755 1756 1757
  bool send_eof() { return 0; };
};

unknown's avatar
unknown committed
1758
/* Single value subselect interface class */
unknown's avatar
unknown committed
1759
class select_singlerow_subselect :public select_subselect
unknown's avatar
unknown committed
1760 1761
{
public:
unknown's avatar
unknown committed
1762
  select_singlerow_subselect(Item_subselect *item):select_subselect(item){}
unknown's avatar
unknown committed
1763 1764 1765
  bool send_data(List<Item> &items);
};

1766 1767 1768 1769 1770 1771 1772 1773 1774 1775
/* used in independent ALL/ANY optimisation */
class select_max_min_finder_subselect :public select_subselect
{
  Item_cache *cache;
  bool (select_max_min_finder_subselect::*op)();
  bool fmax;
public:
  select_max_min_finder_subselect(Item_subselect *item, bool mx)
    :select_subselect(item), cache(0), fmax(mx)
  {}
unknown's avatar
Merge  
unknown committed
1776
  void cleanup();
1777 1778 1779
  bool send_data(List<Item> &items);
  bool cmp_real();
  bool cmp_int();
unknown's avatar
Merge  
unknown committed
1780
  bool cmp_decimal();
1781 1782 1783
  bool cmp_str();
};

unknown's avatar
unknown committed
1784 1785 1786 1787 1788 1789 1790 1791
/* EXISTS subselect interface class */
class select_exists_subselect :public select_subselect
{
public:
  select_exists_subselect(Item_subselect *item):select_subselect(item){}
  bool send_data(List<Item> &items);
};

unknown's avatar
unknown committed
1792 1793 1794 1795 1796 1797 1798
/* 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 */
  Item_result result_type;		/* Type of item */
1799 1800
  bool reverse;				/* if descending sort */
  bool need_strxnfrm;			/* If we have to use strxnfrm() */
unknown's avatar
unknown committed
1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813
} 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 */

1814 1815
class Table_ident :public Sql_alloc
{
unknown's avatar
unknown committed
1816 1817 1818
 public:
  LEX_STRING db;
  LEX_STRING table;
unknown's avatar
unknown committed
1819
  SELECT_LEX_UNIT *sel;
unknown's avatar
unknown committed
1820 1821
  inline Table_ident(THD *thd, LEX_STRING db_arg, LEX_STRING table_arg,
		     bool force)
unknown's avatar
unknown committed
1822
    :table(table_arg), sel((SELECT_LEX_UNIT *)0)
unknown's avatar
unknown committed
1823
  {
unknown's avatar
unknown committed
1824
    if (!force && (thd->client_capabilities & CLIENT_NO_SCHEMA))
unknown's avatar
unknown committed
1825 1826 1827 1828
      db.str=0;
    else
      db= db_arg;
  }
unknown's avatar
unknown committed
1829 1830 1831 1832 1833 1834 1835
  inline Table_ident(LEX_STRING table_arg) 
    :table(table_arg), sel((SELECT_LEX_UNIT *)0)
  {
    db.str=0;
  }
  inline Table_ident(SELECT_LEX_UNIT *s) : sel(s) 
  {
unknown's avatar
unknown committed
1836 1837
    /* We must have a table name here as this is used with add_table_to_list */
    db.str=0; table.str= internal_table_name; table.length=1;
unknown's avatar
unknown committed
1838
  }
unknown's avatar
unknown committed
1839
  inline void change_db(char *db_name)
unknown's avatar
unknown committed
1840 1841 1842
  {
    db.str= db_name; db.length= (uint) strlen(db_name);
  }
unknown's avatar
unknown committed
1843 1844 1845 1846 1847 1848 1849 1850
};

// this is needed for user_vars hash
class user_var_entry
{
 public:
  LEX_STRING name;
  char *value;
1851 1852
  ulong length;
  query_id_t update_query_id, used_query_id;
unknown's avatar
unknown committed
1853
  Item_result type;
1854

unknown's avatar
Merge  
unknown committed
1855
  double val_real(my_bool *null_value);
1856 1857
  longlong val_int(my_bool *null_value);
  String *val_str(my_bool *null_value, String *str, uint decimals);
unknown's avatar
Merge  
unknown committed
1858
  my_decimal *val_decimal(my_bool *null_value, my_decimal *result);
1859
  DTCollation collation;
unknown's avatar
unknown committed
1860 1861
};

1862 1863 1864 1865 1866 1867 1868
/*
   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.
 */
1869 1870 1871 1872 1873 1874 1875

class Unique :public Sql_alloc
{
  DYNAMIC_ARRAY file_ptrs;
  ulong max_elements, max_in_memory_size;
  IO_CACHE file;
  TREE tree;
unknown's avatar
unknown committed
1876
  byte *record_pointers;
1877
  bool flush();
1878
  uint size;
1879 1880 1881

public:
  ulong elements;
1882
  Unique(qsort_cmp2 comp_func, void *comp_func_fixed_arg,
1883
	 uint size_arg, ulong max_in_memory_size_arg);
1884
  ~Unique();
1885
  ulong elements_in_tree() { return tree.elements_in_tree; }
1886
  inline bool unique_add(void *ptr)
1887
  {
unknown's avatar
Merge  
unknown committed
1888 1889
    DBUG_ENTER("unique_add");
    DBUG_PRINT("info", ("tree %u - %u", tree.elements_in_tree, max_elements));
1890
    if (tree.elements_in_tree > max_elements && flush())
unknown's avatar
Merge  
unknown committed
1891 1892
      DBUG_RETURN(1);
    DBUG_RETURN(!tree_insert(&tree, ptr, 0, tree.custom_arg));
1893 1894 1895
  }

  bool get(TABLE *table);
1896
  static double get_use_cost(uint *buffer, uint nkeys, uint key_size, 
1897
                             ulong max_in_memory_size);
1898 1899 1900 1901 1902 1903 1904 1905
  inline static int get_cost_calc_buff_size(ulong nkeys, uint key_size, 
                                            ulong max_in_memory_size)
  {
    register ulong max_elems_in_tree= 
      (1 + max_in_memory_size / ALIGN_SIZE(sizeof(TREE_ELEMENT)+key_size));
    return sizeof(uint)*(1 + nkeys/max_elems_in_tree);
  }

1906 1907 1908
  void reset();
  bool walk(tree_walk_action action, void *walk_action_arg);

1909 1910
  friend int unique_write_to_file(gptr key, element_count count, Unique *unique);
  friend int unique_write_to_ptrs(gptr key, element_count count, Unique *unique);
1911
};
1912

unknown's avatar
unknown committed
1913

1914
class multi_delete :public select_result_interceptor
unknown's avatar
unknown committed
1915 1916
{
  TABLE_LIST *delete_tables, *table_being_deleted;
unknown's avatar
unknown committed
1917
  Unique **tempfiles;
unknown's avatar
unknown committed
1918
  THD *thd;
1919
  ha_rows deleted, found;
unknown's avatar
unknown committed
1920 1921
  uint num_of_tables;
  int error;
1922 1923
  bool do_delete, transactional_tables, normal_tables, delete_while_scanning;

unknown's avatar
unknown committed
1924 1925 1926 1927 1928 1929 1930
public:
  multi_delete(THD *thd, TABLE_LIST *dt, uint num_of_tables);
  ~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);
1931
  int  do_deletes();
unknown's avatar
unknown committed
1932 1933 1934
  bool send_eof();
};

1935

1936
class multi_update :public select_result_interceptor
unknown's avatar
unknown committed
1937
{
1938 1939 1940
  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
1941
  THD *thd;
unknown's avatar
unknown committed
1942
  TABLE **tmp_tables, *main_table, *table_to_update;
unknown's avatar
unknown committed
1943 1944 1945 1946 1947 1948 1949
  TMP_TABLE_PARAM *tmp_table_param;
  ha_rows updated, found;
  List <Item> *fields, *values;
  List <Item> **fields_for_table, **values_for_table;
  uint table_count;
  Copy_field *copy_field;
  enum enum_duplicates handle_duplicates;
unknown's avatar
unknown committed
1950
  bool do_update, trans_safe, transactional_tables, ignore;
unknown's avatar
unknown committed
1951 1952

public:
1953 1954
  multi_update(THD *thd_arg, TABLE_LIST *ut, TABLE_LIST *leaves_list,
	       List<Item> *fields, List<Item> *values,
1955
	       enum_duplicates handle_duplicates, bool ignore);
unknown's avatar
unknown committed
1956
  ~multi_update();
unknown's avatar
unknown committed
1957
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
1958 1959 1960 1961 1962 1963
  bool send_data(List<Item> &items);
  bool initialize_tables (JOIN *join);
  void send_error(uint errcode,const char *err);
  int  do_updates (bool from_send_error);
  bool send_eof();
};
1964

unknown's avatar
unknown committed
1965 1966 1967 1968 1969
class my_var : public Sql_alloc  {
public:
  LEX_STRING s;
  bool local;
  uint offset;
1970 1971 1972 1973
  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
1974 1975
  ~my_var() {}
};
1976

1977
class select_dumpvar :public select_result_interceptor {
unknown's avatar
unknown committed
1978 1979
  ha_rows row_count;
public:
unknown's avatar
unknown committed
1980
  List<my_var> var_list;
1981
  List<Item_func_set_user_var> vars;
unknown's avatar
unknown committed
1982 1983
  List<Item_splocal> local_vars;
  select_dumpvar(void)  { var_list.empty(); local_vars.empty(); vars.empty(); row_count=0;}
unknown's avatar
unknown committed
1984
  ~select_dumpvar() {}
1985
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
1986 1987
  bool send_data(List<Item> &items);
  bool send_eof();
1988
  void cleanup();
unknown's avatar
unknown committed
1989
};
1990 1991 1992 1993

/* Functions in sql_class.cc */

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