sql_class.h 61.2 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
/*
  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;

1012 1013 1014 1015 1016 1017 1018
  /*
    This constructor serves for creation of Open_tables_state instances
    which are used as backup storage.
  */
  Open_tables_state() {};

  Open_tables_state(ulong version_arg);
1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033

  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
1034 1035 1036 1037
/*
  For each client connection we create a separate thread with THD serving as
  a thread/connection descriptor
*/
1038

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

1078 1079 1080 1081
  /*
    host - host of the client
    user - user of the client, set to NULL until the user has been read from
     the connection
1082
    priv_user - The user privilege we are using. May be '' for anonymous user.
1083
    db - currently selected database
1084
    catalog - currently selected catalog
1085
    ip - client IP
1086 1087 1088 1089 1090 1091 1092
    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.
1093
   */
1094
  char	  *host,*user,*priv_user,*db,*catalog,*ip;
1095
  char	  priv_host[MAX_HOSTNAME];
unknown's avatar
unknown committed
1096 1097
  /* remote (peer) port */
  uint16 peer_port;
1098 1099 1100 1101 1102
  /*
    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
1103 1104 1105
  const char *proc_info;
  /* points to host if host is available, otherwise points to ip */
  const char *host_or_ip;
1106

1107
  ulong client_capabilities;		/* What the client supports */
1108
  ulong max_client_packet_length;
unknown's avatar
unknown committed
1109 1110
  ulong master_access;			/* Global privileges from mysql.user */
  ulong db_access;			/* Privileges for current db */
1111

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

unknown's avatar
unknown committed
1194
  /*
unknown's avatar
unknown committed
1195 1196 1197 1198 1199 1200 1201 1202 1203 1204
    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
1205
  */
unknown's avatar
unknown committed
1206
  Query_arena *current_arena;
1207 1208 1209 1210 1211
  /*
    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;
1212 1213
  /* Remember last next_insert_id to reset it if something went wrong */
  ulonglong  prev_insert_id;
1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225
  /*
    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
1226
  ha_rows    cuted_fields,
unknown's avatar
unknown committed
1227
             sent_row_count, examined_row_count;
unknown's avatar
unknown committed
1228
  table_map  used_tables;
1229
  USER_CONN *user_connect;
1230
  CHARSET_INFO *db_charset;
unknown's avatar
unknown committed
1231 1232 1233
  /*
    FIXME: this, and some other variables like 'count_cuted_fields'
    maybe should be statement/cursor local, that is, moved to Statement
1234 1235
    class. With current implementation warnings produced in each prepared
    statement/cursor settle here.
unknown's avatar
unknown committed
1236
  */
1237
  List	     <MYSQL_ERROR> warn_list;
1238
  uint	     warn_count[(uint) MYSQL_ERROR::WARN_LEVEL_END];
unknown's avatar
unknown committed
1239
  uint	     total_warn_count;
1240 1241 1242 1243 1244 1245 1246 1247
  /*
    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).
  */
1248
  query_id_t query_id, warn_id;
1249 1250
  ulonglong  options;
  ulong      thread_id, col_access;
1251 1252 1253

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

unknown's avatar
unknown committed
1268
  enum killed_state { NOT_KILLED=0, KILL_BAD_DATA=1, KILL_CONNECTION=ER_SERVER_SHUTDOWN, KILL_QUERY=ER_QUERY_INTERRUPTED };
1269 1270
  killed_state volatile killed;

1271
  /* scramble - random string sent to client on handshake */
unknown's avatar
unknown committed
1272
  char	     scramble[SCRAMBLE_LENGTH+1];
1273

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

unknown's avatar
unknown committed
1295 1296 1297 1298 1299
  /*
    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
1300
  LOG_INFO*  current_linfo;
unknown's avatar
unknown committed
1301
  NET*       slave_net;			// network connection from slave -> m.
unknown's avatar
unknown committed
1302 1303 1304 1305 1306 1307 1308
  /* 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
1309 1310
  THD();
  ~THD();
1311

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

  bool convert_string(LEX_STRING *to, CHARSET_INFO *to_cs,
		      const char *from, uint from_length,
		      CHARSET_INFO *from_cs);
1416 1417 1418

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

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

unknown's avatar
unknown committed
1445
  inline Query_arena *change_arena_if_needed(Query_arena *backup)
unknown's avatar
unknown committed
1446 1447 1448 1449 1450
  {
    /*
      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
1451
    if (!current_arena->is_conventional() &&
1452
        mem_root != current_arena->mem_root)
unknown's avatar
unknown committed
1453 1454 1455 1456 1457 1458 1459
    {
      set_n_backup_item_arena(current_arena, backup);
      return current_arena;
    }
    return 0;
  }

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

  /*
    Cleanup statement parse state (parse tree, lex) and execution
    state after execution of a non-prepared SQL statement.
  */
  void end_statement();
1476 1477
  inline int killed_errno() const
  {
unknown's avatar
unknown committed
1478
    return killed != KILL_BAD_DATA ? killed : 0;
1479 1480 1481
  }
  inline void send_kill_message() const
  {
unknown's avatar
unknown committed
1482
    int err= killed_errno();
1483 1484
    if (err)
      my_message(err, ER(err), MYF(0));
1485
  }
unknown's avatar
unknown committed
1486 1487 1488 1489 1490 1491 1492
  /* 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)));
  }
1493
  void set_status_var_init();
1494 1495
  bool is_context_analysis_only()
    { return current_arena->is_stmt_prepare() || lex->view_prepare_mode; }
1496 1497
  void reset_n_backup_open_tables_state(Open_tables_state *backup);
  void restore_backup_open_tables_state(Open_tables_state *backup);
unknown's avatar
unknown committed
1498 1499
};

1500

1501
#define tmp_disable_binlog(A)       \
1502
  {ulonglong tmp_disable_binlog__save_options= (A)->options; \
1503
  (A)->options&= ~OPTION_BIN_LOG
1504

1505
#define reenable_binlog(A)   (A)->options= tmp_disable_binlog__save_options;}
1506

1507 1508 1509 1510 1511
/* 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
1512 1513 1514
/*
  Used to hold information about file and file structure in exchainge 
  via non-DB file (...INTO OUTFILE..., ...LOAD DATA...)
1515
  XXX: We never call destructor for objects of this class.
unknown's avatar
unknown committed
1516
*/
1517

unknown's avatar
unknown committed
1518 1519 1520 1521 1522 1523 1524
class sql_exchange :public Sql_alloc
{
public:
  char *file_name;
  String *field_term,*enclosed,*line_term,*line_start,*escaped;
  bool opt_enclosed;
  bool dumpfile;
1525
  ulong skip_lines;
unknown's avatar
unknown committed
1526 1527 1528 1529 1530 1531
  sql_exchange(char *name,bool dumpfile_flag);
};

#include "log_event.h"

/*
1532
  This is used to get result from a select
unknown's avatar
unknown committed
1533 1534
*/

unknown's avatar
unknown committed
1535 1536
class JOIN;

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


1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586
/*
  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
1587 1588 1589
class select_send :public select_result {
public:
  select_send() {}
1590
  bool send_fields(List<Item> &list, uint flags);
unknown's avatar
unknown committed
1591 1592
  bool send_data(List<Item> &items);
  bool send_eof();
unknown's avatar
unknown committed
1593
  bool simple_select() { return 1; }
unknown's avatar
unknown committed
1594 1595 1596
};


1597
class select_to_file :public select_result_interceptor {
1598
protected:
unknown's avatar
unknown committed
1599 1600 1601 1602
  sql_exchange *exchange;
  File file;
  IO_CACHE cache;
  ha_rows row_count;
1603 1604 1605 1606 1607 1608 1609
  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);
1610 1611
  bool send_eof();
  void cleanup();
1612 1613 1614 1615
};


class select_export :public select_to_file {
unknown's avatar
unknown committed
1616 1617 1618 1619
  uint field_term_length;
  int field_sep_char,escape_char,line_sep_char;
  bool fixed_row_size;
public:
1620
  select_export(sql_exchange *ex) :select_to_file(ex) {}
unknown's avatar
unknown committed
1621
  ~select_export();
1622
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
1623 1624 1625
  bool send_data(List<Item> &items);
};

unknown's avatar
unknown committed
1626

1627
class select_dump :public select_to_file {
unknown's avatar
unknown committed
1628
public:
1629
  select_dump(sql_exchange *ex) :select_to_file(ex) {}
1630
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
1631 1632
  bool send_data(List<Item> &items);
};
unknown's avatar
unknown committed
1633 1634


1635
class select_insert :public select_result_interceptor {
unknown's avatar
unknown committed
1636
 public:
unknown's avatar
VIEW  
unknown committed
1637
  TABLE_LIST *table_list;
unknown's avatar
unknown committed
1638 1639 1640 1641
  TABLE *table;
  List<Item> *fields;
  ulonglong last_insert_id;
  COPY_INFO info;
unknown's avatar
VIEW  
unknown committed
1642
  bool insert_into_view;
unknown's avatar
unknown committed
1643

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

unknown's avatar
unknown committed
1659

unknown's avatar
unknown committed
1660 1661
class select_create: public select_insert {
  ORDER *group;
unknown's avatar
VIEW  
unknown committed
1662
  TABLE_LIST *create_table;
unknown's avatar
unknown committed
1663 1664 1665 1666 1667 1668
  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
1669 1670 1671 1672
  select_create (TABLE_LIST *table,
		 HA_CREATE_INFO *create_info_par,
		 List<create_field> &fields_par,
		 List<Key> &keys_par,
1673 1674
		 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
1675 1676
    extra_fields(&fields_par),keys(&keys_par), create_info(create_info_par),
    lock(0)
unknown's avatar
unknown committed
1677
    {}
1678
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
1679
  void store_values(List<Item> &values);
1680
  void send_error(uint errcode,const char *err);
unknown's avatar
unknown committed
1681 1682 1683 1684
  bool send_eof();
  void abort();
};

1685 1686
#include <myisam.h>

unknown's avatar
unknown committed
1687 1688 1689 1690 1691
/* 
  Param to create temporary tables when doing SELECT:s 
  NOTE
    This structure is copied using memcpy as a part of JOIN.
*/
1692 1693 1694

class TMP_TABLE_PARAM :public Sql_alloc
{
1695 1696 1697 1698 1699 1700
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:
1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714
  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;
1715 1716
  /* If >0 convert all blob fields to varchar(convert_blob_length) */
  uint  convert_blob_length; 
unknown's avatar
unknown committed
1717
  CHARSET_INFO *table_charset; 
1718
  bool schema_table;
1719 1720

  TMP_TABLE_PARAM()
unknown's avatar
unknown committed
1721
    :copy_field(0), group_parts(0),
unknown's avatar
unknown committed
1722 1723
     group_length(0), group_null_parts(0), convert_blob_length(0),
     schema_table(0)
1724 1725 1726 1727 1728
  {}
  ~TMP_TABLE_PARAM()
  {
    cleanup();
  }
1729
  void init(void);
1730 1731 1732 1733 1734
  inline void cleanup(void)
  {
    if (copy_field)				/* Fix for Intel compiler */
    {
      delete [] copy_field;
1735
      save_copy_field= copy_field= 0;
1736 1737 1738 1739
    }
  }
};

1740
class select_union :public select_result_interceptor {
unknown's avatar
unknown committed
1741 1742
 public:
  TABLE *table;
1743
  TMP_TABLE_PARAM tmp_table_param;
unknown's avatar
unknown committed
1744 1745 1746

  select_union(TABLE *table_par);
  ~select_union();
1747
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
1748 1749 1750
  bool send_data(List<Item> &items);
  bool send_eof();
  bool flush();
1751
  void set_table(TABLE *tbl) { table= tbl; }
unknown's avatar
unknown committed
1752 1753
};

unknown's avatar
unknown committed
1754
/* Base subselect interface class */
1755
class select_subselect :public select_result_interceptor
1756
{
unknown's avatar
unknown committed
1757
protected:
1758 1759 1760
  Item_subselect *item;
public:
  select_subselect(Item_subselect *item);
unknown's avatar
unknown committed
1761
  bool send_data(List<Item> &items)=0;
1762 1763 1764
  bool send_eof() { return 0; };
};

unknown's avatar
unknown committed
1765
/* Single value subselect interface class */
unknown's avatar
unknown committed
1766
class select_singlerow_subselect :public select_subselect
unknown's avatar
unknown committed
1767 1768
{
public:
unknown's avatar
unknown committed
1769
  select_singlerow_subselect(Item_subselect *item):select_subselect(item){}
unknown's avatar
unknown committed
1770 1771 1772
  bool send_data(List<Item> &items);
};

1773 1774 1775 1776 1777 1778 1779 1780 1781 1782
/* 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
1783
  void cleanup();
1784 1785 1786
  bool send_data(List<Item> &items);
  bool cmp_real();
  bool cmp_int();
unknown's avatar
Merge  
unknown committed
1787
  bool cmp_decimal();
1788 1789 1790
  bool cmp_str();
};

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

1821 1822
class Table_ident :public Sql_alloc
{
unknown's avatar
unknown committed
1823 1824 1825
 public:
  LEX_STRING db;
  LEX_STRING table;
unknown's avatar
unknown committed
1826
  SELECT_LEX_UNIT *sel;
unknown's avatar
unknown committed
1827 1828
  inline Table_ident(THD *thd, LEX_STRING db_arg, LEX_STRING table_arg,
		     bool force)
unknown's avatar
unknown committed
1829
    :table(table_arg), sel((SELECT_LEX_UNIT *)0)
unknown's avatar
unknown committed
1830
  {
unknown's avatar
unknown committed
1831
    if (!force && (thd->client_capabilities & CLIENT_NO_SCHEMA))
unknown's avatar
unknown committed
1832 1833 1834 1835
      db.str=0;
    else
      db= db_arg;
  }
unknown's avatar
unknown committed
1836 1837 1838 1839 1840 1841 1842
  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
1843 1844
    /* 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
1845
  }
unknown's avatar
unknown committed
1846
  inline void change_db(char *db_name)
unknown's avatar
unknown committed
1847 1848 1849
  {
    db.str= db_name; db.length= (uint) strlen(db_name);
  }
unknown's avatar
unknown committed
1850 1851 1852 1853 1854 1855 1856 1857
};

// this is needed for user_vars hash
class user_var_entry
{
 public:
  LEX_STRING name;
  char *value;
1858 1859
  ulong length;
  query_id_t update_query_id, used_query_id;
unknown's avatar
unknown committed
1860
  Item_result type;
1861

unknown's avatar
Merge  
unknown committed
1862
  double val_real(my_bool *null_value);
1863 1864
  longlong val_int(my_bool *null_value);
  String *val_str(my_bool *null_value, String *str, uint decimals);
unknown's avatar
Merge  
unknown committed
1865
  my_decimal *val_decimal(my_bool *null_value, my_decimal *result);
1866
  DTCollation collation;
unknown's avatar
unknown committed
1867 1868
};

1869 1870 1871 1872 1873 1874 1875
/*
   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.
 */
1876 1877 1878 1879 1880 1881 1882

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
1883
  byte *record_pointers;
1884
  bool flush();
1885
  uint size;
1886 1887 1888

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

  bool get(TABLE *table);
1903
  static double get_use_cost(uint *buffer, uint nkeys, uint key_size, 
1904
                             ulong max_in_memory_size);
1905 1906 1907 1908 1909 1910 1911 1912
  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);
  }

1913 1914 1915
  void reset();
  bool walk(tree_walk_action action, void *walk_action_arg);

1916 1917
  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);
1918
};
1919

unknown's avatar
unknown committed
1920

1921
class multi_delete :public select_result_interceptor
unknown's avatar
unknown committed
1922 1923
{
  TABLE_LIST *delete_tables, *table_being_deleted;
unknown's avatar
unknown committed
1924
  Unique **tempfiles;
1925
  ha_rows deleted, found;
unknown's avatar
unknown committed
1926 1927
  uint num_of_tables;
  int error;
1928 1929
  bool do_delete, transactional_tables, normal_tables, delete_while_scanning;

unknown's avatar
unknown committed
1930
public:
1931
  multi_delete(TABLE_LIST *dt, uint num_of_tables);
unknown's avatar
unknown committed
1932 1933 1934 1935 1936
  ~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);
1937
  int  do_deletes();
unknown's avatar
unknown committed
1938 1939 1940
  bool send_eof();
};

1941

1942
class multi_update :public select_result_interceptor
unknown's avatar
unknown committed
1943
{
1944 1945 1946
  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
1947
  TABLE **tmp_tables, *main_table, *table_to_update;
unknown's avatar
unknown committed
1948 1949 1950 1951 1952 1953 1954
  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
1955
  bool do_update, trans_safe, transactional_tables, ignore;
unknown's avatar
unknown committed
1956 1957

public:
1958
  multi_update(TABLE_LIST *ut, TABLE_LIST *leaves_list,
1959
	       List<Item> *fields, List<Item> *values,
1960
	       enum_duplicates handle_duplicates, bool ignore);
unknown's avatar
unknown committed
1961
  ~multi_update();
unknown's avatar
unknown committed
1962
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
1963 1964 1965 1966 1967 1968
  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();
};
1969

unknown's avatar
unknown committed
1970 1971 1972 1973 1974
class my_var : public Sql_alloc  {
public:
  LEX_STRING s;
  bool local;
  uint offset;
1975 1976 1977 1978
  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
1979 1980
  ~my_var() {}
};
1981

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

/* Functions in sql_class.cc */

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