← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/table.h

  • Committer: Monty Taylor
  • Date: 2008-08-01 22:33:44 UTC
  • mto: (236.1.42 codestyle)
  • mto: This revision was merged to the branch mainline in revision 261.
  • Revision ID: monty@inaugust.com-20080801223344-vzhlflfmtijp1imv
First pass at gettexizing the error messages.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/table.h
1
 
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
 
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
 
 *
4
 
 *  Copyright (C) 2008 Sun Microsystems, Inc.
5
 
 *
6
 
 *  This program is free software; you can redistribute it and/or modify
7
 
 *  it under the terms of the GNU General Public License as published by
8
 
 *  the Free Software Foundation; either version 2 of the License, or
9
 
 *  (at your option) any later version.
10
 
 *
11
 
 *  This program is distributed in the hope that it will be useful,
12
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
 
 *  GNU General Public License for more details.
15
 
 *
16
 
 *  You should have received a copy of the GNU General Public License
17
 
 *  along with this program; if not, write to the Free Software
18
 
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19
 
 */
20
 
 
21
 
/* Structs that defines the Table */
22
 
 
23
 
 
24
 
 
25
 
#ifndef DRIZZLED_TABLE_H
26
 
#define DRIZZLED_TABLE_H
27
 
 
28
 
#include <string>
29
 
#include <boost/dynamic_bitset.hpp>
30
 
 
31
 
#include <drizzled/order.h>
32
 
#include <drizzled/filesort_info.h>
33
 
#include <drizzled/natural_join_column.h>
34
 
#include <drizzled/field_iterator.h>
35
 
#include <drizzled/cursor.h>
36
 
#include <drizzled/lex_string.h>
37
 
#include <drizzled/table/instance.h>
38
 
#include <drizzled/atomics.h>
39
 
#include <drizzled/query_id.h>
40
 
 
41
 
#include <drizzled/visibility.h>
42
 
 
43
 
namespace drizzled
44
 
{
45
 
 
 
1
/* Copyright (C) 2000-2006 MySQL AB
 
2
 
 
3
   This program is free software; you can redistribute it and/or modify
 
4
   it under the terms of the GNU General Public License as published by
 
5
   the Free Software Foundation; version 2 of the License.
 
6
 
 
7
   This program is distributed in the hope that it will be useful,
 
8
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
9
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
10
   GNU General Public License for more details.
 
11
 
 
12
   You should have received a copy of the GNU General Public License
 
13
   along with this program; if not, write to the Free Software
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
15
 
 
16
 
 
17
/* Structs that defines the TABLE */
 
18
 
 
19
class Item;                             /* Needed by ORDER */
 
20
class Item_subselect;
 
21
class st_select_lex_unit;
 
22
class st_select_lex;
46
23
class COND_EQUAL;
 
24
class Security_context;
 
25
 
 
26
/*************************************************************************/
 
27
 
 
28
/* Order clause list element */
 
29
 
 
30
typedef struct st_order {
 
31
  struct st_order *next;
 
32
  Item   **item;                        /* Point at item in select fields */
 
33
  Item   *item_ptr;                     /* Storage for initial item */
 
34
  Item   **item_copy;                   /* For SPs; the original item ptr */
 
35
  int    counter;                       /* position in SELECT list, correct
 
36
                                           only if counter_used is true*/
 
37
  bool   asc;                           /* true if ascending */
 
38
  bool   free_me;                       /* true if item isn't shared  */
 
39
  bool   in_field_list;                 /* true if in select field list */
 
40
  bool   counter_used;                  /* parameter was counter of columns */
 
41
  Field  *field;                        /* If tmp-table group */
 
42
  char   *buff;                         /* If tmp-table group */
 
43
  table_map used, depend_map;
 
44
} ORDER;
 
45
 
 
46
enum tmp_table_type
 
47
{
 
48
  NO_TMP_TABLE, NON_TRANSACTIONAL_TMP_TABLE, TRANSACTIONAL_TMP_TABLE,
 
49
  INTERNAL_TMP_TABLE, SYSTEM_TMP_TABLE, TMP_TABLE_FRM_FILE_ONLY
 
50
};
 
51
 
 
52
enum frm_type_enum
 
53
{
 
54
  FRMTYPE_ERROR= 0,
 
55
  FRMTYPE_TABLE
 
56
};
 
57
 
 
58
frm_type_enum mysql_frm_type(THD *thd, char *path, enum legacy_db_type *dbt);
 
59
 
 
60
 
 
61
enum release_type { RELEASE_NORMAL, RELEASE_WAIT_FOR_DROP };
 
62
 
 
63
typedef struct st_filesort_info
 
64
{
 
65
  IO_CACHE *io_cache;           /* If sorted through filesort */
 
66
  uchar     **sort_keys;        /* Buffer for sorting keys */
 
67
  uchar     *buffpek;           /* Buffer for buffpek structures */
 
68
  uint      buffpek_len;        /* Max number of buffpeks in the buffer */
 
69
  uchar     *addon_buf;         /* Pointer to a buffer if sorted with fields */
 
70
  size_t    addon_length;       /* Length of the buffer */
 
71
  struct st_sort_addon_field *addon_field;     /* Pointer to the fields info */
 
72
  void    (*unpack)(struct st_sort_addon_field *, uchar *); /* To unpack back */
 
73
  uchar     *record_pointers;    /* If sorted in memory */
 
74
  ha_rows   found_records;      /* How many records in sort */
 
75
} FILESORT_INFO;
 
76
 
 
77
 
 
78
/*
 
79
  Values in this enum are used to indicate how a tables TIMESTAMP field
 
80
  should be treated. It can be set to the current timestamp on insert or
 
81
  update or both.
 
82
  WARNING: The values are used for bit operations. If you change the
 
83
  enum, you must keep the bitwise relation of the values. For example:
 
84
  (int) TIMESTAMP_AUTO_SET_ON_BOTH must be equal to
 
85
  (int) TIMESTAMP_AUTO_SET_ON_INSERT | (int) TIMESTAMP_AUTO_SET_ON_UPDATE.
 
86
  We use an enum here so that the debugger can display the value names.
 
87
*/
 
88
enum timestamp_auto_set_type
 
89
{
 
90
  TIMESTAMP_NO_AUTO_SET= 0, TIMESTAMP_AUTO_SET_ON_INSERT= 1,
 
91
  TIMESTAMP_AUTO_SET_ON_UPDATE= 2, TIMESTAMP_AUTO_SET_ON_BOTH= 3
 
92
};
 
93
#define clear_timestamp_auto_bits(_target_, _bits_) \
 
94
  (_target_)= (enum timestamp_auto_set_type)((int)(_target_) & ~(int)(_bits_))
 
95
 
 
96
class Field_timestamp;
47
97
class Field_blob;
48
 
class Item;
49
 
class Item_subselect;
50
 
class SecurityContext;
51
 
class Select_Lex;
52
 
class Select_Lex_Unit;
53
 
class TableList;
54
 
namespace field { class Epoch; }
55
 
namespace plugin { class StorageEngine; }
56
 
 
 
98
class Table_triggers_list;
 
99
 
 
100
/**
 
101
  Category of table found in the table share.
 
102
*/
 
103
enum enum_table_category
 
104
{
 
105
  /**
 
106
    Unknown value.
 
107
  */
 
108
  TABLE_UNKNOWN_CATEGORY=0,
 
109
 
 
110
  /**
 
111
    Temporary table.
 
112
    The table is visible only in the session.
 
113
    Therefore,
 
114
    - FLUSH TABLES WITH READ LOCK
 
115
    - SET GLOBAL READ_ONLY = ON
 
116
    do not apply to this table.
 
117
    Note that LOCK TABLE t FOR READ/WRITE
 
118
    can be used on temporary tables.
 
119
    Temporary tables are not part of the table cache.
 
120
  */
 
121
  TABLE_CATEGORY_TEMPORARY=1,
 
122
 
 
123
  /**
 
124
    User table.
 
125
    These tables do honor:
 
126
    - LOCK TABLE t FOR READ/WRITE
 
127
    - FLUSH TABLES WITH READ LOCK
 
128
    - SET GLOBAL READ_ONLY = ON
 
129
    User tables are cached in the table cache.
 
130
  */
 
131
  TABLE_CATEGORY_USER=2,
 
132
 
 
133
  /**
 
134
    System table, maintained by the server.
 
135
    These tables do honor:
 
136
    - LOCK TABLE t FOR READ/WRITE
 
137
    - FLUSH TABLES WITH READ LOCK
 
138
    - SET GLOBAL READ_ONLY = ON
 
139
    Typically, writes to system tables are performed by
 
140
    the server implementation, not explicitly be a user.
 
141
    System tables are cached in the table cache.
 
142
  */
 
143
  TABLE_CATEGORY_SYSTEM=3,
 
144
 
 
145
  /**
 
146
    Information schema tables.
 
147
    These tables are an interface provided by the system
 
148
    to inspect the system metadata.
 
149
    These tables do *not* honor:
 
150
    - LOCK TABLE t FOR READ/WRITE
 
151
    - FLUSH TABLES WITH READ LOCK
 
152
    - SET GLOBAL READ_ONLY = ON
 
153
    as there is no point in locking explicitely
 
154
    an INFORMATION_SCHEMA table.
 
155
    Nothing is directly written to information schema tables.
 
156
    Note that this value is not used currently,
 
157
    since information schema tables are not shared,
 
158
    but implemented as session specific temporary tables.
 
159
  */
 
160
  /*
 
161
    TODO: Fixing the performance issues of I_S will lead
 
162
    to I_S tables in the table cache, which should use
 
163
    this table type.
 
164
  */
 
165
  TABLE_CATEGORY_INFORMATION=4
 
166
};
57
167
typedef enum enum_table_category TABLE_CATEGORY;
58
 
typedef struct st_columndef MI_COLUMNDEF;
59
 
 
60
 
/**
61
 
 * Class representing a set of records, either in a temporary, 
62
 
 * normal, or derived table.
63
 
 */
64
 
class DRIZZLED_API Table 
65
 
{
66
 
  Field **field; /**< Pointer to fields collection */
67
 
 
68
 
public:
69
 
  Field **getFields() const
70
 
  {
71
 
    return field;
72
 
  }
73
 
 
74
 
  Field *getField(uint32_t arg) const
75
 
  {
76
 
    return field[arg];
77
 
  }
78
 
 
79
 
  void setFields(Field **arg)
80
 
  {
81
 
    field= arg;
82
 
  }
83
 
 
84
 
  void setFieldAt(Field *arg, uint32_t arg_pos)
85
 
  {
86
 
    field[arg_pos]= arg;
87
 
  }
88
 
 
89
 
  Cursor *cursor; /**< Pointer to the storage engine's Cursor managing this table */
90
 
 
91
 
private:
92
 
  Table *next;
93
 
 
94
 
public:
95
 
  Table *getNext() const
96
 
  {
97
 
    return next;
98
 
  }
99
 
 
100
 
  Table **getNextPtr()
101
 
  {
102
 
    return &next;
103
 
  }
104
 
 
105
 
  void setNext(Table *arg)
106
 
  {
107
 
    next= arg;
108
 
  }
109
 
 
110
 
  void unlink()
111
 
  {
112
 
    getNext()->setPrev(getPrev());              /* remove from used chain */
113
 
    getPrev()->setNext(getNext());
114
 
  }
115
 
 
116
 
private:
117
 
  Table *prev;
118
 
public:
119
 
  Table *getPrev() const
120
 
  {
121
 
    return prev;
122
 
  }
123
 
 
124
 
  Table **getPrevPtr()
125
 
  {
126
 
    return &prev;
127
 
  }
128
 
 
129
 
  void setPrev(Table *arg)
130
 
  {
131
 
    prev= arg;
132
 
  }
133
 
 
134
 
  boost::dynamic_bitset<> *read_set; /* Active column sets */
135
 
  boost::dynamic_bitset<> *write_set; /* Active column sets */
136
 
 
137
 
  uint32_t tablenr;
138
 
  uint32_t db_stat; /**< information about the cursor as in Cursor.h */
139
 
 
140
 
  boost::dynamic_bitset<> def_read_set; /**< Default read set of columns */
141
 
  boost::dynamic_bitset<> def_write_set; /**< Default write set of columns */
142
 
  boost::dynamic_bitset<> tmp_set; /* Not sure about this... */
143
 
 
144
 
  Session *in_use; /**< Pointer to the current session using this object */
145
 
  Session *getSession()
146
 
  {
147
 
    return in_use;
148
 
  }
149
 
 
150
 
  unsigned char *getInsertRecord() const
151
 
  {
152
 
    return record[0];
153
 
  }
154
 
 
155
 
  unsigned char *getUpdateRecord()
156
 
  {
157
 
    return record[1];
158
 
  }
159
 
 
160
 
  unsigned char *record[2]; /**< Pointer to "records" */
161
 
  std::vector<unsigned char> insert_values; /* used by INSERT ... UPDATE */
162
 
  KeyInfo  *key_info; /**< data of keys in database */
163
 
  Field *next_number_field; /**< Set if next_number is activated. @TODO What the heck is the difference between this and the next member? */
164
 
  Field *found_next_number_field; /**< Points to the "next-number" field (autoincrement field) */
165
 
  field::Epoch *timestamp_field; /**< Points to the auto-setting timestamp field, if any */
166
 
 
167
 
  TableList *pos_in_table_list; /* Element referring to this table */
168
 
  Order *group;
169
 
  
170
 
  const char *getAlias() const
171
 
  {
172
 
    return _alias.c_str();
173
 
  }
174
 
 
175
 
  void clearAlias()
176
 
  {
177
 
    _alias.clear();
178
 
  }
179
 
 
180
 
  void setAlias(const char *arg)
181
 
  {
182
 
    _alias= arg;
183
 
  }
184
 
 
185
 
private:
186
 
  std::string _alias; /**< alias or table name if no alias */
187
 
public:
188
 
 
189
 
  unsigned char *null_flags;
190
 
 
191
 
  uint32_t lock_position; /**< Position in DRIZZLE_LOCK.table */
192
 
  uint32_t lock_data_start; /**< Start pos. in DRIZZLE_LOCK.locks */
193
 
  uint32_t lock_count; /**< Number of locks */
194
 
  uint32_t used_fields;
195
 
  uint32_t status; /* What's in getInsertRecord() */
 
168
 
 
169
TABLE_CATEGORY get_table_category(const LEX_STRING *db,
 
170
                                  const LEX_STRING *name);
 
171
 
 
172
/*
 
173
  This structure is shared between different table objects. There is one
 
174
  instance of table share per one table in the database.
 
175
*/
 
176
 
 
177
typedef struct st_table_share
 
178
{
 
179
  st_table_share() {}                    /* Remove gcc warning */
 
180
 
 
181
  /** Category of this table. */
 
182
  TABLE_CATEGORY table_category;
 
183
 
 
184
  /* hash of field names (contains pointers to elements of field array) */
 
185
  HASH  name_hash;                      /* hash of field names */
 
186
  MEM_ROOT mem_root;
 
187
  TYPELIB keynames;                     /* Pointers to keynames */
 
188
  TYPELIB fieldnames;                   /* Pointer to fieldnames */
 
189
  TYPELIB *intervals;                   /* pointer to interval info */
 
190
  pthread_mutex_t mutex;                /* For locking the share  */
 
191
  pthread_cond_t cond;                  /* To signal that share is ready */
 
192
  struct st_table_share *next,          /* Link to unused shares */
 
193
    **prev;
 
194
 
 
195
  /* The following is copied to each TABLE on OPEN */
 
196
  Field **field;
 
197
  Field **found_next_number_field;
 
198
  Field *timestamp_field;               /* Used only during open */
 
199
  KEY  *key_info;                       /* data of keys in database */
 
200
  uint  *blob_field;                    /* Index to blobs in Field arrray*/
 
201
 
 
202
  uchar *default_values;                /* row with default values */
 
203
  LEX_STRING comment;                   /* Comment about table */
 
204
  CHARSET_INFO *table_charset;          /* Default charset of string fields */
 
205
 
 
206
  MY_BITMAP all_set;
 
207
  /*
 
208
    Key which is used for looking-up table in table cache and in the list
 
209
    of thread's temporary tables. Has the form of:
 
210
      "database_name\0table_name\0" + optional part for temporary tables.
 
211
 
 
212
    Note that all three 'table_cache_key', 'db' and 'table_name' members
 
213
    must be set (and be non-zero) for tables in table cache. They also
 
214
    should correspond to each other.
 
215
    To ensure this one can use set_table_cache() methods.
 
216
  */
 
217
  LEX_STRING table_cache_key;
 
218
  LEX_STRING db;                        /* Pointer to db */
 
219
  LEX_STRING table_name;                /* Table name (for open) */
 
220
  LEX_STRING path;                      /* Path to .frm file (from datadir) */
 
221
  LEX_STRING normalized_path;           /* unpack_filename(path) */
 
222
  LEX_STRING connect_string;
 
223
 
 
224
  /* 
 
225
     Set of keys in use, implemented as a Bitmap.
 
226
     Excludes keys disabled by ALTER TABLE ... DISABLE KEYS.
 
227
  */
 
228
  key_map keys_in_use;
 
229
  key_map keys_for_keyread;
 
230
  ha_rows min_rows, max_rows;           /* create information */
 
231
  ulong   avg_row_length;               /* create information */
 
232
  ulong   version, mysql_version;
 
233
  ulong   timestamp_offset;             /* Set to offset+1 of record */
 
234
  ulong   reclength;                    /* Recordlength */
 
235
 
 
236
  plugin_ref db_plugin;                 /* storage engine plugin */
 
237
  inline handlerton *db_type() const    /* table_type for handler */
 
238
  { 
 
239
    // assert(db_plugin);
 
240
    return db_plugin ? plugin_data(db_plugin, handlerton*) : NULL;
 
241
  }
 
242
  enum row_type row_type;               /* How rows are stored */
 
243
  enum tmp_table_type tmp_table;
 
244
  enum ha_choice transactional;
 
245
  enum ha_choice page_checksum;
 
246
 
 
247
  uint ref_count;                       /* How many TABLE objects uses this */
 
248
  uint open_count;                      /* Number of tables in open list */
 
249
  uint blob_ptr_size;                   /* 4 or 8 */
 
250
  uint key_block_size;                  /* create key_block_size, if used */
 
251
  uint null_bytes, last_null_bit_pos;
 
252
  uint fields;                          /* Number of fields */
 
253
  uint rec_buff_length;                 /* Size of table->record[] buffer */
 
254
  uint keys, key_parts;
 
255
  uint max_key_length, max_unique_length, total_key_length;
 
256
  uint uniques;                         /* Number of UNIQUE index */
 
257
  uint null_fields;                     /* number of null fields */
 
258
  uint blob_fields;                     /* number of blob fields */
 
259
  uint timestamp_field_offset;          /* Field number for timestamp field */
 
260
  uint varchar_fields;                  /* number of varchar fields */
 
261
  uint db_create_options;               /* Create options from database */
 
262
  uint db_options_in_use;               /* Options in use */
 
263
  uint db_record_offset;                /* if HA_REC_IN_SEQ */
 
264
  uint raid_type, raid_chunks;
 
265
  uint rowid_field_offset;              /* Field_nr +1 to rowid field */
 
266
  /* Index of auto-updated TIMESTAMP field in field array */
 
267
  uint primary_key;
 
268
  uint next_number_index;               /* autoincrement key number */
 
269
  uint next_number_key_offset;          /* autoinc keypart offset in a key */
 
270
  uint next_number_keypart;             /* autoinc keypart number in a key */
 
271
  uint error, open_errno, errarg;       /* error from open_table_def() */
 
272
  uint column_bitmap_size;
 
273
  uchar frm_version;
 
274
  bool null_field_first;
 
275
  bool system;                          /* Set if system table (one record) */
 
276
  bool crypted;                         /* If .frm file is crypted */
 
277
  bool db_low_byte_first;               /* Portable row format */
 
278
  bool crashed;
 
279
  bool name_lock, replace_with_name_lock;
 
280
  bool waiting_on_cond;                 /* Protection against free */
 
281
  ulong table_map_id;                   /* for row-based replication */
 
282
  uint64_t table_map_version;
 
283
 
 
284
  /*
 
285
    Cache for row-based replication table share checks that does not
 
286
    need to be repeated. Possible values are: -1 when cache value is
 
287
    not calculated yet, 0 when table *shall not* be replicated, 1 when
 
288
    table *may* be replicated.
 
289
  */
 
290
  int cached_row_logging_check;
 
291
 
 
292
  /*
 
293
    Set share's table cache key and update its db and table name appropriately.
 
294
 
 
295
    SYNOPSIS
 
296
      set_table_cache_key()
 
297
        key_buff    Buffer with already built table cache key to be
 
298
                    referenced from share.
 
299
        key_length  Key length.
 
300
 
 
301
    NOTES
 
302
      Since 'key_buff' buffer will be referenced from share it should has same
 
303
      life-time as share itself.
 
304
      This method automatically ensures that TABLE_SHARE::table_name/db have
 
305
      appropriate values by using table cache key as their source.
 
306
  */
 
307
 
 
308
  void set_table_cache_key(char *key_buff, uint key_length)
 
309
  {
 
310
    table_cache_key.str= key_buff;
 
311
    table_cache_key.length= key_length;
 
312
    /*
 
313
      Let us use the fact that the key is "db/0/table_name/0" + optional
 
314
      part for temporary tables.
 
315
    */
 
316
    db.str=            table_cache_key.str;
 
317
    db.length=         strlen(db.str);
 
318
    table_name.str=    db.str + db.length + 1;
 
319
    table_name.length= strlen(table_name.str);
 
320
  }
 
321
 
 
322
 
 
323
  /*
 
324
    Set share's table cache key and update its db and table name appropriately.
 
325
 
 
326
    SYNOPSIS
 
327
      set_table_cache_key()
 
328
        key_buff    Buffer to be used as storage for table cache key
 
329
                    (should be at least key_length bytes).
 
330
        key         Value for table cache key.
 
331
        key_length  Key length.
 
332
 
 
333
    NOTE
 
334
      Since 'key_buff' buffer will be used as storage for table cache key
 
335
      it should has same life-time as share itself.
 
336
  */
 
337
 
 
338
  void set_table_cache_key(char *key_buff, const char *key, uint key_length)
 
339
  {
 
340
    memcpy(key_buff, key, key_length);
 
341
    set_table_cache_key(key_buff, key_length);
 
342
  }
 
343
 
 
344
  inline bool honor_global_locks()
 
345
  {
 
346
    return ((table_category == TABLE_CATEGORY_USER)
 
347
            || (table_category == TABLE_CATEGORY_SYSTEM));
 
348
  }
 
349
 
 
350
  inline ulong get_table_def_version()
 
351
  {
 
352
    return table_map_id;
 
353
  }
 
354
 
 
355
} TABLE_SHARE;
 
356
 
 
357
 
 
358
extern ulong refresh_version;
 
359
 
 
360
/* Information for one open table */
 
361
enum index_hint_type
 
362
{
 
363
  INDEX_HINT_IGNORE,
 
364
  INDEX_HINT_USE,
 
365
  INDEX_HINT_FORCE
 
366
};
 
367
 
 
368
struct st_table {
 
369
  st_table() {}                               /* Remove gcc warning */
 
370
 
 
371
  TABLE_SHARE   *s;
 
372
  handler       *file;
 
373
  struct st_table *next, *prev;
 
374
 
 
375
  THD   *in_use;                        /* Which thread uses this */
 
376
  Field **field;                        /* Pointer to fields */
 
377
 
 
378
  uchar *record[2];                     /* Pointer to records */
 
379
  uchar *write_row_record;              /* Used as optimisation in
 
380
                                           THD::write_row */
 
381
  uchar *insert_values;                  /* used by INSERT ... UPDATE */
 
382
  /* 
 
383
    Map of keys that can be used to retrieve all data from this table 
 
384
    needed by the query without reading the row.
 
385
  */
 
386
  key_map covering_keys;
 
387
  key_map quick_keys, merge_keys;
 
388
  /*
 
389
    A set of keys that can be used in the query that references this
 
390
    table.
 
391
 
 
392
    All indexes disabled on the table's TABLE_SHARE (see TABLE::s) will be 
 
393
    subtracted from this set upon instantiation. Thus for any TABLE t it holds
 
394
    that t.keys_in_use_for_query is a subset of t.s.keys_in_use. Generally we 
 
395
    must not introduce any new keys here (see setup_tables).
 
396
 
 
397
    The set is implemented as a bitmap.
 
398
  */
 
399
  key_map keys_in_use_for_query;
 
400
  /* Map of keys that can be used to calculate GROUP BY without sorting */
 
401
  key_map keys_in_use_for_group_by;
 
402
  /* Map of keys that can be used to calculate ORDER BY without sorting */
 
403
  key_map keys_in_use_for_order_by;
 
404
  KEY  *key_info;                       /* data of keys in database */
 
405
 
 
406
  Field *next_number_field;             /* Set if next_number is activated */
 
407
  Field *found_next_number_field;       /* Set on open */
 
408
  Field_timestamp *timestamp_field;
 
409
 
 
410
  /* Table's triggers, 0 if there are no of them */
 
411
  Table_triggers_list *triggers;
 
412
  TABLE_LIST *pos_in_table_list;/* Element referring to this table */
 
413
  ORDER         *group;
 
414
  const char    *alias;                   /* alias or table name */
 
415
  uchar         *null_flags;
 
416
  my_bitmap_map *bitmap_init_value;
 
417
  MY_BITMAP     def_read_set, def_write_set, tmp_set; /* containers */
 
418
  MY_BITMAP     *read_set, *write_set;          /* Active column sets */
 
419
  /*
 
420
   The ID of the query that opened and is using this table. Has different
 
421
   meanings depending on the table type.
 
422
 
 
423
   Temporary tables:
 
424
 
 
425
   table->query_id is set to thd->query_id for the duration of a statement
 
426
   and is reset to 0 once it is closed by the same statement. A non-zero
 
427
   table->query_id means that a statement is using the table even if it's
 
428
   not the current statement (table is in use by some outer statement).
 
429
 
 
430
   Non-temporary tables:
 
431
 
 
432
   Under pre-locked or LOCK TABLES mode: query_id is set to thd->query_id
 
433
   for the duration of a statement and is reset to 0 once it is closed by
 
434
   the same statement. A non-zero query_id is used to control which tables
 
435
   in the list of pre-opened and locked tables are actually being used.
 
436
  */
 
437
  query_id_t    query_id;
 
438
 
 
439
  /* 
 
440
    For each key that has quick_keys.is_set(key) == true: estimate of #records
 
441
    and max #key parts that range access would use.
 
442
  */
 
443
  ha_rows       quick_rows[MAX_KEY];
 
444
 
 
445
  /* Bitmaps of key parts that =const for the entire join. */
 
446
  key_part_map  const_key_parts[MAX_KEY];
 
447
 
 
448
  uint          quick_key_parts[MAX_KEY];
 
449
  uint          quick_n_ranges[MAX_KEY];
 
450
 
 
451
  /* 
 
452
    Estimate of number of records that satisfy SARGable part of the table
 
453
    condition, or table->file->records if no SARGable condition could be
 
454
    constructed.
 
455
    This value is used by join optimizer as an estimate of number of records
 
456
    that will pass the table condition (condition that depends on fields of 
 
457
    this table and constants)
 
458
  */
 
459
  ha_rows       quick_condition_rows;
 
460
 
 
461
  /*
 
462
    If this table has TIMESTAMP field with auto-set property (pointed by
 
463
    timestamp_field member) then this variable indicates during which
 
464
    operations (insert only/on update/in both cases) we should set this
 
465
    field to current timestamp. If there are no such field in this table
 
466
    or we should not automatically set its value during execution of current
 
467
    statement then the variable contains TIMESTAMP_NO_AUTO_SET (i.e. 0).
 
468
 
 
469
    Value of this variable is set for each statement in open_table() and
 
470
    if needed cleared later in statement processing code (see mysql_update()
 
471
    as example).
 
472
  */
 
473
  timestamp_auto_set_type timestamp_field_type;
 
474
  table_map     map;                    /* ID bit of table (1,2,4,8,16...) */
 
475
 
 
476
  uint          lock_position;          /* Position in MYSQL_LOCK.table */
 
477
  uint          lock_data_start;        /* Start pos. in MYSQL_LOCK.locks */
 
478
  uint          lock_count;             /* Number of locks */
 
479
  uint          tablenr,used_fields;
 
480
  uint          temp_pool_slot;         /* Used by intern temp tables */
 
481
  uint          status;                 /* What's in record[0] */
 
482
  uint          db_stat;                /* mode of file as in handler.h */
196
483
  /* number of select if it is derived table */
197
 
  uint32_t derived_select_number;
198
 
  int current_lock; /**< Type of lock on table */
199
 
  bool copy_blobs; /**< Should blobs by copied when storing? */
 
484
  uint          derived_select_number;
 
485
  int           current_lock;           /* Type of lock on table */
 
486
  my_bool copy_blobs;                   /* copy_blobs when storing */
200
487
 
201
488
  /*
202
489
    0 or JOIN_TYPE_{LEFT|RIGHT}. Currently this is only compared to 0.
203
490
    If maybe_null !=0, this table is inner w.r.t. some outer join operation,
204
491
    and null_row may be true.
205
492
  */
206
 
  bool maybe_null;
207
 
 
 
493
  uint maybe_null;
208
494
  /*
209
 
    If true, the current table row is considered to have all columns set to
 
495
    If true, the current table row is considered to have all columns set to 
210
496
    NULL, including columns declared as "not null" (see maybe_null).
211
497
  */
212
 
  bool null_row;
 
498
  my_bool null_row;
213
499
 
214
 
  bool force_index;
215
 
  bool distinct;
216
 
  bool const_table;
217
 
  bool no_rows;
218
 
  bool key_read;
219
 
  bool no_keyread;
 
500
  /*
 
501
    TODO: Each of the following flags take up 8 bits. They can just as easily
 
502
    be put into one single unsigned long and instead of taking up 18
 
503
    bytes, it would take up 4.
 
504
  */
 
505
  my_bool force_index;
 
506
  my_bool distinct,const_table,no_rows;
 
507
  my_bool key_read, no_keyread;
220
508
  /*
221
509
    Placeholder for an open table which prevents other connections
222
510
    from taking name-locks on this table. Typically used with
223
 
    TableShare::version member to take an exclusive name-lock on
 
511
    TABLE_SHARE::version member to take an exclusive name-lock on
224
512
    this table name -- a name lock that not only prevents other
225
513
    threads from opening the table, but also blocks other name
226
514
    locks. This is achieved by:
230
518
    - setting version to 0 - this will force other threads to close
231
519
      the instance of this table and wait (this is the same approach
232
520
      as used for usual name locks).
233
 
    An exclusively name-locked table currently can have no Cursor
 
521
    An exclusively name-locked table currently can have no handler
234
522
    object associated with it (db_stat is always 0), but please do
235
523
    not rely on that.
236
524
  */
237
 
  bool open_placeholder;
238
 
  bool locked_by_name;
239
 
  bool no_cache;
 
525
  my_bool open_placeholder;
 
526
  my_bool locked_by_logger;
 
527
  my_bool no_replicate;
 
528
  my_bool locked_by_name;
 
529
  my_bool no_cache;
 
530
  /* To signal that the table is associated with a HANDLER statement */
 
531
  my_bool open_by_handler;
240
532
  /*
241
533
    To indicate that a non-null value of the auto_increment field
242
534
    was provided by the user or retrieved from the current record.
243
535
    Used only in the MODE_NO_AUTO_VALUE_ON_ZERO mode.
244
536
  */
245
 
  bool auto_increment_field_not_null;
246
 
  bool alias_name_used; /* true if table_name is alias */
247
 
 
248
 
  /*
249
 
   The ID of the query that opened and is using this table. Has different
250
 
   meanings depending on the table type.
251
 
 
252
 
   Temporary tables:
253
 
 
254
 
   table->query_id is set to session->query_id for the duration of a statement
255
 
   and is reset to 0 once it is closed by the same statement. A non-zero
256
 
   table->query_id means that a statement is using the table even if it's
257
 
   not the current statement (table is in use by some outer statement).
258
 
 
259
 
   Non-temporary tables:
260
 
 
261
 
   Under pre-locked or LOCK TABLES mode: query_id is set to session->query_id
262
 
   for the duration of a statement and is reset to 0 once it is closed by
263
 
   the same statement. A non-zero query_id is used to control which tables
264
 
   in the list of pre-opened and locked tables are actually being used.
265
 
  */
266
 
  query_id_t query_id;
267
 
 
268
 
  /**
269
 
   * Estimate of number of records that satisfy SARGable part of the table
270
 
   * condition, or table->cursor->records if no SARGable condition could be
271
 
   * constructed.
272
 
   * This value is used by join optimizer as an estimate of number of records
273
 
   * that will pass the table condition (condition that depends on fields of
274
 
   * this table and constants)
275
 
   */
276
 
  ha_rows quick_condition_rows;
277
 
 
278
 
  /*
279
 
    If this table has TIMESTAMP field with auto-set property (pointed by
280
 
    timestamp_field member) then this variable indicates during which
281
 
    operations (insert only/on update/in both cases) we should set this
282
 
    field to current timestamp. If there are no such field in this table
283
 
    or we should not automatically set its value during execution of current
284
 
    statement then the variable contains TIMESTAMP_NO_AUTO_SET (i.e. 0).
285
 
 
286
 
    Value of this variable is set for each statement in open_table() and
287
 
    if needed cleared later in statement processing code (see update_query()
288
 
    as example).
289
 
  */
290
 
  timestamp_auto_set_type timestamp_field_type;
291
 
  table_map map; ///< ID bit of table (1,2,4,8,16...)
292
 
 
293
 
  RegInfo reginfo; /* field connections */
294
 
 
295
 
  /*
296
 
    Map of keys that can be used to retrieve all data from this table
297
 
    needed by the query without reading the row.
298
 
  */
299
 
  key_map covering_keys;
300
 
  key_map quick_keys;
301
 
  key_map merge_keys;
302
 
 
303
 
  /*
304
 
    A set of keys that can be used in the query that references this
305
 
    table.
306
 
 
307
 
    All indexes disabled on the table's TableShare (see Table::s) will be
308
 
    subtracted from this set upon instantiation. Thus for any Table t it holds
309
 
    that t.keys_in_use_for_query is a subset of t.s.keys_in_use. Generally we
310
 
    must not introduce any new keys here (see setup_tables).
311
 
 
312
 
    The set is implemented as a bitmap.
313
 
  */
314
 
  key_map keys_in_use_for_query;
315
 
 
316
 
  /* Map of keys that can be used to calculate GROUP BY without sorting */
317
 
  key_map keys_in_use_for_group_by;
318
 
 
319
 
  /* Map of keys that can be used to calculate ORDER BY without sorting */
320
 
  key_map keys_in_use_for_order_by;
321
 
 
322
 
  /*
323
 
    For each key that has quick_keys.test(key) == true: estimate of #records
324
 
    and max #key parts that range access would use.
325
 
  */
326
 
  ha_rows quick_rows[MAX_KEY];
327
 
 
328
 
  /* Bitmaps of key parts that =const for the entire join. */
329
 
  key_part_map  const_key_parts[MAX_KEY];
330
 
 
331
 
  uint32_t quick_key_parts[MAX_KEY];
332
 
  uint32_t quick_n_ranges[MAX_KEY];
333
 
 
334
 
private:
335
 
  memory::Root mem_root;
336
 
 
337
 
  void init_mem_root()
338
 
  {
339
 
    init_sql_alloc(&mem_root, TABLE_ALLOC_BLOCK_SIZE, 0);
340
 
  }
341
 
public:
342
 
  memory::Root *getMemRoot()
343
 
  {
344
 
    if (not mem_root.alloc_root_inited())
345
 
    {
346
 
      init_mem_root();
347
 
    }
348
 
 
349
 
    return &mem_root;
350
 
  }
351
 
 
352
 
  void *alloc_root(size_t arg)
353
 
  {
354
 
    if (not mem_root.alloc_root_inited())
355
 
    {
356
 
      init_mem_root();
357
 
    }
358
 
 
359
 
    return mem_root.alloc_root(arg);
360
 
  }
361
 
 
362
 
  char *strmake_root(const char *str_arg, size_t len_arg)
363
 
  {
364
 
    if (not mem_root.alloc_root_inited())
365
 
    {
366
 
      init_mem_root();
367
 
    }
368
 
 
369
 
    return mem_root.strmake_root(str_arg, len_arg);
370
 
  }
371
 
 
372
 
  filesort_info sort;
373
 
 
374
 
  Table();
375
 
  virtual ~Table();
376
 
 
377
 
  int report_error(int error);
378
 
  /**
379
 
   * Free information allocated by openfrm
380
 
   *
381
 
   * @param If true if we also want to free table_share
382
 
   * @note this should all be the destructor
383
 
   */
384
 
  int delete_table(bool free_share= false);
385
 
 
386
 
  void resetTable(Session *session, TableShare *share, uint32_t db_stat_arg);
387
 
 
388
 
  /* SHARE methods */
389
 
  virtual const TableShare *getShare() const= 0; /* Get rid of this long term */
390
 
  virtual TableShare *getMutableShare()= 0; /* Get rid of this long term */
391
 
  virtual bool hasShare() const= 0; /* Get rid of this long term */
392
 
  virtual void setShare(TableShare *new_share)= 0; /* Get rid of this long term */
393
 
 
394
 
  virtual void release(void)= 0;
395
 
 
396
 
  uint32_t sizeKeys() { return getMutableShare()->sizeKeys(); }
397
 
  uint32_t sizeFields() { return getMutableShare()->sizeFields(); }
398
 
  uint32_t getRecordLength() const { return getShare()->getRecordLength(); }
399
 
  uint32_t sizeBlobFields() { return getMutableShare()->blob_fields; }
400
 
  uint32_t *getBlobField() { return &getMutableShare()->blob_field[0]; }
401
 
 
402
 
public:
403
 
  virtual bool hasVariableWidth() const
404
 
  {
405
 
    return getShare()->hasVariableWidth(); // We should calculate this.
406
 
  }
407
 
 
408
 
  virtual void setVariableWidth(void);
409
 
 
410
 
  Field_blob *getBlobFieldAt(uint32_t arg) const
411
 
  {
412
 
    if (arg < getShare()->blob_fields)
413
 
      return (Field_blob*) field[getShare()->blob_field[arg]]; /*NOTE: Using 'Table.field' NOT SharedTable.field. */
414
 
 
415
 
    return NULL;
416
 
  }
417
 
  inline uint8_t getBlobPtrSize() const { return getShare()->sizeBlobPtr(); }
418
 
  inline uint32_t getNullBytes() const { return getShare()->null_bytes; }
419
 
  inline uint32_t getNullFields() const { return getShare()->null_fields; }
420
 
  inline unsigned char *getDefaultValues() { return  getMutableShare()->getDefaultValues(); }
421
 
  inline const char *getSchemaName()  const { return getShare()->getSchemaName(); }
422
 
  inline const char *getTableName()  const { return getShare()->getTableName(); }
423
 
 
424
 
  inline bool isDatabaseLowByteFirst() const { return getShare()->db_low_byte_first; } /* Portable row format */
425
 
  inline bool isNameLock() const { return open_placeholder; }
426
 
 
427
 
  uint32_t index_flags(uint32_t idx) const;
428
 
 
429
 
  inline plugin::StorageEngine *getEngine() const   /* table_type for handler */
430
 
  {
431
 
    return getShare()->getEngine();
432
 
  }
433
 
 
434
 
  Cursor &getCursor() const /* table_type for handler */
435
 
  {
436
 
    assert(cursor);
437
 
    return *cursor;
438
 
  }
439
 
 
440
 
  size_t max_row_length(const unsigned char *data);
441
 
  uint32_t find_shortest_key(const key_map *usable_keys);
442
 
  bool compare_record(Field **ptr);
443
 
  bool records_are_comparable();
444
 
  bool compare_records();
445
 
  /* TODO: the (re)storeRecord's may be able to be further condensed */
446
 
  void storeRecord();
447
 
  void storeRecordAsInsert();
448
 
  void storeRecordAsDefault();
449
 
  void restoreRecord();
450
 
  void restoreRecordAsDefault();
451
 
  void emptyRecord();
452
 
 
453
 
 
454
 
  /* See if this can be blown away */
455
 
  inline uint32_t getDBStat () { return db_stat; }
456
 
  inline uint32_t setDBStat () { return db_stat; }
457
 
  /**
458
 
   * Create Item_field for each column in the table.
459
 
   *
460
 
   * @param[out] a pointer to an empty list used to store items
461
 
   *
462
 
   * @details
463
 
   *
464
 
   * Create Item_field object for each column in the table and
465
 
   * initialize it with the corresponding Field. New items are
466
 
   * created in the current Session memory root.
467
 
   *
468
 
   * @retval
469
 
   *  false on success
470
 
   * @retval
471
 
   *  true when out of memory
472
 
   */
 
537
  my_bool auto_increment_field_not_null;
 
538
  my_bool insert_or_update;             /* Can be used by the handler */
 
539
  my_bool alias_name_used;              /* true if table_name is alias */
 
540
  my_bool get_fields_in_item_tree;      /* Signal to fix_field */
 
541
 
 
542
  REGINFO reginfo;                      /* field connections */
 
543
  MEM_ROOT mem_root;
 
544
  FILESORT_INFO sort;
 
545
 
473
546
  bool fill_item_list(List<Item> *item_list) const;
 
547
  void reset_item_list(List<Item> *item_list) const;
474
548
  void clear_column_bitmaps(void);
475
549
  void prepare_for_position(void);
476
 
  void mark_columns_used_by_index_no_reset(uint32_t index, boost::dynamic_bitset<>& bitmap);
477
 
  void mark_columns_used_by_index_no_reset(uint32_t index);
478
 
  void mark_columns_used_by_index(uint32_t index);
 
550
  void mark_columns_used_by_index_no_reset(uint index, MY_BITMAP *map);
 
551
  void mark_columns_used_by_index(uint index);
479
552
  void restore_column_maps_after_mark_index();
480
553
  void mark_auto_increment_column(void);
481
554
  void mark_columns_needed_for_update(void);
482
555
  void mark_columns_needed_for_delete(void);
483
556
  void mark_columns_needed_for_insert(void);
484
 
  void column_bitmaps_set(boost::dynamic_bitset<>& read_set_arg,
485
 
                          boost::dynamic_bitset<>& write_set_arg);
486
 
 
487
 
  void restore_column_map(const boost::dynamic_bitset<>& old);
488
 
 
489
 
  const boost::dynamic_bitset<> use_all_columns(boost::dynamic_bitset<>& map);
 
557
  inline void column_bitmaps_set(MY_BITMAP *read_set_arg,
 
558
                                 MY_BITMAP *write_set_arg)
 
559
  {
 
560
    read_set= read_set_arg;
 
561
    write_set= write_set_arg;
 
562
    if (file)
 
563
      file->column_bitmaps_signal();
 
564
  }
 
565
  inline void column_bitmaps_set_no_signal(MY_BITMAP *read_set_arg,
 
566
                                           MY_BITMAP *write_set_arg)
 
567
  {
 
568
    read_set= read_set_arg;
 
569
    write_set= write_set_arg;
 
570
  }
490
571
  inline void use_all_columns()
491
572
  {
492
 
    column_bitmaps_set(getMutableShare()->all_set, getMutableShare()->all_set);
 
573
    column_bitmaps_set(&s->all_set, &s->all_set);
493
574
  }
494
 
 
495
575
  inline void default_column_bitmaps()
496
576
  {
497
577
    read_set= &def_read_set;
498
578
    write_set= &def_write_set;
499
579
  }
500
 
 
501
 
  /* Both of the below should go away once we can move this bit to the field objects */
502
 
  inline bool isReadSet(uint32_t index) const
503
 
  {
504
 
    return read_set->test(index);
505
 
  }
506
 
 
507
 
  inline void setReadSet(uint32_t index)
508
 
  {
509
 
    read_set->set(index);
510
 
  }
511
 
 
512
 
  inline void setReadSet()
513
 
  {
514
 
    read_set->set();
515
 
  }
516
 
 
517
 
  inline void clearReadSet(uint32_t index)
518
 
  {
519
 
    read_set->reset(index);
520
 
  }
521
 
 
522
 
  inline void clearReadSet()
523
 
  {
524
 
    read_set->reset();
525
 
  }
526
 
 
527
 
  inline bool isWriteSet(uint32_t index)
528
 
  {
529
 
    return write_set->test(index);
530
 
  }
531
 
 
532
 
  inline void setWriteSet(uint32_t index)
533
 
  {
534
 
    write_set->set(index);
535
 
  }
536
 
 
537
 
  inline void setWriteSet()
538
 
  {
539
 
    write_set->set();
540
 
  }
541
 
 
542
 
  inline void clearWriteSet(uint32_t index)
543
 
  {
544
 
    write_set->reset(index);
545
 
  }
546
 
 
547
 
  inline void clearWriteSet()
548
 
  {
549
 
    write_set->reset();
550
 
  }
551
 
 
552
580
  /* Is table open or should be treated as such by name-locking? */
553
 
  inline bool is_name_opened()
554
 
  {
555
 
    return db_stat || open_placeholder;
556
 
  }
557
 
 
 
581
  inline bool is_name_opened() { return db_stat || open_placeholder; }
558
582
  /*
559
583
    Is this instance of the table should be reopen or represents a name-lock?
560
584
  */
561
 
  bool needs_reopen_or_name_lock() const;
562
 
 
563
 
  /**
564
 
    clean/setup table fields and map.
565
 
 
566
 
    @param table        Table structure pointer (which should be setup)
567
 
    @param table_list   TableList structure pointer (owner of Table)
568
 
    @param tablenr     table number
569
 
  */
570
 
  void setup_table_map(TableList *table_list, uint32_t tablenr);
571
 
  inline void mark_as_null_row()
572
 
  {
573
 
    null_row= 1;
574
 
    status|= STATUS_NULL_ROW;
575
 
    memset(null_flags, 255, getShare()->null_bytes);
576
 
  }
577
 
 
578
 
  void free_io_cache();
579
 
  void filesort_free_buffers(bool full= false);
580
 
  void intern_close_table();
581
 
 
582
 
  void print_error(int error, myf errflag) const;
583
 
 
584
 
  /**
585
 
    @return
586
 
    key if error because of duplicated keys
587
 
  */
588
 
  uint32_t get_dup_key(int error) const
589
 
  {
590
 
    cursor->errkey  = (uint32_t) -1;
591
 
    if (error == HA_ERR_FOUND_DUPP_KEY || error == HA_ERR_FOREIGN_DUPLICATE_KEY ||
592
 
        error == HA_ERR_FOUND_DUPP_UNIQUE ||
593
 
        error == HA_ERR_DROP_INDEX_FK)
594
 
      cursor->info(HA_STATUS_ERRKEY | HA_STATUS_NO_LOCK);
595
 
 
596
 
    return(cursor->errkey);
597
 
  }
598
 
 
599
 
  /*
600
 
    This is a short term fix. Long term we will used the TableIdentifier to do the actual comparison.
601
 
  */
602
 
  bool operator<(const Table &right) const
603
 
  {
604
 
    return getShare()->getCacheKey() < right.getShare()->getCacheKey();
605
 
  }
606
 
 
607
 
  static bool compare(const Table *a, const Table *b)
608
 
  {
609
 
    return *a < *b;
610
 
  }
611
 
 
612
 
  friend std::ostream& operator<<(std::ostream& output, const Table &table)
613
 
  {
614
 
    if (table.getShare())
615
 
    {
616
 
      output << "Table:(";
617
 
      output << table.getShare()->getSchemaName();
618
 
      output << ", ";
619
 
      output <<  table.getShare()->getTableName();
620
 
      output << ", ";
621
 
      output <<  table.getShare()->getTableTypeAsString();
622
 
      output << ")";
623
 
    }
624
 
    else
625
 
    {
626
 
      output << "Table:(has no share)";
627
 
    }
628
 
 
629
 
    return output;  // for multiple << operators.
630
 
  }
631
 
 
632
 
public:
633
 
  virtual bool isPlaceHolder(void) const
634
 
  {
635
 
    return false;
636
 
  }
637
 
};
638
 
 
639
 
/**
640
 
 * @class
641
 
 *  ForeignKeyInfo
642
 
 *
643
 
 * @brief
644
 
 *  This class defines the information for foreign keys.
645
 
 */
646
 
class ForeignKeyInfo
647
 
{
648
 
public:
649
 
    /**
650
 
     * @brief
651
 
     *  This is the constructor with all properties set.
652
 
     *
653
 
     * @param[in] in_foreign_id The id of the foreign key
654
 
     * @param[in] in_referenced_db The referenced database name of the foreign key
655
 
     * @param[in] in_referenced_table The referenced table name of the foreign key
656
 
     * @param[in] in_update_method The update method of the foreign key.
657
 
     * @param[in] in_delete_method The delete method of the foreign key.
658
 
     * @param[in] in_referenced_key_name The name of referenced key
659
 
     * @param[in] in_foreign_fields The foreign fields
660
 
     * @param[in] in_referenced_fields The referenced fields
661
 
     */
662
 
    ForeignKeyInfo(LEX_STRING *in_foreign_id,
663
 
                   LEX_STRING *in_referenced_db,
664
 
                   LEX_STRING *in_referenced_table,
665
 
                   LEX_STRING *in_update_method,
666
 
                   LEX_STRING *in_delete_method,
667
 
                   LEX_STRING *in_referenced_key_name,
668
 
                   List<LEX_STRING> in_foreign_fields,
669
 
                   List<LEX_STRING> in_referenced_fields)
670
 
    :
671
 
      foreign_id(in_foreign_id),
672
 
      referenced_db(in_referenced_db),
673
 
      referenced_table(in_referenced_table),
674
 
      update_method(in_update_method),
675
 
      delete_method(in_delete_method),
676
 
      referenced_key_name(in_referenced_key_name),
677
 
      foreign_fields(in_foreign_fields),
678
 
      referenced_fields(in_referenced_fields)
679
 
    {}
680
 
 
681
 
    /**
682
 
     * @brief
683
 
     *  This is the default constructor. All properties are set to default values for their types.
684
 
     */
685
 
    ForeignKeyInfo()
686
 
    : foreign_id(NULL), referenced_db(NULL), referenced_table(NULL),
687
 
      update_method(NULL), delete_method(NULL), referenced_key_name(NULL)
688
 
    {}
689
 
 
690
 
    /**
691
 
     * @brief
692
 
     *  Gets the foreign id.
693
 
     *
694
 
     * @ retval  the foreign id
695
 
     */
696
 
    const LEX_STRING *getForeignId() const
697
 
    {
698
 
        return foreign_id;
699
 
    }
700
 
 
701
 
    /**
702
 
     * @brief
703
 
     *  Gets the name of the referenced database.
704
 
     *
705
 
     * @ retval  the name of the referenced database
706
 
     */
707
 
    const LEX_STRING *getReferencedDb() const
708
 
    {
709
 
        return referenced_db;
710
 
    }
711
 
 
712
 
    /**
713
 
     * @brief
714
 
     *  Gets the name of the referenced table.
715
 
     *
716
 
     * @ retval  the name of the referenced table
717
 
     */
718
 
    const LEX_STRING *getReferencedTable() const
719
 
    {
720
 
        return referenced_table;
721
 
    }
722
 
 
723
 
    /**
724
 
     * @brief
725
 
     *  Gets the update method.
726
 
     *
727
 
     * @ retval  the update method
728
 
     */
729
 
    const LEX_STRING *getUpdateMethod() const
730
 
    {
731
 
        return update_method;
732
 
    }
733
 
 
734
 
    /**
735
 
     * @brief
736
 
     *  Gets the delete method.
737
 
     *
738
 
     * @ retval  the delete method
739
 
     */
740
 
    const LEX_STRING *getDeleteMethod() const
741
 
    {
742
 
        return delete_method;
743
 
    }
744
 
 
745
 
    /**
746
 
     * @brief
747
 
     *  Gets the name of the referenced key.
748
 
     *
749
 
     * @ retval  the name of the referenced key
750
 
     */
751
 
    const LEX_STRING *getReferencedKeyName() const
752
 
    {
753
 
        return referenced_key_name;
754
 
    }
755
 
 
756
 
    /**
757
 
     * @brief
758
 
     *  Gets the foreign fields.
759
 
     *
760
 
     * @ retval  the foreign fields
761
 
     */
762
 
    const List<LEX_STRING> &getForeignFields() const
763
 
    {
764
 
        return foreign_fields;
765
 
    }
766
 
 
767
 
    /**
768
 
     * @brief
769
 
     *  Gets the referenced fields.
770
 
     *
771
 
     * @ retval  the referenced fields
772
 
     */
773
 
    const List<LEX_STRING> &getReferencedFields() const
774
 
    {
775
 
        return referenced_fields;
776
 
    }
777
 
private:
778
 
    /**
779
 
     * The foreign id.
780
 
     */
781
 
    LEX_STRING *foreign_id;
782
 
    /**
783
 
     * The name of the reference database.
784
 
     */
785
 
    LEX_STRING *referenced_db;
786
 
    /**
787
 
     * The name of the reference table.
788
 
     */
789
 
    LEX_STRING *referenced_table;
790
 
    /**
791
 
     * The update method.
792
 
     */
793
 
    LEX_STRING *update_method;
794
 
    /**
795
 
     * The delete method.
796
 
     */
797
 
    LEX_STRING *delete_method;
798
 
    /**
799
 
     * The name of the referenced key.
800
 
     */
801
 
    LEX_STRING *referenced_key_name;
802
 
    /**
803
 
     * The foreign fields.
804
 
     */
805
 
    List<LEX_STRING> foreign_fields;
806
 
    /**
807
 
     * The referenced fields.
808
 
     */
809
 
    List<LEX_STRING> referenced_fields;
810
 
};
811
 
 
812
 
class TableList;
813
 
 
814
 
#define JOIN_TYPE_LEFT  1
815
 
#define JOIN_TYPE_RIGHT 2
 
585
  inline bool needs_reopen_or_name_lock()
 
586
  { return s->version != refresh_version; }
 
587
};
 
588
 
 
589
enum enum_schema_table_state
 
590
{ 
 
591
  NOT_PROCESSED= 0,
 
592
  PROCESSED_BY_CREATE_SORT_INDEX,
 
593
  PROCESSED_BY_JOIN_EXEC
 
594
};
 
595
 
 
596
typedef struct st_foreign_key_info
 
597
{
 
598
  LEX_STRING *forein_id;
 
599
  LEX_STRING *referenced_db;
 
600
  LEX_STRING *referenced_table;
 
601
  LEX_STRING *update_method;
 
602
  LEX_STRING *delete_method;
 
603
  LEX_STRING *referenced_key_name;
 
604
  List<LEX_STRING> foreign_fields;
 
605
  List<LEX_STRING> referenced_fields;
 
606
} FOREIGN_KEY_INFO;
 
607
 
 
608
/*
 
609
  Make sure that the order of schema_tables and enum_schema_tables are the same.
 
610
*/
 
611
 
 
612
enum enum_schema_tables
 
613
{
 
614
  SCH_CHARSETS= 0,
 
615
  SCH_COLLATIONS,
 
616
  SCH_COLLATION_CHARACTER_SET_APPLICABILITY,
 
617
  SCH_COLUMNS,
 
618
  SCH_GLOBAL_STATUS,
 
619
  SCH_GLOBAL_VARIABLES,
 
620
  SCH_KEY_COLUMN_USAGE,
 
621
  SCH_OPEN_TABLES,
 
622
  SCH_PLUGINS,
 
623
  SCH_PROCESSLIST,
 
624
  SCH_REFERENTIAL_CONSTRAINTS,
 
625
  SCH_SCHEMATA,
 
626
  SCH_SESSION_STATUS,
 
627
  SCH_SESSION_VARIABLES,
 
628
  SCH_STATISTICS,
 
629
  SCH_STATUS,
 
630
  SCH_TABLES,
 
631
  SCH_TABLE_CONSTRAINTS,
 
632
  SCH_TABLE_NAMES,
 
633
  SCH_VARIABLES
 
634
};
 
635
 
 
636
 
 
637
#define MY_I_S_MAYBE_NULL 1
 
638
#define MY_I_S_UNSIGNED   2
 
639
 
 
640
 
 
641
#define SKIP_OPEN_TABLE 0                // do not open table
 
642
#define OPEN_FRM_ONLY   1                // open FRM file only
 
643
#define OPEN_FULL_TABLE 2                // open FRM,MYD, MYI files
 
644
 
 
645
typedef struct st_field_info
 
646
{
 
647
  /** 
 
648
      This is used as column name. 
 
649
  */
 
650
  const char* field_name;
 
651
  /**
 
652
     For string-type columns, this is the maximum number of
 
653
     characters. Otherwise, it is the 'display-length' for the column.
 
654
  */
 
655
  uint field_length;
 
656
  /**
 
657
     This denotes data type for the column. For the most part, there seems to
 
658
     be one entry in the enum for each SQL data type, although there seem to
 
659
     be a number of additional entries in the enum.
 
660
  */
 
661
  enum enum_field_types field_type;
 
662
  int value;
 
663
  /**
 
664
     This is used to set column attributes. By default, columns are @c NOT
 
665
     @c NULL and @c SIGNED, and you can deviate from the default
 
666
     by setting the appopriate flags. You can use either one of the flags
 
667
     @c MY_I_S_MAYBE_NULL and @cMY_I_S_UNSIGNED or
 
668
     combine them using the bitwise or operator @c |. Both flags are
 
669
     defined in table.h.
 
670
   */
 
671
  uint field_flags;        // Field atributes(maybe_null, signed, unsigned etc.)
 
672
  const char* old_name;
 
673
  /**
 
674
     This should be one of @c SKIP_OPEN_TABLE,
 
675
     @c OPEN_FRM_ONLY or @c OPEN_FULL_TABLE.
 
676
  */
 
677
  uint open_method;
 
678
} ST_FIELD_INFO;
 
679
 
 
680
 
 
681
struct TABLE_LIST;
 
682
typedef class Item COND;
 
683
 
 
684
typedef struct st_schema_table
 
685
{
 
686
  const char* table_name;
 
687
  ST_FIELD_INFO *fields_info;
 
688
  /* Create information_schema table */
 
689
  TABLE *(*create_table)  (THD *thd, TABLE_LIST *table_list);
 
690
  /* Fill table with data */
 
691
  int (*fill_table) (THD *thd, TABLE_LIST *tables, COND *cond);
 
692
  /* Handle fileds for old SHOW */
 
693
  int (*old_format) (THD *thd, struct st_schema_table *schema_table);
 
694
  int (*process_table) (THD *thd, TABLE_LIST *tables, TABLE *table,
 
695
                        bool res, LEX_STRING *db_name, LEX_STRING *table_name);
 
696
  int idx_field1, idx_field2; 
 
697
  bool hidden;
 
698
  uint i_s_requested_object;  /* the object we need to open(TABLE | VIEW) */
 
699
} ST_SCHEMA_TABLE;
 
700
 
 
701
 
 
702
#define JOIN_TYPE_LEFT  1
 
703
#define JOIN_TYPE_RIGHT 2
816
704
 
817
705
struct st_lex;
818
706
class select_union;
819
 
class Tmp_Table_Param;
820
 
 
821
 
void free_blobs(Table *table);
822
 
int set_zone(int nr,int min_zone,int max_zone);
823
 
uint32_t convert_period_to_month(uint32_t period);
824
 
uint32_t convert_month_to_period(uint32_t month);
825
 
 
826
 
int test_if_number(char *str,int *res,bool allow_wildcards);
827
 
void change_byte(unsigned char *,uint,char,char);
828
 
 
829
 
namespace optimizer { class SqlSelect; }
830
 
 
831
 
void change_double_for_sort(double nr,unsigned char *to);
832
 
int get_quick_record(optimizer::SqlSelect *select);
833
 
 
834
 
void find_date(char *pos,uint32_t *vek,uint32_t flag);
835
 
TYPELIB *convert_strings_to_array_type(char * *typelibs, char * *end);
836
 
TYPELIB *typelib(memory::Root *mem_root, List<String> &strings);
837
 
ulong get_form_pos(int file, unsigned char *head, TYPELIB *save_names);
838
 
void append_unescaped(String *res, const char *pos, uint32_t length);
839
 
 
840
 
DRIZZLED_API int rename_file_ext(const char * from,const char * to,const char * ext);
841
 
bool check_column_name(const char *name);
842
 
bool check_table_name(const char *name, uint32_t length);
843
 
 
844
 
} /* namespace drizzled */
845
 
 
846
 
#include <drizzled/table/singular.h>
847
 
#include <drizzled/table/concurrent.h>
848
 
 
849
 
#endif /* DRIZZLED_TABLE_H */
 
707
class TMP_TABLE_PARAM;
 
708
 
 
709
Item *create_view_field(THD *thd, TABLE_LIST *view, Item **field_ref,
 
710
                        const char *name);
 
711
 
 
712
struct Field_translator
 
713
{
 
714
  Item *item;
 
715
  const char *name;
 
716
};
 
717
 
 
718
 
 
719
/*
 
720
  Column reference of a NATURAL/USING join. Since column references in
 
721
  joins can be both from views and stored tables, may point to either a
 
722
  Field (for tables), or a Field_translator (for views).
 
723
*/
 
724
 
 
725
class Natural_join_column: public Sql_alloc
 
726
{
 
727
public:
 
728
  Field_translator *view_field;  /* Column reference of merge view. */
 
729
  Field            *table_field; /* Column reference of table or temp view. */
 
730
  TABLE_LIST *table_ref; /* Original base table/view reference. */
 
731
  /*
 
732
    True if a common join column of two NATURAL/USING join operands. Notice
 
733
    that when we have a hierarchy of nested NATURAL/USING joins, a column can
 
734
    be common at some level of nesting but it may not be common at higher
 
735
    levels of nesting. Thus this flag may change depending on at which level
 
736
    we are looking at some column.
 
737
  */
 
738
  bool is_common;
 
739
public:
 
740
  Natural_join_column(Field_translator *field_param, TABLE_LIST *tab);
 
741
  Natural_join_column(Field *field_param, TABLE_LIST *tab);
 
742
  const char *name();
 
743
  Item *create_item(THD *thd);
 
744
  Field *field();
 
745
  const char *table_name();
 
746
  const char *db_name();
 
747
};
 
748
 
 
749
 
 
750
/*
 
751
  Table reference in the FROM clause.
 
752
 
 
753
  These table references can be of several types that correspond to
 
754
  different SQL elements. Below we list all types of TABLE_LISTs with
 
755
  the necessary conditions to determine when a TABLE_LIST instance
 
756
  belongs to a certain type.
 
757
 
 
758
  1) table (TABLE_LIST::view == NULL)
 
759
     - base table
 
760
       (TABLE_LIST::derived == NULL)
 
761
     - subquery - TABLE_LIST::table is a temp table
 
762
       (TABLE_LIST::derived != NULL)
 
763
     - information schema table
 
764
       (TABLE_LIST::schema_table != NULL)
 
765
       NOTICE: for schema tables TABLE_LIST::field_translation may be != NULL
 
766
  2) view (TABLE_LIST::view != NULL)
 
767
     - merge    (TABLE_LIST::effective_algorithm == VIEW_ALGORITHM_MERGE)
 
768
           also (TABLE_LIST::field_translation != NULL)
 
769
     - tmptable (TABLE_LIST::effective_algorithm == VIEW_ALGORITHM_TMPTABLE)
 
770
           also (TABLE_LIST::field_translation == NULL)
 
771
  3) nested table reference (TABLE_LIST::nested_join != NULL)
 
772
     - table sequence - e.g. (t1, t2, t3)
 
773
       TODO: how to distinguish from a JOIN?
 
774
     - general JOIN
 
775
       TODO: how to distinguish from a table sequence?
 
776
     - NATURAL JOIN
 
777
       (TABLE_LIST::natural_join != NULL)
 
778
       - JOIN ... USING
 
779
         (TABLE_LIST::join_using_fields != NULL)
 
780
     - semi-join
 
781
       ;
 
782
*/
 
783
 
 
784
class Index_hint;
 
785
struct TABLE_LIST
 
786
{
 
787
  TABLE_LIST() {}                          /* Remove gcc warning */
 
788
 
 
789
  /**
 
790
    Prepare TABLE_LIST that consists of one table instance to use in
 
791
    simple_open_and_lock_tables
 
792
  */
 
793
  inline void init_one_table(const char *db_name_arg,
 
794
                             const char *table_name_arg,
 
795
                             enum thr_lock_type lock_type_arg)
 
796
  {
 
797
    memset(this, 0, sizeof(*this));
 
798
    db= (char*) db_name_arg;
 
799
    table_name= alias= (char*) table_name_arg;
 
800
    lock_type= lock_type_arg;
 
801
  }
 
802
 
 
803
  /*
 
804
    List of tables local to a subquery (used by SQL_LIST). Considers
 
805
    views as leaves (unlike 'next_leaf' below). Created at parse time
 
806
    in st_select_lex::add_table_to_list() -> table_list.link_in_list().
 
807
  */
 
808
  TABLE_LIST *next_local;
 
809
  /* link in a global list of all queries tables */
 
810
  TABLE_LIST *next_global, **prev_global;
 
811
  char          *db, *alias, *table_name, *schema_table_name;
 
812
  char          *option;                /* Used by cache index  */
 
813
  Item          *on_expr;               /* Used with outer join */
 
814
  Item          *sj_on_expr;
 
815
  /*
 
816
    (Valid only for semi-join nests) Bitmap of tables that are within the
 
817
    semi-join (this is different from bitmap of all nest's children because
 
818
    tables that were pulled out of the semi-join nest remain listed as
 
819
    nest's children).
 
820
  */
 
821
  table_map     sj_inner_tables;
 
822
  /* Number of IN-compared expressions */
 
823
  uint          sj_in_exprs; 
 
824
  /*
 
825
    The structure of ON expression presented in the member above
 
826
    can be changed during certain optimizations. This member
 
827
    contains a snapshot of AND-OR structure of the ON expression
 
828
    made after permanent transformations of the parse tree, and is
 
829
    used to restore ON clause before every reexecution of a prepared
 
830
    statement or stored procedure.
 
831
  */
 
832
  Item          *prep_on_expr;
 
833
  COND_EQUAL    *cond_equal;            /* Used with outer join */
 
834
  /*
 
835
    During parsing - left operand of NATURAL/USING join where 'this' is
 
836
    the right operand. After parsing (this->natural_join == this) iff
 
837
    'this' represents a NATURAL or USING join operation. Thus after
 
838
    parsing 'this' is a NATURAL/USING join iff (natural_join != NULL).
 
839
  */
 
840
  TABLE_LIST *natural_join;
 
841
  /*
 
842
    True if 'this' represents a nested join that is a NATURAL JOIN.
 
843
    For one of the operands of 'this', the member 'natural_join' points
 
844
    to the other operand of 'this'.
 
845
  */
 
846
  bool is_natural_join;
 
847
  /* Field names in a USING clause for JOIN ... USING. */
 
848
  List<String> *join_using_fields;
 
849
  /*
 
850
    Explicitly store the result columns of either a NATURAL/USING join or
 
851
    an operand of such a join.
 
852
  */
 
853
  List<Natural_join_column> *join_columns;
 
854
  /* true if join_columns contains all columns of this table reference. */
 
855
  bool is_join_columns_complete;
 
856
 
 
857
  /*
 
858
    List of nodes in a nested join tree, that should be considered as
 
859
    leaves with respect to name resolution. The leaves are: views,
 
860
    top-most nodes representing NATURAL/USING joins, subqueries, and
 
861
    base tables. All of these TABLE_LIST instances contain a
 
862
    materialized list of columns. The list is local to a subquery.
 
863
  */
 
864
  TABLE_LIST *next_name_resolution_table;
 
865
  /* Index names in a "... JOIN ... USE/IGNORE INDEX ..." clause. */
 
866
  List<Index_hint> *index_hints;
 
867
  TABLE        *table;                          /* opened table */
 
868
  uint          table_id; /* table id (from binlog) for opened table */
 
869
  /*
 
870
    select_result for derived table to pass it from table creation to table
 
871
    filling procedure
 
872
  */
 
873
  select_union  *derived_result;
 
874
  /*
 
875
    Reference from aux_tables to local list entry of main select of
 
876
    multi-delete statement:
 
877
    delete t1 from t2,t1 where t1.a<'B' and t2.b=t1.b;
 
878
    here it will be reference of first occurrence of t1 to second (as you
 
879
    can see this lists can't be merged)
 
880
  */
 
881
  TABLE_LIST    *correspondent_table;
 
882
  st_select_lex_unit *derived;          /* SELECT_LEX_UNIT of derived table */
 
883
  ST_SCHEMA_TABLE *schema_table;        /* Information_schema table */
 
884
  st_select_lex *schema_select_lex;
 
885
  /*
 
886
    True when the view field translation table is used to convert
 
887
    schema table fields for backwards compatibility with SHOW command.
 
888
  */
 
889
  bool schema_table_reformed;
 
890
  TMP_TABLE_PARAM *schema_table_param;
 
891
  /* link to select_lex where this table was used */
 
892
  st_select_lex *select_lex;
 
893
  Field_translator *field_translation;  /* array of VIEW fields */
 
894
  /* pointer to element after last one in translation table above */
 
895
  Field_translator *field_translation_end;
 
896
  /*
 
897
    List (based on next_local) of underlying tables of this view. I.e. it
 
898
    does not include the tables of subqueries used in the view. Is set only
 
899
    for merged views.
 
900
  */
 
901
  TABLE_LIST    *merge_underlying_list;
 
902
  /*
 
903
    - 0 for base tables
 
904
    - in case of the view it is the list of all (not only underlying
 
905
    tables but also used in subquery ones) tables of the view.
 
906
  */
 
907
  List<TABLE_LIST> *view_tables;
 
908
  /* most upper view this table belongs to */
 
909
  TABLE_LIST    *belong_to_view;
 
910
  /* Ptr to parent MERGE table list item. See top comment in ha_myisammrg.cc */
 
911
  TABLE_LIST    *parent_l;
 
912
  /*
 
913
    List of all base tables local to a subquery including all view
 
914
    tables. Unlike 'next_local', this in this list views are *not*
 
915
    leaves. Created in setup_tables() -> make_leaves_list().
 
916
  */
 
917
  TABLE_LIST    *next_leaf;
 
918
  /* data need by some engines in query cache*/
 
919
  uint64_t     engine_data;
 
920
  /* call back function for asking handler about caching in query cache */
 
921
  qc_engine_callback callback_func;
 
922
  thr_lock_type lock_type;
 
923
  uint          outer_join;             /* Which join type */
 
924
  uint          shared;                 /* Used in multi-upd */
 
925
  size_t        db_length;
 
926
  size_t        table_name_length;
 
927
  bool          straight;               /* optimize with prev table */
 
928
  bool          updating;               /* for replicate-do/ignore table */
 
929
  bool          force_index;            /* prefer index over table scan */
 
930
  bool          ignore_leaves;          /* preload only non-leaf nodes */
 
931
  table_map     dep_tables;             /* tables the table depends on      */
 
932
  table_map     on_expr_dep_tables;     /* tables on expression depends on  */
 
933
  struct st_nested_join *nested_join;   /* if the element is a nested join  */
 
934
  TABLE_LIST *embedding;             /* nested join containing the table */
 
935
  List<TABLE_LIST> *join_list;/* join list the table belongs to   */
 
936
  bool          cacheable_table;        /* stop PS caching */
 
937
  /* FRMTYPE_ERROR if any type is acceptable */
 
938
  enum frm_type_enum required_type;
 
939
  handlerton    *db_type;               /* table_type for handler */
 
940
  char          timestamp_buffer[20];   /* buffer for timestamp (19+1) */
 
941
  /*
 
942
    This TABLE_LIST object corresponds to the table to be created
 
943
    so it is possible that it does not exist (used in CREATE TABLE
 
944
    ... SELECT implementation).
 
945
  */
 
946
  bool          create;
 
947
  /* For transactional locking. */
 
948
  int           lock_timeout;           /* NOWAIT or WAIT [X]               */
 
949
  bool          lock_transactional;     /* If transactional lock requested. */
 
950
  bool          internal_tmp_table;
 
951
  /** true if an alias for this table was specified in the SQL. */
 
952
  bool          is_alias;
 
953
  /** true if the table is referred to in the statement using a fully
 
954
      qualified name (<db_name>.<table_name>).
 
955
  */
 
956
  bool          is_fqtn;
 
957
 
 
958
  uint i_s_requested_object;
 
959
  bool has_db_lookup_value;
 
960
  bool has_table_lookup_value;
 
961
  uint table_open_method;
 
962
  enum enum_schema_table_state schema_table_state;
 
963
  void set_underlying_merge();
 
964
  bool setup_underlying(THD *thd);
 
965
  void cleanup_items();
 
966
  /*
 
967
    If you change placeholder(), please check the condition in
 
968
    check_transactional_lock() too.
 
969
  */
 
970
  bool placeholder()
 
971
  {
 
972
    return derived || schema_table || (create && !table->db_stat) || !table;
 
973
  }
 
974
  void print(THD *thd, String *str, enum_query_type query_type);
 
975
  bool set_insert_values(MEM_ROOT *mem_root);
 
976
  TABLE_LIST *find_underlying_table(TABLE *table);
 
977
  TABLE_LIST *first_leaf_for_name_resolution();
 
978
  TABLE_LIST *last_leaf_for_name_resolution();
 
979
  bool is_leaf_for_name_resolution();
 
980
  inline TABLE_LIST *top_table()
 
981
    { return belong_to_view ? belong_to_view : this; }
 
982
 
 
983
  /*
 
984
    Cleanup for re-execution in a prepared statement or a stored
 
985
    procedure.
 
986
  */
 
987
  void reinit_before_use(THD *thd);
 
988
  Item_subselect *containing_subselect();
 
989
 
 
990
  /* 
 
991
    Compiles the tagged hints list and fills up st_table::keys_in_use_for_query,
 
992
    st_table::keys_in_use_for_group_by, st_table::keys_in_use_for_order_by,
 
993
    st_table::force_index and st_table::covering_keys.
 
994
  */
 
995
  bool process_index_hints(TABLE *table);
 
996
 
 
997
private:
 
998
  bool prep_where(THD *thd, Item **conds, bool no_where_clause);
 
999
  /*
 
1000
    Cleanup for re-execution in a prepared statement or a stored
 
1001
    procedure.
 
1002
  */
 
1003
};
 
1004
 
 
1005
class Item;
 
1006
 
 
1007
/*
 
1008
  Iterator over the fields of a generic table reference.
 
1009
*/
 
1010
 
 
1011
class Field_iterator: public Sql_alloc
 
1012
{
 
1013
public:
 
1014
  Field_iterator() {}                         /* Remove gcc warning */
 
1015
  virtual ~Field_iterator() {}
 
1016
  virtual void set(TABLE_LIST *)= 0;
 
1017
  virtual void next()= 0;
 
1018
  virtual bool end_of_fields()= 0;              /* Return 1 at end of list */
 
1019
  virtual const char *name()= 0;
 
1020
  virtual Item *create_item(THD *)= 0;
 
1021
  virtual Field *field()= 0;
 
1022
};
 
1023
 
 
1024
 
 
1025
/* 
 
1026
  Iterator over the fields of a base table, view with temporary
 
1027
  table, or subquery.
 
1028
*/
 
1029
 
 
1030
class Field_iterator_table: public Field_iterator
 
1031
{
 
1032
  Field **ptr;
 
1033
public:
 
1034
  Field_iterator_table() :ptr(0) {}
 
1035
  void set(TABLE_LIST *table) { ptr= table->table->field; }
 
1036
  void set_table(TABLE *table) { ptr= table->field; }
 
1037
  void next() { ptr++; }
 
1038
  bool end_of_fields() { return *ptr == 0; }
 
1039
  const char *name();
 
1040
  Item *create_item(THD *thd);
 
1041
  Field *field() { return *ptr; }
 
1042
};
 
1043
 
 
1044
 
 
1045
/* Iterator over the fields of a merge view. */
 
1046
 
 
1047
class Field_iterator_view: public Field_iterator
 
1048
{
 
1049
  Field_translator *ptr, *array_end;
 
1050
  TABLE_LIST *view;
 
1051
public:
 
1052
  Field_iterator_view() :ptr(0), array_end(0) {}
 
1053
  void set(TABLE_LIST *table);
 
1054
  void next() { ptr++; }
 
1055
  bool end_of_fields() { return ptr == array_end; }
 
1056
  const char *name();
 
1057
  Item *create_item(THD *thd);
 
1058
  Item **item_ptr() {return &ptr->item; }
 
1059
  Field *field() { return 0; }
 
1060
  inline Item *item() { return ptr->item; }
 
1061
  Field_translator *field_translator() { return ptr; }
 
1062
};
 
1063
 
 
1064
 
 
1065
/*
 
1066
  Field_iterator interface to the list of materialized fields of a
 
1067
  NATURAL/USING join.
 
1068
*/
 
1069
 
 
1070
class Field_iterator_natural_join: public Field_iterator
 
1071
{
 
1072
  List_iterator_fast<Natural_join_column> column_ref_it;
 
1073
  Natural_join_column *cur_column_ref;
 
1074
public:
 
1075
  Field_iterator_natural_join() :cur_column_ref(NULL) {}
 
1076
  ~Field_iterator_natural_join() {}
 
1077
  void set(TABLE_LIST *table);
 
1078
  void next();
 
1079
  bool end_of_fields() { return !cur_column_ref; }
 
1080
  const char *name() { return cur_column_ref->name(); }
 
1081
  Item *create_item(THD *thd) { return cur_column_ref->create_item(thd); }
 
1082
  Field *field() { return cur_column_ref->field(); }
 
1083
  Natural_join_column *column_ref() { return cur_column_ref; }
 
1084
};
 
1085
 
 
1086
 
 
1087
/*
 
1088
  Generic iterator over the fields of an arbitrary table reference.
 
1089
 
 
1090
  DESCRIPTION
 
1091
    This class unifies the various ways of iterating over the columns
 
1092
    of a table reference depending on the type of SQL entity it
 
1093
    represents. If such an entity represents a nested table reference,
 
1094
    this iterator encapsulates the iteration over the columns of the
 
1095
    members of the table reference.
 
1096
 
 
1097
  IMPLEMENTATION
 
1098
    The implementation assumes that all underlying NATURAL/USING table
 
1099
    references already contain their result columns and are linked into
 
1100
    the list TABLE_LIST::next_name_resolution_table.
 
1101
*/
 
1102
 
 
1103
class Field_iterator_table_ref: public Field_iterator
 
1104
{
 
1105
  TABLE_LIST *table_ref, *first_leaf, *last_leaf;
 
1106
  Field_iterator_table        table_field_it;
 
1107
  Field_iterator_view         view_field_it;
 
1108
  Field_iterator_natural_join natural_join_it;
 
1109
  Field_iterator *field_it;
 
1110
  void set_field_iterator();
 
1111
public:
 
1112
  Field_iterator_table_ref() :field_it(NULL) {}
 
1113
  void set(TABLE_LIST *table);
 
1114
  void next();
 
1115
  bool end_of_fields()
 
1116
  { return (table_ref == last_leaf && field_it->end_of_fields()); }
 
1117
  const char *name() { return field_it->name(); }
 
1118
  const char *table_name();
 
1119
  const char *db_name();
 
1120
  Item *create_item(THD *thd) { return field_it->create_item(thd); }
 
1121
  Field *field() { return field_it->field(); }
 
1122
  Natural_join_column *get_or_create_column_ref(TABLE_LIST *parent_table_ref);
 
1123
  Natural_join_column *get_natural_column_ref();
 
1124
};
 
1125
 
 
1126
 
 
1127
typedef struct st_nested_join
 
1128
{
 
1129
  List<TABLE_LIST>  join_list;       /* list of elements in the nested join */
 
1130
  table_map         used_tables;     /* bitmap of tables in the nested join */
 
1131
  table_map         not_null_tables; /* tables that rejects nulls           */
 
1132
  struct st_join_table *first_nested;/* the first nested table in the plan  */
 
1133
  /* 
 
1134
    Used to count tables in the nested join in 2 isolated places:
 
1135
    1. In make_outerjoin_info(). 
 
1136
    2. check_interleaving_with_nj/restore_prev_nj_state (these are called
 
1137
       by the join optimizer. 
 
1138
    Before each use the counters are zeroed by reset_nj_counters.
 
1139
  */
 
1140
  uint              counter_;
 
1141
  nested_join_map   nj_map;          /* Bit used to identify this nested join*/
 
1142
  /*
 
1143
    (Valid only for semi-join nests) Bitmap of tables outside the semi-join
 
1144
    that are used within the semi-join's ON condition.
 
1145
  */
 
1146
  table_map         sj_depends_on;
 
1147
  /* Outer non-trivially correlated tables */
 
1148
  table_map         sj_corr_tables;
 
1149
  List<Item>        sj_outer_expr_list;
 
1150
} NESTED_JOIN;
 
1151
 
 
1152
 
 
1153
typedef struct st_changed_table_list
 
1154
{
 
1155
  struct        st_changed_table_list *next;
 
1156
  char          *key;
 
1157
  uint32_t        key_length;
 
1158
} CHANGED_TABLE_LIST;
 
1159
 
 
1160
 
 
1161
typedef struct st_open_table_list{
 
1162
  struct st_open_table_list *next;
 
1163
  char  *db,*table;
 
1164
  uint32_t in_use,locked;
 
1165
} OPEN_TABLE_LIST;
 
1166
 
 
1167
typedef struct st_table_field_w_type
 
1168
{
 
1169
  LEX_STRING name;
 
1170
  LEX_STRING type;
 
1171
  LEX_STRING cset;
 
1172
} TABLE_FIELD_W_TYPE;
 
1173
 
 
1174
 
 
1175
bool
 
1176
table_check_intact(TABLE *table, const uint table_f_count,
 
1177
                   const TABLE_FIELD_W_TYPE *table_def);
 
1178
 
 
1179
static inline my_bitmap_map *tmp_use_all_columns(TABLE *table,
 
1180
                                                 MY_BITMAP *bitmap)
 
1181
{
 
1182
  my_bitmap_map *old= bitmap->bitmap;
 
1183
  bitmap->bitmap= table->s->all_set.bitmap;
 
1184
  return old;
 
1185
}
 
1186
 
 
1187
 
 
1188
static inline void tmp_restore_column_map(MY_BITMAP *bitmap,
 
1189
                                          my_bitmap_map *old)
 
1190
{
 
1191
  bitmap->bitmap= old;
 
1192
}
 
1193
 
 
1194
/* The following is only needed for debugging */
 
1195
 
 
1196
static inline my_bitmap_map *dbug_tmp_use_all_columns(TABLE *table __attribute__((unused)),
 
1197
                                                      MY_BITMAP *bitmap __attribute__((unused)))
 
1198
{
 
1199
  return 0;
 
1200
}
 
1201
 
 
1202
static inline void dbug_tmp_restore_column_map(MY_BITMAP *bitmap __attribute__((unused)),
 
1203
                                               my_bitmap_map *old __attribute__((unused)))
 
1204
{
 
1205
  return;
 
1206
}
 
1207
 
 
1208
size_t max_row_length(TABLE *table, const uchar *data);
 
1209