sql_class.h 40 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 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

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 };
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 };
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);
134
  void signal_update() { pthread_cond_broadcast(&update_cond);}
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 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
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

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

/* character conversion tables */


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


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:
237
  enum Keytype { PRIMARY, UNIQUE, MULTIPLE, FULLTEXT, SPATIAL, FOREIGN_KEY};
unknown's avatar
unknown committed
238
  enum Keytype type;
239
  enum ha_key_alg algorithm;
unknown's avatar
unknown committed
240
  List<key_part_spec> columns;
241
  const char *name;
unknown's avatar
unknown committed
242

243 244 245
  Key(enum Keytype type_par, const char *name_arg, enum ha_key_alg alg_par,
      List<key_part_spec> &cols)
    :type(type_par), algorithm(alg_par), columns(cols), name(name_arg)
246
  {}
unknown's avatar
unknown committed
247 248 249
  ~Key() {}
};

250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270
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)
    :Key(FOREIGN_KEY, name_arg, HA_KEY_ALG_UNDEF, cols),
    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
271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289

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

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

unknown's avatar
unknown committed
292 293 294 295 296 297 298 299
class i_string: public ilink
{
public:
  char* ptr;
  i_string():ptr(0) { }
  i_string(char* s) : ptr(s) {}
};

300
/* needed for linked list of two strings for replicate-rewrite-db */
unknown's avatar
unknown committed
301 302 303 304 305 306
class i_string_pair: public ilink
{
public:
  char* key;
  char* val;
  i_string_pair():key(0),val(0) { }
unknown's avatar
unknown committed
307
  i_string_pair(char* key_arg, char* val_arg) : key(key_arg),val(val_arg) {}
unknown's avatar
unknown committed
308 309 310
};


311
class MYSQL_ERROR: public Sql_alloc
unknown's avatar
unknown committed
312 313
{
public:
314 315 316
  enum enum_warning_level
  { WARN_LEVEL_NOTE, WARN_LEVEL_WARN, WARN_LEVEL_ERROR, WARN_LEVEL_END};

unknown's avatar
unknown committed
317
  uint code;
318 319
  enum_warning_level level;
  char *msg;
unknown's avatar
unknown committed
320
  
321
  MYSQL_ERROR(THD *thd, uint code_arg, enum_warning_level level_arg,
322 323
	      const char *msg_arg)
    :code(code_arg), level(level_arg)
unknown's avatar
unknown committed
324
  {
unknown's avatar
SCRUM  
unknown committed
325
    if (msg_arg)
326
      set_msg(thd, msg_arg);
unknown's avatar
unknown committed
327
  }
328
  void set_msg(THD *thd, const char *msg_arg);
unknown's avatar
unknown committed
329
};
unknown's avatar
unknown committed
330

331

unknown's avatar
unknown committed
332
class delayed_insert;
unknown's avatar
unknown committed
333
class select_result;
unknown's avatar
unknown committed
334

335 336 337 338 339
#define THD_SENTRY_MAGIC 0xfeedd1ff
#define THD_SENTRY_GONE  0xdeadbeef

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

340 341
struct system_variables
{
unknown's avatar
unknown committed
342 343
  ulonglong myisam_max_extra_sort_file_size;
  ulonglong myisam_max_sort_file_size;
344 345
  ha_rows select_limit;
  ha_rows max_join_size;
unknown's avatar
unknown committed
346
  ulong bulk_insert_buff_size;
347 348
  ulong join_buff_size;
  ulong long_query_time;
unknown's avatar
unknown committed
349
  ulong max_allowed_packet;
350
  ulong max_error_count;
351
  ulong max_heap_table_size;
unknown's avatar
unknown committed
352
  ulong max_length_for_sort_data;
353
  ulong max_sort_length;
354
  ulong max_tmp_tables;
355
  ulong max_insert_delayed_threads;
356
  ulong myisam_repair_threads;
unknown's avatar
unknown committed
357 358
  ulong myisam_sort_buff_size;
  ulong net_buffer_length;
359
  ulong net_interactive_timeout;
unknown's avatar
unknown committed
360
  ulong net_read_timeout;
361
  ulong net_retry_count;
362
  ulong net_wait_timeout;
unknown's avatar
unknown committed
363
  ulong net_write_timeout;
unknown's avatar
unknown committed
364
  ulong preload_buff_size;
unknown's avatar
unknown committed
365 366 367
  ulong query_cache_type;
  ulong read_buff_size;
  ulong read_rnd_buff_size;
368
  ulong sortbuff_size;
369
  ulong table_type;
370
  ulong tmp_table_size;
unknown's avatar
unknown committed
371
  ulong tx_isolation;
372
  /* Determines which non-standard SQL behaviour should be enabled */
373
  ulong sql_mode;
unknown's avatar
unknown committed
374
  ulong default_week_format;
375
  ulong max_seeks_for_key;
376 377 378 379 380
  ulong range_alloc_block_size;
  ulong query_alloc_block_size;
  ulong query_prealloc_size;
  ulong trans_alloc_block_size;
  ulong trans_prealloc_size;
381
  ulong group_concat_max_len;
unknown's avatar
unknown committed
382 383 384 385 386 387
  /*
    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
388
  my_bool log_warnings;
unknown's avatar
unknown committed
389 390
  my_bool low_priority_updates;
  my_bool new_mode;
391
  my_bool query_cache_wlock_invalidate;
392
  my_bool old_passwords;
393
  
394
  /* Only charset part of these variables is sensible */
395 396
  CHARSET_INFO 	*character_set_client;
  CHARSET_INFO  *character_set_results;
397 398 399 400
  
  /* Both charset and collation parts of these variables are important */
  CHARSET_INFO	*collation_server;
  CHARSET_INFO	*collation_database;
unknown's avatar
unknown committed
401
  CHARSET_INFO  *collation_connection;
402 403 404 405 406

  /* 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
407 408
};

409
void free_tmp_table(THD *thd, TABLE *entry);
410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432


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

class Statement
{
  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
433

434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467
  /*
    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;

  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.
  */
  char *query;
  uint32 query_length;                          // current query length
  /*
unknown's avatar
unknown committed
468
    List of items created in the parser for this query. Every item puts
469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494
    itself to the list on creation (see Item::Item() for details))
  */
  Item *free_list;
  MEM_ROOT mem_root;

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

  /*
    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);
  /* return class type */
  virtual Type type() const;
unknown's avatar
unknown committed
495

496 497
  inline gptr alloc(unsigned int size) { return alloc_root(&mem_root,size); }
  inline gptr calloc(unsigned int size)
unknown's avatar
unknown committed
498
  {
499 500 501 502
    gptr ptr;
    if ((ptr=alloc_root(&mem_root,size)))
      bzero((char*) ptr,size);
    return ptr;
unknown's avatar
unknown committed
503
  }
504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519
  inline char *strdup(const char *str)
  { return strdup_root(&mem_root,str); }
  inline char *strmake(const char *str, uint size)
  { return strmake_root(&mem_root,str,size); }
  inline char *memdup(const char *str, uint size)
  { return memdup_root(&mem_root,str,size); }
  inline char *memdup_w_gap(const char *str, uint size, uint gap)
  {
    gptr ptr;
    if ((ptr=alloc_root(&mem_root,size+gap)))
      memcpy(ptr,str,size);
    return ptr;
  }

  void set_n_backup_item_arena(Statement *set, Statement *backup);
  void restore_backup_item_arena(Statement *set, Statement *backup);
520
  void set_item_arena(Statement *set);
521 522 523 524 525 526 527 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 554 555 556 557 558 559 560 561 562 563 564 565
};


/*
  Used to seek all existing statements in the connection
  Deletes all statements in destructor.
*/

class Statement_map
{
public:
  Statement_map();
  
  int insert(Statement *statement)
  {
    int rc= my_hash_insert(&st_hash, (byte *) statement);
    if (rc == 0)
      last_found_statement= statement;
    return rc;
  }

  Statement *find(ulong id)
  {
    if (last_found_statement == 0 || id != last_found_statement->id)
      last_found_statement= (Statement *) hash_search(&st_hash, (byte *) &id,
                                                      sizeof(id));
    return last_found_statement;
  }
  void erase(Statement *statement)
  {
    if (statement == last_found_statement)
      last_found_statement= 0;
    hash_delete(&st_hash, (byte *) statement);
  }

  ~Statement_map()
  {
    hash_free(&st_hash);
  }
private:
  HASH st_hash;
  Statement *last_found_statement;
};


unknown's avatar
unknown committed
566 567 568 569
/*
  For each client connection we create a separate thread with THD serving as
  a thread/connection descriptor
*/
570

571 572
class THD :public ilink, 
           public Statement
unknown's avatar
unknown committed
573
{
unknown's avatar
unknown committed
574
public:
575 576
#ifdef EMBEDDED_LIBRARY
  struct st_mysql  *mysql;
unknown's avatar
SCRUM  
unknown committed
577 578 579
  struct st_mysql_data *data;
  unsigned long	 client_stmt_id;
  unsigned long  client_param_count;
unknown's avatar
unknown committed
580
  struct st_mysql_bind *client_params;
unknown's avatar
unknown committed
581 582
  char *extra_data;
  ulong extra_length;
unknown's avatar
unknown committed
583
  String query_rest;
584
#endif
unknown's avatar
unknown committed
585
  NET	  net;				// client connection descriptor
586
  MEM_ROOT warn_root;			// For warnings and errors
587 588 589
  Protocol *protocol;			// Current protocol
  Protocol_simple protocol_simple;	// Normal protocol
  Protocol_prep protocol_prep;		// Binary protocol
unknown's avatar
unknown committed
590 591 592 593 594
  HASH    user_vars;			// hash for user variables
  String  packet;			// dynamic buffer for network I/O
  struct  sockaddr_in remote;		// client socket address
  struct  rand_struct rand;		// used for authentication
  struct  system_variables variables;	// Changeable local variables
595 596
  pthread_mutex_t LOCK_delete;		// Locked before thd is deleted

597 598 599 600
  /* all prepared statements and cursors of this connection */
  Statement_map stmt_map; 
  /*
    keeps THD state while it is used for active statement
601
    Note: we perform special cleanup for it in THD destructor.
602 603
  */
  Statement stmt_backup;
unknown's avatar
unknown committed
604 605 606 607 608 609
  /*
    A pointer to the stack frame of handle_one_connection(),
    which is called first in the thread for handling a client
  */
  char	  *thread_stack;

610 611 612 613
  /*
    host - host of the client
    user - user of the client, set to NULL until the user has been read from
     the connection
614
    priv_user - The user privilege we are using. May be '' for anonymous user.
615 616 617
    db - currently selected database
    ip - client IP
   */
unknown's avatar
unknown committed
618
  char	  *host,*user,*priv_user,*db,*ip;
619
  char	  priv_host[MAX_HOSTNAME];
unknown's avatar
unknown committed
620 621
  /* remote (peer) port */
  uint16 peer_port;
622 623 624 625 626
  /*
    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
627 628 629
  const char *proc_info;
  /* points to host if host is available, otherwise points to ip */
  const char *host_or_ip;
630

631
  ulong client_capabilities;		/* What the client supports */
632
  ulong max_client_packet_length;
unknown's avatar
unknown committed
633 634
  ulong master_access;			/* Global privileges from mysql.user */
  ulong db_access;			/* Privileges for current db */
635 636 637 638 639 640

  /*
    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
641
  */
642
  TABLE   *open_tables,*temporary_tables, *handler_tables, *derived_tables;
643 644 645
  /*
    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
646
    statement execution, and all acquired locks are stored in 'lock'
647 648 649 650 651
    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
652
    stored in 'locked_tables' member.  Manual locking is described in
653 654 655
    the 'LOCK_TABLES' chapter of the MySQL manual.
    See also lock_tables() for details.
  */
656 657
  MYSQL_LOCK	*lock;				/* Current locks */
  MYSQL_LOCK	*locked_tables;			/* Tables locked with LOCK */
unknown's avatar
unknown committed
658 659 660 661 662
  /*
    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. 
  */
663
  User_level_lock *ull;
664 665
#ifndef DBUG_OFF
  uint dbug_sentry; // watch out for memory corruption
666
#endif
unknown's avatar
unknown committed
667
  struct st_my_thread_var *mysys_var;
668 669 670 671 672
  /*
    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
673
  uint32     server_id;
unknown's avatar
unknown committed
674
  uint32     file_id;			// for LOAD DATA INFILE
675 676 677 678 679
  /*
    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
680
  const char *where;
unknown's avatar
unknown committed
681 682
  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
683 684
  thr_lock_type update_lock_default;
  delayed_insert *di;
unknown's avatar
unknown committed
685
  my_bool    tablespace_op;	/* This is TRUE in DISCARD/IMPORT TABLESPACE */
unknown's avatar
unknown committed
686
  struct st_transactions {
687
    IO_CACHE trans_log;                 // Inited ONLY if binlog is open !
unknown's avatar
unknown committed
688 689
    THD_TRANS all;			// Trans since BEGIN WORK
    THD_TRANS stmt;			// Trans for current statement
unknown's avatar
unknown committed
690
    uint bdb_lock_count;
unknown's avatar
unknown committed
691 692 693 694
    uint ndb_lock_count;
#ifdef HAVE_NDBCLUSTER_DB
    void* ndb;
#endif
695
    /*
696
       Tables changed in transaction (that must be invalidated in query cache).
697
       List contain only transactional tables, that not invalidated in query
698 699 700 701 702 703 704 705 706
       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
707 708 709 710 711
  } transaction;
  Field      *dupp_field;
#ifndef __WIN__
  sigset_t signals,block_signals;
#endif
712 713
#ifdef SIGNAL_WITH_VIO_CLOSE
  Vio* active_vio;
714
#endif
unknown's avatar
unknown committed
715 716 717 718
  /*
    Current prepared Statement if there one, or 0
  */
  Statement *current_statement;
719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735
  /*
    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;
unknown's avatar
unknown committed
736
  ha_rows    cuted_fields,
unknown's avatar
unknown committed
737
             sent_row_count, examined_row_count;
unknown's avatar
unknown committed
738
  table_map  used_tables;
739
  USER_CONN *user_connect;
740
  CHARSET_INFO *db_charset;
741
  List<TABLE> temporary_tables_should_be_free; // list of temporary tables
742 743 744 745 746 747
  /*
    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.
  */
748
  List	     <MYSQL_ERROR> warn_list;
749
  uint	     warn_count[(uint) MYSQL_ERROR::WARN_LEVEL_END];
unknown's avatar
unknown committed
750
  uint	     total_warn_count;
751 752 753 754 755 756 757 758 759
  /*
    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;
760 761 762 763
  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;
764
  ulong	     rand_saved_seed1, rand_saved_seed2;
765
  ulong      row_count;  // Row counter, mainly for errors and warnings
unknown's avatar
unknown committed
766
  long	     dbug_thread_id;
unknown's avatar
unknown committed
767
  pthread_t  real_id;
768
  uint	     current_tablenr,tmp_table;
769
  uint	     server_status,open_options,system_thread;
unknown's avatar
unknown committed
770
  uint32     db_length;
unknown's avatar
unknown committed
771
  uint       select_number;             //number of select (used for EXPLAIN)
unknown's avatar
unknown committed
772 773
  /* variables.transaction_isolation is reset to this after each commit */
  enum_tx_isolation session_tx_isolation;
774
  enum_check_fields count_cuted_fields;
unknown's avatar
unknown committed
775 776
  /* for user variables replication*/
  DYNAMIC_ARRAY user_var_events;
777 778

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

unknown's avatar
unknown committed
781
  bool       slave_thread;
782
  bool	     locked, some_tables_deleted;
783
  bool       last_cuted_field;
784
  bool	     no_errors, password, is_fatal_error;
unknown's avatar
unknown committed
785
  bool	     query_start_used,last_insert_id_used,insert_id_used,rand_used;
786
  bool	     in_lock_tables,global_read_lock;
unknown's avatar
unknown committed
787
  bool       query_error, bootstrap, cleanup_done;
unknown's avatar
unknown committed
788
  bool	     volatile killed;
unknown's avatar
unknown committed
789
  bool	     tmp_table_used;
unknown's avatar
unknown committed
790
  bool	     charset_is_system_charset, charset_is_collation_connection;
791
  bool       slow_command;
unknown's avatar
unknown committed
792

unknown's avatar
unknown committed
793 794 795 796 797
  /*
    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
798
  LOG_INFO*  current_linfo;
unknown's avatar
unknown committed
799
  NET*       slave_net;			// network connection from slave -> m.
unknown's avatar
unknown committed
800 801 802 803 804 805 806
  /* Used by the sys_var class to store temporary values */
  union
  {
    my_bool my_bool_value;
    long    long_value;
  } sys_var_tmp;

unknown's avatar
unknown committed
807 808
  THD();
  ~THD();
809

unknown's avatar
unknown committed
810
  void init(void);
811 812 813 814 815 816 817 818 819 820
  /*
    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
821
  void change_user(void);
unknown's avatar
unknown committed
822
  void cleanup(void);
unknown's avatar
unknown committed
823
  bool store_globals();
824 825
#ifdef SIGNAL_WITH_VIO_CLOSE
  inline void set_active_vio(Vio* vio)
826
  {
827
    pthread_mutex_lock(&LOCK_delete);
828
    active_vio = vio;
829
    pthread_mutex_unlock(&LOCK_delete);
830
  }
831
  inline void clear_active_vio()
832
  {
833
    pthread_mutex_lock(&LOCK_delete);
834
    active_vio = 0;
835
    pthread_mutex_unlock(&LOCK_delete);
836
  }
unknown's avatar
unknown committed
837
  void close_active_vio();
838
#endif  
839
  void awake(bool prepare_to_die);
unknown's avatar
unknown committed
840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856
  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)
  {
    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
857
  inline time_t query_start() { query_start_used=1; return start_time; }
unknown's avatar
unknown committed
858
  inline void	set_time()    { if (user_time) start_time=time_after_lock=user_time; else time_after_lock=time(&start_time); }
859
  inline void	end_time()    { time(&start_time); }
unknown's avatar
unknown committed
860
  inline void	set_time(time_t t) { time_after_lock=start_time=user_time=t; }
861
  inline void	lock_time()   { time(&time_after_lock); }
862 863 864 865 866
  inline void	insert_id(ulonglong id_arg)
  {
    last_insert_id= id_arg;
    insert_id_used=1;
  }
unknown's avatar
unknown committed
867 868 869 870 871 872 873 874 875
  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;
  }
876 877 878 879
  inline ulonglong found_rows(void)
  {
    return limit_found_rows;
  }                                                                         
880 881
  inline bool active_transaction()
  {
882
#ifdef USING_TRANSACTIONS    
883
    return (transaction.all.bdb_tid != 0 ||
unknown's avatar
unknown committed
884 885
	    transaction.all.innodb_active_trans != 0 ||
	    transaction.all.ndb_tid != 0);
886 887 888
#else
    return 0;
#endif
889
  }
890 891 892 893
  inline gptr trans_alloc(unsigned int size) 
  { 
    return alloc_root(&transaction.mem_root,size);
  }
894 895 896 897

  bool convert_string(LEX_STRING *to, CHARSET_INFO *to_cs,
		      const char *from, uint from_length,
		      CHARSET_INFO *from_cs);
898
  void add_changed_table(TABLE *table);
unknown's avatar
unknown committed
899 900
  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
901
  int send_explain_fields(select_result *result);
902
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
903 904 905 906 907 908
  inline void clear_error()
  {
    net.last_error[0]= 0;
    net.last_errno= 0;
    net.report_error= 0;
  }
909 910 911
#else
  void clear_error();
#endif
912 913 914 915
  inline void fatal_error()
  {
    is_fatal_error= 1;
    net.report_error= 1; 
unknown's avatar
unknown committed
916
    DBUG_PRINT("error",("Fatal error set"));
917
  }
918
  inline CHARSET_INFO *charset() { return variables.character_set_client; }
unknown's avatar
unknown committed
919
  void update_charset();
920

unknown's avatar
unknown committed
921
  inline void allocate_temporary_memory_pool_for_ps_preparing()
922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937
  {
    DBUG_ASSERT(current_statement!=0);
    /*
      We do not want to have in PS memory all that junk,
      which will be created by preparation => substitute memory
      from original thread pool.

      We know that PS memory pool is now copied to THD, we move it back
      to allow some code use it.
    */
    current_statement->set_item_arena(this);
    init_sql_alloc(&mem_root,
		   variables.query_alloc_block_size,
		   variables.query_prealloc_size);
    free_list= 0;
  }
unknown's avatar
unknown committed
938
  inline void free_temporary_memory_pool_for_ps_preparing()
939 940 941 942
  {
    DBUG_ASSERT(current_statement!=0);
    cleanup_items(current_statement->free_list);
    free_items(free_list);
943
    close_thread_tables(this); // to close derived tables
944 945 946
    free_root(&mem_root, MYF(0));
    set_item_arena(current_statement);
  }
unknown's avatar
unknown committed
947 948
};

949 950 951 952 953
/* 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
954 955 956 957
/*
  Used to hold information about file and file structure in exchainge 
  via non-DB file (...INTO OUTFILE..., ...LOAD DATA...)
*/
unknown's avatar
unknown committed
958 959 960 961 962 963 964
class sql_exchange :public Sql_alloc
{
public:
  char *file_name;
  String *field_term,*enclosed,*line_term,*line_start,*escaped;
  bool opt_enclosed;
  bool dumpfile;
965
  ulong skip_lines;
unknown's avatar
unknown committed
966 967 968 969 970 971 972
  sql_exchange(char *name,bool dumpfile_flag);
  ~sql_exchange() {}
};

#include "log_event.h"

/*
973
  This is used to get result from a select
unknown's avatar
unknown committed
974 975
*/

unknown's avatar
unknown committed
976 977
class JOIN;

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

unknown's avatar
unknown committed
980 981 982
class select_result :public Sql_alloc {
protected:
  THD *thd;
983
  SELECT_LEX_UNIT *unit;
unknown's avatar
unknown committed
984 985 986
public:
  select_result();
  virtual ~select_result() {};
987 988 989 990 991
  virtual int prepare(List<Item> &list, SELECT_LEX_UNIT *u)
  {
    unit= u;
    return 0;
  }
unknown's avatar
unknown committed
992 993
  virtual bool send_fields(List<Item> &list,uint flag)=0;
  virtual bool send_data(List<Item> &items)=0;
unknown's avatar
unknown committed
994
  virtual bool initialize_tables (JOIN *join=0) { return 0; }
995
  virtual void send_error(uint errcode,const char *err);
unknown's avatar
unknown committed
996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009
  virtual bool send_eof()=0;
  virtual void abort() {}
};


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();
};


1010 1011
class select_to_file :public select_result {
protected:
unknown's avatar
unknown committed
1012 1013 1014 1015
  sql_exchange *exchange;
  File file;
  IO_CACHE cache;
  ha_rows row_count;
1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027
  char path[FN_REFLEN];

public:
  select_to_file(sql_exchange *ex) :exchange(ex), file(-1),row_count(0L)
  { path[0]=0; }
  ~select_to_file();
  bool send_fields(List<Item> &list, uint flag) { return 0; }
  void send_error(uint errcode,const char *err);
};


class select_export :public select_to_file {
unknown's avatar
unknown committed
1028 1029 1030 1031
  uint field_term_length;
  int field_sep_char,escape_char,line_sep_char;
  bool fixed_row_size;
public:
1032
  select_export(sql_exchange *ex) :select_to_file(ex) {}
unknown's avatar
unknown committed
1033
  ~select_export();
1034
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
1035 1036 1037 1038
  bool send_data(List<Item> &items);
  bool send_eof();
};

unknown's avatar
unknown committed
1039

1040
class select_dump :public select_to_file {
unknown's avatar
unknown committed
1041
public:
1042
  select_dump(sql_exchange *ex) :select_to_file(ex) {}
1043
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
1044 1045 1046
  bool send_data(List<Item> &items);
  bool send_eof();
};
unknown's avatar
unknown committed
1047 1048


unknown's avatar
unknown committed
1049
class select_insert :public select_result {
unknown's avatar
unknown committed
1050
 public:
unknown's avatar
unknown committed
1051 1052 1053 1054 1055
  TABLE *table;
  List<Item> *fields;
  ulonglong last_insert_id;
  COPY_INFO info;

1056 1057 1058
  select_insert(TABLE *table_par, List<Item> *fields_par,
		enum_duplicates duplic)
    :table(table_par), fields(fields_par), last_insert_id(0)
unknown's avatar
unknown committed
1059
  {
unknown's avatar
unknown committed
1060 1061 1062
    bzero((char*) &info,sizeof(info));
    info.handle_duplicates=duplic;
  }
unknown's avatar
unknown committed
1063
  ~select_insert();
1064
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
1065 1066
  bool send_fields(List<Item> &list, uint flag)
  { return 0; }
unknown's avatar
unknown committed
1067 1068 1069 1070 1071
  bool send_data(List<Item> &items);
  void send_error(uint errcode,const char *err);
  bool send_eof();
};

unknown's avatar
unknown committed
1072

unknown's avatar
unknown committed
1073 1074 1075 1076 1077 1078 1079 1080 1081 1082
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:
unknown's avatar
unknown committed
1083 1084 1085 1086 1087
  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)
unknown's avatar
unknown committed
1088
    :select_insert (NULL, &select_fields, duplic), db(db_name),
unknown's avatar
unknown committed
1089
    name(table_name), extra_fields(&fields_par),keys(&keys_par),
1090
    create_info(create_info_par), lock(0)
unknown's avatar
unknown committed
1091
    {}
1092
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
1093 1094 1095 1096 1097
  bool send_data(List<Item> &values);
  bool send_eof();
  void abort();
};

1098 1099 1100 1101 1102 1103
#include <myisam.h>

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

class TMP_TABLE_PARAM :public Sql_alloc
{
1104 1105 1106 1107 1108 1109
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:
1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123
  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;
1124
  bool  using_indirect_summary_function;
1125 1126 1127

  TMP_TABLE_PARAM()
    :copy_funcs_it(copy_funcs), copy_field(0), group_parts(0),
1128
    group_length(0), group_null_parts(0)
1129 1130 1131 1132 1133
  {}
  ~TMP_TABLE_PARAM()
  {
    cleanup();
  }
1134
  void init(void);
1135 1136 1137 1138 1139 1140 1141 1142 1143 1144
  inline void cleanup(void)
  {
    if (copy_field)				/* Fix for Intel compiler */
    {
      delete [] copy_field;
      copy_field=0;
    }
  }
};

unknown's avatar
unknown committed
1145 1146 1147 1148
class select_union :public select_result {
 public:
  TABLE *table;
  COPY_INFO info;
1149
  TMP_TABLE_PARAM tmp_table_param;
unknown's avatar
unknown committed
1150
  bool not_describe;
unknown's avatar
unknown committed
1151 1152 1153

  select_union(TABLE *table_par);
  ~select_union();
1154
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
1155 1156 1157 1158 1159
  bool send_fields(List<Item> &list, uint flag)
  { return 0; }
  bool send_data(List<Item> &items);
  bool send_eof();
  bool flush();
1160
  void set_table(TABLE *tbl) { table= tbl; }
unknown's avatar
unknown committed
1161 1162
};

unknown's avatar
unknown committed
1163
/* Base subselect interface class */
1164 1165
class select_subselect :public select_result
{
unknown's avatar
unknown committed
1166
protected:
1167 1168 1169 1170
  Item_subselect *item;
public:
  select_subselect(Item_subselect *item);
  bool send_fields(List<Item> &list, uint flag) { return 0; };
unknown's avatar
unknown committed
1171
  bool send_data(List<Item> &items)=0;
1172
  bool send_eof() { return 0; };
unknown's avatar
unknown committed
1173

1174 1175 1176
  friend class Ttem_subselect;
};

unknown's avatar
unknown committed
1177
/* Single value subselect interface class */
unknown's avatar
unknown committed
1178
class select_singlerow_subselect :public select_subselect
unknown's avatar
unknown committed
1179 1180
{
public:
unknown's avatar
unknown committed
1181
  select_singlerow_subselect(Item_subselect *item):select_subselect(item){}
unknown's avatar
unknown committed
1182 1183 1184
  bool send_data(List<Item> &items);
};

1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200
/* 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();
};

unknown's avatar
unknown committed
1201 1202 1203 1204 1205 1206 1207 1208
/* 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
1209 1210 1211 1212 1213 1214 1215
/* 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 */
1216 1217
  bool reverse;				/* if descending sort */
  bool need_strxnfrm;			/* If we have to use strxnfrm() */
unknown's avatar
unknown committed
1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230
} 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 */

1231 1232
class Table_ident :public Sql_alloc
{
unknown's avatar
unknown committed
1233 1234 1235
 public:
  LEX_STRING db;
  LEX_STRING table;
unknown's avatar
unknown committed
1236
  SELECT_LEX_UNIT *sel;
unknown's avatar
unknown committed
1237 1238
  inline Table_ident(THD *thd, LEX_STRING db_arg, LEX_STRING table_arg,
		     bool force)
unknown's avatar
unknown committed
1239
    :table(table_arg), sel((SELECT_LEX_UNIT *)0)
unknown's avatar
unknown committed
1240
  {
unknown's avatar
unknown committed
1241
    if (!force && (thd->client_capabilities & CLIENT_NO_SCHEMA))
unknown's avatar
unknown committed
1242 1243 1244 1245
      db.str=0;
    else
      db= db_arg;
  }
unknown's avatar
unknown committed
1246 1247 1248 1249 1250 1251 1252
  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
1253 1254
    /* 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
1255
  }
unknown's avatar
unknown committed
1256
  inline void change_db(char *db_name)
unknown's avatar
unknown committed
1257 1258 1259
  {
    db.str= db_name; db.length= (uint) strlen(db_name);
  }
unknown's avatar
unknown committed
1260 1261 1262 1263 1264 1265 1266 1267
};

// this is needed for user_vars hash
class user_var_entry
{
 public:
  LEX_STRING name;
  char *value;
unknown's avatar
unknown committed
1268
  ulong length, update_query_id, used_query_id;
unknown's avatar
unknown committed
1269
  Item_result type;
1270 1271 1272 1273

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

1277

1278 1279 1280 1281 1282 1283 1284 1285
/* 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
1286
  byte *record_pointers;
1287
  bool flush();
1288
  uint size;
1289 1290 1291

public:
  ulong elements;
1292
  Unique(qsort_cmp2 comp_func, void * comp_func_fixed_arg,
1293
	 uint size_arg, ulong max_in_memory_size_arg);
1294
  ~Unique();
unknown's avatar
unknown committed
1295
  inline bool unique_add(gptr ptr)
1296 1297 1298
  {
    if (tree.elements_in_tree > max_elements && flush())
      return 1;
1299
    return !tree_insert(&tree, ptr, 0, tree.custom_arg);
1300 1301 1302 1303
  }

  bool get(TABLE *table);

1304 1305
  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);
1306
};
1307

unknown's avatar
unknown committed
1308 1309

class multi_delete :public select_result
unknown's avatar
unknown committed
1310 1311
{
  TABLE_LIST *delete_tables, *table_being_deleted;
unknown's avatar
unknown committed
1312
  Unique **tempfiles;
unknown's avatar
unknown committed
1313
  THD *thd;
1314
  ha_rows deleted, found;
unknown's avatar
unknown committed
1315 1316 1317 1318 1319 1320 1321 1322
  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_fields(List<Item> &list,
1323
 		   uint flag) { return 0; }
unknown's avatar
unknown committed
1324 1325 1326 1327 1328 1329 1330
  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();
};

1331

unknown's avatar
unknown committed
1332
class multi_update :public select_result
unknown's avatar
unknown committed
1333 1334 1335
{
  TABLE_LIST *all_tables, *update_tables, *table_being_updated;
  THD *thd;
unknown's avatar
unknown committed
1336
  TABLE **tmp_tables, *main_table, *table_to_update;
unknown's avatar
unknown committed
1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349
  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();
unknown's avatar
unknown committed
1350
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
1351 1352 1353 1354 1355 1356 1357
  bool send_fields(List<Item> &list, uint flag) { return 0; }
  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();
};
1358 1359


unknown's avatar
unknown committed
1360 1361 1362
class select_dumpvar :public select_result {
  ha_rows row_count;
public:
1363 1364 1365
  List<LEX_STRING> var_list;
  List<Item_func_set_user_var> vars;
  select_dumpvar(void)  { var_list.empty(); vars.empty(); row_count=0;}
unknown's avatar
unknown committed
1366
  ~select_dumpvar() {}
1367 1368
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
  bool send_fields(List<Item> &list, uint flag) {return 0;}
unknown's avatar
unknown committed
1369 1370 1371
  bool send_data(List<Item> &items);
  bool send_eof();
};