← 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-16 21:06:22 UTC
  • Revision ID: monty@inaugust.com-20080816210622-zpnn13unyinqzn72
Updated po files.

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
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
 
#ifndef DRIZZLED_TABLE_H
24
 
#define DRIZZLED_TABLE_H
25
 
 
26
 
#include <storage/myisam/myisam.h>
27
 
#include <drizzled/order.h>
28
 
#include <drizzled/filesort_info.h>
29
 
#include <drizzled/natural_join_column.h>
30
 
#include <drizzled/field_iterator.h>
31
 
#include <mysys/hash.h>
32
 
#include <drizzled/handler.h>
33
 
#include <drizzled/lex_string.h>
34
 
#include <drizzled/table_list.h>
35
 
 
36
 
class Item;
 
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 */
37
20
class Item_subselect;
38
21
class st_select_lex_unit;
39
22
class st_select_lex;
40
23
class COND_EQUAL;
41
24
class Security_context;
42
 
class TableList;
43
25
 
44
26
/*************************************************************************/
45
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_))
46
95
 
47
96
class Field_timestamp;
48
97
class Field_blob;
49
98
 
 
99
/**
 
100
  Category of table found in the table share.
 
101
*/
 
102
enum enum_table_category
 
103
{
 
104
  /**
 
105
    Unknown value.
 
106
  */
 
107
  TABLE_UNKNOWN_CATEGORY=0,
 
108
 
 
109
  /**
 
110
    Temporary table.
 
111
    The table is visible only in the session.
 
112
    Therefore,
 
113
    - FLUSH TABLES WITH READ LOCK
 
114
    - SET GLOBAL READ_ONLY = ON
 
115
    do not apply to this table.
 
116
    Note that LOCK TABLE t FOR READ/WRITE
 
117
    can be used on temporary tables.
 
118
    Temporary tables are not part of the table cache.
 
119
  */
 
120
  TABLE_CATEGORY_TEMPORARY=1,
 
121
 
 
122
  /**
 
123
    User table.
 
124
    These tables do honor:
 
125
    - LOCK TABLE t FOR READ/WRITE
 
126
    - FLUSH TABLES WITH READ LOCK
 
127
    - SET GLOBAL READ_ONLY = ON
 
128
    User tables are cached in the table cache.
 
129
  */
 
130
  TABLE_CATEGORY_USER=2,
 
131
 
 
132
  /**
 
133
    Information schema tables.
 
134
    These tables are an interface provided by the system
 
135
    to inspect the system metadata.
 
136
    These tables do *not* honor:
 
137
    - LOCK TABLE t FOR READ/WRITE
 
138
    - FLUSH TABLES WITH READ LOCK
 
139
    - SET GLOBAL READ_ONLY = ON
 
140
    as there is no point in locking explicitely
 
141
    an INFORMATION_SCHEMA table.
 
142
    Nothing is directly written to information schema tables.
 
143
    Note that this value is not used currently,
 
144
    since information schema tables are not shared,
 
145
    but implemented as session specific temporary tables.
 
146
  */
 
147
  /*
 
148
    TODO: Fixing the performance issues of I_S will lead
 
149
    to I_S tables in the table cache, which should use
 
150
    this table type.
 
151
  */
 
152
  TABLE_CATEGORY_INFORMATION
 
153
};
50
154
typedef enum enum_table_category TABLE_CATEGORY;
51
155
 
52
156
TABLE_CATEGORY get_table_category(const LEX_STRING *db,
75
179
  struct st_table_share *next,          /* Link to unused shares */
76
180
    **prev;
77
181
 
78
 
  /* The following is copied to each Table on OPEN */
 
182
  /* The following is copied to each TABLE on OPEN */
79
183
  Field **field;
80
184
  Field **found_next_number_field;
81
185
  Field *timestamp_field;               /* Used only during open */
82
186
  KEY  *key_info;                       /* data of keys in database */
83
187
  uint  *blob_field;                    /* Index to blobs in Field arrray*/
84
188
 
85
 
  unsigned char *default_values;                /* row with default values */
 
189
  uchar *default_values;                /* row with default values */
86
190
  LEX_STRING comment;                   /* Comment about table */
87
191
  const CHARSET_INFO *table_charset; /* Default charset of string fields */
88
192
 
100
204
  LEX_STRING table_cache_key;
101
205
  LEX_STRING db;                        /* Pointer to db */
102
206
  LEX_STRING table_name;                /* Table name (for open) */
103
 
  LEX_STRING path;      /* Path to .frm file (from datadir) */
 
207
  LEX_STRING path;                      /* Path to .frm file (from datadir) */
104
208
  LEX_STRING normalized_path;           /* unpack_filename(path) */
105
209
  LEX_STRING connect_string;
106
210
 
107
 
  /*
 
211
  /* 
108
212
     Set of keys in use, implemented as a Bitmap.
109
 
     Excludes keys disabled by ALTER Table ... DISABLE KEYS.
 
213
     Excludes keys disabled by ALTER TABLE ... DISABLE KEYS.
110
214
  */
111
215
  key_map keys_in_use;
112
216
  key_map keys_for_keyread;
113
217
  ha_rows min_rows, max_rows;           /* create information */
114
 
  uint32_t   avg_row_length;            /* create information */
115
 
  uint32_t   block_size;                   /* create information */
116
 
  uint32_t   version, mysql_version;
117
 
  uint32_t   timestamp_offset;          /* Set to offset+1 of record */
118
 
  uint32_t   reclength;                 /* Recordlength */
119
 
  uint32_t   stored_rec_length;         /* Stored record length
120
 
                                           (no generated-only virtual fields) */
 
218
  ulong   avg_row_length;               /* create information */
 
219
  ulong   block_size;                   /* create information */
 
220
  ulong   version, mysql_version;
 
221
  ulong   timestamp_offset;             /* Set to offset+1 of record */
 
222
  ulong   reclength;                    /* Recordlength */
121
223
 
122
224
  plugin_ref db_plugin;                 /* storage engine plugin */
123
225
  inline handlerton *db_type() const    /* table_type for handler */
124
 
  {
 
226
  { 
125
227
    // assert(db_plugin);
126
228
    return db_plugin ? plugin_data(db_plugin, handlerton*) : NULL;
127
229
  }
130
232
  enum ha_choice transactional;
131
233
  enum ha_choice page_checksum;
132
234
 
133
 
  uint32_t ref_count;       /* How many Table objects uses this */
134
 
  uint32_t open_count;                  /* Number of tables in open list */
135
 
  uint32_t blob_ptr_size;                       /* 4 or 8 */
136
 
  uint32_t key_block_size;                      /* create key_block_size, if used */
137
 
  uint32_t null_bytes;
138
 
  uint32_t last_null_bit_pos;
139
 
  uint32_t fields;                              /* Number of fields */
140
 
  uint32_t stored_fields;                   /* Number of stored fields
141
 
                                           (i.e. without generated-only ones) */
142
 
  uint32_t rec_buff_length;                 /* Size of table->record[] buffer */
143
 
  uint32_t keys, key_parts;
144
 
  uint32_t max_key_length, max_unique_length, total_key_length;
145
 
  uint32_t uniques;                         /* Number of UNIQUE index */
146
 
  uint32_t null_fields;                 /* number of null fields */
147
 
  uint32_t blob_fields;                 /* number of blob fields */
148
 
  uint32_t timestamp_field_offset;              /* Field number for timestamp field */
149
 
  uint32_t varchar_fields;                  /* number of varchar fields */
150
 
  uint32_t db_create_options;           /* Create options from database */
151
 
  uint32_t db_options_in_use;           /* Options in use */
152
 
  uint32_t db_record_offset;            /* if HA_REC_IN_SEQ */
153
 
  uint32_t rowid_field_offset;          /* Field_nr +1 to rowid field */
 
235
  uint ref_count;                       /* How many TABLE objects uses this */
 
236
  uint open_count;                      /* Number of tables in open list */
 
237
  uint blob_ptr_size;                   /* 4 or 8 */
 
238
  uint key_block_size;                  /* create key_block_size, if used */
 
239
  uint null_bytes, last_null_bit_pos;
 
240
  uint fields;                          /* Number of fields */
 
241
  uint rec_buff_length;                 /* Size of table->record[] buffer */
 
242
  uint keys, key_parts;
 
243
  uint max_key_length, max_unique_length, total_key_length;
 
244
  uint uniques;                         /* Number of UNIQUE index */
 
245
  uint null_fields;                     /* number of null fields */
 
246
  uint blob_fields;                     /* number of blob fields */
 
247
  uint timestamp_field_offset;          /* Field number for timestamp field */
 
248
  uint varchar_fields;                  /* number of varchar fields */
 
249
  uint db_create_options;               /* Create options from database */
 
250
  uint db_options_in_use;               /* Options in use */
 
251
  uint db_record_offset;                /* if HA_REC_IN_SEQ */
 
252
  uint rowid_field_offset;              /* Field_nr +1 to rowid field */
154
253
  /* Index of auto-updated TIMESTAMP field in field array */
155
 
  uint32_t primary_key;
156
 
  uint32_t next_number_index;               /* autoincrement key number */
157
 
  uint32_t next_number_key_offset;          /* autoinc keypart offset in a key */
158
 
  uint32_t next_number_keypart;             /* autoinc keypart number in a key */
159
 
  uint32_t error, open_errno, errarg;       /* error from open_table_def() */
160
 
  uint32_t column_bitmap_size;
161
 
 
162
 
  uint32_t vfields;                         /* Number of virtual fields */
 
254
  uint primary_key;
 
255
  uint next_number_index;               /* autoincrement key number */
 
256
  uint next_number_key_offset;          /* autoinc keypart offset in a key */
 
257
  uint next_number_keypart;             /* autoinc keypart number in a key */
 
258
  uint error, open_errno, errarg;       /* error from open_table_def() */
 
259
  uint column_bitmap_size;
 
260
  uchar frm_version;
163
261
  bool null_field_first;
 
262
  bool system;                          /* Set if system table (one record) */
164
263
  bool db_low_byte_first;               /* Portable row format */
165
264
  bool crashed;
166
265
  bool name_lock, replace_with_name_lock;
167
266
  bool waiting_on_cond;                 /* Protection against free */
168
 
  uint32_t table_map_id;                   /* for row-based replication */
 
267
  ulong table_map_id;                   /* for row-based replication */
169
268
  uint64_t table_map_version;
170
269
 
171
270
  /*
192
291
      appropriate values by using table cache key as their source.
193
292
  */
194
293
 
195
 
  void set_table_cache_key(char *key_buff, uint32_t key_length)
 
294
  void set_table_cache_key(char *key_buff, uint key_length)
196
295
  {
197
296
    table_cache_key.str= key_buff;
198
297
    table_cache_key.length= key_length;
222
321
      it should has same life-time as share itself.
223
322
  */
224
323
 
225
 
  void set_table_cache_key(char *key_buff, const char *key, uint32_t key_length)
 
324
  void set_table_cache_key(char *key_buff, const char *key, uint key_length)
226
325
  {
227
326
    memcpy(key_buff, key, key_length);
228
327
    set_table_cache_key(key_buff, key_length);
233
332
    return (table_category == TABLE_CATEGORY_USER);
234
333
  }
235
334
 
236
 
  inline uint32_t get_table_def_version()
 
335
  inline ulong get_table_def_version()
237
336
  {
238
337
    return table_map_id;
239
338
  }
241
340
} TABLE_SHARE;
242
341
 
243
342
 
244
 
extern uint32_t refresh_version;
 
343
extern ulong refresh_version;
245
344
 
246
 
typedef struct st_table_field_w_type
 
345
/* Information for one open table */
 
346
enum index_hint_type
247
347
{
248
 
  LEX_STRING name;
249
 
  LEX_STRING type;
250
 
  LEX_STRING cset;
251
 
} TABLE_FIELD_W_TYPE;
252
 
 
253
 
bool create_myisam_from_heap(Session *session, Table *table,
254
 
                             MI_COLUMNDEF *start_recinfo,
255
 
                             MI_COLUMNDEF **recinfo,
256
 
                             int error, bool ignore_last_dupp_key_error);
257
 
 
258
 
class Table {
259
 
 
260
 
public:
 
348
  INDEX_HINT_IGNORE,
 
349
  INDEX_HINT_USE,
 
350
  INDEX_HINT_FORCE
 
351
};
 
352
 
 
353
struct st_table {
 
354
  st_table() {}                               /* Remove gcc warning */
 
355
 
261
356
  TABLE_SHARE   *s;
262
 
  Table() {}                               /* Remove gcc warning */
263
 
 
264
 
  /* SHARE methods */
265
 
  inline TABLE_SHARE *getShare() { return s; } /* Get rid of this long term */
266
 
  inline void setShare(TABLE_SHARE *new_share) { s= new_share; } /* Get rid of this long term */
267
 
  inline uint32_t sizeKeys() { return s->keys; }
268
 
  inline uint32_t sizeFields() { return s->fields; }
269
 
  inline uint32_t getRecordLength() { return s->reclength; }
270
 
  inline uint32_t sizeBlobFields() { return s->blob_fields; }
271
 
  inline uint32_t *getBlobField() { return s->blob_field; }
272
 
  inline uint32_t getNullBytes() { return s->null_bytes; }
273
 
  inline uint32_t getNullFields() { return s->null_fields; }
274
 
  inline unsigned char *getDefaultValues() { return s->default_values; }
275
 
 
276
 
  inline bool isNullFieldFirst() { return s->null_field_first; }
277
 
  inline bool isDatabaseLowByteFirst() { return s->db_low_byte_first; }         /* Portable row format */
278
 
  inline bool isCrashed() { return s->crashed; }
279
 
  inline bool isNameLock() { return s->name_lock; }
280
 
  inline bool isReplaceWithNameLock() { return s->replace_with_name_lock; }
281
 
  inline bool isWaitingOnCondition() { return s->waiting_on_cond; }                 /* Protection against free */
282
 
 
283
 
  /* For TMP tables, should be pulled out as a class */
284
 
  void updateCreateInfo(HA_CREATE_INFO *create_info);
285
 
  void setup_tmp_table_column_bitmaps(unsigned char *bitmaps);
286
 
  bool create_myisam_tmp_table(KEY *keyinfo,
287
 
                               MI_COLUMNDEF *start_recinfo,
288
 
                               MI_COLUMNDEF **recinfo,
289
 
                               uint64_t options);
290
 
  void free_tmp_table(Session *session);
291
 
  bool open_tmp_table();
292
 
  size_t max_row_length(const unsigned char *data);
293
 
  uint32_t find_shortest_key(const key_map *usable_keys);
294
 
  bool compare_record(Field **ptr);
295
 
  bool compare_record();
296
 
 
297
 
  bool table_check_intact(const uint32_t table_f_count, const TABLE_FIELD_W_TYPE *table_def);
298
 
 
299
 
  /* See if this can be blown away */
300
 
  inline uint32_t getDBStat () { return db_stat; }
301
 
  inline uint32_t setDBStat () { return db_stat; }
302
 
  uint          db_stat;                /* mode of file as in handler.h */
303
 
 
304
357
  handler       *file;
305
 
  Table *next, *prev;
 
358
  struct st_table *next, *prev;
306
359
 
307
 
  Session       *in_use;                        /* Which thread uses this */
 
360
  THD   *in_use;                        /* Which thread uses this */
308
361
  Field **field;                        /* Pointer to fields */
309
362
 
310
 
  unsigned char *record[2];                     /* Pointer to records */
311
 
  unsigned char *write_row_record;              /* Used as optimisation in
312
 
                                           Session::write_row */
313
 
  unsigned char *insert_values;                  /* used by INSERT ... UPDATE */
314
 
  /*
315
 
    Map of keys that can be used to retrieve all data from this table
 
363
  uchar *record[2];                     /* Pointer to records */
 
364
  uchar *write_row_record;              /* Used as optimisation in
 
365
                                           THD::write_row */
 
366
  uchar *insert_values;                  /* used by INSERT ... UPDATE */
 
367
  /* 
 
368
    Map of keys that can be used to retrieve all data from this table 
316
369
    needed by the query without reading the row.
317
370
  */
318
371
  key_map covering_keys;
321
374
    A set of keys that can be used in the query that references this
322
375
    table.
323
376
 
324
 
    All indexes disabled on the table's TABLE_SHARE (see Table::s) will be
325
 
    subtracted from this set upon instantiation. Thus for any Table t it holds
326
 
    that t.keys_in_use_for_query is a subset of t.s.keys_in_use. Generally we
 
377
    All indexes disabled on the table's TABLE_SHARE (see TABLE::s) will be 
 
378
    subtracted from this set upon instantiation. Thus for any TABLE t it holds
 
379
    that t.keys_in_use_for_query is a subset of t.s.keys_in_use. Generally we 
327
380
    must not introduce any new keys here (see setup_tables).
328
381
 
329
382
    The set is implemented as a bitmap.
338
391
  Field *next_number_field;             /* Set if next_number is activated */
339
392
  Field *found_next_number_field;       /* Set on open */
340
393
  Field_timestamp *timestamp_field;
341
 
  Field **vfield;                       /* Pointer to virtual fields*/
342
394
 
343
 
  TableList *pos_in_table_list;/* Element referring to this table */
344
 
  order_st *group;
 
395
  TABLE_LIST *pos_in_table_list;/* Element referring to this table */
 
396
  ORDER         *group;
345
397
  const char    *alias;                   /* alias or table name */
346
 
  unsigned char         *null_flags;
 
398
  uchar         *null_flags;
347
399
  my_bitmap_map *bitmap_init_value;
348
400
  MY_BITMAP     def_read_set, def_write_set, tmp_set; /* containers */
349
401
  MY_BITMAP     *read_set, *write_set;          /* Active column sets */
353
405
 
354
406
   Temporary tables:
355
407
 
356
 
   table->query_id is set to session->query_id for the duration of a statement
 
408
   table->query_id is set to thd->query_id for the duration of a statement
357
409
   and is reset to 0 once it is closed by the same statement. A non-zero
358
410
   table->query_id means that a statement is using the table even if it's
359
411
   not the current statement (table is in use by some outer statement).
360
412
 
361
413
   Non-temporary tables:
362
414
 
363
 
   Under pre-locked or LOCK TABLES mode: query_id is set to session->query_id
 
415
   Under pre-locked or LOCK TABLES mode: query_id is set to thd->query_id
364
416
   for the duration of a statement and is reset to 0 once it is closed by
365
417
   the same statement. A non-zero query_id is used to control which tables
366
418
   in the list of pre-opened and locked tables are actually being used.
367
419
  */
368
420
  query_id_t    query_id;
369
421
 
370
 
  /*
 
422
  /* 
371
423
    For each key that has quick_keys.is_set(key) == true: estimate of #records
372
424
    and max #key parts that range access would use.
373
425
  */
379
431
  uint          quick_key_parts[MAX_KEY];
380
432
  uint          quick_n_ranges[MAX_KEY];
381
433
 
382
 
  /*
 
434
  /* 
383
435
    Estimate of number of records that satisfy SARGable part of the table
384
436
    condition, or table->file->records if no SARGable condition could be
385
437
    constructed.
386
438
    This value is used by join optimizer as an estimate of number of records
387
 
    that will pass the table condition (condition that depends on fields of
 
439
    that will pass the table condition (condition that depends on fields of 
388
440
    this table and constants)
389
441
  */
390
442
  ha_rows       quick_condition_rows;
404
456
  timestamp_auto_set_type timestamp_field_type;
405
457
  table_map     map;                    /* ID bit of table (1,2,4,8,16...) */
406
458
 
407
 
  uint32_t          lock_position;          /* Position in DRIZZLE_LOCK.table */
408
 
  uint32_t          lock_data_start;        /* Start pos. in DRIZZLE_LOCK.locks */
409
 
  uint32_t          lock_count;             /* Number of locks */
 
459
  uint          lock_position;          /* Position in DRIZZLE_LOCK.table */
 
460
  uint          lock_data_start;        /* Start pos. in DRIZZLE_LOCK.locks */
 
461
  uint          lock_count;             /* Number of locks */
410
462
  uint          tablenr,used_fields;
411
 
  uint32_t          temp_pool_slot;             /* Used by intern temp tables */
 
463
  uint          temp_pool_slot;         /* Used by intern temp tables */
412
464
  uint          status;                 /* What's in record[0] */
 
465
  uint          db_stat;                /* mode of file as in handler.h */
413
466
  /* number of select if it is derived table */
414
 
  uint32_t          derived_select_number;
 
467
  uint          derived_select_number;
415
468
  int           current_lock;           /* Type of lock on table */
416
469
  bool copy_blobs;                      /* copy_blobs when storing */
417
470
 
420
473
    If maybe_null !=0, this table is inner w.r.t. some outer join operation,
421
474
    and null_row may be true.
422
475
  */
423
 
  bool maybe_null;
424
 
 
 
476
  uint maybe_null;
425
477
  /*
426
 
    If true, the current table row is considered to have all columns set to
 
478
    If true, the current table row is considered to have all columns set to 
427
479
    NULL, including columns declared as "not null" (see maybe_null).
428
480
  */
429
481
  bool null_row;
430
482
 
 
483
  /*
 
484
    TODO: Each of the following flags take up 8 bits. They can just as easily
 
485
    be put into one single unsigned long and instead of taking up 18
 
486
    bytes, it would take up 4.
 
487
  */
431
488
  bool force_index;
432
489
  bool distinct,const_table,no_rows;
433
490
  bool key_read, no_keyread;
467
524
 
468
525
  REGINFO reginfo;                      /* field connections */
469
526
  MEM_ROOT mem_root;
470
 
  filesort_info_st sort;
 
527
  FILESORT_INFO sort;
471
528
 
472
529
  bool fill_item_list(List<Item> *item_list) const;
473
530
  void reset_item_list(List<Item> *item_list) const;
474
531
  void clear_column_bitmaps(void);
475
532
  void prepare_for_position(void);
476
 
  void mark_columns_used_by_index_no_reset(uint32_t index, MY_BITMAP *map);
477
 
  void mark_columns_used_by_index(uint32_t index);
 
533
  void mark_columns_used_by_index_no_reset(uint index, MY_BITMAP *map);
 
534
  void mark_columns_used_by_index(uint index);
478
535
  void restore_column_maps_after_mark_index();
479
536
  void mark_auto_increment_column(void);
480
537
  void mark_columns_needed_for_update(void);
481
538
  void mark_columns_needed_for_delete(void);
482
539
  void mark_columns_needed_for_insert(void);
483
 
  void mark_virtual_columns(void);
484
540
  inline void column_bitmaps_set(MY_BITMAP *read_set_arg,
485
541
                                 MY_BITMAP *write_set_arg)
486
542
  {
495
551
    read_set= read_set_arg;
496
552
    write_set= write_set_arg;
497
553
  }
498
 
 
499
 
  void restore_column_map(my_bitmap_map *old);
500
 
 
501
 
  my_bitmap_map *use_all_columns(MY_BITMAP *bitmap);
502
554
  inline void use_all_columns()
503
555
  {
504
556
    column_bitmaps_set(&s->all_set, &s->all_set);
505
557
  }
506
 
 
507
558
  inline void default_column_bitmaps()
508
559
  {
509
560
    read_set= &def_read_set;
510
561
    write_set= &def_write_set;
511
562
  }
512
 
 
513
563
  /* Is table open or should be treated as such by name-locking? */
514
564
  inline bool is_name_opened() { return db_stat || open_placeholder; }
515
565
  /*
517
567
  */
518
568
  inline bool needs_reopen_or_name_lock()
519
569
  { return s->version != refresh_version; }
520
 
 
521
 
  int report_error(int error);
522
 
};
523
 
 
524
 
Table *create_virtual_tmp_table(Session *session,
525
 
                                List<Create_field> &field_list);
 
570
};
 
571
 
 
572
enum enum_schema_table_state
 
573
{ 
 
574
  NOT_PROCESSED= 0,
 
575
  PROCESSED_BY_CREATE_SORT_INDEX,
 
576
  PROCESSED_BY_JOIN_EXEC
 
577
};
526
578
 
527
579
typedef struct st_foreign_key_info
528
580
{
536
588
  List<LEX_STRING> referenced_fields;
537
589
} FOREIGN_KEY_INFO;
538
590
 
 
591
/*
 
592
  Make sure that the order of schema_tables and enum_schema_tables are the same.
 
593
*/
 
594
 
 
595
enum enum_schema_tables
 
596
{
 
597
  SCH_CHARSETS= 0,
 
598
  SCH_COLLATIONS,
 
599
  SCH_COLLATION_CHARACTER_SET_APPLICABILITY,
 
600
  SCH_COLUMNS,
 
601
  SCH_GLOBAL_STATUS,
 
602
  SCH_GLOBAL_VARIABLES,
 
603
  SCH_KEY_COLUMN_USAGE,
 
604
  SCH_OPEN_TABLES,
 
605
  SCH_PLUGINS,
 
606
  SCH_PROCESSLIST,
 
607
  SCH_REFERENTIAL_CONSTRAINTS,
 
608
  SCH_SCHEMATA,
 
609
  SCH_SESSION_STATUS,
 
610
  SCH_SESSION_VARIABLES,
 
611
  SCH_STATISTICS,
 
612
  SCH_STATUS,
 
613
  SCH_TABLES,
 
614
  SCH_TABLE_CONSTRAINTS,
 
615
  SCH_TABLE_NAMES,
 
616
  SCH_VARIABLES
 
617
};
 
618
 
 
619
 
 
620
#define MY_I_S_MAYBE_NULL 1
 
621
#define MY_I_S_UNSIGNED   2
 
622
 
 
623
 
 
624
#define SKIP_OPEN_TABLE 0                // do not open table
 
625
#define OPEN_FRM_ONLY   1                // open FRM file only
 
626
#define OPEN_FULL_TABLE 2                // open FRM,MYD, MYI files
 
627
 
539
628
typedef struct st_field_info
540
629
{
541
 
  /**
542
 
      This is used as column name.
 
630
  /** 
 
631
      This is used as column name. 
543
632
  */
544
633
  const char* field_name;
545
634
  /**
546
635
     For string-type columns, this is the maximum number of
547
636
     characters. Otherwise, it is the 'display-length' for the column.
548
637
  */
549
 
  uint32_t field_length;
 
638
  uint field_length;
550
639
  /**
551
640
     This denotes data type for the column. For the most part, there seems to
552
641
     be one entry in the enum for each SQL data type, although there seem to
562
651
     combine them using the bitwise or operator @c |. Both flags are
563
652
     defined in table.h.
564
653
   */
565
 
  uint32_t field_flags;        // Field atributes(maybe_null, signed, unsigned etc.)
 
654
  uint field_flags;        // Field atributes(maybe_null, signed, unsigned etc.)
566
655
  const char* old_name;
567
656
  /**
568
657
     This should be one of @c SKIP_OPEN_TABLE,
569
658
     @c OPEN_FRM_ONLY or @c OPEN_FULL_TABLE.
570
659
  */
571
 
  uint32_t open_method;
 
660
  uint open_method;
572
661
} ST_FIELD_INFO;
573
662
 
574
663
 
575
 
class TableList;
 
664
struct TABLE_LIST;
576
665
typedef class Item COND;
577
666
 
578
 
struct ST_SCHEMA_TABLE
 
667
typedef struct st_schema_table
579
668
{
580
669
  const char* table_name;
581
670
  ST_FIELD_INFO *fields_info;
582
671
  /* Create information_schema table */
583
 
  Table *(*create_table)  (Session *session, TableList *table_list);
 
672
  TABLE *(*create_table)  (THD *thd, TABLE_LIST *table_list);
584
673
  /* Fill table with data */
585
 
  int (*fill_table) (Session *session, TableList *tables, COND *cond);
 
674
  int (*fill_table) (THD *thd, TABLE_LIST *tables, COND *cond);
586
675
  /* Handle fileds for old SHOW */
587
 
  int (*old_format) (Session *session, struct ST_SCHEMA_TABLE *schema_table);
588
 
  int (*process_table) (Session *session, TableList *tables, Table *table,
 
676
  int (*old_format) (THD *thd, struct st_schema_table *schema_table);
 
677
  int (*process_table) (THD *thd, TABLE_LIST *tables, TABLE *table,
589
678
                        bool res, LEX_STRING *db_name, LEX_STRING *table_name);
590
 
  int idx_field1, idx_field2;
 
679
  int idx_field1, idx_field2; 
591
680
  bool hidden;
592
 
  uint32_t i_s_requested_object;  /* the object we need to open(Table | VIEW) */
593
 
};
 
681
  uint i_s_requested_object;  /* the object we need to open(TABLE | VIEW) */
 
682
} ST_SCHEMA_TABLE;
594
683
 
595
684
 
596
685
#define JOIN_TYPE_LEFT  1
600
689
class select_union;
601
690
class TMP_TABLE_PARAM;
602
691
 
 
692
Item *create_view_field(THD *thd, TABLE_LIST *view, Item **field_ref,
 
693
                        const char *name);
 
694
 
 
695
struct Field_translator
 
696
{
 
697
  Item *item;
 
698
  const char *name;
 
699
};
 
700
 
 
701
 
 
702
/*
 
703
  Column reference of a NATURAL/USING join. Since column references in
 
704
  joins can be both from views and stored tables, may point to either a
 
705
  Field (for tables), or a Field_translator (for views).
 
706
*/
 
707
 
 
708
class Natural_join_column: public Sql_alloc
 
709
{
 
710
public:
 
711
  Field_translator *view_field;  /* Column reference of merge view. */
 
712
  Field            *table_field; /* Column reference of table or temp view. */
 
713
  TABLE_LIST *table_ref; /* Original base table/view reference. */
 
714
  /*
 
715
    True if a common join column of two NATURAL/USING join operands. Notice
 
716
    that when we have a hierarchy of nested NATURAL/USING joins, a column can
 
717
    be common at some level of nesting but it may not be common at higher
 
718
    levels of nesting. Thus this flag may change depending on at which level
 
719
    we are looking at some column.
 
720
  */
 
721
  bool is_common;
 
722
public:
 
723
  Natural_join_column(Field_translator *field_param, TABLE_LIST *tab);
 
724
  Natural_join_column(Field *field_param, TABLE_LIST *tab);
 
725
  const char *name();
 
726
  Item *create_item(THD *thd);
 
727
  Field *field();
 
728
  const char *table_name();
 
729
  const char *db_name();
 
730
};
 
731
 
 
732
 
 
733
/*
 
734
  Table reference in the FROM clause.
 
735
 
 
736
  These table references can be of several types that correspond to
 
737
  different SQL elements. Below we list all types of TABLE_LISTs with
 
738
  the necessary conditions to determine when a TABLE_LIST instance
 
739
  belongs to a certain type.
 
740
 
 
741
  1) table (TABLE_LIST::view == NULL)
 
742
     - base table
 
743
       (TABLE_LIST::derived == NULL)
 
744
     - subquery - TABLE_LIST::table is a temp table
 
745
       (TABLE_LIST::derived != NULL)
 
746
     - information schema table
 
747
       (TABLE_LIST::schema_table != NULL)
 
748
       NOTICE: for schema tables TABLE_LIST::field_translation may be != NULL
 
749
  2) view (TABLE_LIST::view != NULL)
 
750
     - merge    (TABLE_LIST::effective_algorithm == VIEW_ALGORITHM_MERGE)
 
751
           also (TABLE_LIST::field_translation != NULL)
 
752
     - tmptable (TABLE_LIST::effective_algorithm == VIEW_ALGORITHM_TMPTABLE)
 
753
           also (TABLE_LIST::field_translation == NULL)
 
754
  3) nested table reference (TABLE_LIST::nested_join != NULL)
 
755
     - table sequence - e.g. (t1, t2, t3)
 
756
       TODO: how to distinguish from a JOIN?
 
757
     - general JOIN
 
758
       TODO: how to distinguish from a table sequence?
 
759
     - NATURAL JOIN
 
760
       (TABLE_LIST::natural_join != NULL)
 
761
       - JOIN ... USING
 
762
         (TABLE_LIST::join_using_fields != NULL)
 
763
     - semi-join
 
764
       ;
 
765
*/
 
766
 
 
767
class Index_hint;
 
768
struct TABLE_LIST
 
769
{
 
770
  TABLE_LIST() {}                          /* Remove gcc warning */
 
771
 
 
772
  /**
 
773
    Prepare TABLE_LIST that consists of one table instance to use in
 
774
    simple_open_and_lock_tables
 
775
  */
 
776
  inline void init_one_table(const char *db_name_arg,
 
777
                             const char *table_name_arg,
 
778
                             enum thr_lock_type lock_type_arg)
 
779
  {
 
780
    memset(this, 0, sizeof(*this));
 
781
    db= (char*) db_name_arg;
 
782
    table_name= alias= (char*) table_name_arg;
 
783
    lock_type= lock_type_arg;
 
784
  }
 
785
 
 
786
  /*
 
787
    List of tables local to a subquery (used by SQL_LIST). Considers
 
788
    views as leaves (unlike 'next_leaf' below). Created at parse time
 
789
    in st_select_lex::add_table_to_list() -> table_list.link_in_list().
 
790
  */
 
791
  TABLE_LIST *next_local;
 
792
  /* link in a global list of all queries tables */
 
793
  TABLE_LIST *next_global, **prev_global;
 
794
  char          *db, *alias, *table_name, *schema_table_name;
 
795
  char          *option;                /* Used by cache index  */
 
796
  Item          *on_expr;               /* Used with outer join */
 
797
  Item          *sj_on_expr;
 
798
  /*
 
799
    (Valid only for semi-join nests) Bitmap of tables that are within the
 
800
    semi-join (this is different from bitmap of all nest's children because
 
801
    tables that were pulled out of the semi-join nest remain listed as
 
802
    nest's children).
 
803
  */
 
804
  table_map     sj_inner_tables;
 
805
  /* Number of IN-compared expressions */
 
806
  uint          sj_in_exprs; 
 
807
  /*
 
808
    The structure of ON expression presented in the member above
 
809
    can be changed during certain optimizations. This member
 
810
    contains a snapshot of AND-OR structure of the ON expression
 
811
    made after permanent transformations of the parse tree, and is
 
812
    used to restore ON clause before every reexecution of a prepared
 
813
    statement or stored procedure.
 
814
  */
 
815
  Item          *prep_on_expr;
 
816
  COND_EQUAL    *cond_equal;            /* Used with outer join */
 
817
  /*
 
818
    During parsing - left operand of NATURAL/USING join where 'this' is
 
819
    the right operand. After parsing (this->natural_join == this) iff
 
820
    'this' represents a NATURAL or USING join operation. Thus after
 
821
    parsing 'this' is a NATURAL/USING join iff (natural_join != NULL).
 
822
  */
 
823
  TABLE_LIST *natural_join;
 
824
  /*
 
825
    True if 'this' represents a nested join that is a NATURAL JOIN.
 
826
    For one of the operands of 'this', the member 'natural_join' points
 
827
    to the other operand of 'this'.
 
828
  */
 
829
  bool is_natural_join;
 
830
  /* Field names in a USING clause for JOIN ... USING. */
 
831
  List<String> *join_using_fields;
 
832
  /*
 
833
    Explicitly store the result columns of either a NATURAL/USING join or
 
834
    an operand of such a join.
 
835
  */
 
836
  List<Natural_join_column> *join_columns;
 
837
  /* true if join_columns contains all columns of this table reference. */
 
838
  bool is_join_columns_complete;
 
839
 
 
840
  /*
 
841
    List of nodes in a nested join tree, that should be considered as
 
842
    leaves with respect to name resolution. The leaves are: views,
 
843
    top-most nodes representing NATURAL/USING joins, subqueries, and
 
844
    base tables. All of these TABLE_LIST instances contain a
 
845
    materialized list of columns. The list is local to a subquery.
 
846
  */
 
847
  TABLE_LIST *next_name_resolution_table;
 
848
  /* Index names in a "... JOIN ... USE/IGNORE INDEX ..." clause. */
 
849
  List<Index_hint> *index_hints;
 
850
  TABLE        *table;                          /* opened table */
 
851
  uint          table_id; /* table id (from binlog) for opened table */
 
852
  /*
 
853
    select_result for derived table to pass it from table creation to table
 
854
    filling procedure
 
855
  */
 
856
  select_union  *derived_result;
 
857
  /*
 
858
    Reference from aux_tables to local list entry of main select of
 
859
    multi-delete statement:
 
860
    delete t1 from t2,t1 where t1.a<'B' and t2.b=t1.b;
 
861
    here it will be reference of first occurrence of t1 to second (as you
 
862
    can see this lists can't be merged)
 
863
  */
 
864
  TABLE_LIST    *correspondent_table;
 
865
  st_select_lex_unit *derived;          /* SELECT_LEX_UNIT of derived table */
 
866
  ST_SCHEMA_TABLE *schema_table;        /* Information_schema table */
 
867
  st_select_lex *schema_select_lex;
 
868
  /*
 
869
    True when the view field translation table is used to convert
 
870
    schema table fields for backwards compatibility with SHOW command.
 
871
  */
 
872
  bool schema_table_reformed;
 
873
  TMP_TABLE_PARAM *schema_table_param;
 
874
  /* link to select_lex where this table was used */
 
875
  st_select_lex *select_lex;
 
876
  Field_translator *field_translation;  /* array of VIEW fields */
 
877
  /* pointer to element after last one in translation table above */
 
878
  Field_translator *field_translation_end;
 
879
  /*
 
880
    List (based on next_local) of underlying tables of this view. I.e. it
 
881
    does not include the tables of subqueries used in the view. Is set only
 
882
    for merged views.
 
883
  */
 
884
  TABLE_LIST    *merge_underlying_list;
 
885
  /*
 
886
    - 0 for base tables
 
887
    - in case of the view it is the list of all (not only underlying
 
888
    tables but also used in subquery ones) tables of the view.
 
889
  */
 
890
  List<TABLE_LIST> *view_tables;
 
891
  /* most upper view this table belongs to */
 
892
  TABLE_LIST    *belong_to_view;
 
893
  /* Ptr to parent MERGE table list item. See top comment in ha_myisammrg.cc */
 
894
  TABLE_LIST    *parent_l;
 
895
  /*
 
896
    List of all base tables local to a subquery including all view
 
897
    tables. Unlike 'next_local', this in this list views are *not*
 
898
    leaves. Created in setup_tables() -> make_leaves_list().
 
899
  */
 
900
  TABLE_LIST    *next_leaf;
 
901
  /* data need by some engines in query cache*/
 
902
  uint64_t     engine_data;
 
903
  /* call back function for asking handler about caching in query cache */
 
904
  qc_engine_callback callback_func;
 
905
  thr_lock_type lock_type;
 
906
  uint          outer_join;             /* Which join type */
 
907
  uint          shared;                 /* Used in multi-upd */
 
908
  size_t        db_length;
 
909
  size_t        table_name_length;
 
910
  bool          straight;               /* optimize with prev table */
 
911
  bool          updating;               /* for replicate-do/ignore table */
 
912
  bool          force_index;            /* prefer index over table scan */
 
913
  bool          ignore_leaves;          /* preload only non-leaf nodes */
 
914
  table_map     dep_tables;             /* tables the table depends on      */
 
915
  table_map     on_expr_dep_tables;     /* tables on expression depends on  */
 
916
  struct st_nested_join *nested_join;   /* if the element is a nested join  */
 
917
  TABLE_LIST *embedding;             /* nested join containing the table */
 
918
  List<TABLE_LIST> *join_list;/* join list the table belongs to   */
 
919
  bool          cacheable_table;        /* stop PS caching */
 
920
  /* FRMTYPE_ERROR if any type is acceptable */
 
921
  enum frm_type_enum required_type;
 
922
  handlerton    *db_type;               /* table_type for handler */
 
923
  char          timestamp_buffer[20];   /* buffer for timestamp (19+1) */
 
924
  /*
 
925
    This TABLE_LIST object corresponds to the table to be created
 
926
    so it is possible that it does not exist (used in CREATE TABLE
 
927
    ... SELECT implementation).
 
928
  */
 
929
  bool          create;
 
930
  /* For transactional locking. */
 
931
  int           lock_timeout;           /* NOWAIT or WAIT [X]               */
 
932
  bool          lock_transactional;     /* If transactional lock requested. */
 
933
  bool          internal_tmp_table;
 
934
  /** true if an alias for this table was specified in the SQL. */
 
935
  bool          is_alias;
 
936
  /** true if the table is referred to in the statement using a fully
 
937
      qualified name (<db_name>.<table_name>).
 
938
  */
 
939
  bool          is_fqtn;
 
940
 
 
941
  uint i_s_requested_object;
 
942
  bool has_db_lookup_value;
 
943
  bool has_table_lookup_value;
 
944
  uint table_open_method;
 
945
  enum enum_schema_table_state schema_table_state;
 
946
  void set_underlying_merge();
 
947
  bool setup_underlying(THD *thd);
 
948
  void cleanup_items();
 
949
  /*
 
950
    If you change placeholder(), please check the condition in
 
951
    check_transactional_lock() too.
 
952
  */
 
953
  bool placeholder()
 
954
  {
 
955
    return derived || schema_table || (create && !table->db_stat) || !table;
 
956
  }
 
957
  void print(THD *thd, String *str, enum_query_type query_type);
 
958
  bool set_insert_values(MEM_ROOT *mem_root);
 
959
  TABLE_LIST *find_underlying_table(TABLE *table);
 
960
  TABLE_LIST *first_leaf_for_name_resolution();
 
961
  TABLE_LIST *last_leaf_for_name_resolution();
 
962
  bool is_leaf_for_name_resolution();
 
963
  inline TABLE_LIST *top_table()
 
964
    { return belong_to_view ? belong_to_view : this; }
 
965
 
 
966
  /*
 
967
    Cleanup for re-execution in a prepared statement or a stored
 
968
    procedure.
 
969
  */
 
970
  void reinit_before_use(THD *thd);
 
971
  Item_subselect *containing_subselect();
 
972
 
 
973
  /* 
 
974
    Compiles the tagged hints list and fills up st_table::keys_in_use_for_query,
 
975
    st_table::keys_in_use_for_group_by, st_table::keys_in_use_for_order_by,
 
976
    st_table::force_index and st_table::covering_keys.
 
977
  */
 
978
  bool process_index_hints(TABLE *table);
 
979
 
 
980
private:
 
981
  bool prep_where(THD *thd, Item **conds, bool no_where_clause);
 
982
  /*
 
983
    Cleanup for re-execution in a prepared statement or a stored
 
984
    procedure.
 
985
  */
 
986
};
 
987
 
 
988
class Item;
 
989
 
 
990
/*
 
991
  Iterator over the fields of a generic table reference.
 
992
*/
 
993
 
 
994
class Field_iterator: public Sql_alloc
 
995
{
 
996
public:
 
997
  Field_iterator() {}                         /* Remove gcc warning */
 
998
  virtual ~Field_iterator() {}
 
999
  virtual void set(TABLE_LIST *)= 0;
 
1000
  virtual void next()= 0;
 
1001
  virtual bool end_of_fields()= 0;              /* Return 1 at end of list */
 
1002
  virtual const char *name()= 0;
 
1003
  virtual Item *create_item(THD *)= 0;
 
1004
  virtual Field *field()= 0;
 
1005
};
 
1006
 
 
1007
 
 
1008
/* 
 
1009
  Iterator over the fields of a base table, view with temporary
 
1010
  table, or subquery.
 
1011
*/
 
1012
 
 
1013
class Field_iterator_table: public Field_iterator
 
1014
{
 
1015
  Field **ptr;
 
1016
public:
 
1017
  Field_iterator_table() :ptr(0) {}
 
1018
  void set(TABLE_LIST *table) { ptr= table->table->field; }
 
1019
  void set_table(TABLE *table) { ptr= table->field; }
 
1020
  void next() { ptr++; }
 
1021
  bool end_of_fields() { return *ptr == 0; }
 
1022
  const char *name();
 
1023
  Item *create_item(THD *thd);
 
1024
  Field *field() { return *ptr; }
 
1025
};
 
1026
 
 
1027
 
 
1028
/* Iterator over the fields of a merge view. */
 
1029
 
 
1030
class Field_iterator_view: public Field_iterator
 
1031
{
 
1032
  Field_translator *ptr, *array_end;
 
1033
  TABLE_LIST *view;
 
1034
public:
 
1035
  Field_iterator_view() :ptr(0), array_end(0) {}
 
1036
  void set(TABLE_LIST *table);
 
1037
  void next() { ptr++; }
 
1038
  bool end_of_fields() { return ptr == array_end; }
 
1039
  const char *name();
 
1040
  Item *create_item(THD *thd);
 
1041
  Item **item_ptr() {return &ptr->item; }
 
1042
  Field *field() { return 0; }
 
1043
  inline Item *item() { return ptr->item; }
 
1044
  Field_translator *field_translator() { return ptr; }
 
1045
};
 
1046
 
 
1047
 
 
1048
/*
 
1049
  Field_iterator interface to the list of materialized fields of a
 
1050
  NATURAL/USING join.
 
1051
*/
 
1052
 
 
1053
class Field_iterator_natural_join: public Field_iterator
 
1054
{
 
1055
  List_iterator_fast<Natural_join_column> column_ref_it;
 
1056
  Natural_join_column *cur_column_ref;
 
1057
public:
 
1058
  Field_iterator_natural_join() :cur_column_ref(NULL) {}
 
1059
  ~Field_iterator_natural_join() {}
 
1060
  void set(TABLE_LIST *table);
 
1061
  void next();
 
1062
  bool end_of_fields() { return !cur_column_ref; }
 
1063
  const char *name() { return cur_column_ref->name(); }
 
1064
  Item *create_item(THD *thd) { return cur_column_ref->create_item(thd); }
 
1065
  Field *field() { return cur_column_ref->field(); }
 
1066
  Natural_join_column *column_ref() { return cur_column_ref; }
 
1067
};
 
1068
 
 
1069
 
 
1070
/*
 
1071
  Generic iterator over the fields of an arbitrary table reference.
 
1072
 
 
1073
  DESCRIPTION
 
1074
    This class unifies the various ways of iterating over the columns
 
1075
    of a table reference depending on the type of SQL entity it
 
1076
    represents. If such an entity represents a nested table reference,
 
1077
    this iterator encapsulates the iteration over the columns of the
 
1078
    members of the table reference.
 
1079
 
 
1080
  IMPLEMENTATION
 
1081
    The implementation assumes that all underlying NATURAL/USING table
 
1082
    references already contain their result columns and are linked into
 
1083
    the list TABLE_LIST::next_name_resolution_table.
 
1084
*/
 
1085
 
 
1086
class Field_iterator_table_ref: public Field_iterator
 
1087
{
 
1088
  TABLE_LIST *table_ref, *first_leaf, *last_leaf;
 
1089
  Field_iterator_table        table_field_it;
 
1090
  Field_iterator_view         view_field_it;
 
1091
  Field_iterator_natural_join natural_join_it;
 
1092
  Field_iterator *field_it;
 
1093
  void set_field_iterator();
 
1094
public:
 
1095
  Field_iterator_table_ref() :field_it(NULL) {}
 
1096
  void set(TABLE_LIST *table);
 
1097
  void next();
 
1098
  bool end_of_fields()
 
1099
  { return (table_ref == last_leaf && field_it->end_of_fields()); }
 
1100
  const char *name() { return field_it->name(); }
 
1101
  const char *table_name();
 
1102
  const char *db_name();
 
1103
  Item *create_item(THD *thd) { return field_it->create_item(thd); }
 
1104
  Field *field() { return field_it->field(); }
 
1105
  Natural_join_column *get_or_create_column_ref(TABLE_LIST *parent_table_ref);
 
1106
  Natural_join_column *get_natural_column_ref();
 
1107
};
 
1108
 
 
1109
 
 
1110
typedef struct st_nested_join
 
1111
{
 
1112
  List<TABLE_LIST>  join_list;       /* list of elements in the nested join */
 
1113
  table_map         used_tables;     /* bitmap of tables in the nested join */
 
1114
  table_map         not_null_tables; /* tables that rejects nulls           */
 
1115
  struct st_join_table *first_nested;/* the first nested table in the plan  */
 
1116
  /* 
 
1117
    Used to count tables in the nested join in 2 isolated places:
 
1118
    1. In make_outerjoin_info(). 
 
1119
    2. check_interleaving_with_nj/restore_prev_nj_state (these are called
 
1120
       by the join optimizer. 
 
1121
    Before each use the counters are zeroed by reset_nj_counters.
 
1122
  */
 
1123
  uint              counter_;
 
1124
  nested_join_map   nj_map;          /* Bit used to identify this nested join*/
 
1125
  /*
 
1126
    (Valid only for semi-join nests) Bitmap of tables outside the semi-join
 
1127
    that are used within the semi-join's ON condition.
 
1128
  */
 
1129
  table_map         sj_depends_on;
 
1130
  /* Outer non-trivially correlated tables */
 
1131
  table_map         sj_corr_tables;
 
1132
  List<Item>        sj_outer_expr_list;
 
1133
} NESTED_JOIN;
 
1134
 
 
1135
 
603
1136
typedef struct st_changed_table_list
604
1137
{
605
1138
  struct        st_changed_table_list *next;
606
1139
  char          *key;
607
1140
  uint32_t        key_length;
608
 
} CHANGED_TableList;
609
 
 
610
 
 
611
 
typedef struct st_open_table_list
612
 
{
 
1141
} CHANGED_TABLE_LIST;
 
1142
 
 
1143
 
 
1144
typedef struct st_open_table_list{
613
1145
  struct st_open_table_list *next;
614
1146
  char  *db,*table;
615
1147
  uint32_t in_use,locked;
616
 
} OPEN_TableList;
617
 
 
618
 
 
619
 
inline void mark_as_null_row(Table *table)
620
 
{
621
 
  table->null_row=1;
622
 
  table->status|=STATUS_NULL_ROW;
623
 
  memset(table->null_flags, 255, table->s->null_bytes);
624
 
}
625
 
 
626
 
/**
627
 
  clean/setup table fields and map.
628
 
 
629
 
  @param table        Table structure pointer (which should be setup)
630
 
  @param table_list   TableList structure pointer (owner of Table)
631
 
  @param tablenr     table number
632
 
*/
633
 
void setup_table_map(Table *table, TableList *table_list, uint32_t tablenr);
634
 
 
635
 
#endif /* DRIZZLED_TABLE_H */
 
1148
} OPEN_TABLE_LIST;
 
1149
 
 
1150
typedef struct st_table_field_w_type
 
1151
{
 
1152
  LEX_STRING name;
 
1153
  LEX_STRING type;
 
1154
  LEX_STRING cset;
 
1155
} TABLE_FIELD_W_TYPE;
 
1156
 
 
1157
 
 
1158
bool
 
1159
table_check_intact(TABLE *table, const uint table_f_count,
 
1160
                   const TABLE_FIELD_W_TYPE *table_def);
 
1161
 
 
1162
static inline my_bitmap_map *tmp_use_all_columns(TABLE *table,
 
1163
                                                 MY_BITMAP *bitmap)
 
1164
{
 
1165
  my_bitmap_map *old= bitmap->bitmap;
 
1166
  bitmap->bitmap= table->s->all_set.bitmap;
 
1167
  return old;
 
1168
}
 
1169
 
 
1170
 
 
1171
static inline void tmp_restore_column_map(MY_BITMAP *bitmap,
 
1172
                                          my_bitmap_map *old)
 
1173
{
 
1174
  bitmap->bitmap= old;
 
1175
}
 
1176
 
 
1177
/* The following is only needed for debugging */
 
1178
 
 
1179
static inline my_bitmap_map *dbug_tmp_use_all_columns(TABLE *table __attribute__((unused)),
 
1180
                                                      MY_BITMAP *bitmap __attribute__((unused)))
 
1181
{
 
1182
  return 0;
 
1183
}
 
1184
 
 
1185
static inline void dbug_tmp_restore_column_map(MY_BITMAP *bitmap __attribute__((unused)),
 
1186
                                               my_bitmap_map *old __attribute__((unused)))
 
1187
{
 
1188
  return;
 
1189
}
 
1190
 
 
1191
size_t max_row_length(TABLE *table, const uchar *data);
 
1192