sql_class.h 44.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);
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);
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
  my_bool old_passwords;
403
  
404
  /* Only charset part of these variables is sensible */
405 406
  CHARSET_INFO 	*character_set_client;
  CHARSET_INFO  *character_set_results;
407 408 409 410
  
  /* Both charset and collation parts of these variables are important */
  CHARSET_INFO	*collation_server;
  CHARSET_INFO	*collation_database;
411
  CHARSET_INFO  *collation_connection;
412

413 414
  Time_zone *time_zone;

415 416 417 418
  /* DATE, DATETIME and TIME formats */
  DATE_TIME_FORMAT *date_format;
  DATE_TIME_FORMAT *datetime_format;
  DATE_TIME_FORMAT *time_format;
419 420
};

421
void free_tmp_table(THD *thd, TABLE *entry);
422 423


424 425 426 427 428 429 430 431 432
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;
  MEM_ROOT mem_root;
433
  enum enum_state 
434 435 436 437 438
  {
    INITIALIZED= 0, PREPARED= 1, EXECUTED= 3, CONVENTIONAL_EXECUTION= 2, 
    ERROR= -1
  };
  
439
  enum_state state;
440 441 442 443 444 445 446

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

447 448 449 450 451 452 453 454 455
  /*
    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.
  */
456
  Item_arena(THD *thd);
457 458 459 460
  /*
    Create arena and optionally init memory root with minimal values.
    Particularly used if Item_arena is part of Statement.
  */
461 462
  Item_arena(bool init_mem_root);
  virtual Type type() const;
463
  virtual ~Item_arena() {};
464

465 466
  inline bool is_stmt_prepare() const { return (int)state < (int)PREPARED; }
  inline bool is_first_stmt_execute() const { return state == PREPARED; }
467 468
  inline bool is_conventional_execution() const
  { return state == CONVENTIONAL_EXECUTION; }
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 495 496
  inline gptr alloc(unsigned int size) { return alloc_root(&mem_root,size); }
  inline gptr calloc(unsigned int size)
  {
    gptr ptr;
    if ((ptr=alloc_root(&mem_root,size)))
      bzero((char*) ptr,size);
    return ptr;
  }
  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(Item_arena *set, Item_arena *backup);
  void restore_backup_item_arena(Item_arena *set, Item_arena *backup);
  void set_item_arena(Item_arena *set);
};


497 498 499 500 501 502 503 504 505 506 507 508 509 510
/*
  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.
*/

511
class Statement: public Item_arena
512 513 514 515 516 517
{
  Statement(const Statement &rhs);              /* not implemented: */
  Statement &operator=(const Statement &rhs);   /* non-copyable */
public:
  /* FIXME: must be private */
  LEX     main_lex;
518

519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543
  /*
    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;

544
  LEX_STRING name; /* name for named prepared statements */
545 546 547 548 549
  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.
550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566

    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.
567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583
  */
  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);
584 585
  void set_n_backup_statement(Statement *stmt, Statement *backup);
  void restore_backup_statement(Statement *stmt, Statement *backup);
586 587 588 589 590 591
  /* return class type */
  virtual Type type() const;
};


/*
592 593 594 595 596
  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
597

598 599
  Statements are auto-deleted when they are removed from the map and when the
  map is deleted.
600 601 602 603 604 605
*/

class Statement_map
{
public:
  Statement_map();
606

607 608 609
  int insert(Statement *statement);

  Statement *find_by_name(LEX_STRING *name)
610
  {
611 612 613 614
    Statement *stmt;
    stmt= (Statement*)hash_search(&names_hash, (byte*)name->str,
                                  name->length);
    return stmt;
615 616 617 618 619
  }

  Statement *find(ulong id)
  {
    if (last_found_statement == 0 || id != last_found_statement->id)
620 621 622
    {
      Statement *stmt;
      stmt= (Statement *) hash_search(&st_hash, (byte *) &id, sizeof(id));
623
      if (stmt && stmt->name.str)
624 625 626
        return NULL;
      last_found_statement= stmt;
    }
627 628 629 630 631 632
    return last_found_statement;
  }
  void erase(Statement *statement)
  {
    if (statement == last_found_statement)
      last_found_statement= 0;
633 634 635 636
    if (statement->name.str)
    {
      hash_delete(&names_hash, (byte *) statement);  
    }
637 638
    hash_delete(&st_hash, (byte *) statement);
  }
639 640 641 642 643 644 645
  /* Erase all statements (calls Statement destructor) */
  void reset()
  {
    hash_reset(&names_hash);
    hash_reset(&st_hash);
    last_found_statement= 0;
  }
646 647 648

  ~Statement_map()
  {
649
    hash_free(&names_hash);
650
    hash_free(&st_hash);
651 652 653
  }
private:
  HASH st_hash;
654
  HASH names_hash;
655 656 657 658
  Statement *last_found_statement;
};


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


670 671 672 673
/*
  For each client connection we create a separate thread with THD serving as
  a thread/connection descriptor
*/
674

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

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

735
  ulong client_capabilities;		/* What the client supports */
736
  ulong max_client_packet_length;
737 738
  ulong master_access;			/* Global privileges from mysql.user */
  ulong db_access;			/* Privileges for current db */
739 740 741 742 743 744

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

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

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

894
  bool       slave_thread, one_shot_set;
895
  bool	     locked, some_tables_deleted;
896
  bool       last_cuted_field;
897
  bool	     no_errors, password, is_fatal_error;
nick@mysql.com's avatar
nick@mysql.com committed
898
  bool	     query_start_used,last_insert_id_used,insert_id_used,rand_used;
899
  bool	     time_zone_used;
900
  bool	     in_lock_tables;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
901
  bool       query_error, bootstrap, cleanup_done;
902
  bool	     tmp_table_used;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
903
  bool	     charset_is_system_charset, charset_is_collation_connection;
904
  bool       slow_command;
905
  my_bool    volatile killed;
906

907 908 909 910 911
  /*
    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
  */
912
  LOG_INFO*  current_linfo;
913
  NET*       slave_net;			// network connection from slave -> m.
914 915 916 917 918 919 920
  /* 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
921 922
  THD();
  ~THD();
923

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

  bool convert_string(LEX_STRING *to, CHARSET_INFO *to_cs,
		      const char *from, uint from_length,
		      CHARSET_INFO *from_cs);
1025 1026 1027

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

1028
  void add_changed_table(TABLE *table);
1029 1030
  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
1031
  int send_explain_fields(select_result *result);
1032
#ifndef EMBEDDED_LIBRARY
1033 1034 1035 1036 1037 1038
  inline void clear_error()
  {
    net.last_error[0]= 0;
    net.last_errno= 0;
    net.report_error= 0;
  }
1039
  inline bool vio_ok() const { return net.vio != 0; }
1040 1041
#else
  void clear_error();
1042
  inline bool vio_ok() const { return true; }
1043
#endif
1044 1045 1046 1047
  inline void fatal_error()
  {
    is_fatal_error= 1;
    net.report_error= 1; 
1048
    DBUG_PRINT("error",("Fatal error set"));
1049
  }
1050
  inline CHARSET_INFO *charset() { return variables.character_set_client; }
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1051
  void update_charset();
1052

1053
  void change_item_tree(Item **place, Item *new_value)
1054
  {
1055
    /* TODO: check for OOM condition here */
1056
    if (!current_arena->is_conventional_execution())
1057 1058
      nocheck_register_item_tree_change(place, *place, &mem_root);
    *place= new_value;
1059 1060
  }
  void nocheck_register_item_tree_change(Item **place, Item *old_value,
1061
                                         MEM_ROOT *runtime_memroot);
1062
  void rollback_item_tree_changes();
1063 1064 1065 1066 1067 1068

  /*
    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
1069 1070
};

1071 1072 1073 1074 1075
/* 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
1076 1077 1078
/*
  Used to hold information about file and file structure in exchainge 
  via non-DB file (...INTO OUTFILE..., ...LOAD DATA...)
1079
  XXX: We never call destructor for objects of this class.
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1080
*/
1081

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1082 1083 1084 1085 1086 1087 1088
class sql_exchange :public Sql_alloc
{
public:
  char *file_name;
  String *field_term,*enclosed,*line_term,*line_start,*escaped;
  bool opt_enclosed;
  bool dumpfile;
1089
  ulong skip_lines;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1090 1091 1092 1093 1094 1095
  sql_exchange(char *name,bool dumpfile_flag);
};

#include "log_event.h"

/*
1096
  This is used to get result from a select
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1097 1098
*/

1099 1100
class JOIN;

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

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1103 1104 1105
class select_result :public Sql_alloc {
protected:
  THD *thd;
1106
  SELECT_LEX_UNIT *unit;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1107 1108 1109
public:
  select_result();
  virtual ~select_result() {};
1110 1111 1112 1113 1114
  virtual int prepare(List<Item> &list, SELECT_LEX_UNIT *u)
  {
    unit= u;
    return 0;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1115 1116
  virtual bool send_fields(List<Item> &list,uint flag)=0;
  virtual bool send_data(List<Item> &items)=0;
1117
  virtual bool initialize_tables (JOIN *join=0) { return 0; }
1118
  virtual void send_error(uint errcode,const char *err);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1119 1120
  virtual bool send_eof()=0;
  virtual void abort() {}
1121 1122 1123 1124 1125
  /*
    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
1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137
};


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


1138 1139
class select_to_file :public select_result {
protected:
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1140 1141 1142 1143
  sql_exchange *exchange;
  File file;
  IO_CACHE cache;
  ha_rows row_count;
1144 1145 1146 1147 1148 1149 1150 1151
  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);
1152 1153
  bool send_eof();
  void cleanup();
1154 1155 1156 1157
};


class select_export :public select_to_file {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1158 1159 1160 1161
  uint field_term_length;
  int field_sep_char,escape_char,line_sep_char;
  bool fixed_row_size;
public:
1162
  select_export(sql_exchange *ex) :select_to_file(ex) {}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1163
  ~select_export();
1164
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1165 1166 1167
  bool send_data(List<Item> &items);
};

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

1169
class select_dump :public select_to_file {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1170
public:
1171
  select_dump(sql_exchange *ex) :select_to_file(ex) {}
1172
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1173 1174
  bool send_data(List<Item> &items);
};
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
1175 1176


bk@work.mysql.com's avatar
bk@work.mysql.com committed
1177
class select_insert :public select_result {
1178
 public:
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1179 1180 1181 1182 1183
  TABLE *table;
  List<Item> *fields;
  ulonglong last_insert_id;
  COPY_INFO info;

1184 1185 1186
  select_insert(TABLE *table_par, List<Item> *fields_par,
		enum_duplicates duplic)
    :table(table_par), fields(fields_par), last_insert_id(0)
1187
  {
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
1188 1189 1190
    bzero((char*) &info,sizeof(info));
    info.handle_duplicates=duplic;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1191
  ~select_insert();
1192
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
1193 1194
  bool send_fields(List<Item> &list, uint flag)
  { return 0; }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1195 1196 1197
  bool send_data(List<Item> &items);
  void send_error(uint errcode,const char *err);
  bool send_eof();
1198 1199
  /* not implemented: select_insert is never re-used in prepared statements */
  void cleanup();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1200 1201
};

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

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1203 1204 1205 1206 1207 1208 1209 1210 1211 1212
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:
1213 1214 1215 1216 1217
  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
1218
    :select_insert (NULL, &select_fields, duplic), db(db_name),
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1219
    name(table_name), extra_fields(&fields_par),keys(&keys_par),
1220
    create_info(create_info_par), lock(0)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1221
    {}
1222
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1223 1224 1225 1226 1227
  bool send_data(List<Item> &values);
  bool send_eof();
  void abort();
};

1228 1229 1230 1231 1232 1233
#include <myisam.h>

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

class TMP_TABLE_PARAM :public Sql_alloc
{
1234 1235 1236 1237 1238 1239
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:
1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253
  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;
1254
  bool  using_indirect_summary_function;
1255 1256
  /* If >0 convert all blob fields to varchar(convert_blob_length) */
  uint  convert_blob_length; 
1257 1258 1259

  TMP_TABLE_PARAM()
    :copy_funcs_it(copy_funcs), copy_field(0), group_parts(0),
1260
    group_length(0), group_null_parts(0), convert_blob_length(0)
1261 1262 1263 1264 1265
  {}
  ~TMP_TABLE_PARAM()
  {
    cleanup();
  }
1266
  void init(void);
1267 1268 1269 1270 1271 1272 1273 1274 1275 1276
  inline void cleanup(void)
  {
    if (copy_field)				/* Fix for Intel compiler */
    {
      delete [] copy_field;
      copy_field=0;
    }
  }
};

monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
1277 1278 1279 1280
class select_union :public select_result {
 public:
  TABLE *table;
  COPY_INFO info;
1281
  TMP_TABLE_PARAM tmp_table_param;
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
1282 1283 1284

  select_union(TABLE *table_par);
  ~select_union();
1285
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
1286 1287 1288 1289 1290
  bool send_fields(List<Item> &list, uint flag)
  { return 0; }
  bool send_data(List<Item> &items);
  bool send_eof();
  bool flush();
1291
  void set_table(TABLE *tbl) { table= tbl; }
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
1292 1293
};

1294
/* Base subselect interface class */
1295 1296
class select_subselect :public select_result
{
1297
protected:
1298 1299 1300 1301
  Item_subselect *item;
public:
  select_subselect(Item_subselect *item);
  bool send_fields(List<Item> &list, uint flag) { return 0; };
1302
  bool send_data(List<Item> &items)=0;
1303 1304 1305
  bool send_eof() { return 0; };
};

1306
/* Single value subselect interface class */
1307
class select_singlerow_subselect :public select_subselect
1308 1309
{
public:
1310
  select_singlerow_subselect(Item_subselect *item):select_subselect(item){}
1311 1312 1313
  bool send_data(List<Item> &items);
};

1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329
/* 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();
};

1330 1331 1332 1333 1334 1335 1336 1337
/* 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
1338 1339 1340 1341 1342 1343 1344
/* 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 */
1345 1346
  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
1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359
} 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 */

1360 1361
class Table_ident :public Sql_alloc
{
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1362 1363 1364
 public:
  LEX_STRING db;
  LEX_STRING table;
1365
  SELECT_LEX_UNIT *sel;
1366 1367
  inline Table_ident(THD *thd, LEX_STRING db_arg, LEX_STRING table_arg,
		     bool force)
1368
    :table(table_arg), sel((SELECT_LEX_UNIT *)0)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1369
  {
1370
    if (!force && (thd->client_capabilities & CLIENT_NO_SCHEMA))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1371 1372 1373 1374
      db.str=0;
    else
      db= db_arg;
  }
1375 1376 1377 1378 1379 1380 1381
  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) 
  {
1382 1383
    /* 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;
1384
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1385
  inline void change_db(char *db_name)
1386 1387 1388
  {
    db.str= db_name; db.length= (uint) strlen(db_name);
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1389 1390 1391 1392 1393 1394 1395 1396
};

// this is needed for user_vars hash
class user_var_entry
{
 public:
  LEX_STRING name;
  char *value;
1397
  ulong length, update_query_id, used_query_id;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1398
  Item_result type;
1399 1400 1401 1402

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

1406

1407 1408 1409 1410 1411 1412 1413 1414
/* 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
1415
  byte *record_pointers;
1416
  bool flush();
1417
  uint size;
1418 1419 1420

public:
  ulong elements;
1421
  Unique(qsort_cmp2 comp_func, void * comp_func_fixed_arg,
1422
	 uint size_arg, ulong max_in_memory_size_arg);
1423
  ~Unique();
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1424
  inline bool unique_add(gptr ptr)
1425 1426 1427
  {
    if (tree.elements_in_tree > max_elements && flush())
      return 1;
1428
    return !tree_insert(&tree, ptr, 0, tree.custom_arg);
1429 1430 1431 1432
  }

  bool get(TABLE *table);

1433 1434
  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);
1435
};
1436

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1437 1438

class multi_delete :public select_result
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1439 1440
{
  TABLE_LIST *delete_tables, *table_being_deleted;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1441
  Unique **tempfiles;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1442
  THD *thd;
1443
  ha_rows deleted, found;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1444 1445 1446 1447 1448 1449 1450 1451
  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,
1452
 		   uint flag) { return 0; }
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1453 1454 1455 1456 1457 1458 1459
  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();
};

1460

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1461
class multi_update :public select_result
1462 1463 1464
{
  TABLE_LIST *all_tables, *update_tables, *table_being_updated;
  THD *thd;
1465
  TABLE **tmp_tables, *main_table, *table_to_update;
1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478
  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
1479
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
1480 1481 1482 1483 1484 1485 1486
  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();
};
1487 1488


Sinisa@sinisa.nasamreza.org's avatar
Sinisa@sinisa.nasamreza.org committed
1489 1490 1491
class select_dumpvar :public select_result {
  ha_rows row_count;
public:
1492 1493 1494
  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
1495
  ~select_dumpvar() {}
1496 1497
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
  bool send_fields(List<Item> &list, uint flag) {return 0;}
Sinisa@sinisa.nasamreza.org's avatar
Sinisa@sinisa.nasamreza.org committed
1498 1499
  bool send_data(List<Item> &items);
  bool send_eof();
1500
  void cleanup();
Sinisa@sinisa.nasamreza.org's avatar
Sinisa@sinisa.nasamreza.org committed
1501
};