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

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

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

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

#ifdef __GNUC__
#pragma interface			/* gcc class implementation */
#endif

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

bk@work.mysql.com's avatar
bk@work.mysql.com committed
26 27
class Query_log_event;
class Load_log_event;
28
class Slave_log_event;
bk@work.mysql.com's avatar
bk@work.mysql.com 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_IGNORE, 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 };
bk@work.mysql.com's avatar
bk@work.mysql.com committed
36

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

40 41
extern char internal_table_name[2];

42
/* log info errors */
bk@work.mysql.com's avatar
bk@work.mysql.com 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
47 48 49
#define LOG_INFO_MEM -6
#define LOG_INFO_FATAL -7
#define LOG_INFO_IN_USE -8
bk@work.mysql.com's avatar
bk@work.mysql.com 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;

bk@work.mysql.com's avatar
bk@work.mysql.com 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;
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);}
66
  ~st_log_info() { pthread_mutex_destroy(&lock);}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
67 68
} LOG_INFO;

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;

monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
78
class Log_event;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
79

80 81
class MYSQL_LOG
 {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
82
 private:
83
  /* LOCK_log and LOCK_index are inited by init_pthread_objects() */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
84
  pthread_mutex_t LOCK_log, LOCK_index;
85 86
  pthread_cond_t update_cond;
  ulonglong bytes_written;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
87
  time_t last_time,query_start;
88
  IO_CACHE log_file;
89
  IO_CACHE index_file;
bk@work.mysql.com's avatar
bk@work.mysql.com 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];
93 94 95
  // current file sequence number for load data infile binary logging
  uint file_id;
  uint open_count;				// For replication
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
96 97
  volatile enum_log_type log_type;
  enum cache_type io_cache_type;
98
  bool write_error, inited;
99
  bool need_start_event;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi 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;

bk@work.mysql.com's avatar
bk@work.mysql.com committed
114 115 116
public:
  MYSQL_LOG();
  ~MYSQL_LOG();
117
  void reset_bytes_written()
118 119 120
  {
    bytes_written = 0;
  }
121
  void harvest_bytes_written(ulonglong* counter)
122
  {
123
#ifndef DBUG_OFF
124
    char buf1[22],buf2[22];
125
#endif	
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);
monty@mysql.com's avatar
monty@mysql.com 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);
guilhem@mysql.com's avatar
guilhem@mysql.com committed
140
  void init_pthread_objects();
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi 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 148
  bool write(THD *thd, enum enum_server_command command,
	     const char *format,...);
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
guilhem@mysql.com's avatar
guilhem@mysql.com committed
152
  bool write(THD *thd, IO_CACHE *cache, bool commit_or_rollback);
153

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
  
bk@work.mysql.com's avatar
bk@work.mysql.com 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);
guilhem@mysql.com's avatar
guilhem@mysql.com committed
172 173
  bool cut_spurious_tail();
  void report_pos_in_innodb();
bk@work.mysql.com's avatar
bk@work.mysql.com 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);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
179
  int get_current_log(LOG_INFO* linfo);
180
  uint next_file_id();
181
  inline bool is_open() { return log_type != LOG_CLOSED; }
182 183 184 185 186 187 188
  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);}
189
  inline IO_CACHE *get_index_file() { return &index_file;}
190
  inline uint32 get_open_count() { return open_count; }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
191 192 193 194 195 196 197 198
};

/* character conversion tables */


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


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:
240
  enum Keytype { PRIMARY, UNIQUE, MULTIPLE, FULLTEXT, SPATIAL, FOREIGN_KEY};
bk@work.mysql.com's avatar
bk@work.mysql.com committed
241
  enum Keytype type;
242
  enum ha_key_alg algorithm;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
243
  List<key_part_spec> columns;
244
  const char *name;
245
  bool generated;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
246

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

257 258 259 260 261 262 263 264 265 266 267 268 269 270 271
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)
272
    :Key(FOREIGN_KEY, name_arg, HA_KEY_ALG_UNDEF, 0, cols),
273 274 275 276 277
    ref_table(table), ref_columns(cols),
    delete_opt(delete_opt_arg), update_opt(update_opt_arg),
    match_opt(match_opt_arg)
  {}
};
bk@work.mysql.com's avatar
bk@work.mysql.com committed
278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296

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

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

bk@work.mysql.com's avatar
bk@work.mysql.com committed
299 300 301 302 303 304 305 306
class i_string: public ilink
{
public:
  char* ptr;
  i_string():ptr(0) { }
  i_string(char* s) : ptr(s) {}
};

307
/* needed for linked list of two strings for replicate-rewrite-db */
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
308 309 310 311 312 313
class i_string_pair: public ilink
{
public:
  char* key;
  char* val;
  i_string_pair():key(0),val(0) { }
314
  i_string_pair(char* key_arg, char* val_arg) : key(key_arg),val(val_arg) {}
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
315 316 317
};


318
class MYSQL_ERROR: public Sql_alloc
319 320
{
public:
321 322 323
  enum enum_warning_level
  { WARN_LEVEL_NOTE, WARN_LEVEL_WARN, WARN_LEVEL_ERROR, WARN_LEVEL_END};

324
  uint code;
325 326
  enum_warning_level level;
  char *msg;
327
  
328
  MYSQL_ERROR(THD *thd, uint code_arg, enum_warning_level level_arg,
329 330
	      const char *msg_arg)
    :code(code_arg), level(level_arg)
331
  {
wax@kishkin.ru's avatar
SCRUM  
wax@kishkin.ru committed
332
    if (msg_arg)
333
      set_msg(thd, msg_arg);
334
  }
335
  void set_msg(THD *thd, const char *msg_arg);
336
};
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
337

338

bk@work.mysql.com's avatar
bk@work.mysql.com committed
339
class delayed_insert;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
340
class select_result;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
341

342 343 344 345 346
#define THD_SENTRY_MAGIC 0xfeedd1ff
#define THD_SENTRY_GONE  0xdeadbeef

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

347 348
struct system_variables
{
349 350
  ulonglong myisam_max_extra_sort_file_size;
  ulonglong myisam_max_sort_file_size;
351 352
  ha_rows select_limit;
  ha_rows max_join_size;
353
  ulong bulk_insert_buff_size;
354 355
  ulong join_buff_size;
  ulong long_query_time;
356
  ulong max_allowed_packet;
357
  ulong max_error_count;
358
  ulong max_heap_table_size;
igor@hundin.mysql.fi's avatar
igor@hundin.mysql.fi committed
359
  ulong max_length_for_sort_data;
360
  ulong max_sort_length;
361
  ulong max_tmp_tables;
362
  ulong max_insert_delayed_threads;
363
  ulong myisam_repair_threads;
364 365
  ulong myisam_sort_buff_size;
  ulong net_buffer_length;
366
  ulong net_interactive_timeout;
367
  ulong net_read_timeout;
368
  ulong net_retry_count;
369
  ulong net_wait_timeout;
370
  ulong net_write_timeout;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
371
  ulong preload_buff_size;
372 373 374
  ulong query_cache_type;
  ulong read_buff_size;
  ulong read_rnd_buff_size;
375
  ulong sortbuff_size;
376
  ulong table_type;
377
  ulong tmp_table_size;
378
  ulong tx_isolation;
379
  /* Determines which non-standard SQL behaviour should be enabled */
380
  ulong sql_mode;
381
  ulong default_week_format;
382
  ulong max_seeks_for_key;
383 384 385 386 387
  ulong range_alloc_block_size;
  ulong query_alloc_block_size;
  ulong query_prealloc_size;
  ulong trans_alloc_block_size;
  ulong trans_prealloc_size;
388
  ulong log_warnings;
389
  ulong group_concat_max_len;
390 391 392 393 394 395
  /*
    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;

396 397
  my_bool low_priority_updates;
  my_bool new_mode;
398
  my_bool query_cache_wlock_invalidate;
399
#ifdef HAVE_INNOBASE_DB
400
  my_bool innodb_table_locks;
401
#endif /* HAVE_INNOBASE_DB */
402 403 404 405
#ifdef HAVE_NDBCLUSTER_DB
  ulong ndb_autoincrement_prefetch_sz;
  my_bool ndb_force_send;
  my_bool ndb_use_exact_count;
406
  my_bool ndb_use_local_query_cache;
407 408
  my_bool ndb_use_transactions;
#endif /* HAVE_NDBCLUSTER_DB */
409
  my_bool old_passwords;
410
  
411
  /* Only charset part of these variables is sensible */
412 413
  CHARSET_INFO 	*character_set_client;
  CHARSET_INFO  *character_set_results;
414 415 416 417
  
  /* Both charset and collation parts of these variables are important */
  CHARSET_INFO	*collation_server;
  CHARSET_INFO	*collation_database;
418
  CHARSET_INFO  *collation_connection;
419

420 421
  Time_zone *time_zone;

422 423 424 425
  /* DATE, DATETIME and TIME formats */
  DATE_TIME_FORMAT *date_format;
  DATE_TIME_FORMAT *datetime_format;
  DATE_TIME_FORMAT *time_format;
426 427
};

428
void free_tmp_table(THD *thd, TABLE *entry);
429 430


431 432 433 434 435 436 437 438
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;
439 440
  MEM_ROOT main_mem_root;
  MEM_ROOT *mem_root;                   // Pointer to current memroot
441
  enum enum_state 
442 443 444 445 446
  {
    INITIALIZED= 0, PREPARED= 1, EXECUTED= 3, CONVENTIONAL_EXECUTION= 2, 
    ERROR= -1
  };
  
447
  enum_state state;
448 449 450 451 452 453 454

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

455 456 457 458 459 460 461 462 463
  /*
    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.
  */
464
  Item_arena(THD *thd);
465 466 467 468
  /*
    Create arena and optionally init memory root with minimal values.
    Particularly used if Item_arena is part of Statement.
  */
469 470
  Item_arena(bool init_mem_root);
  virtual Type type() const;
471
  virtual ~Item_arena() {};
472

473 474
  inline bool is_stmt_prepare() const { return (int)state < (int)PREPARED; }
  inline bool is_first_stmt_execute() const { return state == PREPARED; }
475 476
  inline bool is_stmt_execute() const
  { return state == PREPARED || state == EXECUTED; }
477 478
  inline bool is_conventional_execution() const
  { return state == CONVENTIONAL_EXECUTION; }
479
  inline gptr alloc(unsigned int size) { return alloc_root(mem_root,size); }
480 481 482
  inline gptr calloc(unsigned int size)
  {
    gptr ptr;
483
    if ((ptr=alloc_root(mem_root,size)))
484 485 486 487
      bzero((char*) ptr,size);
    return ptr;
  }
  inline char *strdup(const char *str)
488
  { return strdup_root(mem_root,str); }
489
  inline char *strmake(const char *str, uint size)
490
  { return strmake_root(mem_root,str,size); }
491
  inline char *memdup(const char *str, uint size)
492
  { return memdup_root(mem_root,str,size); }
493 494 495
  inline char *memdup_w_gap(const char *str, uint size, uint gap)
  {
    gptr ptr;
496
    if ((ptr=alloc_root(mem_root,size+gap)))
497 498 499 500 501 502 503 504 505 506
      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);
};


507 508 509 510 511 512 513 514 515 516 517 518 519 520
/*
  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.
*/

521
class Statement: public Item_arena
522 523 524 525 526 527
{
  Statement(const Statement &rhs);              /* not implemented: */
  Statement &operator=(const Statement &rhs);   /* non-copyable */
public:
  /* FIXME: must be private */
  LEX     main_lex;
528

529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553
  /*
    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;

554
  LEX_STRING name; /* name for named prepared statements */
555 556 557 558 559
  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.
560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576

    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.
577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593
  */
  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);
594 595
  void set_n_backup_statement(Statement *stmt, Statement *backup);
  void restore_backup_statement(Statement *stmt, Statement *backup);
596 597 598 599 600 601
  /* return class type */
  virtual Type type() const;
};


/*
602 603 604 605 606
  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
607

608 609
  Statements are auto-deleted when they are removed from the map and when the
  map is deleted.
610 611 612 613 614 615
*/

class Statement_map
{
public:
  Statement_map();
616

617 618 619
  int insert(Statement *statement);

  Statement *find_by_name(LEX_STRING *name)
620
  {
621 622 623 624
    Statement *stmt;
    stmt= (Statement*)hash_search(&names_hash, (byte*)name->str,
                                  name->length);
    return stmt;
625 626 627 628 629
  }

  Statement *find(ulong id)
  {
    if (last_found_statement == 0 || id != last_found_statement->id)
630 631 632
    {
      Statement *stmt;
      stmt= (Statement *) hash_search(&st_hash, (byte *) &id, sizeof(id));
633
      if (stmt && stmt->name.str)
634 635 636
        return NULL;
      last_found_statement= stmt;
    }
637 638 639 640 641 642
    return last_found_statement;
  }
  void erase(Statement *statement)
  {
    if (statement == last_found_statement)
      last_found_statement= 0;
643 644 645 646
    if (statement->name.str)
    {
      hash_delete(&names_hash, (byte *) statement);  
    }
647 648
    hash_delete(&st_hash, (byte *) statement);
  }
649 650 651 652 653 654 655
  /* Erase all statements (calls Statement destructor) */
  void reset()
  {
    hash_reset(&names_hash);
    hash_reset(&st_hash);
    last_found_statement= 0;
  }
656 657 658

  ~Statement_map()
  {
659
    hash_free(&names_hash);
660
    hash_free(&st_hash);
661 662 663
  }
private:
  HASH st_hash;
664
  HASH names_hash;
665 666 667 668
  Statement *last_found_statement;
};


669 670 671 672 673 674 675 676 677 678 679
/*
  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;


680 681 682 683
/*
  For each client connection we create a separate thread with THD serving as
  a thread/connection descriptor
*/
684

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

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

745
  ulong client_capabilities;		/* What the client supports */
746
  ulong max_client_packet_length;
747 748
  ulong master_access;			/* Global privileges from mysql.user */
  ulong db_access;			/* Privileges for current db */
749 750 751 752 753 754

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

838
  /*
839
    Current prepared Item_arena if there one, or 0
840
  */
841
  Item_arena *current_arena;
842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858
  /*
    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;
  /*
    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;
859
  ha_rows    cuted_fields,
860
             sent_row_count, examined_row_count;
861
  table_map  used_tables;
862
  USER_CONN *user_connect;
863
  CHARSET_INFO *db_charset;
864
  List<TABLE> temporary_tables_should_be_free; // list of temporary tables
865 866 867 868 869 870
  /*
    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.
  */
871
  List	     <MYSQL_ERROR> warn_list;
872
  uint	     warn_count[(uint) MYSQL_ERROR::WARN_LEVEL_END];
873
  uint	     total_warn_count;
874 875 876 877 878 879 880 881 882
  /*
    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;
883 884 885 886
  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;
887
  ulong	     rand_saved_seed1, rand_saved_seed2;
888
  ulong      row_count;  // Row counter, mainly for errors and warnings
889
  long	     dbug_thread_id;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
890
  pthread_t  real_id;
serg@serg.mylan's avatar
serg@serg.mylan committed
891
  uint	     current_tablenr,tmp_table,global_read_lock;
892
  uint	     server_status,open_options,system_thread;
893
  uint32     db_length;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
894
  uint       select_number;             //number of select (used for EXPLAIN)
895 896
  /* variables.transaction_isolation is reset to this after each commit */
  enum_tx_isolation session_tx_isolation;
897
  enum_check_fields count_cuted_fields;
898 899
  /* for user variables replication*/
  DYNAMIC_ARRAY user_var_events;
900 901

  /* scramble - random string sent to client on handshake */
902
  char	     scramble[SCRAMBLE_LENGTH+1];
903

904
  bool       slave_thread, one_shot_set;
905
  bool	     locked, some_tables_deleted;
906
  bool       last_cuted_field;
907
  bool	     no_errors, password, is_fatal_error;
nick@mysql.com's avatar
nick@mysql.com committed
908
  bool	     query_start_used,last_insert_id_used,insert_id_used,rand_used;
909
  bool	     time_zone_used;
910
  bool	     in_lock_tables;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
911
  bool       query_error, bootstrap, cleanup_done;
912
  bool	     tmp_table_used;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
913
  bool	     charset_is_system_charset, charset_is_collation_connection;
914
  bool       slow_command;
915
  my_bool    volatile killed;
916

917 918 919 920 921
  /*
    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
  */
922
  LOG_INFO*  current_linfo;
923
  NET*       slave_net;			// network connection from slave -> m.
924 925 926 927 928 929 930
  /* Used by the sys_var class to store temporary values */
  union
  {
    my_bool my_bool_value;
    long    long_value;
  } sys_var_tmp;

bk@work.mysql.com's avatar
bk@work.mysql.com committed
931 932
  THD();
  ~THD();
933

934
  void init(void);
935 936 937 938 939 940 941 942 943 944
  /*
    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();
945
  void change_user(void);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
946
  void cleanup(void);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
947
  bool store_globals();
948 949
#ifdef SIGNAL_WITH_VIO_CLOSE
  inline void set_active_vio(Vio* vio)
950
  {
951
    pthread_mutex_lock(&LOCK_delete);
952
    active_vio = vio;
953
    pthread_mutex_unlock(&LOCK_delete);
954
  }
955
  inline void clear_active_vio()
956
  {
957
    pthread_mutex_lock(&LOCK_delete);
958
    active_vio = 0;
959
    pthread_mutex_unlock(&LOCK_delete);
960
  }
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
961
  void close_active_vio();
962
#endif  
963
  void awake(bool prepare_to_die);
964 965
  /*
    For enter_cond() / exit_cond() to work the mutex must be got before
guilhem@mysql.com's avatar
guilhem@mysql.com committed
966 967 968
    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().
969
  */
970 971 972 973 974 975 976 977 978 979 980
  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)
  {
guilhem@mysql.com's avatar
guilhem@mysql.com committed
981 982 983 984 985 986 987
    /*
      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);
988 989 990 991 992 993
    pthread_mutex_lock(&mysys_var->mutex);
    mysys_var->current_mutex = 0;
    mysys_var->current_cond = 0;
    proc_info = old_msg;
    pthread_mutex_unlock(&mysys_var->mutex);
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
994
  inline time_t query_start() { query_start_used=1; return start_time; }
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
995
  inline void	set_time()    { if (user_time) start_time=time_after_lock=user_time; else time_after_lock=time(&start_time); }
996
  inline void	end_time()    { time(&start_time); }
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
997
  inline void	set_time(time_t t) { time_after_lock=start_time=user_time=t; }
998
  inline void	lock_time()   { time(&time_after_lock); }
999 1000 1001 1002 1003
  inline void	insert_id(ulonglong id_arg)
  {
    last_insert_id= id_arg;
    insert_id_used=1;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1004 1005 1006 1007 1008 1009 1010 1011 1012
  inline ulonglong insert_id(void)
  {
    if (!last_insert_id_used)
    {      
      last_insert_id_used=1;
      current_insert_id=last_insert_id;
    }
    return last_insert_id;
  }
1013 1014 1015 1016
  inline ulonglong found_rows(void)
  {
    return limit_found_rows;
  }                                                                         
1017 1018
  inline bool active_transaction()
  {
1019
#ifdef USING_TRANSACTIONS    
1020
    return (transaction.all.bdb_tid != 0 ||
1021 1022
	    transaction.all.innodb_active_trans != 0 ||
	    transaction.all.ndb_tid != 0);
1023 1024 1025
#else
    return 0;
#endif
1026
  }
1027 1028 1029 1030
  inline gptr trans_alloc(unsigned int size) 
  { 
    return alloc_root(&transaction.mem_root,size);
  }
1031 1032 1033 1034

  bool convert_string(LEX_STRING *to, CHARSET_INFO *to_cs,
		      const char *from, uint from_length,
		      CHARSET_INFO *from_cs);
1035 1036 1037

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

1038
  void add_changed_table(TABLE *table);
1039 1040
  void add_changed_table(const char *key, long key_length);
  CHANGED_TABLE_LIST * changed_table_dup(const char *key, long key_length);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1041
  int send_explain_fields(select_result *result);
1042
#ifndef EMBEDDED_LIBRARY
1043 1044 1045 1046 1047 1048
  inline void clear_error()
  {
    net.last_error[0]= 0;
    net.last_errno= 0;
    net.report_error= 0;
  }
1049
  inline bool vio_ok() const { return net.vio != 0; }
1050 1051
#else
  void clear_error();
1052
  inline bool vio_ok() const { return true; }
1053
#endif
1054 1055 1056 1057
  inline void fatal_error()
  {
    is_fatal_error= 1;
    net.report_error= 1; 
1058
    DBUG_PRINT("error",("Fatal error set"));
1059
  }
1060
  inline CHARSET_INFO *charset() { return variables.character_set_client; }
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1061
  void update_charset();
1062

1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077
  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;
  }

1078
  void change_item_tree(Item **place, Item *new_value)
1079
  {
1080
    /* TODO: check for OOM condition here */
1081
    if (!current_arena->is_conventional_execution())
1082
      nocheck_register_item_tree_change(place, *place, mem_root);
1083
    *place= new_value;
1084 1085
  }
  void nocheck_register_item_tree_change(Item **place, Item *old_value,
1086
                                         MEM_ROOT *runtime_memroot);
1087
  void rollback_item_tree_changes();
1088 1089 1090 1091 1092 1093

  /*
    Cleanup statement parse state (parse tree, lex) and execution
    state after execution of a non-prepared SQL statement.
  */
  void end_statement();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1094 1095
};

1096 1097 1098 1099 1100
/* 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

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1101 1102 1103
/*
  Used to hold information about file and file structure in exchainge 
  via non-DB file (...INTO OUTFILE..., ...LOAD DATA...)
1104
  XXX: We never call destructor for objects of this class.
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1105
*/
1106

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1107 1108 1109 1110 1111 1112 1113
class sql_exchange :public Sql_alloc
{
public:
  char *file_name;
  String *field_term,*enclosed,*line_term,*line_start,*escaped;
  bool opt_enclosed;
  bool dumpfile;
1114
  ulong skip_lines;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1115 1116 1117 1118 1119 1120
  sql_exchange(char *name,bool dumpfile_flag);
};

#include "log_event.h"

/*
1121
  This is used to get result from a select
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1122 1123
*/

1124 1125
class JOIN;

1126
void send_error(THD *thd, uint sql_errno=0, const char *err=0);
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
1127

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1128 1129 1130
class select_result :public Sql_alloc {
protected:
  THD *thd;
1131
  SELECT_LEX_UNIT *unit;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1132 1133 1134
public:
  select_result();
  virtual ~select_result() {};
1135 1136 1137 1138 1139
  virtual int prepare(List<Item> &list, SELECT_LEX_UNIT *u)
  {
    unit= u;
    return 0;
  }
1140 1141 1142 1143 1144 1145 1146
  /*
    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; }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1147 1148
  virtual bool send_fields(List<Item> &list,uint flag)=0;
  virtual bool send_data(List<Item> &items)=0;
1149
  virtual bool initialize_tables (JOIN *join=0) { return 0; }
1150
  virtual void send_error(uint errcode,const char *err);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1151 1152
  virtual bool send_eof()=0;
  virtual void abort() {}
1153 1154 1155 1156 1157
  /*
    Cleanup instance of this class for next execution of a prepared
    statement/stored procedure.
  */
  virtual void cleanup();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1158 1159 1160
};


1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174
/*
  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; }
};


bk@work.mysql.com's avatar
bk@work.mysql.com committed
1175 1176 1177 1178 1179 1180 1181 1182 1183
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();
};


1184
class select_to_file :public select_result_interceptor {
1185
protected:
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1186 1187 1188 1189
  sql_exchange *exchange;
  File file;
  IO_CACHE cache;
  ha_rows row_count;
1190 1191 1192 1193 1194 1195 1196
  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);
1197 1198
  bool send_eof();
  void cleanup();
1199 1200 1201 1202
};


class select_export :public select_to_file {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1203 1204 1205 1206
  uint field_term_length;
  int field_sep_char,escape_char,line_sep_char;
  bool fixed_row_size;
public:
1207
  select_export(sql_exchange *ex) :select_to_file(ex) {}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1208
  ~select_export();
1209
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1210 1211 1212
  bool send_data(List<Item> &items);
};

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

1214
class select_dump :public select_to_file {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1215
public:
1216
  select_dump(sql_exchange *ex) :select_to_file(ex) {}
1217
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1218 1219
  bool send_data(List<Item> &items);
};
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
1220 1221


1222
class select_insert :public select_result_interceptor {
1223
 public:
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1224 1225 1226 1227 1228
  TABLE *table;
  List<Item> *fields;
  ulonglong last_insert_id;
  COPY_INFO info;

1229 1230 1231
  select_insert(TABLE *table_par, List<Item> *fields_par,
		enum_duplicates duplic)
    :table(table_par), fields(fields_par), last_insert_id(0)
1232
  {
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
1233 1234 1235
    bzero((char*) &info,sizeof(info));
    info.handle_duplicates=duplic;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1236
  ~select_insert();
1237
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1238 1239 1240
  bool send_data(List<Item> &items);
  void send_error(uint errcode,const char *err);
  bool send_eof();
1241 1242
  /* not implemented: select_insert is never re-used in prepared statements */
  void cleanup();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1243 1244
};

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

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1246 1247 1248 1249 1250 1251 1252 1253 1254 1255
class select_create: public select_insert {
  ORDER *group;
  const char *db;
  const char *name;
  List<create_field> *extra_fields;
  List<Key> *keys;
  HA_CREATE_INFO *create_info;
  MYSQL_LOCK *lock;
  Field **field;
public:
1256 1257 1258 1259 1260
  select_create(const char *db_name, const char *table_name,
		HA_CREATE_INFO *create_info_par,
		List<create_field> &fields_par,
		List<Key> &keys_par,
		List<Item> &select_fields,enum_duplicates duplic)
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
1261
    :select_insert (NULL, &select_fields, duplic), db(db_name),
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1262
    name(table_name), extra_fields(&fields_par),keys(&keys_par),
1263
    create_info(create_info_par), lock(0)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1264
    {}
1265
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1266 1267 1268 1269 1270
  bool send_data(List<Item> &values);
  bool send_eof();
  void abort();
};

1271 1272 1273 1274 1275 1276
#include <myisam.h>

/* Param to create temporary tables when doing SELECT:s */

class TMP_TABLE_PARAM :public Sql_alloc
{
1277 1278 1279 1280 1281 1282
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:
1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296
  List<Item> copy_funcs;
  List<Item> save_copy_funcs;
  List_iterator_fast<Item> copy_funcs_it;
  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;
1297
  bool  using_indirect_summary_function;
1298 1299
  /* If >0 convert all blob fields to varchar(convert_blob_length) */
  uint  convert_blob_length; 
1300 1301 1302

  TMP_TABLE_PARAM()
    :copy_funcs_it(copy_funcs), copy_field(0), group_parts(0),
1303
    group_length(0), group_null_parts(0), convert_blob_length(0)
1304 1305 1306 1307 1308
  {}
  ~TMP_TABLE_PARAM()
  {
    cleanup();
  }
1309
  void init(void);
1310 1311 1312 1313 1314 1315 1316 1317 1318 1319
  inline void cleanup(void)
  {
    if (copy_field)				/* Fix for Intel compiler */
    {
      delete [] copy_field;
      copy_field=0;
    }
  }
};

1320
class select_union :public select_result_interceptor {
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
1321 1322 1323
 public:
  TABLE *table;
  COPY_INFO info;
1324
  TMP_TABLE_PARAM tmp_table_param;
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
1325 1326 1327

  select_union(TABLE *table_par);
  ~select_union();
1328
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
1329 1330 1331
  bool send_data(List<Item> &items);
  bool send_eof();
  bool flush();
1332
  void set_table(TABLE *tbl) { table= tbl; }
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
1333 1334
};

1335
/* Base subselect interface class */
1336
class select_subselect :public select_result_interceptor
1337
{
1338
protected:
1339 1340 1341
  Item_subselect *item;
public:
  select_subselect(Item_subselect *item);
1342
  bool send_data(List<Item> &items)=0;
1343 1344 1345
  bool send_eof() { return 0; };
};

1346
/* Single value subselect interface class */
1347
class select_singlerow_subselect :public select_subselect
1348 1349
{
public:
1350
  select_singlerow_subselect(Item_subselect *item):select_subselect(item){}
1351 1352 1353
  bool send_data(List<Item> &items);
};

1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369
/* 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)
  {}
  bool send_data(List<Item> &items);
  bool cmp_real();
  bool cmp_int();
  bool cmp_str();
};

1370 1371 1372 1373 1374 1375 1376 1377
/* EXISTS subselect interface class */
class select_exists_subselect :public select_subselect
{
public:
  select_exists_subselect(Item_subselect *item):select_subselect(item){}
  bool send_data(List<Item> &items);
};

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1378 1379 1380 1381 1382 1383 1384
/* 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 */
1385 1386
  bool reverse;				/* if descending sort */
  bool need_strxnfrm;			/* If we have to use strxnfrm() */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399
} 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 */

1400 1401
class Table_ident :public Sql_alloc
{
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1402 1403 1404
 public:
  LEX_STRING db;
  LEX_STRING table;
1405
  SELECT_LEX_UNIT *sel;
1406 1407
  inline Table_ident(THD *thd, LEX_STRING db_arg, LEX_STRING table_arg,
		     bool force)
1408
    :table(table_arg), sel((SELECT_LEX_UNIT *)0)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1409
  {
1410
    if (!force && (thd->client_capabilities & CLIENT_NO_SCHEMA))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1411 1412 1413 1414
      db.str=0;
    else
      db= db_arg;
  }
1415 1416 1417 1418 1419 1420 1421
  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) 
  {
1422 1423
    /* 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;
1424
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1425
  inline void change_db(char *db_name)
1426 1427 1428
  {
    db.str= db_name; db.length= (uint) strlen(db_name);
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1429 1430 1431 1432 1433 1434 1435 1436
};

// this is needed for user_vars hash
class user_var_entry
{
 public:
  LEX_STRING name;
  char *value;
1437
  ulong length, update_query_id, used_query_id;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1438
  Item_result type;
1439 1440 1441 1442

  double val(my_bool *null_value);
  longlong val_int(my_bool *null_value);
  String *val_str(my_bool *null_value, String *str, uint decimals);
1443
  DTCollation collation;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1444 1445
};

1446

1447 1448 1449 1450 1451 1452 1453 1454
/* 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;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1455
  byte *record_pointers;
1456
  bool flush();
1457
  uint size;
1458 1459 1460

public:
  ulong elements;
1461
  Unique(qsort_cmp2 comp_func, void * comp_func_fixed_arg,
1462
	 uint size_arg, ulong max_in_memory_size_arg);
1463
  ~Unique();
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1464
  inline bool unique_add(gptr ptr)
1465 1466 1467
  {
    if (tree.elements_in_tree > max_elements && flush())
      return 1;
1468
    return !tree_insert(&tree, ptr, 0, tree.custom_arg);
1469 1470 1471 1472
  }

  bool get(TABLE *table);

1473 1474
  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);
1475
};
1476

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

1478
class multi_delete :public select_result_interceptor
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1479 1480
{
  TABLE_LIST *delete_tables, *table_being_deleted;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1481
  Unique **tempfiles;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1482
  THD *thd;
1483
  ha_rows deleted, found;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497
  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();
};

1498

1499
class multi_update :public select_result_interceptor
1500 1501 1502
{
  TABLE_LIST *all_tables, *update_tables, *table_being_updated;
  THD *thd;
1503
  TABLE **tmp_tables, *main_table, *table_to_update;
1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516
  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;
  bool do_update, trans_safe, transactional_tables, log_delayed;

public:
  multi_update(THD *thd_arg, TABLE_LIST *ut, List<Item> *fields,
	       List<Item> *values, enum_duplicates handle_duplicates);
  ~multi_update();
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1517
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
1518 1519 1520 1521 1522 1523
  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();
};
1524 1525


1526
class select_dumpvar :public select_result_interceptor {
Sinisa@sinisa.nasamreza.org's avatar
Sinisa@sinisa.nasamreza.org committed
1527 1528
  ha_rows row_count;
public:
1529 1530 1531
  List<LEX_STRING> var_list;
  List<Item_func_set_user_var> vars;
  select_dumpvar(void)  { var_list.empty(); vars.empty(); row_count=0;}
Sinisa@sinisa.nasamreza.org's avatar
Sinisa@sinisa.nasamreza.org committed
1532
  ~select_dumpvar() {}
1533
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
Sinisa@sinisa.nasamreza.org's avatar
Sinisa@sinisa.nasamreza.org committed
1534 1535
  bool send_data(List<Item> &items);
  bool send_eof();
1536
  void cleanup();
Sinisa@sinisa.nasamreza.org's avatar
Sinisa@sinisa.nasamreza.org committed
1537
};