sql_class.h 47.7 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;
unknown's avatar
unknown committed
29

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

37 38 39
enum enum_check_fields { CHECK_FIELD_IGNORE, CHECK_FIELD_WARN,
			 CHECK_FIELD_ERROR_FOR_NULL };

unknown's avatar
unknown committed
40 41
extern char internal_table_name[2];

42
/* log info errors */
unknown's avatar
unknown committed
43 44 45 46
#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
47 48 49
#define LOG_INFO_MEM -6
#define LOG_INFO_FATAL -7
#define LOG_INFO_IN_USE -8
unknown's avatar
unknown committed
50

51 52 53 54 55
/* bitmap to SQL_LOG::close() */
#define LOG_CLOSE_INDEX		1
#define LOG_CLOSE_TO_BE_OPENED	2
#define LOG_CLOSE_STOP_EVENT	4

56 57
struct st_relay_log_info;

unknown's avatar
unknown committed
58 59 60
typedef struct st_log_info
{
  char log_file_name[FN_REFLEN];
61
  my_off_t index_file_offset, index_file_start_offset;
unknown's avatar
unknown committed
62 63 64
  my_off_t pos;
  bool fatal; // if the purge happens to give us a negative offset
  pthread_mutex_t lock;
65
  st_log_info():fatal(0) { pthread_mutex_init(&lock, MY_MUTEX_INIT_FAST);}
unknown's avatar
unknown committed
66
  ~st_log_info() { pthread_mutex_destroy(&lock);}
unknown's avatar
unknown committed
67 68
} LOG_INFO;

unknown's avatar
unknown committed
69 70 71 72 73 74 75 76 77
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;

unknown's avatar
unknown committed
78
class Log_event;
unknown's avatar
unknown committed
79

unknown's avatar
unknown committed
80 81
class MYSQL_LOG
 {
unknown's avatar
unknown committed
82
 private:
unknown's avatar
unknown committed
83
  /* LOCK_log and LOCK_index are inited by init_pthread_objects() */
unknown's avatar
unknown committed
84
  pthread_mutex_t LOCK_log, LOCK_index;
unknown's avatar
unknown committed
85 86
  pthread_cond_t update_cond;
  ulonglong bytes_written;
unknown's avatar
unknown committed
87
  time_t last_time,query_start;
88
  IO_CACHE log_file;
89
  IO_CACHE index_file;
unknown's avatar
unknown committed
90 91 92
  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
93 94 95
  // current file sequence number for load data infile binary logging
  uint file_id;
  uint open_count;				// For replication
unknown's avatar
unknown committed
96 97
  volatile enum_log_type log_type;
  enum cache_type io_cache_type;
unknown's avatar
unknown committed
98
  bool write_error, inited;
99
  bool need_start_event;
unknown's avatar
unknown committed
100
  bool no_auto_events;				// For relay binlog
101 102 103 104 105 106 107 108 109 110 111
  /* 
     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
     fix_max_relay_log_size). 
  */
  ulong max_size;
112 113
  friend class Log_event;

unknown's avatar
unknown committed
114 115 116
public:
  MYSQL_LOG();
  ~MYSQL_LOG();
unknown's avatar
unknown committed
117
  void reset_bytes_written()
unknown's avatar
unknown committed
118 119 120
  {
    bytes_written = 0;
  }
unknown's avatar
unknown committed
121
  void harvest_bytes_written(ulonglong* counter)
unknown's avatar
unknown committed
122
  {
unknown's avatar
unknown committed
123
#ifndef DBUG_OFF
unknown's avatar
unknown committed
124
    char buf1[22],buf2[22];
unknown's avatar
unknown committed
125
#endif	
unknown's avatar
unknown committed
126 127 128 129 130 131 132
    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;
  }
133
  void set_max_size(ulong max_size_arg);
unknown's avatar
unknown committed
134
  void signal_update();
135
  void wait_for_update(THD* thd, bool master_or_slave);
136 137
  void set_need_start_event() { need_start_event = 1; }
  void init(enum_log_type log_type_arg,
138 139
	    enum cache_type io_cache_type_arg,
	    bool no_auto_events_arg, ulong max_size);
unknown's avatar
unknown committed
140
  void init_pthread_objects();
unknown's avatar
unknown committed
141
  void cleanup();
142 143 144
  bool open(const char *log_name,enum_log_type log_type,
	    const char *new_name, const char *index_file_name_arg,
	    enum cache_type io_cache_type_arg,
145
	    bool no_auto_events_arg, ulong max_size);
146
  void new_file(bool need_lock= 1);
147
  bool write(THD *thd, enum enum_server_command command,
148
	     const char *format, ...) ATTRIBUTE_FORMAT(printf, 4, 5);
149
  bool write(THD *thd, const char *query, uint query_length,
150
	     time_t query_start=0);
151
  bool write(Log_event* event_info); // binary log write
unknown's avatar
unknown committed
152
  bool write(THD *thd, IO_CACHE *cache, bool commit_or_rollback);
153

unknown's avatar
unknown committed
154 155 156 157
  /*
    v stands for vector
    invoked as appendv(buf1,len1,buf2,len2,...,bufn,lenn,0)
  */
158
  bool appendv(const char* buf,uint len,...);
159
  bool append(Log_event* ev);
160
  
unknown's avatar
unknown committed
161 162 163
  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);
164 165 166 167 168 169
  int update_log_index(LOG_INFO* linfo, bool need_update_threads);
  int purge_logs(const char *to_log, bool included, 
                 bool need_mutex, bool need_update_threads,
                 ulonglong *decrease_log_space);
  int purge_logs_before_date(time_t purge_time);
  int purge_first_log(struct st_relay_log_info* rli, bool included); 
170
  bool reset_logs(THD* thd);
171
  void close(uint exiting);
unknown's avatar
unknown committed
172 173
  bool cut_spurious_tail();
  void report_pos_in_innodb();
unknown's avatar
unknown committed
174 175

  // iterating through the log index file
176
  int find_log_pos(LOG_INFO* linfo, const char* log_name,
177 178
		   bool need_mutex);
  int find_next_log(LOG_INFO* linfo, bool need_mutex);
unknown's avatar
unknown committed
179
  int get_current_log(LOG_INFO* linfo);
unknown's avatar
unknown committed
180
  int raw_get_current_log(LOG_INFO* linfo);
unknown's avatar
unknown committed
181
  uint next_file_id();
182
  inline bool is_open() { return log_type != LOG_CLOSED; }
unknown's avatar
unknown committed
183 184 185 186 187 188 189
  inline char* get_index_fname() { return index_file_name;}
  inline char* get_log_fname() { return log_file_name; }
  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);}
190
  inline IO_CACHE *get_index_file() { return &index_file;}
unknown's avatar
unknown committed
191
  inline uint32 get_open_count() { return open_count; }
unknown's avatar
unknown committed
192 193 194 195 196 197 198 199
};

/* character conversion tables */


typedef struct st_copy_info {
  ha_rows records;
  ha_rows deleted;
unknown's avatar
unknown committed
200
  ha_rows updated;
unknown's avatar
unknown committed
201
  ha_rows copied;
202
  ha_rows error_count;
unknown's avatar
unknown committed
203
  enum enum_duplicates handle_duplicates;
204
  int escape_char, last_errno;
205 206
  bool ignore;
  /* for INSERT ... UPDATE */
207 208
  List<Item> *update_fields;
  List<Item> *update_values;
unknown's avatar
unknown committed
209 210 211 212 213 214 215 216
} 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) {}
217
  bool operator==(const key_part_spec& other) const;
unknown's avatar
unknown committed
218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241
};


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:
242
  enum Keytype { PRIMARY, UNIQUE, MULTIPLE, FULLTEXT, SPATIAL, FOREIGN_KEY};
unknown's avatar
unknown committed
243
  enum Keytype type;
244
  enum ha_key_alg algorithm;
unknown's avatar
unknown committed
245
  List<key_part_spec> columns;
246
  const char *name;
247
  bool generated;
unknown's avatar
unknown committed
248

249
  Key(enum Keytype type_par, const char *name_arg, enum ha_key_alg alg_par,
250 251 252
      bool generated_arg, List<key_part_spec> &cols)
    :type(type_par), algorithm(alg_par), columns(cols), name(name_arg),
    generated(generated_arg)
253
  {}
unknown's avatar
unknown committed
254
  ~Key() {}
255
  /* Equality comparison of keys (ignoring name) */
256
  friend bool foreign_key_prefix(Key *a, Key *b);
unknown's avatar
unknown committed
257 258
};

259 260 261 262 263 264 265 266 267 268 269 270 271 272 273
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)
274
    :Key(FOREIGN_KEY, name_arg, HA_KEY_ALG_UNDEF, 0, cols),
275 276 277 278 279
    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
280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298

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

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

unknown's avatar
unknown committed
301 302 303 304 305 306 307 308
class i_string: public ilink
{
public:
  char* ptr;
  i_string():ptr(0) { }
  i_string(char* s) : ptr(s) {}
};

309
/* needed for linked list of two strings for replicate-rewrite-db */
unknown's avatar
unknown committed
310 311 312 313 314 315
class i_string_pair: public ilink
{
public:
  char* key;
  char* val;
  i_string_pair():key(0),val(0) { }
unknown's avatar
unknown committed
316
  i_string_pair(char* key_arg, char* val_arg) : key(key_arg),val(val_arg) {}
unknown's avatar
unknown committed
317 318 319
};


320
class MYSQL_ERROR: public Sql_alloc
unknown's avatar
unknown committed
321 322
{
public:
323 324 325
  enum enum_warning_level
  { WARN_LEVEL_NOTE, WARN_LEVEL_WARN, WARN_LEVEL_ERROR, WARN_LEVEL_END};

unknown's avatar
unknown committed
326
  uint code;
327 328
  enum_warning_level level;
  char *msg;
unknown's avatar
unknown committed
329
  
330
  MYSQL_ERROR(THD *thd, uint code_arg, enum_warning_level level_arg,
331 332
	      const char *msg_arg)
    :code(code_arg), level(level_arg)
unknown's avatar
unknown committed
333
  {
unknown's avatar
SCRUM  
unknown committed
334
    if (msg_arg)
335
      set_msg(thd, msg_arg);
unknown's avatar
unknown committed
336
  }
337
  void set_msg(THD *thd, const char *msg_arg);
unknown's avatar
unknown committed
338
};
unknown's avatar
unknown committed
339

340

unknown's avatar
unknown committed
341
class delayed_insert;
unknown's avatar
unknown committed
342
class select_result;
unknown's avatar
unknown committed
343

344 345 346 347 348
#define THD_SENTRY_MAGIC 0xfeedd1ff
#define THD_SENTRY_GONE  0xdeadbeef

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

349 350
struct system_variables
{
unknown's avatar
unknown committed
351 352
  ulonglong myisam_max_extra_sort_file_size;
  ulonglong myisam_max_sort_file_size;
353 354
  ha_rows select_limit;
  ha_rows max_join_size;
unknown's avatar
unknown committed
355
  ulong bulk_insert_buff_size;
356 357
  ulong join_buff_size;
  ulong long_query_time;
unknown's avatar
unknown committed
358
  ulong max_allowed_packet;
359
  ulong max_error_count;
360
  ulong max_heap_table_size;
unknown's avatar
unknown committed
361
  ulong max_length_for_sort_data;
362
  ulong max_sort_length;
363
  ulong max_tmp_tables;
364
  ulong max_insert_delayed_threads;
365
  ulong myisam_repair_threads;
unknown's avatar
unknown committed
366
  ulong myisam_sort_buff_size;
367
  ulong myisam_stats_method;
unknown's avatar
unknown committed
368
  ulong net_buffer_length;
369
  ulong net_interactive_timeout;
unknown's avatar
unknown committed
370
  ulong net_read_timeout;
371
  ulong net_retry_count;
372
  ulong net_wait_timeout;
unknown's avatar
unknown committed
373
  ulong net_write_timeout;
unknown's avatar
unknown committed
374
  ulong preload_buff_size;
unknown's avatar
unknown committed
375 376 377
  ulong query_cache_type;
  ulong read_buff_size;
  ulong read_rnd_buff_size;
378
  ulong sortbuff_size;
379
  ulong table_type;
380
  ulong tmp_table_size;
unknown's avatar
unknown committed
381
  ulong tx_isolation;
382
  /* Determines which non-standard SQL behaviour should be enabled */
383
  ulong sql_mode;
unknown's avatar
unknown committed
384
  ulong default_week_format;
385
  ulong max_seeks_for_key;
386 387 388 389 390
  ulong range_alloc_block_size;
  ulong query_alloc_block_size;
  ulong query_prealloc_size;
  ulong trans_alloc_block_size;
  ulong trans_prealloc_size;
391
  ulong log_warnings;
392
  ulong group_concat_max_len;
unknown's avatar
unknown committed
393 394 395 396 397 398
  /*
    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
399 400
  my_bool low_priority_updates;
  my_bool new_mode;
401
  my_bool query_cache_wlock_invalidate;
402 403 404 405 406
#ifdef HAVE_REPLICATION
  ulong sync_replication;
  ulong sync_replication_slave_id;
  ulong sync_replication_timeout;
#endif /* HAVE_REPLICATION */
407
#ifdef HAVE_INNOBASE_DB
408
  my_bool innodb_table_locks;
409
#endif /* HAVE_INNOBASE_DB */
410 411 412 413 414 415
#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 */
416
  my_bool old_passwords;
417
  
418
  /* Only charset part of these variables is sensible */
419 420
  CHARSET_INFO 	*character_set_client;
  CHARSET_INFO  *character_set_results;
421 422 423 424
  
  /* Both charset and collation parts of these variables are important */
  CHARSET_INFO	*collation_server;
  CHARSET_INFO	*collation_database;
unknown's avatar
unknown committed
425
  CHARSET_INFO  *collation_connection;
426

unknown's avatar
unknown committed
427 428 429
  /* Locale Support */
  MY_LOCALE *lc_time_names;

430 431
  Time_zone *time_zone;

432 433 434 435
  /* 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
436 437
};

438
void free_tmp_table(THD *thd, TABLE *entry);
439 440


441 442 443 444 445 446 447 448
class Item_arena
{
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
449 450
  MEM_ROOT main_mem_root;
  MEM_ROOT *mem_root;                   // Pointer to current memroot
unknown's avatar
unknown committed
451
  enum enum_state 
452 453 454 455 456
  {
    INITIALIZED= 0, PREPARED= 1, EXECUTED= 3, CONVENTIONAL_EXECUTION= 2, 
    ERROR= -1
  };
  
unknown's avatar
unknown committed
457
  enum_state state;
458 459 460 461 462 463 464

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

465 466 467 468 469 470 471 472 473
  /*
    This constructor is used only when Item_arena is created as
    backup storage for another instance of Item_arena.
  */
  Item_arena() {};
  /*
    Create arena for already constructed THD using its variables as
    parameters for memory root initialization.
  */
474
  Item_arena(THD *thd);
475 476 477 478
  /*
    Create arena and optionally init memory root with minimal values.
    Particularly used if Item_arena is part of Statement.
  */
479 480
  Item_arena(bool init_mem_root);
  virtual Type type() const;
481
  virtual ~Item_arena() {};
482

unknown's avatar
unknown committed
483 484
  inline bool is_stmt_prepare() const { return (int)state < (int)PREPARED; }
  inline bool is_first_stmt_execute() const { return state == PREPARED; }
485 486
  inline bool is_stmt_execute() const
  { return state == PREPARED || state == EXECUTED; }
487 488
  inline bool is_conventional_execution() const
  { return state == CONVENTIONAL_EXECUTION; }
unknown's avatar
unknown committed
489
  inline gptr alloc(unsigned int size) { return alloc_root(mem_root,size); }
490 491 492
  inline gptr calloc(unsigned int size)
  {
    gptr ptr;
unknown's avatar
unknown committed
493
    if ((ptr=alloc_root(mem_root,size)))
494 495 496 497
      bzero((char*) ptr,size);
    return ptr;
  }
  inline char *strdup(const char *str)
unknown's avatar
unknown committed
498
  { return strdup_root(mem_root,str); }
499
  inline char *strmake(const char *str, uint size)
unknown's avatar
unknown committed
500
  { return strmake_root(mem_root,str,size); }
501
  inline char *memdup(const char *str, uint size)
unknown's avatar
unknown committed
502
  { return memdup_root(mem_root,str,size); }
503 504 505
  inline char *memdup_w_gap(const char *str, uint size, uint gap)
  {
    gptr ptr;
unknown's avatar
unknown committed
506
    if ((ptr=alloc_root(mem_root,size+gap)))
507 508 509 510 511 512 513 514 515 516
      memcpy(ptr,str,size);
    return ptr;
  }

  void set_n_backup_item_arena(Item_arena *set, Item_arena *backup);
  void restore_backup_item_arena(Item_arena *set, Item_arena *backup);
  void set_item_arena(Item_arena *set);
};


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

531
class Statement: public Item_arena
532 533 534 535 536 537
{
  Statement(const Statement &rhs);              /* not implemented: */
  Statement &operator=(const Statement &rhs);   /* non-copyable */
public:
  /* FIXME: must be private */
  LEX     main_lex;
unknown's avatar
unknown committed
538

539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563
  /*
    Uniquely identifies each statement object in thread scope; change during
    statement lifetime. FIXME: must be const
  */
   ulong id;

  /*
    - if set_query_id=1, we set field->query_id for all fields. In that case 
    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;

564
  LEX_STRING name; /* name for named prepared statements */
565 566 567 568 569
  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.
570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586

    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.
587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603
  */
  char *query;
  uint32 query_length;                          // current query length

public:

  /*
    This constructor is called when statement is a subobject of THD:
    some variables are initialized in THD::init due to locking problems
  */
  Statement();

  Statement(THD *thd);
  virtual ~Statement();

  /* Assign execution context (note: not all members) of given stmt to self */
  void set_statement(Statement *stmt);
604 605
  void set_n_backup_statement(Statement *stmt, Statement *backup);
  void restore_backup_statement(Statement *stmt, Statement *backup);
606 607 608 609 610 611
  /* return class type */
  virtual Type type() const;
};


/*
612 613 614 615 616
  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
617

618 619
  Statements are auto-deleted when they are removed from the map and when the
  map is deleted.
620 621 622 623 624 625
*/

class Statement_map
{
public:
  Statement_map();
626

627
  int insert(THD *thd, Statement *statement);
628 629

  Statement *find_by_name(LEX_STRING *name)
630
  {
631 632 633 634
    Statement *stmt;
    stmt= (Statement*)hash_search(&names_hash, (byte*)name->str,
                                  name->length);
    return stmt;
635 636 637 638 639
  }

  Statement *find(ulong id)
  {
    if (last_found_statement == 0 || id != last_found_statement->id)
640 641 642
    {
      Statement *stmt;
      stmt= (Statement *) hash_search(&st_hash, (byte *) &id, sizeof(id));
643
      if (stmt && stmt->name.str)
644 645 646
        return NULL;
      last_found_statement= stmt;
    }
647 648
    return last_found_statement;
  }
649
  void erase(Statement *statement);
650
  /* Erase all statements (calls Statement destructor) */
651 652
  void reset();
  ~Statement_map();
653 654
private:
  HASH st_hash;
655
  HASH names_hash;
656 657 658 659
  Statement *last_found_statement;
};


660 661 662 663 664 665 666 667 668 669 670
/*
  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;


unknown's avatar
unknown committed
671 672 673 674
/*
  For each client connection we create a separate thread with THD serving as
  a thread/connection descriptor
*/
675

676 677
class THD :public ilink, 
           public Statement
unknown's avatar
unknown committed
678
{
unknown's avatar
unknown committed
679
public:
680 681
#ifdef EMBEDDED_LIBRARY
  struct st_mysql  *mysql;
unknown's avatar
SCRUM  
unknown committed
682 683 684
  struct st_mysql_data *data;
  unsigned long	 client_stmt_id;
  unsigned long  client_param_count;
unknown's avatar
unknown committed
685
  struct st_mysql_bind *client_params;
unknown's avatar
unknown committed
686 687
  char *extra_data;
  ulong extra_length;
unknown's avatar
unknown committed
688
  String query_rest;
689 690 691 692 693 694
  /*
    In embedded server it points to the statement that is processed
    in the current query. We store some results directly in statement
    fields then.
  */
  struct st_mysql_stmt *current_stmt;
695
#endif
unknown's avatar
unknown committed
696
  NET	  net;				// client connection descriptor
697
  MEM_ROOT warn_root;			// For warnings and errors
698 699 700
  Protocol *protocol;			// Current protocol
  Protocol_simple protocol_simple;	// Normal protocol
  Protocol_prep protocol_prep;		// Binary protocol
unknown's avatar
unknown committed
701 702
  HASH    user_vars;			// hash for user variables
  String  packet;			// dynamic buffer for network I/O
703
  String  convert_buffer;               // buffer for charset conversions
unknown's avatar
unknown committed
704 705 706
  struct  sockaddr_in remote;		// client socket address
  struct  rand_struct rand;		// used for authentication
  struct  system_variables variables;	// Changeable local variables
707
  pthread_mutex_t LOCK_delete;		// Locked before thd is deleted
708 709 710 711
  /* all prepared statements and cursors of this connection */
  Statement_map stmt_map; 
  /*
    keeps THD state while it is used for active statement
712
    Note: we perform special cleanup for it in THD destructor.
713 714
  */
  Statement stmt_backup;
unknown's avatar
unknown committed
715 716 717 718 719 720
  /*
    A pointer to the stack frame of handle_one_connection(),
    which is called first in the thread for handling a client
  */
  char	  *thread_stack;

721 722 723 724
  /*
    host - host of the client
    user - user of the client, set to NULL until the user has been read from
     the connection
725
    priv_user - The user privilege we are using. May be '' for anonymous user.
726 727 728
    db - currently selected database
    ip - client IP
   */
unknown's avatar
unknown committed
729
  char	  *host,*user,*priv_user,*db,*ip;
730
  char	  priv_host[MAX_HOSTNAME];
unknown's avatar
unknown committed
731 732
  /* remote (peer) port */
  uint16 peer_port;
733 734 735 736 737
  /*
    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
738 739 740
  const char *proc_info;
  /* points to host if host is available, otherwise points to ip */
  const char *host_or_ip;
741

742
  ulong client_capabilities;		/* What the client supports */
743
  ulong max_client_packet_length;
unknown's avatar
unknown committed
744 745
  ulong master_access;			/* Global privileges from mysql.user */
  ulong db_access;			/* Privileges for current db */
746 747 748 749 750 751

  /*
    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
unknown's avatar
unknown committed
752
  */
753
  TABLE   *open_tables,*temporary_tables, *handler_tables, *derived_tables;
754 755 756
  /*
    During a MySQL session, one can lock tables in two modes: automatic
    or manual. In automatic mode all necessary tables are locked just before
unknown's avatar
unknown committed
757
    statement execution, and all acquired locks are stored in 'lock'
758 759 760 761 762
    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
unknown's avatar
unknown committed
763
    stored in 'locked_tables' member.  Manual locking is described in
764 765 766
    the 'LOCK_TABLES' chapter of the MySQL manual.
    See also lock_tables() for details.
  */
767 768
  MYSQL_LOCK	*lock;				/* Current locks */
  MYSQL_LOCK	*locked_tables;			/* Tables locked with LOCK */
unknown's avatar
unknown committed
769
  HASH		handler_tables_hash;
unknown's avatar
unknown committed
770 771 772 773 774
  /*
    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. 
  */
775
  User_level_lock *ull;
776 777
#ifndef DBUG_OFF
  uint dbug_sentry; // watch out for memory corruption
778
#endif
unknown's avatar
unknown committed
779
  struct st_my_thread_var *mysys_var;
780 781 782 783 784
  /*
    Type of current query: COM_PREPARE, COM_QUERY, etc. Set from 
    first byte of the packet in do_command()
  */
  enum enum_server_command command;
unknown's avatar
unknown committed
785
  uint32     server_id;
unknown's avatar
unknown committed
786
  uint32     file_id;			// for LOAD DATA INFILE
787 788 789 790 791
  /*
    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
792
  const char *where;
unknown's avatar
unknown committed
793 794
  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
795 796
  thr_lock_type update_lock_default;
  delayed_insert *di;
unknown's avatar
unknown committed
797
  my_bool    tablespace_op;	/* This is TRUE in DISCARD/IMPORT TABLESPACE */
unknown's avatar
unknown committed
798
  struct st_transactions {
799
    IO_CACHE trans_log;                 // Inited ONLY if binlog is open !
unknown's avatar
unknown committed
800 801
    THD_TRANS all;			// Trans since BEGIN WORK
    THD_TRANS stmt;			// Trans for current statement
unknown's avatar
unknown committed
802
    uint bdb_lock_count;
unknown's avatar
unknown committed
803
#ifdef HAVE_NDBCLUSTER_DB
804
    void* thd_ndb;
unknown's avatar
unknown committed
805
#endif
806
    bool on;
807
    /*
808
       Tables changed in transaction (that must be invalidated in query cache).
809
       List contain only transactional tables, that not invalidated in query
810 811 812 813 814 815 816 817 818
       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()
    {
      changed_tables = 0;
      free_root(&mem_root,MYF(MY_KEEP_PREALLOC));
    }
unknown's avatar
unknown committed
819 820 821 822 823
  } transaction;
  Field      *dupp_field;
#ifndef __WIN__
  sigset_t signals,block_signals;
#endif
824 825
#ifdef SIGNAL_WITH_VIO_CLOSE
  Vio* active_vio;
826
#endif
827 828 829 830 831 832 833 834
  /*
    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
    rollback_item_tree_changes(). For conventional execution it's always 0.
  */
  Item_change_list change_list;

unknown's avatar
unknown committed
835
  /*
836
    Current prepared Item_arena if there one, or 0
unknown's avatar
unknown committed
837
  */
838
  Item_arena *current_arena;
839 840 841 842 843
  /*
    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;
844

845
  /*
846 847 848 849 850 851 852 853 854 855
    At the beginning of the statement last_insert_id holds the first
    generated value of the previous statement.  During statement
    execution it is updated to the value just generated, but then
    restored to the value that was generated first, so for the next
    statement it will again be "the first generated value of the
    previous statement".

    It may also be set with "LAST_INSERT_ID(expr)" or
    "@@LAST_INSERT_ID= expr", but the effect of such setting will be
    seen only in the next statement.
856 857
  */
  ulonglong  last_insert_id;
858

859
  /*
860 861 862 863
    current_insert_id remembers the first generated value of the
    previous statement, and does not change during statement
    execution.  Its value returned from LAST_INSERT_ID() and
    @@LAST_INSERT_ID.
864 865
  */
  ulonglong  current_insert_id;
866

867
  ulonglong  limit_found_rows;
unknown's avatar
unknown committed
868
  ha_rows    cuted_fields,
unknown's avatar
unknown committed
869
             sent_row_count, examined_row_count;
unknown's avatar
unknown committed
870
  table_map  used_tables;
871
  USER_CONN *user_connect;
872
  CHARSET_INFO *db_charset;
873
  List<TABLE> temporary_tables_should_be_free; // list of temporary tables
874 875 876 877 878 879
  /*
    FIXME: this, and some other variables like 'count_cuted_fields'
    maybe should be statement/cursor local, that is, moved to Statement
    class. With current implementation warnings produced in each prepared
    statement/cursor settle here.
  */
880
  List	     <MYSQL_ERROR> warn_list;
881
  uint	     warn_count[(uint) MYSQL_ERROR::WARN_LEVEL_END];
unknown's avatar
unknown committed
882
  uint	     total_warn_count;
883 884 885 886 887 888 889 890 891
  /*
    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).
  */
  ulong	     query_id;
892 893 894 895
  ulong	     warn_id, version, options, thread_id, col_access;

  /* Statement id is thread-wide. This counter is used to generate ids */
  ulong      statement_id_counter;
896
  ulong	     rand_saved_seed1, rand_saved_seed2;
897
  ulong      row_count;  // Row counter, mainly for errors and warnings
unknown's avatar
unknown committed
898
  long	     dbug_thread_id;
unknown's avatar
unknown committed
899
  pthread_t  real_id;
unknown's avatar
unknown committed
900
  uint	     current_tablenr,tmp_table,global_read_lock;
901
  uint	     server_status,open_options,system_thread;
unknown's avatar
unknown committed
902
  uint32     db_length;
unknown's avatar
unknown committed
903
  uint       select_number;             //number of select (used for EXPLAIN)
unknown's avatar
unknown committed
904 905
  /* variables.transaction_isolation is reset to this after each commit */
  enum_tx_isolation session_tx_isolation;
906
  enum_check_fields count_cuted_fields;
unknown's avatar
unknown committed
907 908
  /* for user variables replication*/
  DYNAMIC_ARRAY user_var_events;
909 910

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

913
  bool       slave_thread, one_shot_set;
914
  bool	     locked, some_tables_deleted;
915
  bool       last_cuted_field;
916
  bool	     no_errors, password, is_fatal_error;
917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932
  bool	     query_start_used, rand_used;

  /*
    last_insert_id_used is set when current statement calls
    LAST_INSERT_ID() or reads @@LAST_INSERT_ID, so that binary log
    LAST_INSERT_ID_EVENT be generated.
  */
  bool	     last_insert_id_used;

  /*
    insert_id_used is set when current statement updates
    THD::last_insert_id, so that binary log INSERT_ID_EVENT be
    generated.
  */
  bool       insert_id_used;

933 934
  /* for IS NULL => = last_insert_id() fix in remove_eq_conds() */
  bool       substitute_null_with_insert_id;
935
  bool	     time_zone_used;
936
  bool	     in_lock_tables;
unknown's avatar
unknown committed
937
  bool       query_error, bootstrap, cleanup_done;
unknown's avatar
unknown committed
938
  bool	     tmp_table_used;
unknown's avatar
unknown committed
939
  bool	     charset_is_system_charset, charset_is_collation_connection;
940
  bool       enable_slow_log;   /* enable slow log for current statement */
941
  my_bool    volatile killed;
unknown's avatar
unknown committed
942

unknown's avatar
unknown committed
943 944 945 946 947
  /*
    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
948
  LOG_INFO*  current_linfo;
unknown's avatar
unknown committed
949
  NET*       slave_net;			// network connection from slave -> m.
unknown's avatar
unknown committed
950 951 952 953 954
  /* Used by the sys_var class to store temporary values */
  union
  {
    my_bool my_bool_value;
    long    long_value;
955
    ulong   ulong_value;
unknown's avatar
unknown committed
956 957
  } sys_var_tmp;

unknown's avatar
unknown committed
958 959
  THD();
  ~THD();
960

unknown's avatar
unknown committed
961
  void init(void);
962 963 964 965 966 967 968 969 970 971
  /*
    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
972
  void change_user(void);
unknown's avatar
unknown committed
973
  void cleanup(void);
unknown's avatar
unknown committed
974
  bool store_globals();
975 976
#ifdef SIGNAL_WITH_VIO_CLOSE
  inline void set_active_vio(Vio* vio)
977
  {
978
    pthread_mutex_lock(&LOCK_delete);
979
    active_vio = vio;
980
    pthread_mutex_unlock(&LOCK_delete);
981
  }
982
  inline void clear_active_vio()
983
  {
984
    pthread_mutex_lock(&LOCK_delete);
985
    active_vio = 0;
986
    pthread_mutex_unlock(&LOCK_delete);
987
  }
unknown's avatar
unknown committed
988
  void close_active_vio();
989
#endif  
990
  void awake(bool prepare_to_die);
991 992
  /*
    For enter_cond() / exit_cond() to work the mutex must be got before
unknown's avatar
unknown committed
993 994 995
    enter_cond() (in 4.1 an assertion will soon ensure this); this mutex is
    then released by exit_cond(). Use must be:
    lock mutex; enter_cond(); your code; exit_cond().
996
  */
unknown's avatar
unknown committed
997 998 999 1000 1001 1002 1003 1004 1005 1006 1007
  inline const char* enter_cond(pthread_cond_t *cond, pthread_mutex_t* mutex,
			  const char* msg)
  {
    const char* old_msg = proc_info;
    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
1008 1009 1010 1011 1012 1013 1014
    /*
      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
1015 1016 1017 1018 1019 1020
    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
1021
  inline time_t query_start() { query_start_used=1; return start_time; }
unknown's avatar
unknown committed
1022
  inline void	set_time()    { if (user_time) start_time=time_after_lock=user_time; else time_after_lock=time(&start_time); }
1023
  inline void	end_time()    { time(&start_time); }
unknown's avatar
unknown committed
1024
  inline void	set_time(time_t t) { time_after_lock=start_time=user_time=t; }
1025
  inline void	lock_time()   { time(&time_after_lock); }
1026 1027 1028 1029
  inline void	insert_id(ulonglong id_arg)
  {
    last_insert_id= id_arg;
    insert_id_used=1;
1030
    substitute_null_with_insert_id= TRUE;
1031
  }
1032 1033 1034 1035
  inline ulonglong found_rows(void)
  {
    return limit_found_rows;
  }                                                                         
1036 1037
  inline bool active_transaction()
  {
1038
#ifdef USING_TRANSACTIONS    
1039
    return (transaction.all.bdb_tid != 0 ||
unknown's avatar
unknown committed
1040 1041
	    transaction.all.innodb_active_trans != 0 ||
	    transaction.all.ndb_tid != 0);
1042 1043 1044
#else
    return 0;
#endif
1045
  }
1046 1047 1048 1049
  inline gptr trans_alloc(unsigned int size) 
  { 
    return alloc_root(&transaction.mem_root,size);
  }
1050 1051 1052 1053

  bool convert_string(LEX_STRING *to, CHARSET_INFO *to_cs,
		      const char *from, uint from_length,
		      CHARSET_INFO *from_cs);
1054 1055 1056

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

1057
  void add_changed_table(TABLE *table);
unknown's avatar
unknown committed
1058 1059
  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
1060
  int send_explain_fields(select_result *result);
1061
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
1062 1063 1064 1065 1066 1067
  inline void clear_error()
  {
    net.last_error[0]= 0;
    net.last_errno= 0;
    net.report_error= 0;
  }
1068
  inline bool vio_ok() const { return net.vio != 0; }
1069 1070
#else
  void clear_error();
1071
  inline bool vio_ok() const { return true; }
1072
#endif
1073 1074 1075 1076
  inline void fatal_error()
  {
    is_fatal_error= 1;
    net.report_error= 1; 
unknown's avatar
unknown committed
1077
    DBUG_PRINT("error",("Fatal error set"));
1078
  }
1079
  inline CHARSET_INFO *charset() { return variables.character_set_client; }
unknown's avatar
unknown committed
1080
  void update_charset();
1081

unknown's avatar
unknown committed
1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096
  inline Item_arena *change_arena_if_needed(Item_arena *backup)
  {
    /*
      use new arena if we are in a prepared statements and we have not
      already changed to use this arena.
    */
    if (current_arena->is_stmt_prepare() &&
        mem_root != &current_arena->main_mem_root)
    {
      set_n_backup_item_arena(current_arena, backup);
      return current_arena;
    }
    return 0;
  }

1097
  void change_item_tree(Item **place, Item *new_value)
1098
  {
1099
    /* TODO: check for OOM condition here */
1100
    if (!current_arena->is_conventional_execution())
unknown's avatar
unknown committed
1101
      nocheck_register_item_tree_change(place, *place, mem_root);
1102
    *place= new_value;
1103 1104
  }
  void nocheck_register_item_tree_change(Item **place, Item *old_value,
1105
                                         MEM_ROOT *runtime_memroot);
1106
  void rollback_item_tree_changes();
1107 1108 1109 1110 1111 1112

  /*
    Cleanup statement parse state (parse tree, lex) and execution
    state after execution of a non-prepared SQL statement.
  */
  void end_statement();
unknown's avatar
unknown committed
1113 1114
};

1115 1116 1117 1118 1119
#define tmp_disable_binlog(A)       \
  ulong save_options= (A)->options; \
  (A)->options&= ~OPTION_BIN_LOG;

#define reenable_binlog(A)          (A)->options= save_options;
1120

1121 1122 1123 1124 1125
/* 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
1126 1127 1128
/*
  Used to hold information about file and file structure in exchainge 
  via non-DB file (...INTO OUTFILE..., ...LOAD DATA...)
1129
  XXX: We never call destructor for objects of this class.
unknown's avatar
unknown committed
1130
*/
1131

unknown's avatar
unknown committed
1132 1133 1134 1135 1136 1137 1138
class sql_exchange :public Sql_alloc
{
public:
  char *file_name;
  String *field_term,*enclosed,*line_term,*line_start,*escaped;
  bool opt_enclosed;
  bool dumpfile;
1139
  ulong skip_lines;
unknown's avatar
unknown committed
1140 1141 1142 1143 1144 1145
  sql_exchange(char *name,bool dumpfile_flag);
};

#include "log_event.h"

/*
1146
  This is used to get result from a select
unknown's avatar
unknown committed
1147 1148
*/

unknown's avatar
unknown committed
1149 1150
class JOIN;

1151
void send_error(THD *thd, uint sql_errno=0, const char *err=0);
unknown's avatar
unknown committed
1152

unknown's avatar
unknown committed
1153 1154 1155
class select_result :public Sql_alloc {
protected:
  THD *thd;
1156
  SELECT_LEX_UNIT *unit;
unknown's avatar
unknown committed
1157 1158 1159
public:
  select_result();
  virtual ~select_result() {};
1160 1161 1162 1163 1164
  virtual int prepare(List<Item> &list, SELECT_LEX_UNIT *u)
  {
    unit= u;
    return 0;
  }
1165 1166 1167 1168 1169 1170 1171
  /*
    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; }
unknown's avatar
unknown committed
1172 1173
  virtual bool send_fields(List<Item> &list,uint flag)=0;
  virtual bool send_data(List<Item> &items)=0;
unknown's avatar
unknown committed
1174
  virtual bool initialize_tables (JOIN *join=0) { return 0; }
1175
  virtual void send_error(uint errcode,const char *err);
unknown's avatar
unknown committed
1176 1177
  virtual bool send_eof()=0;
  virtual void abort() {}
1178 1179 1180 1181 1182
  /*
    Cleanup instance of this class for next execution of a prepared
    statement/stored procedure.
  */
  virtual void cleanup();
unknown's avatar
unknown committed
1183 1184 1185
};


1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199
/*
  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
1200 1201 1202 1203 1204 1205 1206 1207 1208
class select_send :public select_result {
public:
  select_send() {}
  bool send_fields(List<Item> &list,uint flag);
  bool send_data(List<Item> &items);
  bool send_eof();
};


1209
class select_to_file :public select_result_interceptor {
1210
protected:
unknown's avatar
unknown committed
1211 1212 1213 1214
  sql_exchange *exchange;
  File file;
  IO_CACHE cache;
  ha_rows row_count;
1215 1216 1217 1218 1219 1220 1221
  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);
1222 1223
  bool send_eof();
  void cleanup();
1224 1225 1226 1227
};


class select_export :public select_to_file {
unknown's avatar
unknown committed
1228 1229 1230 1231
  uint field_term_length;
  int field_sep_char,escape_char,line_sep_char;
  bool fixed_row_size;
public:
1232
  select_export(sql_exchange *ex) :select_to_file(ex) {}
unknown's avatar
unknown committed
1233
  ~select_export();
1234
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
1235 1236 1237
  bool send_data(List<Item> &items);
};

unknown's avatar
unknown committed
1238

1239
class select_dump :public select_to_file {
unknown's avatar
unknown committed
1240
public:
1241
  select_dump(sql_exchange *ex) :select_to_file(ex) {}
1242
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
1243 1244
  bool send_data(List<Item> &items);
};
unknown's avatar
unknown committed
1245 1246


1247
class select_insert :public select_result_interceptor {
unknown's avatar
unknown committed
1248
 public:
unknown's avatar
unknown committed
1249 1250 1251 1252
  TABLE *table;
  List<Item> *fields;
  ulonglong last_insert_id;
  COPY_INFO info;
unknown's avatar
unknown committed
1253 1254
  TABLE_LIST *insert_table_list;
  TABLE_LIST *dup_table_list;
unknown's avatar
unknown committed
1255

1256
  select_insert(TABLE *table_par, List<Item> *fields_par,
1257
		enum_duplicates duplic, bool ignore)
unknown's avatar
unknown committed
1258 1259
    :table(table_par), fields(fields_par), last_insert_id(0),
     insert_table_list(0), dup_table_list(0)
unknown's avatar
unknown committed
1260
  {
unknown's avatar
unknown committed
1261
    bzero((char*) &info,sizeof(info));
1262
    info.ignore= ignore;
unknown's avatar
unknown committed
1263 1264
    info.handle_duplicates=duplic;
  }
unknown's avatar
unknown committed
1265 1266 1267 1268
  select_insert(TABLE *table_par,
		TABLE_LIST *insert_table_list_par,
		TABLE_LIST *dup_table_list_par,
		List<Item> *fields_par,
unknown's avatar
unknown committed
1269
		List<Item> *update_fields, List<Item> *update_values,
1270
		enum_duplicates duplic, bool ignore)
unknown's avatar
unknown committed
1271 1272 1273
    :table(table_par), fields(fields_par), last_insert_id(0),
     insert_table_list(insert_table_list_par),
     dup_table_list(dup_table_list_par)
unknown's avatar
unknown committed
1274 1275
  {
    bzero((char*) &info,sizeof(info));
1276 1277
    info.ignore= ignore;
    info.handle_duplicates= duplic;
unknown's avatar
unknown committed
1278 1279 1280
    info.update_fields= update_fields;
    info.update_values= update_values;
  }
unknown's avatar
unknown committed
1281
  ~select_insert();
1282
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
1283
  bool send_data(List<Item> &items);
unknown's avatar
unknown committed
1284
  virtual void store_values(List<Item> &values);
unknown's avatar
unknown committed
1285 1286
  void send_error(uint errcode,const char *err);
  bool send_eof();
1287 1288
  /* not implemented: select_insert is never re-used in prepared statements */
  void cleanup();
unknown's avatar
unknown committed
1289 1290
};

unknown's avatar
unknown committed
1291

unknown's avatar
unknown committed
1292 1293 1294 1295 1296
class select_create: public select_insert {
  ORDER *group;
  const char *db;
  const char *name;
  HA_CREATE_INFO *create_info;
unknown's avatar
unknown committed
1297
  Alter_info *alter_info;
unknown's avatar
unknown committed
1298 1299 1300
  MYSQL_LOCK *lock;
  Field **field;
public:
unknown's avatar
unknown committed
1301
  select_create(const char *db_name, const char *table_name,
unknown's avatar
unknown committed
1302 1303 1304 1305 1306 1307 1308 1309 1310
                HA_CREATE_INFO *create_info_arg,
                Alter_info *alter_info_arg,
                List<Item> &select_fields,
                enum_duplicates duplic, bool ignore)
    :select_insert(NULL, &select_fields, duplic, ignore),
    db(db_name), name(table_name),
    create_info(create_info_arg),
    alter_info(alter_info_arg),
    lock(0)
unknown's avatar
unknown committed
1311
    {}
1312
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
1313
  void store_values(List<Item> &values);
1314
  void send_error(uint errcode,const char *err);
unknown's avatar
unknown committed
1315 1316 1317 1318
  bool send_eof();
  void abort();
};

1319 1320
#include <myisam.h>

unknown's avatar
unknown committed
1321 1322 1323 1324 1325
/* 
  Param to create temporary tables when doing SELECT:s 
  NOTE
    This structure is copied using memcpy as a part of JOIN.
*/
1326 1327 1328

class TMP_TABLE_PARAM :public Sql_alloc
{
1329 1330 1331 1332 1333 1334
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:
1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347
  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;
1348
  bool  using_indirect_summary_function;
1349 1350
  /* If >0 convert all blob fields to varchar(convert_blob_length) */
  uint  convert_blob_length; 
1351
  bool force_copy_fields;
1352
  TMP_TABLE_PARAM()
unknown's avatar
unknown committed
1353
    :copy_field(0), group_parts(0),
1354 1355
    group_length(0), group_null_parts(0), convert_blob_length(0),
    force_copy_fields(0)
1356 1357 1358 1359 1360
  {}
  ~TMP_TABLE_PARAM()
  {
    cleanup();
  }
1361
  void init(void);
1362 1363 1364 1365 1366
  inline void cleanup(void)
  {
    if (copy_field)				/* Fix for Intel compiler */
    {
      delete [] copy_field;
1367
      save_copy_field= copy_field= 0;
1368 1369 1370 1371
    }
  }
};

1372
class select_union :public select_result_interceptor {
unknown's avatar
unknown committed
1373 1374 1375
 public:
  TABLE *table;
  COPY_INFO info;
1376
  TMP_TABLE_PARAM tmp_table_param;
unknown's avatar
unknown committed
1377 1378 1379

  select_union(TABLE *table_par);
  ~select_union();
1380
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
1381 1382 1383
  bool send_data(List<Item> &items);
  bool send_eof();
  bool flush();
1384
  void set_table(TABLE *tbl) { table= tbl; }
unknown's avatar
unknown committed
1385 1386
};

unknown's avatar
unknown committed
1387
/* Base subselect interface class */
1388
class select_subselect :public select_result_interceptor
1389
{
unknown's avatar
unknown committed
1390
protected:
1391 1392 1393
  Item_subselect *item;
public:
  select_subselect(Item_subselect *item);
unknown's avatar
unknown committed
1394
  bool send_data(List<Item> &items)=0;
1395 1396 1397
  bool send_eof() { return 0; };
};

unknown's avatar
unknown committed
1398
/* Single value subselect interface class */
unknown's avatar
unknown committed
1399
class select_singlerow_subselect :public select_subselect
unknown's avatar
unknown committed
1400 1401
{
public:
unknown's avatar
unknown committed
1402
  select_singlerow_subselect(Item_subselect *item):select_subselect(item){}
unknown's avatar
unknown committed
1403 1404 1405
  bool send_data(List<Item> &items);
};

1406 1407 1408 1409 1410 1411 1412 1413 1414 1415
/* 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)
  {}
1416
  void cleanup();
1417 1418 1419 1420 1421 1422
  bool send_data(List<Item> &items);
  bool cmp_real();
  bool cmp_int();
  bool cmp_str();
};

unknown's avatar
unknown committed
1423 1424 1425 1426 1427 1428 1429 1430
/* 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
1431 1432 1433 1434 1435 1436 1437
/* 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 */
1438 1439
  bool reverse;				/* if descending sort */
  bool need_strxnfrm;			/* If we have to use strxnfrm() */
unknown's avatar
unknown committed
1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452
} 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 */

1453 1454
class Table_ident :public Sql_alloc
{
unknown's avatar
unknown committed
1455 1456 1457
 public:
  LEX_STRING db;
  LEX_STRING table;
unknown's avatar
unknown committed
1458
  SELECT_LEX_UNIT *sel;
unknown's avatar
unknown committed
1459 1460
  inline Table_ident(THD *thd, LEX_STRING db_arg, LEX_STRING table_arg,
		     bool force)
unknown's avatar
unknown committed
1461
    :table(table_arg), sel((SELECT_LEX_UNIT *)0)
unknown's avatar
unknown committed
1462
  {
unknown's avatar
unknown committed
1463
    if (!force && (thd->client_capabilities & CLIENT_NO_SCHEMA))
unknown's avatar
unknown committed
1464 1465 1466 1467
      db.str=0;
    else
      db= db_arg;
  }
unknown's avatar
unknown committed
1468 1469 1470 1471 1472 1473 1474
  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
1475 1476
    /* 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
1477
  }
unknown's avatar
unknown committed
1478
  inline void change_db(char *db_name)
unknown's avatar
unknown committed
1479 1480 1481
  {
    db.str= db_name; db.length= (uint) strlen(db_name);
  }
unknown's avatar
unknown committed
1482 1483 1484 1485 1486 1487 1488 1489
};

// this is needed for user_vars hash
class user_var_entry
{
 public:
  LEX_STRING name;
  char *value;
unknown's avatar
unknown committed
1490
  ulong length, update_query_id, used_query_id;
unknown's avatar
unknown committed
1491
  Item_result type;
1492 1493 1494 1495

  double val(my_bool *null_value);
  longlong val_int(my_bool *null_value);
  String *val_str(my_bool *null_value, String *str, uint decimals);
1496
  DTCollation collation;
unknown's avatar
unknown committed
1497 1498
};

1499

1500 1501 1502 1503 1504 1505 1506 1507
/* Class for unique (removing of duplicates) */

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
1508
  byte *record_pointers;
1509
  bool flush();
1510
  uint size;
1511 1512 1513

public:
  ulong elements;
1514
  Unique(qsort_cmp2 comp_func, void * comp_func_fixed_arg,
1515
	 uint size_arg, ulong max_in_memory_size_arg);
1516
  ~Unique();
unknown's avatar
unknown committed
1517
  inline bool unique_add(gptr ptr)
1518 1519 1520
  {
    if (tree.elements_in_tree > max_elements && flush())
      return 1;
1521
    return !tree_insert(&tree, ptr, 0, tree.custom_arg);
1522 1523 1524 1525
  }

  bool get(TABLE *table);

1526 1527
  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);
1528
};
1529

unknown's avatar
unknown committed
1530

1531
class multi_delete :public select_result_interceptor
unknown's avatar
unknown committed
1532 1533
{
  TABLE_LIST *delete_tables, *table_being_deleted;
unknown's avatar
unknown committed
1534
  Unique **tempfiles;
unknown's avatar
unknown committed
1535
  THD *thd;
1536
  ha_rows deleted, found;
unknown's avatar
unknown committed
1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550
  uint num_of_tables;
  int error;
  bool do_delete, transactional_tables, log_delayed, normal_tables;
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);
  int  do_deletes (bool from_send_error);
  bool send_eof();
};

1551

1552
class multi_update :public select_result_interceptor
unknown's avatar
unknown committed
1553 1554 1555
{
  TABLE_LIST *all_tables, *update_tables, *table_being_updated;
  THD *thd;
unknown's avatar
unknown committed
1556
  TABLE **tmp_tables, *main_table, *table_to_update;
unknown's avatar
unknown committed
1557 1558 1559 1560 1561 1562 1563
  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;
1564
  bool do_update, trans_safe, transactional_tables, log_delayed, ignore;
unknown's avatar
unknown committed
1565 1566 1567

public:
  multi_update(THD *thd_arg, TABLE_LIST *ut, List<Item> *fields,
1568
	       List<Item> *values, enum_duplicates handle_duplicates, bool ignore);
unknown's avatar
unknown committed
1569
  ~multi_update();
unknown's avatar
unknown committed
1570
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
1571 1572 1573 1574 1575 1576
  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();
};
1577 1578


1579
class select_dumpvar :public select_result_interceptor {
unknown's avatar
unknown committed
1580 1581
  ha_rows row_count;
public:
1582
  List<LEX_STRING> var_list;
1583
  select_dumpvar()  { var_list.empty(); row_count= 0;}
unknown's avatar
unknown committed
1584
  ~select_dumpvar() {}
1585
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
1586 1587
  bool send_data(List<Item> &items);
  bool send_eof();
1588
  void cleanup();
unknown's avatar
unknown committed
1589
};