sql_class.h 59.3 KB
Newer Older
unknown's avatar
unknown committed
1
/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
unknown's avatar
unknown committed
2

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

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

unknown's avatar
unknown committed
13 14 15 16 17 18 19
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */


/* Classes in mysql */

20
#ifdef USE_PRAGMA_INTERFACE
unknown's avatar
unknown committed
21 22 23
#pragma interface			/* gcc class implementation */
#endif

24 25 26
#include "log.h"
#include "rpl_rli.h"
#include "rpl_tblmap.h"
27

unknown's avatar
unknown committed
28 29
class Query_log_event;
class Load_log_event;
30
class Slave_log_event;
31
class sp_rcontext;
32
class sp_cache;
33
class Rows_log_event;
unknown's avatar
unknown committed
34

35
enum enum_enable_or_disable { LEAVE_AS_IS, ENABLE, DISABLE };
36
enum enum_ha_read_modes { RFIRST, RNEXT, RPREV, RLAST, RKEY, RNEXT_SAME };
37
enum enum_duplicates { DUP_ERROR, DUP_REPLACE, DUP_UPDATE };
38 39
enum enum_delay_key_write { DELAY_KEY_WRITE_NONE, DELAY_KEY_WRITE_ON,
			    DELAY_KEY_WRITE_ALL };
unknown's avatar
unknown committed
40

41 42 43
enum enum_check_fields { CHECK_FIELD_IGNORE, CHECK_FIELD_WARN,
			 CHECK_FIELD_ERROR_FOR_NULL };

unknown's avatar
unknown committed
44
extern char internal_table_name[2];
unknown's avatar
unknown committed
45
extern const char **errmesg;
unknown's avatar
unknown committed
46

47 48 49 50 51 52 53
#define TC_LOG_PAGE_SIZE   8192
#define TC_LOG_MIN_SIZE    (3*TC_LOG_PAGE_SIZE)

#define TC_HEURISTIC_RECOVER_COMMIT   1
#define TC_HEURISTIC_RECOVER_ROLLBACK 2
extern uint tc_heuristic_recover;

unknown's avatar
unknown committed
54 55 56 57 58 59 60 61 62
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;

63 64 65
#define RP_LOCK_LOG_IS_ALREADY_LOCKED 1
#define RP_FORCE_ROTATE               2

unknown's avatar
unknown committed
66 67 68
typedef struct st_copy_info {
  ha_rows records;
  ha_rows deleted;
unknown's avatar
unknown committed
69
  ha_rows updated;
unknown's avatar
unknown committed
70
  ha_rows copied;
71
  ha_rows error_count;
unknown's avatar
unknown committed
72
  enum enum_duplicates handle_duplicates;
73
  int escape_char, last_errno;
74 75
  bool ignore;
  /* for INSERT ... UPDATE */
76 77
  List<Item> *update_fields;
  List<Item> *update_values;
unknown's avatar
unknown committed
78
  /* for VIEW ... WITH CHECK OPTION */
unknown's avatar
unknown committed
79
  TABLE_LIST *view;
unknown's avatar
unknown committed
80 81 82 83 84 85 86 87
} 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) {}
88
  bool operator==(const key_part_spec& other) const;
unknown's avatar
unknown committed
89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112
};


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:
113
  enum Keytype { PRIMARY, UNIQUE, MULTIPLE, FULLTEXT, SPATIAL, FOREIGN_KEY};
unknown's avatar
unknown committed
114
  enum Keytype type;
unknown's avatar
unknown committed
115
  KEY_CREATE_INFO key_create_info;
unknown's avatar
unknown committed
116
  List<key_part_spec> columns;
117
  const char *name;
118
  bool generated;
unknown's avatar
unknown committed
119

120 121 122
  Key(enum Keytype type_par, const char *name_arg,
      KEY_CREATE_INFO *key_info_arg,
      bool generated_arg, List<key_part_spec> &cols)
unknown's avatar
unknown committed
123 124
    :type(type_par), key_create_info(*key_info_arg), columns(cols),
    name(name_arg), generated(generated_arg)
125
  {}
unknown's avatar
unknown committed
126
  ~Key() {}
127
  /* Equality comparison of keys (ignoring name) */
128
  friend bool foreign_key_prefix(Key *a, Key *b);
unknown's avatar
unknown committed
129 130
};

131 132 133 134 135 136 137 138 139 140 141 142 143 144 145
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)
146
    :Key(FOREIGN_KEY, name_arg, &default_key_create_info, 0, cols),
147 148 149 150 151
    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
152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171

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

class delayed_insert;
unknown's avatar
unknown committed
172
class select_result;
173
class Time_zone;
unknown's avatar
unknown committed
174

175 176 177 178 179
#define THD_SENTRY_MAGIC 0xfeedd1ff
#define THD_SENTRY_GONE  0xdeadbeef

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

180 181
struct system_variables
{
unknown's avatar
unknown committed
182 183
  ulonglong myisam_max_extra_sort_file_size;
  ulonglong myisam_max_sort_file_size;
184 185
  ha_rows select_limit;
  ha_rows max_join_size;
186
  ulong auto_increment_increment, auto_increment_offset;
unknown's avatar
unknown committed
187
  ulong bulk_insert_buff_size;
188 189
  ulong join_buff_size;
  ulong long_query_time;
unknown's avatar
unknown committed
190
  ulong max_allowed_packet;
191
  ulong max_error_count;
192
  ulong max_heap_table_size;
unknown's avatar
unknown committed
193
  ulong max_length_for_sort_data;
194
  ulong max_sort_length;
195
  ulong max_tmp_tables;
196
  ulong max_insert_delayed_threads;
unknown's avatar
unknown committed
197
  ulong multi_range_count;
198
  ulong myisam_repair_threads;
unknown's avatar
unknown committed
199
  ulong myisam_sort_buff_size;
200
  ulong myisam_stats_method;
unknown's avatar
unknown committed
201
  ulong net_buffer_length;
202
  ulong net_interactive_timeout;
unknown's avatar
unknown committed
203
  ulong net_read_timeout;
204
  ulong net_retry_count;
205
  ulong net_wait_timeout;
unknown's avatar
unknown committed
206
  ulong net_write_timeout;
207 208
  ulong optimizer_prune_level;
  ulong optimizer_search_depth;
unknown's avatar
unknown committed
209
  ulong preload_buff_size;
unknown's avatar
unknown committed
210 211 212
  ulong query_cache_type;
  ulong read_buff_size;
  ulong read_rnd_buff_size;
unknown's avatar
unknown committed
213
  ulong div_precincrement;
214
  ulong sortbuff_size;
unknown's avatar
unknown committed
215
  handlerton *table_type;
216
  ulong tmp_table_size;
unknown's avatar
unknown committed
217
  ulong tx_isolation;
unknown's avatar
Merge  
unknown committed
218
  ulong completion_type;
219
  /* Determines which non-standard SQL behaviour should be enabled */
220
  ulong sql_mode;
221
  ulong max_sp_recursion_depth;
unknown's avatar
VIEW  
unknown committed
222
  /* check of key presence in updatable view */
223
  ulong updatable_views_with_limit;
unknown's avatar
unknown committed
224
  ulong default_week_format;
225
  ulong max_seeks_for_key;
226 227 228 229 230
  ulong range_alloc_block_size;
  ulong query_alloc_block_size;
  ulong query_prealloc_size;
  ulong trans_alloc_block_size;
  ulong trans_prealloc_size;
231
  ulong log_warnings;
232
  ulong group_concat_max_len;
unknown's avatar
unknown committed
233 234 235 236 237 238
  /*
    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
239 240
  my_bool low_priority_updates;
  my_bool new_mode;
241
  my_bool query_cache_wlock_invalidate;
unknown's avatar
unknown committed
242
  my_bool engine_condition_pushdown;
243
  my_bool innodb_table_locks;
244
  my_bool innodb_support_xa;
245 246 247
  my_bool ndb_force_send;
  my_bool ndb_use_exact_count;
  my_bool ndb_use_transactions;
248
  my_bool ndb_index_stat_enable;
249
  ulong ndb_autoincrement_prefetch_sz;
250 251
  ulong ndb_index_stat_cache_entries;
  ulong ndb_index_stat_update_freq;
252 253
  ulong binlog_format; // binlog format for this thd (see enum_binlog_format)

unknown's avatar
unknown committed
254
  my_bool old_alter_table;
255
  my_bool old_passwords;
256

257
  /* Only charset part of these variables is sensible */
unknown's avatar
unknown committed
258
  CHARSET_INFO  *character_set_filesystem;
259
  CHARSET_INFO  *character_set_client;
260
  CHARSET_INFO  *character_set_results;
261

262 263 264
  /* Both charset and collation parts of these variables are important */
  CHARSET_INFO	*collation_server;
  CHARSET_INFO	*collation_database;
unknown's avatar
unknown committed
265
  CHARSET_INFO  *collation_connection;
266

267 268
  Time_zone *time_zone;

269 270 271 272
  /* DATE, DATETIME and TIME formats */
  DATE_TIME_FORMAT *date_format;
  DATE_TIME_FORMAT *datetime_format;
  DATE_TIME_FORMAT *time_format;
273
  my_bool sysdate_is_now;
unknown's avatar
unknown committed
274 275
};

276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298

/* per thread status variables */

typedef struct system_status_var
{
  ulong bytes_received;
  ulong bytes_sent;
  ulong com_other;
  ulong com_stat[(uint) SQLCOM_END];
  ulong created_tmp_disk_tables;
  ulong created_tmp_tables;
  ulong ha_commit_count;
  ulong ha_delete_count;
  ulong ha_read_first_count;
  ulong ha_read_last_count;
  ulong ha_read_key_count;
  ulong ha_read_next_count;
  ulong ha_read_prev_count;
  ulong ha_read_rnd_count;
  ulong ha_read_rnd_next_count;
  ulong ha_rollback_count;
  ulong ha_update_count;
  ulong ha_write_count;
299 300 301 302
  ulong ha_prepare_count;
  ulong ha_discover_count;
  ulong ha_savepoint_count;
  ulong ha_savepoint_rollback_count;
303 304 305 306 307 308 309 310 311 312 313 314

  /* KEY_CACHE parts. These are copies of the original */
  ulong key_blocks_changed;
  ulong key_blocks_used;
  ulong key_cache_r_requests;
  ulong key_cache_read;
  ulong key_cache_w_requests;
  ulong key_cache_write;
  /* END OF KEY_CACHE parts */

  ulong net_big_packet_count;
  ulong opened_tables;
unknown's avatar
unknown committed
315
  ulong opened_shares;
316 317 318 319 320 321 322 323 324 325
  ulong select_full_join_count;
  ulong select_full_range_join_count;
  ulong select_range_count;
  ulong select_range_check_count;
  ulong select_scan_count;
  ulong long_query_count;
  ulong filesort_merge_passes;
  ulong filesort_range_count;
  ulong filesort_rows;
  ulong filesort_scan_count;
326
  /* Prepared statements and binary protocol */
unknown's avatar
unknown committed
327 328 329 330 331 332
  ulong com_stmt_prepare;
  ulong com_stmt_execute;
  ulong com_stmt_send_long_data;
  ulong com_stmt_fetch;
  ulong com_stmt_reset;
  ulong com_stmt_close;
333 334

  double last_query_cost;
335 336 337 338 339 340 341
} STATUS_VAR;

/*
  This is used for 'show status'. It must be updated to the last ulong
  variable in system_status_var
*/

unknown's avatar
unknown committed
342
#define last_system_status_var com_stmt_close
343 344


345 346
#ifdef MYSQL_SERVER

347
void free_tmp_table(THD *thd, TABLE *entry);
348 349


unknown's avatar
unknown committed
350 351 352
/* The following macro is to make init of Query_arena simpler */
#ifndef DBUG_OFF
#define INIT_ARENA_DBUG_INFO is_backup_arena= 0
353 354
#else
#define INIT_ARENA_DBUG_INFO
unknown's avatar
unknown committed
355 356
#endif

unknown's avatar
unknown committed
357
class Query_arena
358 359 360 361 362 363 364
{
public:
  /*
    List of items created in the parser for this query. Every item puts
    itself to the list on creation (see Item::Item() for details))
  */
  Item *free_list;
unknown's avatar
unknown committed
365
  MEM_ROOT *mem_root;                   // Pointer to current memroot
unknown's avatar
unknown committed
366
#ifndef DBUG_OFF
367
  bool is_backup_arena; /* True if this arena is used for backup. */
unknown's avatar
unknown committed
368
#endif
unknown's avatar
unknown committed
369
  enum enum_state
370
  {
371 372
    INITIALIZED= 0, INITIALIZED_FOR_SP= 1, PREPARED= 2,
    CONVENTIONAL_EXECUTION= 3, EXECUTED= 4, ERROR= -1
373
  };
unknown's avatar
unknown committed
374

unknown's avatar
unknown committed
375
  enum_state state;
376 377 378 379 380 381 382

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

383 384
  Query_arena(MEM_ROOT *mem_root_arg, enum enum_state state_arg) :
    free_list(0), mem_root(mem_root_arg), state(state_arg)
385
  { INIT_ARENA_DBUG_INFO; }
386
  /*
unknown's avatar
unknown committed
387 388
    This constructor is used only when Query_arena is created as
    backup storage for another instance of Query_arena.
389
  */
390 391
  Query_arena() { INIT_ARENA_DBUG_INFO; }

392
  virtual Type type() const;
unknown's avatar
unknown committed
393
  virtual ~Query_arena() {};
394

395
  inline bool is_stmt_prepare() const { return state == INITIALIZED; }
396 397
  inline bool is_first_sp_execute() const
  { return state == INITIALIZED_FOR_SP; }
398 399
  inline bool is_stmt_prepare_or_first_sp_execute() const
  { return (int)state < (int)PREPARED; }
unknown's avatar
unknown committed
400
  inline bool is_first_stmt_execute() const { return state == PREPARED; }
401 402
  inline bool is_stmt_execute() const
  { return state == PREPARED || state == EXECUTED; }
unknown's avatar
unknown committed
403
  inline bool is_conventional() const
unknown's avatar
unknown committed
404
  { return state == CONVENTIONAL_EXECUTION; }
405

unknown's avatar
unknown committed
406
  inline gptr alloc(unsigned int size) { return alloc_root(mem_root,size); }
407 408 409
  inline gptr calloc(unsigned int size)
  {
    gptr ptr;
unknown's avatar
unknown committed
410
    if ((ptr=alloc_root(mem_root,size)))
411 412 413 414
      bzero((char*) ptr,size);
    return ptr;
  }
  inline char *strdup(const char *str)
unknown's avatar
unknown committed
415
  { return strdup_root(mem_root,str); }
416
  inline char *strmake(const char *str, uint size)
unknown's avatar
unknown committed
417
  { return strmake_root(mem_root,str,size); }
418
  inline char *memdup(const char *str, uint size)
unknown's avatar
unknown committed
419
  { return memdup_root(mem_root,str,size); }
420 421 422
  inline char *memdup_w_gap(const char *str, uint size, uint gap)
  {
    gptr ptr;
unknown's avatar
unknown committed
423
    if ((ptr=alloc_root(mem_root,size+gap)))
424 425 426 427
      memcpy(ptr,str,size);
    return ptr;
  }

unknown's avatar
unknown committed
428
  void set_query_arena(Query_arena *set);
429 430

  void free_items();
431 432
  /* Close the active state associated with execution of this statement */
  virtual void cleanup_stmt();
433 434
};

435

436
class Server_side_cursor;
437

438 439 440 441 442 443 444 445 446 447 448 449 450 451
/*
  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.
*/

452
class Statement: public ilink, public Query_arena
453
{
454 455
  Statement(const Statement &rhs);              /* not implemented: */
  Statement &operator=(const Statement &rhs);   /* non-copyable */
456
public:
457 458
  /* FIXME: these must be protected */
  MEM_ROOT main_mem_root;
459
  LEX     main_lex;
unknown's avatar
unknown committed
460

461
  /*
unknown's avatar
unknown committed
462
    Uniquely identifies each statement object in thread scope; change during
463
    statement lifetime. FIXME: must be const
464
  */
unknown's avatar
unknown committed
465
   ulong id;
466 467

  /*
468
    - if set_query_id=1, we set field->query_id for all fields. In that case 
469
    field list can not contain duplicates.
470 471 472 473 474 475 476
    0: Means query_id is not set and no indicator to handler of fields used
       is set
    1: Means query_id is set for fields in list and bit in read set is set
       to inform handler of that field is to be read
    2: Means query is set for fields in list and bit is set in update set
       to inform handler that it needs to update this field in write_row
       and update_row
477
  */
478
  ulong set_query_id;
479

480
  LEX_STRING name; /* name for named prepared statements */
481 482 483 484 485
  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.
486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502

    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.
503 504 505
  */
  char *query;
  uint32 query_length;                          // current query length
506
  Server_side_cursor *cursor;
507

508 509
public:

unknown's avatar
unknown committed
510 511
  /* This constructor is called for backup statements */
  Statement() { clear_alloc_root(&main_mem_root); }
512

unknown's avatar
unknown committed
513 514
  Statement(enum enum_state state_arg, ulong id_arg,
            ulong alloc_block_size, ulong prealloc_size);
515
  virtual ~Statement();
516 517 518

  /* Assign execution context (note: not all members) of given stmt to self */
  void set_statement(Statement *stmt);
519 520
  void set_n_backup_statement(Statement *stmt, Statement *backup);
  void restore_backup_statement(Statement *stmt, Statement *backup);
521 522
  /* return class type */
  virtual Type type() const;
523 524 525 526
};


/*
527 528 529 530 531
  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
532

533 534
  Statements are auto-deleted when they are removed from the map and when the
  map is deleted.
535 536 537 538 539 540
*/

class Statement_map
{
public:
  Statement_map();
541

542
  int insert(THD *thd, Statement *statement);
543 544

  Statement *find_by_name(LEX_STRING *name)
545
  {
546 547 548 549
    Statement *stmt;
    stmt= (Statement*)hash_search(&names_hash, (byte*)name->str,
                                  name->length);
    return stmt;
550
  }
551 552

  Statement *find(ulong id)
553
  {
554
    if (last_found_statement == 0 || id != last_found_statement->id)
555 556 557
    {
      Statement *stmt;
      stmt= (Statement *) hash_search(&st_hash, (byte *) &id, sizeof(id));
558
      if (stmt && stmt->name.str)
559 560 561
        return NULL;
      last_found_statement= stmt;
    }
562
    return last_found_statement;
563
  }
564 565 566 567 568 569
  /*
    Close all cursors of this connection that use tables of a storage
    engine that has transaction-specific state and therefore can not
    survive COMMIT or ROLLBACK. Currently all but MyISAM cursors are closed.
  */
  void close_transient_cursors();
570
  void erase(Statement *statement);
571
  /* Erase all statements (calls Statement destructor) */
572 573
  void reset();
  ~Statement_map();
574 575
private:
  HASH st_hash;
576
  HASH names_hash;
577
  I_List<Statement> transient_cursor_list;
578
  Statement *last_found_statement;
579 580
};

581 582 583 584 585 586 587
struct st_savepoint {
  struct st_savepoint *prev;
  char                *name;
  uint                 length, nht;
};

enum xa_states {XA_NOTR=0, XA_ACTIVE, XA_IDLE, XA_PREPARED};
unknown's avatar
unknown committed
588
extern const char *xa_state_names[];
589

590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605
typedef struct st_xid_state {
  /* For now, this is only used to catch duplicated external xids */
  XID  xid;                           // transaction identifier
  enum xa_states xa_state;            // used by external XA only
  bool in_thd;
} XID_STATE;

extern pthread_mutex_t LOCK_xid_cache;
extern HASH xid_cache;
bool xid_cache_init(void);
void xid_cache_free(void);
XID_STATE *xid_cache_search(XID *xid);
bool xid_cache_insert(XID *xid, enum xa_states xa_state);
bool xid_cache_insert(XID_STATE *xid_state);
void xid_cache_delete(XID_STATE *xid_state);

606

607 608
class Security_context {
public:
609
  Security_context() {}                       /* Remove gcc warning */
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
    ip - client IP
  */
  char   *host, *user, *priv_user, *ip;
618
  /* The host privilege we are using */
619 620 621 622 623 624 625 626 627
  char   priv_host[MAX_HOSTNAME];
  /* points to host if host is available, otherwise points to ip */
  const char *host_or_ip;
  ulong master_access;                 /* Global privileges from mysql.user */
  ulong db_access;                     /* Privileges for current db */

  void init();
  void destroy();
  void skip_grants();
628
  inline char *priv_host_name()
629 630 631 632 633 634
  {
    return (*priv_host ? priv_host : (char *)"%");
  }
};


635 636 637 638 639 640 641 642 643 644 645
/*
  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;


646 647 648 649 650 651 652 653 654
/*
  Type of prelocked mode.
  See comment for THD::prelocked_mode for complete description.
*/

enum prelocked_mode_type {NON_PRELOCKED= 0, PRELOCKED= 1,
                          PRELOCKED_UNDER_LOCK_TABLES= 2};


655
/*
656
  Class that holds information about tables which were opened and locked
657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718
  by the thread. It is also used to save/restore this information in
  push_open_tables_state()/pop_open_tables_state().
*/

class Open_tables_state
{
public:
  /*
    open_tables - list of regular tables in use by this thread
    temporary_tables - list of temp tables in use by this thread
    handler_tables - list of tables that were opened with HANDLER OPEN
     and are still in use by this thread
  */
  TABLE *open_tables, *temporary_tables, *handler_tables, *derived_tables;
  /*
    During a MySQL session, one can lock tables in two modes: automatic
    or manual. In automatic mode all necessary tables are locked just before
    statement execution, and all acquired locks are stored in 'lock'
    member. Unlocking takes place automatically as well, when the
    statement ends.
    Manual mode comes into play when a user issues a 'LOCK TABLES'
    statement. In this mode the user can only use the locked tables.
    Trying to use any other tables will give an error. The locked tables are
    stored in 'locked_tables' member.  Manual locking is described in
    the 'LOCK_TABLES' chapter of the MySQL manual.
    See also lock_tables() for details.
  */
  MYSQL_LOCK *lock;
  /*
    Tables that were locked with explicit or implicit LOCK TABLES.
    (Implicit LOCK TABLES happens when we are prelocking tables for
     execution of statement which uses stored routines. See description
     THD::prelocked_mode for more info.)
  */
  MYSQL_LOCK *locked_tables;
  /*
    prelocked_mode_type enum and prelocked_mode member are used for
    indicating whenever "prelocked mode" is on, and what type of
    "prelocked mode" is it.

    Prelocked mode is used for execution of queries which explicitly
    or implicitly (via views or triggers) use functions, thus may need
    some additional tables (mentioned in query table list) for their
    execution.

    First open_tables() call for such query will analyse all functions
    used by it and add all additional tables to table its list. It will
    also mark this query as requiring prelocking. After that lock_tables()
    will issue implicit LOCK TABLES for the whole table list and change
    thd::prelocked_mode to non-0. All queries called in functions invoked
    by the main query will use prelocked tables. Non-0 prelocked_mode
    will also surpress mentioned analysys in those queries thus saving
    cycles. Prelocked mode will be turned off once close_thread_tables()
    for the main query will be called.

    Note: Since not all "tables" present in table list are really locked
    thd::prelocked_mode does not imply thd::locked_tables.
  */
  prelocked_mode_type prelocked_mode;
  ulong	version;
  uint current_tablenr;

719 720 721 722 723 724 725 726 727
  enum enum_flags {
    BACKUPS_AVAIL = (1U << 0)     /* There are backups available */
  };

  /*
    Flags with information about the open tables state.
  */
  uint state_flags;

728 729 730 731
  /*
    This constructor serves for creation of Open_tables_state instances
    which are used as backup storage.
  */
732
  Open_tables_state() : state_flags(0U) { }
733 734

  Open_tables_state(ulong version_arg);
735 736 737 738 739 740 741 742 743 744 745

  void set_open_tables_state(Open_tables_state *state)
  {
    *this= *state;
  }

  void reset_open_tables_state()
  {
    open_tables= temporary_tables= handler_tables= derived_tables= 0;
    lock= locked_tables= 0;
    prelocked_mode= NON_PRELOCKED;
746
    state_flags= 0U;
747 748 749 750
  }
};


751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766
/* class to save context when executing a function or trigger */

/* Defines used for Sub_statement_state::in_sub_stmt */

#define SUB_STMT_TRIGGER 1
#define SUB_STMT_FUNCTION 2

class Sub_statement_state
{
public:
  ulonglong options;
  ulonglong last_insert_id, next_insert_id;
  ulonglong limit_found_rows;
  ha_rows    cuted_fields, sent_row_count, examined_row_count;
  ulong client_capabilities;
  uint in_sub_stmt;
767
  bool enable_slow_log, insert_id_used, clear_next_insert_id;
768
  my_bool no_send_ok;
769
  SAVEPOINT *savepoints;
770 771 772
};


unknown's avatar
unknown committed
773 774 775 776
/*
  For each client connection we create a separate thread with THD serving as
  a thread/connection descriptor
*/
777

778
class THD :public Statement,
779
           public Open_tables_state
unknown's avatar
unknown committed
780
{
unknown's avatar
unknown committed
781
public:
782 783 784
  /* Used to execute base64 coded binlog events in MySQL server */
  RELAY_LOG_INFO* rli_fake;

785 786 787 788 789 790 791 792
  /*
    Constant for THD::where initialization in the beginning of every query.

    It's needed because we do not save/restore THD::where normally during
    primary (non subselect) query execution.
  */
  static const char * const DEFAULT_WHERE;

793 794
#ifdef EMBEDDED_LIBRARY
  struct st_mysql  *mysql;
unknown's avatar
SCRUM  
unknown committed
795 796
  unsigned long	 client_stmt_id;
  unsigned long  client_param_count;
unknown's avatar
unknown committed
797
  struct st_mysql_bind *client_params;
unknown's avatar
unknown committed
798 799
  char *extra_data;
  ulong extra_length;
800 801 802 803 804
  struct st_mysql_data *cur_data;
  struct st_mysql_data *first_data;
  struct st_mysql_data **data_tail;
  void clear_data_list();
  struct st_mysql_data *alloc_new_dataset();
805
#endif
unknown's avatar
unknown committed
806
  NET	  net;				// client connection descriptor
807
  MEM_ROOT warn_root;			// For warnings and errors
808 809 810
  Protocol *protocol;			// Current protocol
  Protocol_simple protocol_simple;	// Normal protocol
  Protocol_prep protocol_prep;		// Binary protocol
unknown's avatar
unknown committed
811 812
  HASH    user_vars;			// hash for user variables
  String  packet;			// dynamic buffer for network I/O
813
  String  convert_buffer;               // buffer for charset conversions
unknown's avatar
unknown committed
814 815 816
  struct  sockaddr_in remote;		// client socket address
  struct  rand_struct rand;		// used for authentication
  struct  system_variables variables;	// Changeable local variables
817
  struct  system_status_var status_var; // Per thread statistic vars
818 819 820 821
  THR_LOCK_INFO lock_info;              // Locking info of this thread
  THR_LOCK_OWNER main_lock_id;          // To use for conventional queries
  THR_LOCK_OWNER *lock_id;              // If not main_lock_id, points to
                                        // the lock_id of a cursor.
822
  pthread_mutex_t LOCK_delete;		// Locked before thd is deleted
823
  /* all prepared statements and cursors of this connection */
824
  Statement_map stmt_map;
unknown's avatar
unknown committed
825 826 827 828 829 830
  /*
    A pointer to the stack frame of handle_one_connection(),
    which is called first in the thread for handling a client
  */
  char	  *thread_stack;

831 832
  /*
    db - currently selected database
833
    catalog - currently selected catalog
834 835 836 837 838
    WARNING: some members of THD (currently 'db', 'catalog' and 'query')  are
    set and alloced by the slave SQL thread (for the THD of that thread); that
    thread is (and must remain, for now) the only responsible for freeing these
    3 members. If you add members here, and you add code to set them in
    replication, don't forget to free_them_and_set_them_to_0 in replication
839 840
    properly. For details see the 'err:' label of the handle_slave_sql()
    in sql/slave.cc.
841
   */
842
  char   *db, *catalog;
843 844
  Security_context main_security_ctx;
  Security_context *security_ctx;
845

unknown's avatar
unknown committed
846 847
  /* remote (peer) port */
  uint16 peer_port;
848 849 850 851 852
  /*
    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
853
  const char *proc_info;
854

855
  ulong client_capabilities;		/* What the client supports */
856
  ulong max_client_packet_length;
857

unknown's avatar
unknown committed
858
  HASH		handler_tables_hash;
unknown's avatar
unknown committed
859 860 861 862 863
  /*
    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. 
  */
864
  User_level_lock *ull;
865 866
#ifndef DBUG_OFF
  uint dbug_sentry; // watch out for memory corruption
867
#endif
unknown's avatar
unknown committed
868
  struct st_my_thread_var *mysys_var;
869
  /*
870
    Type of current query: COM_STMT_PREPARE, COM_QUERY, etc. Set from
871 872 873
    first byte of the packet in do_command()
  */
  enum enum_server_command command;
unknown's avatar
unknown committed
874
  uint32     server_id;
unknown's avatar
unknown committed
875
  uint32     file_id;			// for LOAD DATA INFILE
876 877 878 879 880
  /*
    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
881
  const char *where;
unknown's avatar
unknown committed
882 883
  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
884 885
  thr_lock_type update_lock_default;
  delayed_insert *di;
886

887 888
  /* <> 0 if we are inside of trigger or stored function. */
  uint in_sub_stmt;
889

890 891
  /* container for handler's private per-connection data */
  void *ha_data[MAX_HA];
892 893 894 895 896

#ifdef HAVE_ROW_BASED_REPLICATION
#ifndef MYSQL_CLIENT

  /*
897
    Public interface to write RBR events to the binlog
898
  */
899
  int binlog_write_table_map(TABLE *table, bool is_transactional);
900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919
  int binlog_write_row(TABLE* table, bool is_transactional,
                       MY_BITMAP const* cols, my_size_t colcnt,
                       const byte *buf);
  int binlog_delete_row(TABLE* table, bool is_transactional,
                        MY_BITMAP const* cols, my_size_t colcnt,
                        const byte *buf);
  int binlog_update_row(TABLE* table, bool is_transactional,
                        MY_BITMAP const* cols, my_size_t colcnt,
                        const byte *old_data, const byte *new_data);

  void set_server_id(uint32 sid) { server_id = sid; }

  /*
    Member functions to handle pending event for row-level logging.
  */
  template <class RowsEventT> Rows_log_event*
    binlog_prepare_pending_rows_event(TABLE* table, uint32 serv_id,
                                      MY_BITMAP const* cols,
                                      my_size_t colcnt,
                                      my_size_t needed,
unknown's avatar
unknown committed
920 921
                                      bool is_transactional,
				      RowsEventT* hint);
922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942
  Rows_log_event* binlog_get_pending_rows_event() const;
  void            binlog_set_pending_rows_event(Rows_log_event* ev);
  int             binlog_setup_trx_data();
  
  my_size_t max_row_length_blob(TABLE* table, const byte *data) const;
  my_size_t max_row_length(TABLE* table, const byte *data) const
  {
    TABLE_SHARE *table_s= table->s;
    my_size_t length= table_s->reclength + 2 * table_s->fields;
    if (table_s->blob_fields == 0)
      return length;

    return (length+max_row_length_blob(table,data));
  }

  my_size_t pack_row(TABLE* table, MY_BITMAP const* cols, byte *row_data,
                     const byte *data) const;

  int binlog_flush_pending_rows_event(bool stmt_end);
  void binlog_delete_pending_rows_event();

943 944 945 946 947
private:
  uint binlog_table_maps; // Number of table maps currently in the binlog

public:

948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976
#endif
#endif /* HAVE_ROW_BASED_REPLICATION */
#ifndef MYSQL_CLIENT
  enum enum_binlog_query_type {
      /*
        The query can be logged row-based or statement-based
      */
      ROW_QUERY_TYPE,

      /*
        The query has to be logged statement-based
      */
      STMT_QUERY_TYPE,

      /*
        The query represents a change to a table in the "mysql"
        database and is currently mapped to ROW_QUERY_TYPE.
      */
      MYSQL_QUERY_TYPE,
      QUERY_TYPE_COUNT
  };

  int binlog_query(enum_binlog_query_type qtype,
                   char const *query, ulong query_len,
                   bool is_trans, bool suppress_use);
#endif

public:

unknown's avatar
unknown committed
977
  struct st_transactions {
978
    SAVEPOINT *savepoints;
unknown's avatar
unknown committed
979 980
    THD_TRANS all;			// Trans since BEGIN WORK
    THD_TRANS stmt;			// Trans for current statement
981
    bool on;                            // see ha_enable_transaction()
982 983
    XID  xid;                           // transaction identifier
    enum xa_states xa_state;            // used by external XA only
984
    XID_STATE xid_state;
985 986 987 988
#ifdef HAVE_ROW_BASED_REPLICATION
    Rows_log_event *m_pending_rows_event;
#endif

989
    /*
990
       Tables changed in transaction (that must be invalidated in query cache).
991
       List contain only transactional tables, that not invalidated in query
992 993 994 995 996 997
       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()
    {
998 999
      changed_tables= 0;
      savepoints= 0;
1000
#ifdef USING_TRANSACTIONS
1001
      free_root(&mem_root,MYF(MY_KEEP_PREALLOC));
1002
#endif
1003
    }
1004 1005
    st_transactions()
    {
1006
#ifdef USING_TRANSACTIONS
1007
      bzero((char*)this, sizeof(*this));
1008
      xid_state.xid.null();
1009
      init_sql_alloc(&mem_root, ALLOC_ROOT_MIN_BLOCK_SIZE, 0);
1010 1011
#else
      xid_state.xa_state= XA_NOTR;
1012
#endif
1013
    }
unknown's avatar
unknown committed
1014 1015 1016 1017 1018
  } transaction;
  Field      *dupp_field;
#ifndef __WIN__
  sigset_t signals,block_signals;
#endif
1019 1020
#ifdef SIGNAL_WITH_VIO_CLOSE
  Vio* active_vio;
1021
#endif
1022 1023 1024 1025
  /*
    This is to track items changed during execution of a prepared
    statement/stored procedure. It's created by
    register_item_tree_change() in memory root of THD, and freed in
unknown's avatar
unknown committed
1026 1027
    rollback_item_tree_changes(). For conventional execution it's always
    empty.
1028 1029 1030
  */
  Item_change_list change_list;

unknown's avatar
unknown committed
1031
  /*
unknown's avatar
unknown committed
1032 1033
    A permanent memory area of the statement. For conventional
    execution, the parsed tree and execution runtime reside in the same
unknown's avatar
unknown committed
1034
    memory root. In this case stmt_arena points to THD. In case of
unknown's avatar
unknown committed
1035
    a prepared statement or a stored procedure statement, thd->mem_root
unknown's avatar
unknown committed
1036
    conventionally points to runtime memory, and thd->stmt_arena
unknown's avatar
unknown committed
1037 1038 1039
    points to the memory of the PS/SP, where the parsed tree of the
    statement resides. Whenever you need to perform a permanent
    transformation of a parsed tree, you should allocate new memory in
unknown's avatar
unknown committed
1040 1041
    stmt_arena, to allow correct re-execution of PS/SP.
    Note: in the parser, stmt_arena == thd, even for PS/SP.
unknown's avatar
unknown committed
1042
  */
unknown's avatar
unknown committed
1043
  Query_arena *stmt_arena;
1044 1045 1046 1047 1048
  /*
    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;
1049 1050
  /* Remember last next_insert_id to reset it if something went wrong */
  ulonglong  prev_insert_id;
1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062
  /*
    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;
1063 1064
  ulonglong  options;           /* Bitmap of states */
  longlong   row_count_func;	/* For the ROW_COUNT() function */
unknown's avatar
unknown committed
1065
  ha_rows    cuted_fields,
unknown's avatar
unknown committed
1066
             sent_row_count, examined_row_count;
unknown's avatar
unknown committed
1067 1068 1069 1070 1071 1072
  /*
    The set of those tables whose fields are referenced in all subqueries
    of the query.
    TODO: possibly this it is incorrect to have used tables in THD because
    with more than one subquery, it is not clear what does the field mean.
  */
unknown's avatar
unknown committed
1073
  table_map  used_tables;
1074
  USER_CONN *user_connect;
1075
  CHARSET_INFO *db_charset;
unknown's avatar
unknown committed
1076 1077 1078
  /*
    FIXME: this, and some other variables like 'count_cuted_fields'
    maybe should be statement/cursor local, that is, moved to Statement
1079 1080
    class. With current implementation warnings produced in each prepared
    statement/cursor settle here.
unknown's avatar
unknown committed
1081
  */
1082
  List	     <MYSQL_ERROR> warn_list;
1083
  uint	     warn_count[(uint) MYSQL_ERROR::WARN_LEVEL_END];
unknown's avatar
unknown committed
1084
  uint	     total_warn_count;
1085 1086 1087 1088 1089 1090 1091 1092
  /*
    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).
  */
1093
  query_id_t query_id, warn_id;
1094
  ulong      thread_id, col_access;
1095

1096 1097 1098
#ifdef ERROR_INJECT_SUPPORT
  ulong      error_inject_value;
#endif
1099 1100
  /* Statement id is thread-wide. This counter is used to generate ids */
  ulong      statement_id_counter;
1101
  ulong	     rand_saved_seed1, rand_saved_seed2;
1102
  ulong      row_count;  // Row counter, mainly for errors and warnings
unknown's avatar
unknown committed
1103
  long	     dbug_thread_id;
unknown's avatar
unknown committed
1104
  pthread_t  real_id;
1105
  uint	     tmp_table, global_read_lock;
1106
  uint	     server_status,open_options,system_thread;
unknown's avatar
unknown committed
1107
  uint32     db_length;
unknown's avatar
unknown committed
1108
  uint       select_number;             //number of select (used for EXPLAIN)
unknown's avatar
unknown committed
1109 1110
  /* variables.transaction_isolation is reset to this after each commit */
  enum_tx_isolation session_tx_isolation;
1111
  enum_check_fields count_cuted_fields;
1112 1113 1114

  DYNAMIC_ARRAY user_var_events;        /* For user variables replication */
  MEM_ROOT      *user_var_events_alloc; /* Allocate above array elements here */
1115

unknown's avatar
unknown committed
1116
  enum killed_state { NOT_KILLED=0, KILL_BAD_DATA=1, KILL_CONNECTION=ER_SERVER_SHUTDOWN, KILL_QUERY=ER_QUERY_INTERRUPTED };
1117 1118
  killed_state volatile killed;

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

1122
  bool       slave_thread, one_shot_set;
1123 1124
  /* tells if current statement should binlog row-based(1) or stmt-based(0) */
  bool       current_stmt_binlog_row_based;
1125
  bool	     locked, some_tables_deleted;
1126
  bool       last_cuted_field;
1127
  bool	     no_errors, password, is_fatal_error;
1128 1129
  bool	     query_start_used, rand_used, time_zone_used;
  bool	     last_insert_id_used,insert_id_used, clear_next_insert_id;
1130
  bool	     in_lock_tables;
unknown's avatar
unknown committed
1131
  bool       query_error, bootstrap, cleanup_done;
unknown's avatar
unknown committed
1132
  bool	     tmp_table_used;
unknown's avatar
unknown committed
1133
  bool	     charset_is_system_charset, charset_is_collation_connection;
unknown's avatar
unknown committed
1134
  bool       charset_is_character_set_filesystem;
1135
  bool       enable_slow_log;   /* enable slow log for current statement */
unknown's avatar
unknown committed
1136
  bool	     no_trans_update, abort_on_warning;
unknown's avatar
Merge  
unknown committed
1137
  bool 	     got_warning;       /* Set on call to push_warning() */
1138
  bool	     no_warnings_for_error; /* no warnings on call to my_error() */
1139 1140
  /* set during loop of derived table processing */
  bool       derived_tables_processing;
1141 1142
  my_bool    tablespace_op;	/* This is TRUE in DISCARD/IMPORT TABLESPACE */

1143
  sp_rcontext *spcont;		// SP runtime context
1144 1145
  sp_cache   *sp_proc_cache;
  sp_cache   *sp_func_cache;
unknown's avatar
unknown committed
1146

unknown's avatar
unknown committed
1147 1148 1149 1150 1151
  /*
    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
1152
  LOG_INFO*  current_linfo;
unknown's avatar
unknown committed
1153
  NET*       slave_net;			// network connection from slave -> m.
unknown's avatar
unknown committed
1154 1155 1156 1157 1158
  /* Used by the sys_var class to store temporary values */
  union
  {
    my_bool my_bool_value;
    long    long_value;
1159
    ulong   ulong_value;
unknown's avatar
unknown committed
1160
  } sys_var_tmp;
1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179
  
  struct {
    /* 
      If true, mysql_bin_log::write(Log_event) call will not write events to 
      binlog, and maintain 2 below variables instead (use
      mysql_bin_log.start_union_events to turn this on)
    */
    bool do_union;
    /*
      If TRUE, at least one mysql_bin_log::write(Log_event) call has been
      made after last mysql_bin_log.start_union_events() call.
    */
    bool unioned_events;
    /*
      If TRUE, at least one mysql_bin_log::write(Log_event e), where 
      e.cache_stmt == TRUE call has been made after last 
      mysql_bin_log.start_union_events() call.
    */
    bool unioned_events_trans;
1180 1181 1182 1183 1184 1185
    
    /* 
      'queries' (actually SP statements) that run under inside this binlog
      union have thd->query_id >= first_query_id.
    */
    query_id_t first_query_id;
1186
  } binlog_evt_union;
unknown's avatar
unknown committed
1187
#ifdef WITH_PARTITION_STORAGE_ENGINE
unknown's avatar
unknown committed
1188
  partition_info *work_part_info;
unknown's avatar
unknown committed
1189
#endif
1190
  
unknown's avatar
unknown committed
1191 1192
  THD();
  ~THD();
1193

unknown's avatar
unknown committed
1194
  void init(void);
1195 1196 1197 1198 1199 1200 1201 1202 1203 1204
  /*
    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
1205
  void change_user(void);
unknown's avatar
unknown committed
1206
  void cleanup(void);
1207
  void cleanup_after_query();
unknown's avatar
unknown committed
1208
  bool store_globals();
1209 1210
#ifdef SIGNAL_WITH_VIO_CLOSE
  inline void set_active_vio(Vio* vio)
1211
  {
1212
    pthread_mutex_lock(&LOCK_delete);
1213
    active_vio = vio;
1214
    pthread_mutex_unlock(&LOCK_delete);
1215
  }
1216
  inline void clear_active_vio()
1217
  {
1218
    pthread_mutex_lock(&LOCK_delete);
1219
    active_vio = 0;
1220
    pthread_mutex_unlock(&LOCK_delete);
1221
  }
unknown's avatar
unknown committed
1222
  void close_active_vio();
1223
#endif
unknown's avatar
SCRUM  
unknown committed
1224
  void awake(THD::killed_state state_to_set);
1225 1226
  /*
    For enter_cond() / exit_cond() to work the mutex must be got before
1227 1228
    enter_cond(); this mutex is then released by exit_cond().
    Usage must be: lock mutex; enter_cond(); your code; exit_cond().
1229
  */
unknown's avatar
unknown committed
1230 1231 1232 1233
  inline const char* enter_cond(pthread_cond_t *cond, pthread_mutex_t* mutex,
			  const char* msg)
  {
    const char* old_msg = proc_info;
1234
    safe_mutex_assert_owner(mutex);
unknown's avatar
unknown committed
1235 1236 1237 1238 1239 1240 1241
    mysys_var->current_mutex = mutex;
    mysys_var->current_cond = cond;
    proc_info = msg;
    return old_msg;
  }
  inline void exit_cond(const char* old_msg)
  {
unknown's avatar
unknown committed
1242 1243 1244 1245 1246 1247 1248
    /*
      Putting the mutex unlock in exit_cond() ensures that
      mysys_var->current_mutex is always unlocked _before_ mysys_var->mutex is
      locked (if that would not be the case, you'll get a deadlock if someone
      does a THD::awake() on you).
    */
    pthread_mutex_unlock(mysys_var->current_mutex);
unknown's avatar
unknown committed
1249 1250 1251 1252 1253 1254
    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
1255
  inline time_t query_start() { query_start_used=1; return start_time; }
unknown's avatar
unknown committed
1256
  inline void	set_time()    { if (user_time) start_time=time_after_lock=user_time; else time_after_lock=time(&start_time); }
1257
  inline void	end_time()    { time(&start_time); }
unknown's avatar
unknown committed
1258
  inline void	set_time(time_t t) { time_after_lock=start_time=user_time=t; }
1259
  inline void	lock_time()   { time(&time_after_lock); }
1260 1261 1262 1263 1264
  inline void	insert_id(ulonglong id_arg)
  {
    last_insert_id= id_arg;
    insert_id_used=1;
  }
unknown's avatar
unknown committed
1265 1266 1267
  inline ulonglong insert_id(void)
  {
    if (!last_insert_id_used)
1268
    {
unknown's avatar
unknown committed
1269 1270 1271 1272 1273
      last_insert_id_used=1;
      current_insert_id=last_insert_id;
    }
    return last_insert_id;
  }
1274 1275 1276
  inline ulonglong found_rows(void)
  {
    return limit_found_rows;
1277
  }
1278 1279
  inline bool active_transaction()
  {
1280 1281
#ifdef USING_TRANSACTIONS
    return server_status & SERVER_STATUS_IN_TRANS;
1282 1283 1284
#else
    return 0;
#endif
1285
  }
unknown's avatar
unknown committed
1286 1287
  inline bool fill_derived_tables()
  {
unknown's avatar
unknown committed
1288
    return !stmt_arena->is_stmt_prepare() && !lex->only_view_structure();
unknown's avatar
unknown committed
1289 1290 1291
  }
  inline gptr trans_alloc(unsigned int size)
  {
1292 1293
    return alloc_root(&transaction.mem_root,size);
  }
1294 1295 1296 1297

  bool convert_string(LEX_STRING *to, CHARSET_INFO *to_cs,
		      const char *from, uint from_length,
		      CHARSET_INFO *from_cs);
1298 1299 1300

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

1301
  void add_changed_table(TABLE *table);
unknown's avatar
unknown committed
1302 1303
  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
1304
  int send_explain_fields(select_result *result);
1305
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
1306 1307 1308 1309 1310
  inline void clear_error()
  {
    net.last_error[0]= 0;
    net.last_errno= 0;
    net.report_error= 0;
unknown's avatar
unknown committed
1311
    query_error= 0;
unknown's avatar
unknown committed
1312
  }
1313
  inline bool vio_ok() const { return net.vio != 0; }
1314 1315
#else
  void clear_error();
1316
  inline bool vio_ok() const { return true; }
1317
#endif
1318 1319 1320
  inline void fatal_error()
  {
    is_fatal_error= 1;
unknown's avatar
unknown committed
1321
    net.report_error= 1;
unknown's avatar
unknown committed
1322
    DBUG_PRINT("error",("Fatal error set"));
1323
  }
1324
  inline CHARSET_INFO *charset() { return variables.character_set_client; }
unknown's avatar
unknown committed
1325
  void update_charset();
1326

unknown's avatar
unknown committed
1327
  inline Query_arena *activate_stmt_arena_if_needed(Query_arena *backup)
unknown's avatar
unknown committed
1328 1329
  {
    /*
unknown's avatar
unknown committed
1330 1331
      Use the persistent arena if we are in a prepared statement or a stored
      procedure statement and we have not already changed to use this arena.
unknown's avatar
unknown committed
1332
    */
unknown's avatar
unknown committed
1333
    if (!stmt_arena->is_conventional() && mem_root != stmt_arena->mem_root)
unknown's avatar
unknown committed
1334
    {
unknown's avatar
unknown committed
1335 1336
      set_n_backup_active_arena(stmt_arena, backup);
      return stmt_arena;
unknown's avatar
unknown committed
1337 1338 1339 1340
    }
    return 0;
  }

1341
  void change_item_tree(Item **place, Item *new_value)
1342
  {
1343
    /* TODO: check for OOM condition here */
unknown's avatar
unknown committed
1344
    if (!stmt_arena->is_conventional())
unknown's avatar
unknown committed
1345
      nocheck_register_item_tree_change(place, *place, mem_root);
1346
    *place= new_value;
1347 1348
  }
  void nocheck_register_item_tree_change(Item **place, Item *old_value,
1349
                                         MEM_ROOT *runtime_memroot);
1350
  void rollback_item_tree_changes();
1351 1352 1353 1354 1355 1356

  /*
    Cleanup statement parse state (parse tree, lex) and execution
    state after execution of a non-prepared SQL statement.
  */
  void end_statement();
1357 1358
  inline int killed_errno() const
  {
unknown's avatar
unknown committed
1359
    return killed != KILL_BAD_DATA ? killed : 0;
1360 1361 1362
  }
  inline void send_kill_message() const
  {
unknown's avatar
unknown committed
1363
    int err= killed_errno();
1364 1365
    if (err)
      my_message(err, ER(err), MYF(0));
1366
  }
unknown's avatar
unknown committed
1367 1368 1369 1370 1371 1372 1373
  /* return TRUE if we will abort query if we make a warning now */
  inline bool really_abort_on_warning()
  {
    return (abort_on_warning &&
            (!no_trans_update ||
             (variables.sql_mode & MODE_STRICT_ALL_TABLES)));
  }
1374
  void set_status_var_init();
1375
  bool is_context_analysis_only()
unknown's avatar
unknown committed
1376
    { return stmt_arena->is_stmt_prepare() || lex->view_prepare_mode; }
1377 1378
  void reset_n_backup_open_tables_state(Open_tables_state *backup);
  void restore_backup_open_tables_state(Open_tables_state *backup);
1379 1380
  void reset_sub_statement_state(Sub_statement_state *backup, uint new_state);
  void restore_sub_statement_state(Sub_statement_state *backup);
unknown's avatar
unknown committed
1381 1382
  void set_n_backup_active_arena(Query_arena *set, Query_arena *backup);
  void restore_active_arena(Query_arena *set, Query_arena *backup);
1383 1384 1385 1386
  inline void set_current_stmt_binlog_row_based_if_mixed()
  {
    if (variables.binlog_format == BINLOG_FORMAT_MIXED)
      current_stmt_binlog_row_based= 1;
unknown's avatar
unknown committed
1387 1388 1389 1390
  }
  inline void set_current_stmt_binlog_row_based()
  {
    current_stmt_binlog_row_based= 1;
1391 1392 1393 1394 1395
  }
  inline void reset_current_stmt_binlog_row_based()
  {
    current_stmt_binlog_row_based= test(variables.binlog_format == BINLOG_FORMAT_ROW);
  }
unknown's avatar
unknown committed
1396 1397
};

1398

1399
#define tmp_disable_binlog(A)       \
1400
  {ulonglong tmp_disable_binlog__save_options= (A)->options; \
1401
  (A)->options&= ~OPTION_BIN_LOG
1402

1403
#define reenable_binlog(A)   (A)->options= tmp_disable_binlog__save_options;}
1404

1405 1406 1407 1408
/* 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
1409
#define SYSTEM_THREAD_NDBCLUSTER_BINLOG 8
1410

unknown's avatar
unknown committed
1411 1412 1413
/*
  Used to hold information about file and file structure in exchainge 
  via non-DB file (...INTO OUTFILE..., ...LOAD DATA...)
1414
  XXX: We never call destructor for objects of this class.
unknown's avatar
unknown committed
1415
*/
1416

unknown's avatar
unknown committed
1417 1418 1419 1420 1421 1422 1423
class sql_exchange :public Sql_alloc
{
public:
  char *file_name;
  String *field_term,*enclosed,*line_term,*line_start,*escaped;
  bool opt_enclosed;
  bool dumpfile;
1424
  ulong skip_lines;
unknown's avatar
unknown committed
1425 1426 1427 1428 1429 1430
  sql_exchange(char *name,bool dumpfile_flag);
};

#include "log_event.h"

/*
1431
  This is used to get result from a select
unknown's avatar
unknown committed
1432 1433
*/

unknown's avatar
unknown committed
1434 1435
class JOIN;

unknown's avatar
unknown committed
1436 1437 1438
class select_result :public Sql_alloc {
protected:
  THD *thd;
1439
  SELECT_LEX_UNIT *unit;
unknown's avatar
unknown committed
1440 1441 1442
public:
  select_result();
  virtual ~select_result() {};
1443 1444 1445 1446 1447
  virtual int prepare(List<Item> &list, SELECT_LEX_UNIT *u)
  {
    unit= u;
    return 0;
  }
1448
  virtual int prepare2(void) { return 0; }
1449 1450 1451 1452 1453 1454 1455
  /*
    Because of peculiarities of prepared statements protocol
    we need to know number of columns in the result set (if
    there is a result set) apart from sending columns metadata.
  */
  virtual uint field_count(List<Item> &fields) const
  { return fields.elements; }
1456
  virtual bool send_fields(List<Item> &list, uint flags)=0;
unknown's avatar
unknown committed
1457
  virtual bool send_data(List<Item> &items)=0;
unknown's avatar
unknown committed
1458
  virtual bool initialize_tables (JOIN *join=0) { return 0; }
1459
  virtual void send_error(uint errcode,const char *err);
unknown's avatar
unknown committed
1460
  virtual bool send_eof()=0;
unknown's avatar
unknown committed
1461
  virtual bool simple_select() { return 0; }
unknown's avatar
unknown committed
1462
  virtual void abort() {}
1463 1464 1465 1466 1467
  /*
    Cleanup instance of this class for next execution of a prepared
    statement/stored procedure.
  */
  virtual void cleanup();
1468
  void set_thd(THD *thd_arg) { thd= thd_arg; }
1469 1470 1471 1472 1473
#ifdef EMBEDDED_LIBRARY
  virtual void begin_dataset() {}
#else
  void begin_dataset() {}
#endif
unknown's avatar
unknown committed
1474 1475 1476
};


1477 1478 1479 1480 1481 1482 1483 1484 1485
/*
  Base class for select_result descendands which intercept and
  transform result set rows. As the rows are not sent to the client,
  sending of result set metadata should be suppressed as well.
*/

class select_result_interceptor: public select_result
{
public:
1486
  select_result_interceptor() {}              /* Remove gcc warning */
1487 1488 1489 1490 1491
  uint field_count(List<Item> &fields) const { return 0; }
  bool send_fields(List<Item> &fields, uint flag) { return FALSE; }
};


unknown's avatar
unknown committed
1492
class select_send :public select_result {
1493
  int status;
unknown's avatar
unknown committed
1494
public:
1495
  select_send() :status(0) {}
1496
  bool send_fields(List<Item> &list, uint flags);
unknown's avatar
unknown committed
1497 1498
  bool send_data(List<Item> &items);
  bool send_eof();
unknown's avatar
unknown committed
1499
  bool simple_select() { return 1; }
1500
  void abort();
unknown's avatar
unknown committed
1501 1502 1503
};


1504
class select_to_file :public select_result_interceptor {
1505
protected:
unknown's avatar
unknown committed
1506 1507 1508 1509
  sql_exchange *exchange;
  File file;
  IO_CACHE cache;
  ha_rows row_count;
1510 1511 1512 1513 1514 1515 1516
  char path[FN_REFLEN];

public:
  select_to_file(sql_exchange *ex) :exchange(ex), file(-1),row_count(0L)
  { path[0]=0; }
  ~select_to_file();
  void send_error(uint errcode,const char *err);
1517 1518
  bool send_eof();
  void cleanup();
1519 1520 1521 1522
};


class select_export :public select_to_file {
unknown's avatar
unknown committed
1523 1524 1525 1526
  uint field_term_length;
  int field_sep_char,escape_char,line_sep_char;
  bool fixed_row_size;
public:
1527
  select_export(sql_exchange *ex) :select_to_file(ex) {}
unknown's avatar
unknown committed
1528
  ~select_export();
1529
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
1530 1531 1532
  bool send_data(List<Item> &items);
};

unknown's avatar
unknown committed
1533

1534
class select_dump :public select_to_file {
unknown's avatar
unknown committed
1535
public:
1536
  select_dump(sql_exchange *ex) :select_to_file(ex) {}
1537
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
1538 1539
  bool send_data(List<Item> &items);
};
unknown's avatar
unknown committed
1540 1541


1542
class select_insert :public select_result_interceptor {
unknown's avatar
unknown committed
1543
 public:
unknown's avatar
VIEW  
unknown committed
1544
  TABLE_LIST *table_list;
unknown's avatar
unknown committed
1545 1546 1547 1548
  TABLE *table;
  List<Item> *fields;
  ulonglong last_insert_id;
  COPY_INFO info;
unknown's avatar
VIEW  
unknown committed
1549
  bool insert_into_view;
unknown's avatar
unknown committed
1550

unknown's avatar
unknown committed
1551 1552
  select_insert(TABLE_LIST *table_list_par,
		TABLE *table_par, List<Item> *fields_par,
unknown's avatar
unknown committed
1553
		List<Item> *update_fields, List<Item> *update_values,
1554
		enum_duplicates duplic, bool ignore);
unknown's avatar
unknown committed
1555
  ~select_insert();
1556
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
1557
  int prepare2(void);
unknown's avatar
unknown committed
1558
  bool send_data(List<Item> &items);
unknown's avatar
unknown committed
1559
  virtual void store_values(List<Item> &values);
unknown's avatar
unknown committed
1560 1561
  void send_error(uint errcode,const char *err);
  bool send_eof();
1562 1563
  /* not implemented: select_insert is never re-used in prepared statements */
  void cleanup();
unknown's avatar
unknown committed
1564 1565
};

unknown's avatar
unknown committed
1566

unknown's avatar
unknown committed
1567 1568
class select_create: public select_insert {
  ORDER *group;
unknown's avatar
VIEW  
unknown committed
1569
  TABLE_LIST *create_table;
unknown's avatar
unknown committed
1570 1571 1572 1573 1574 1575
  List<create_field> *extra_fields;
  List<Key> *keys;
  HA_CREATE_INFO *create_info;
  MYSQL_LOCK *lock;
  Field **field;
public:
unknown's avatar
VIEW  
unknown committed
1576 1577 1578 1579
  select_create (TABLE_LIST *table,
		 HA_CREATE_INFO *create_info_par,
		 List<create_field> &fields_par,
		 List<Key> &keys_par,
1580 1581
		 List<Item> &select_fields,enum_duplicates duplic, bool ignore)
    :select_insert (NULL, NULL, &select_fields, 0, 0, duplic, ignore), create_table(table),
unknown's avatar
VIEW  
unknown committed
1582
    extra_fields(&fields_par),keys(&keys_par), create_info(create_info_par),
1583
    lock(0)
unknown's avatar
unknown committed
1584
    {}
1585
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
1586
  
1587
  void binlog_show_create_table(TABLE **tables, uint count);
unknown's avatar
unknown committed
1588
  void store_values(List<Item> &values);
1589
  void send_error(uint errcode,const char *err);
unknown's avatar
unknown committed
1590 1591
  bool send_eof();
  void abort();
1592 1593
  // Needed for access from local class MY_HOOKS in prepare(), since thd is proteted.
  THD *get_thd(void) { return thd; }
unknown's avatar
unknown committed
1594 1595
};

1596 1597
#include <myisam.h>

unknown's avatar
unknown committed
1598 1599 1600 1601 1602
/* 
  Param to create temporary tables when doing SELECT:s 
  NOTE
    This structure is copied using memcpy as a part of JOIN.
*/
1603 1604 1605

class TMP_TABLE_PARAM :public Sql_alloc
{
1606 1607 1608 1609 1610 1611
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:
1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625
  List<Item> copy_funcs;
  List<Item> save_copy_funcs;
  Copy_field *copy_field, *copy_field_end;
  Copy_field *save_copy_field, *save_copy_field_end;
  byte	    *group_buff;
  Item	    **items_to_copy;			/* Fields in tmp table */
  MI_COLUMNDEF *recinfo,*start_recinfo;
  KEY *keyinfo;
  ha_rows end_write_records;
  uint	field_count,sum_func_count,func_count;
  uint  hidden_field_count;
  uint	group_parts,group_length,group_null_parts;
  uint	quick_group;
  bool  using_indirect_summary_function;
1626 1627
  /* If >0 convert all blob fields to varchar(convert_blob_length) */
  uint  convert_blob_length; 
unknown's avatar
unknown committed
1628
  CHARSET_INFO *table_charset; 
1629
  bool schema_table;
1630 1631 1632 1633 1634 1635 1636
  /*
    True if GROUP BY and its aggregate functions are already computed
    by a table access method (e.g. by loose index scan). In this case
    query execution should not perform aggregation and should treat
    aggregate functions as normal functions.
  */
  bool precomputed_group_by;
1637
  bool force_copy_fields;
1638 1639

  TMP_TABLE_PARAM()
unknown's avatar
unknown committed
1640
    :copy_field(0), group_parts(0),
unknown's avatar
unknown committed
1641
     group_length(0), group_null_parts(0), convert_blob_length(0),
unknown's avatar
unknown committed
1642
     schema_table(0), precomputed_group_by(0), force_copy_fields(0)
1643 1644 1645 1646 1647
  {}
  ~TMP_TABLE_PARAM()
  {
    cleanup();
  }
1648
  void init(void);
1649 1650 1651 1652 1653
  inline void cleanup(void)
  {
    if (copy_field)				/* Fix for Intel compiler */
    {
      delete [] copy_field;
1654
      save_copy_field= copy_field= 0;
1655 1656 1657 1658
    }
  }
};

1659 1660
class select_union :public select_result_interceptor
{
1661
  TMP_TABLE_PARAM tmp_table_param;
1662 1663
public:
  TABLE *table;
unknown's avatar
unknown committed
1664

1665
  select_union() :table(0) {}
1666
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
1667 1668 1669
  bool send_data(List<Item> &items);
  bool send_eof();
  bool flush();
1670 1671 1672 1673

  bool create_result_table(THD *thd, List<Item> *column_types,
                           bool is_distinct, ulonglong options,
                           const char *alias);
unknown's avatar
unknown committed
1674 1675
};

unknown's avatar
unknown committed
1676
/* Base subselect interface class */
1677
class select_subselect :public select_result_interceptor
1678
{
unknown's avatar
unknown committed
1679
protected:
1680 1681 1682
  Item_subselect *item;
public:
  select_subselect(Item_subselect *item);
unknown's avatar
unknown committed
1683
  bool send_data(List<Item> &items)=0;
1684 1685 1686
  bool send_eof() { return 0; };
};

unknown's avatar
unknown committed
1687
/* Single value subselect interface class */
unknown's avatar
unknown committed
1688
class select_singlerow_subselect :public select_subselect
unknown's avatar
unknown committed
1689 1690
{
public:
unknown's avatar
unknown committed
1691
  select_singlerow_subselect(Item_subselect *item):select_subselect(item){}
unknown's avatar
unknown committed
1692 1693 1694
  bool send_data(List<Item> &items);
};

1695 1696 1697 1698 1699 1700 1701 1702 1703 1704
/* used in independent ALL/ANY optimisation */
class select_max_min_finder_subselect :public select_subselect
{
  Item_cache *cache;
  bool (select_max_min_finder_subselect::*op)();
  bool fmax;
public:
  select_max_min_finder_subselect(Item_subselect *item, bool mx)
    :select_subselect(item), cache(0), fmax(mx)
  {}
unknown's avatar
Merge  
unknown committed
1705
  void cleanup();
1706 1707 1708
  bool send_data(List<Item> &items);
  bool cmp_real();
  bool cmp_int();
unknown's avatar
Merge  
unknown committed
1709
  bool cmp_decimal();
1710 1711 1712
  bool cmp_str();
};

unknown's avatar
unknown committed
1713 1714 1715 1716 1717 1718 1719 1720
/* 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
1721 1722 1723 1724 1725 1726
/* 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 */
1727
  uint   suffix_length;                 /* Length suffix (0-4) */
unknown's avatar
unknown committed
1728
  Item_result result_type;		/* Type of item */
1729 1730
  bool reverse;				/* if descending sort */
  bool need_strxnfrm;			/* If we have to use strxnfrm() */
unknown's avatar
unknown committed
1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743
} 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 */

1744 1745
class Table_ident :public Sql_alloc
{
unknown's avatar
unknown committed
1746 1747 1748
 public:
  LEX_STRING db;
  LEX_STRING table;
unknown's avatar
unknown committed
1749
  SELECT_LEX_UNIT *sel;
unknown's avatar
unknown committed
1750 1751
  inline Table_ident(THD *thd, LEX_STRING db_arg, LEX_STRING table_arg,
		     bool force)
unknown's avatar
unknown committed
1752
    :table(table_arg), sel((SELECT_LEX_UNIT *)0)
unknown's avatar
unknown committed
1753
  {
unknown's avatar
unknown committed
1754
    if (!force && (thd->client_capabilities & CLIENT_NO_SCHEMA))
unknown's avatar
unknown committed
1755 1756 1757 1758
      db.str=0;
    else
      db= db_arg;
  }
unknown's avatar
unknown committed
1759 1760 1761 1762 1763 1764 1765
  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
1766 1767
    /* 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
1768
  }
unknown's avatar
unknown committed
1769
  inline void change_db(char *db_name)
unknown's avatar
unknown committed
1770 1771 1772
  {
    db.str= db_name; db.length= (uint) strlen(db_name);
  }
unknown's avatar
unknown committed
1773 1774 1775 1776 1777 1778
};

// this is needed for user_vars hash
class user_var_entry
{
 public:
1779
  user_var_entry() {}                         /* Remove gcc warning */
unknown's avatar
unknown committed
1780 1781
  LEX_STRING name;
  char *value;
1782 1783
  ulong length;
  query_id_t update_query_id, used_query_id;
unknown's avatar
unknown committed
1784
  Item_result type;
1785

unknown's avatar
Merge  
unknown committed
1786
  double val_real(my_bool *null_value);
1787 1788
  longlong val_int(my_bool *null_value);
  String *val_str(my_bool *null_value, String *str, uint decimals);
unknown's avatar
Merge  
unknown committed
1789
  my_decimal *val_decimal(my_bool *null_value, my_decimal *result);
1790
  DTCollation collation;
unknown's avatar
unknown committed
1791 1792
};

1793 1794 1795 1796 1797 1798 1799
/*
   Unique -- class for unique (removing of duplicates). 
   Puts all values to the TREE. If the tree becomes too big,
   it's dumped to the file. User can request sorted values, or
   just iterate through them. In the last case tree merging is performed in
   memory simultaneously with iteration, so it should be ~2-3x faster.
 */
1800 1801 1802 1803 1804 1805 1806

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
1807
  byte *record_pointers;
1808
  bool flush();
1809
  uint size;
1810 1811 1812

public:
  ulong elements;
1813
  Unique(qsort_cmp2 comp_func, void *comp_func_fixed_arg,
1814
	 uint size_arg, ulong max_in_memory_size_arg);
1815
  ~Unique();
1816
  ulong elements_in_tree() { return tree.elements_in_tree; }
1817
  inline bool unique_add(void *ptr)
1818
  {
unknown's avatar
Merge  
unknown committed
1819 1820
    DBUG_ENTER("unique_add");
    DBUG_PRINT("info", ("tree %u - %u", tree.elements_in_tree, max_elements));
1821
    if (tree.elements_in_tree > max_elements && flush())
unknown's avatar
Merge  
unknown committed
1822 1823
      DBUG_RETURN(1);
    DBUG_RETURN(!tree_insert(&tree, ptr, 0, tree.custom_arg));
1824 1825 1826
  }

  bool get(TABLE *table);
1827
  static double get_use_cost(uint *buffer, uint nkeys, uint key_size, 
1828
                             ulong max_in_memory_size);
1829 1830 1831 1832 1833 1834 1835 1836
  inline static int get_cost_calc_buff_size(ulong nkeys, uint key_size, 
                                            ulong max_in_memory_size)
  {
    register ulong max_elems_in_tree= 
      (1 + max_in_memory_size / ALIGN_SIZE(sizeof(TREE_ELEMENT)+key_size));
    return sizeof(uint)*(1 + nkeys/max_elems_in_tree);
  }

1837 1838 1839
  void reset();
  bool walk(tree_walk_action action, void *walk_action_arg);

1840 1841
  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);
1842
};
1843

unknown's avatar
unknown committed
1844

1845
class multi_delete :public select_result_interceptor
unknown's avatar
unknown committed
1846 1847
{
  TABLE_LIST *delete_tables, *table_being_deleted;
unknown's avatar
unknown committed
1848
  Unique **tempfiles;
1849
  ha_rows deleted, found;
unknown's avatar
unknown committed
1850 1851
  uint num_of_tables;
  int error;
1852 1853 1854 1855 1856 1857
  bool do_delete;
  /* True if at least one table we delete from is transactional */
  bool transactional_tables;
  /* True if at least one table we delete from is not transactional */
  bool normal_tables;
  bool delete_while_scanning;
1858

unknown's avatar
unknown committed
1859
public:
1860
  multi_delete(TABLE_LIST *dt, uint num_of_tables);
unknown's avatar
unknown committed
1861 1862 1863 1864 1865
  ~multi_delete();
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
  bool send_data(List<Item> &items);
  bool initialize_tables (JOIN *join);
  void send_error(uint errcode,const char *err);
1866
  int  do_deletes();
unknown's avatar
unknown committed
1867 1868 1869
  bool send_eof();
};

1870

1871
class multi_update :public select_result_interceptor
unknown's avatar
unknown committed
1872
{
1873 1874 1875
  TABLE_LIST *all_tables; /* query/update command tables */
  TABLE_LIST *leaves;     /* list of leves of join table tree */
  TABLE_LIST *update_tables, *table_being_updated;
unknown's avatar
unknown committed
1876
  TABLE **tmp_tables, *main_table, *table_to_update;
unknown's avatar
unknown committed
1877 1878 1879 1880 1881 1882 1883
  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;
1884 1885 1886 1887
  bool do_update, trans_safe;
  /* True if the update operation has made a change in a transactional table */
  bool transactional_tables;
  bool ignore;
unknown's avatar
unknown committed
1888 1889

public:
1890
  multi_update(TABLE_LIST *ut, TABLE_LIST *leaves_list,
1891
	       List<Item> *fields, List<Item> *values,
1892
	       enum_duplicates handle_duplicates, bool ignore);
unknown's avatar
unknown committed
1893
  ~multi_update();
unknown's avatar
unknown committed
1894
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
1895 1896 1897 1898 1899 1900
  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();
};
1901

unknown's avatar
unknown committed
1902 1903 1904
class my_var : public Sql_alloc  {
public:
  LEX_STRING s;
unknown's avatar
unknown committed
1905
#ifndef DBUG_OFF
1906 1907 1908 1909
  /*
    Routine to which this Item_splocal belongs. Used for checking if correct
    runtime context is used for variable handling.
  */
1910
  sp_head *sp;
1911
#endif
unknown's avatar
unknown committed
1912 1913
  bool local;
  uint offset;
1914 1915 1916 1917
  enum_field_types type;
  my_var (LEX_STRING& j, bool i, uint o, enum_field_types t)
    :s(j), local(i), offset(o), type(t)
  {}
unknown's avatar
unknown committed
1918 1919
  ~my_var() {}
};
1920

1921
class select_dumpvar :public select_result_interceptor {
unknown's avatar
unknown committed
1922 1923
  ha_rows row_count;
public:
unknown's avatar
unknown committed
1924
  List<my_var> var_list;
1925
  List<Item_func_set_user_var> vars;
unknown's avatar
unknown committed
1926 1927
  List<Item_splocal> local_vars;
  select_dumpvar(void)  { var_list.empty(); local_vars.empty(); vars.empty(); row_count=0;}
unknown's avatar
unknown committed
1928
  ~select_dumpvar() {}
1929
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
unknown's avatar
unknown committed
1930 1931
  bool send_data(List<Item> &items);
  bool send_eof();
1932
  void cleanup();
unknown's avatar
unknown committed
1933
};
1934 1935 1936 1937

/* Functions in sql_class.cc */

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

#endif /* MYSQL_SERVER */