← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/table.h

Merged in trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/table.h
23
23
#ifndef DRIZZLED_TABLE_H
24
24
#define DRIZZLED_TABLE_H
25
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/nested_join.h>
31
 
#include <drizzled/field_iterator.h>
32
 
 
33
 
class Item;                             /* Needed by order_st */
 
26
#include <plugin/myisam/myisam.h>
 
27
#include <mysys/hash.h>
 
28
#include <mysys/my_bitmap.h>
 
29
#include "drizzled/order.h"
 
30
#include "drizzled/filesort_info.h"
 
31
#include "drizzled/natural_join_column.h"
 
32
#include "drizzled/field_iterator.h"
 
33
#include "drizzled/handler.h"
 
34
#include "drizzled/lex_string.h"
 
35
#include "drizzled/table_list.h"
 
36
#include "drizzled/table_share.h"
 
37
 
 
38
#include <string>
 
39
 
 
40
using namespace std;
 
41
 
 
42
class Item;
34
43
class Item_subselect;
35
 
class st_select_lex_unit;
36
 
class st_select_lex;
 
44
class Select_Lex_Unit;
 
45
class Select_Lex;
37
46
class COND_EQUAL;
38
47
class Security_context;
39
48
class TableList;
40
 
 
41
 
/*************************************************************************/
42
 
 
43
 
enum tmp_table_type
44
 
{
45
 
  NO_TMP_TABLE, NON_TRANSACTIONAL_TMP_TABLE, TRANSACTIONAL_TMP_TABLE,
46
 
  INTERNAL_TMP_TABLE, SYSTEM_TMP_TABLE, TMP_TABLE_FRM_FILE_ONLY
47
 
};
48
 
 
49
 
bool mysql_frm_type(THD *thd, char *path, enum legacy_db_type *dbt);
50
 
 
51
 
 
52
 
enum release_type { RELEASE_NORMAL, RELEASE_WAIT_FOR_DROP };
53
 
 
54
 
/*
55
 
  Values in this enum are used to indicate how a tables TIMESTAMP field
56
 
  should be treated. It can be set to the current timestamp on insert or
57
 
  update or both.
58
 
  WARNING: The values are used for bit operations. If you change the
59
 
  enum, you must keep the bitwise relation of the values. For example:
60
 
  (int) TIMESTAMP_AUTO_SET_ON_BOTH must be equal to
61
 
  (int) TIMESTAMP_AUTO_SET_ON_INSERT | (int) TIMESTAMP_AUTO_SET_ON_UPDATE.
62
 
  We use an enum here so that the debugger can display the value names.
63
 
*/
64
 
enum timestamp_auto_set_type
65
 
{
66
 
  TIMESTAMP_NO_AUTO_SET= 0, TIMESTAMP_AUTO_SET_ON_INSERT= 1,
67
 
  TIMESTAMP_AUTO_SET_ON_UPDATE= 2, TIMESTAMP_AUTO_SET_ON_BOTH= 3
68
 
};
69
 
#define clear_timestamp_auto_bits(_target_, _bits_) \
70
 
  (_target_)= (enum timestamp_auto_set_type)((int)(_target_) & ~(int)(_bits_))
71
 
 
72
49
class Field_timestamp;
73
50
class Field_blob;
74
51
 
75
 
/**
76
 
  Category of table found in the table share.
77
 
*/
78
 
enum enum_table_category
79
 
{
80
 
  /**
81
 
    Unknown value.
82
 
  */
83
 
  TABLE_UNKNOWN_CATEGORY=0,
84
 
 
85
 
  /**
86
 
    Temporary table.
87
 
    The table is visible only in the session.
88
 
    Therefore,
89
 
    - FLUSH TABLES WITH READ LOCK
90
 
    - SET GLOBAL READ_ONLY = ON
91
 
    do not apply to this table.
92
 
    Note that LOCK Table t FOR READ/WRITE
93
 
    can be used on temporary tables.
94
 
    Temporary tables are not part of the table cache.
95
 
  */
96
 
  TABLE_CATEGORY_TEMPORARY=1,
97
 
 
98
 
  /**
99
 
    User table.
100
 
    These tables do honor:
101
 
    - LOCK Table t FOR READ/WRITE
102
 
    - FLUSH TABLES WITH READ LOCK
103
 
    - SET GLOBAL READ_ONLY = ON
104
 
    User tables are cached in the table cache.
105
 
  */
106
 
  TABLE_CATEGORY_USER=2,
107
 
 
108
 
  /**
109
 
    Information schema tables.
110
 
    These tables are an interface provided by the system
111
 
    to inspect the system metadata.
112
 
    These tables do *not* honor:
113
 
    - LOCK Table t FOR READ/WRITE
114
 
    - FLUSH TABLES WITH READ LOCK
115
 
    - SET GLOBAL READ_ONLY = ON
116
 
    as there is no point in locking explicitely
117
 
    an INFORMATION_SCHEMA table.
118
 
    Nothing is directly written to information schema tables.
119
 
    Note that this value is not used currently,
120
 
    since information schema tables are not shared,
121
 
    but implemented as session specific temporary tables.
122
 
  */
123
 
  /*
124
 
    TODO: Fixing the performance issues of I_S will lead
125
 
    to I_S tables in the table cache, which should use
126
 
    this table type.
127
 
  */
128
 
  TABLE_CATEGORY_INFORMATION
129
 
};
130
52
typedef enum enum_table_category TABLE_CATEGORY;
131
53
 
132
 
TABLE_CATEGORY get_table_category(const LEX_STRING *db,
133
 
                                  const LEX_STRING *name);
134
 
 
135
 
/*
136
 
  This structure is shared between different table objects. There is one
137
 
  instance of table share per one table in the database.
138
 
*/
139
 
 
140
 
typedef struct st_table_share
141
 
{
142
 
  st_table_share() {}                    /* Remove gcc warning */
143
 
 
144
 
  /** Category of this table. */
145
 
  TABLE_CATEGORY table_category;
146
 
 
147
 
  /* hash of field names (contains pointers to elements of field array) */
148
 
  HASH  name_hash;                      /* hash of field names */
149
 
  MEM_ROOT mem_root;
150
 
  TYPELIB keynames;                     /* Pointers to keynames */
151
 
  TYPELIB fieldnames;                   /* Pointer to fieldnames */
152
 
  TYPELIB *intervals;                   /* pointer to interval info */
153
 
  pthread_mutex_t mutex;                /* For locking the share  */
154
 
  pthread_cond_t cond;                  /* To signal that share is ready */
155
 
  struct st_table_share *next,          /* Link to unused shares */
156
 
    **prev;
157
 
 
158
 
  /* The following is copied to each Table on OPEN */
159
 
  Field **field;
160
 
  Field **found_next_number_field;
161
 
  Field *timestamp_field;               /* Used only during open */
162
 
  KEY  *key_info;                       /* data of keys in database */
163
 
  uint  *blob_field;                    /* Index to blobs in Field arrray*/
164
 
 
165
 
  unsigned char *default_values;                /* row with default values */
166
 
  LEX_STRING comment;                   /* Comment about table */
167
 
  const CHARSET_INFO *table_charset; /* Default charset of string fields */
168
 
 
169
 
  MY_BITMAP all_set;
170
 
  /*
171
 
    Key which is used for looking-up table in table cache and in the list
172
 
    of thread's temporary tables. Has the form of:
173
 
      "database_name\0table_name\0" + optional part for temporary tables.
174
 
 
175
 
    Note that all three 'table_cache_key', 'db' and 'table_name' members
176
 
    must be set (and be non-zero) for tables in table cache. They also
177
 
    should correspond to each other.
178
 
    To ensure this one can use set_table_cache() methods.
179
 
  */
180
 
  LEX_STRING table_cache_key;
181
 
  LEX_STRING db;                        /* Pointer to db */
182
 
  LEX_STRING table_name;                /* Table name (for open) */
183
 
  LEX_STRING path;      /* Path to .frm file (from datadir) */
184
 
  LEX_STRING normalized_path;           /* unpack_filename(path) */
185
 
  LEX_STRING connect_string;
186
 
 
187
 
  /*
188
 
     Set of keys in use, implemented as a Bitmap.
189
 
     Excludes keys disabled by ALTER Table ... DISABLE KEYS.
190
 
  */
191
 
  key_map keys_in_use;
192
 
  key_map keys_for_keyread;
193
 
  ha_rows min_rows, max_rows;           /* create information */
194
 
  uint32_t   avg_row_length;            /* create information */
195
 
  uint32_t   block_size;                   /* create information */
196
 
  uint32_t   version, mysql_version;
197
 
  uint32_t   timestamp_offset;          /* Set to offset+1 of record */
198
 
  uint32_t   reclength;                 /* Recordlength */
199
 
 
200
 
  plugin_ref db_plugin;                 /* storage engine plugin */
201
 
  inline handlerton *db_type() const    /* table_type for handler */
202
 
  {
203
 
    // assert(db_plugin);
204
 
    return db_plugin ? plugin_data(db_plugin, handlerton*) : NULL;
205
 
  }
206
 
  enum row_type row_type;               /* How rows are stored */
207
 
  enum tmp_table_type tmp_table;
208
 
  enum ha_choice transactional;
209
 
  enum ha_choice page_checksum;
210
 
 
211
 
  uint32_t ref_count;                       /* How many Table objects uses this */
212
 
  uint32_t open_count;                  /* Number of tables in open list */
213
 
  uint32_t blob_ptr_size;                       /* 4 or 8 */
214
 
  uint32_t key_block_size;                      /* create key_block_size, if used */
215
 
  uint32_t null_bytes, last_null_bit_pos;
216
 
  uint32_t fields;                              /* Number of fields */
217
 
  uint32_t rec_buff_length;                 /* Size of table->record[] buffer */
218
 
  uint32_t keys, key_parts;
219
 
  uint32_t max_key_length, max_unique_length, total_key_length;
220
 
  uint32_t uniques;                         /* Number of UNIQUE index */
221
 
  uint32_t null_fields;                 /* number of null fields */
222
 
  uint32_t blob_fields;                 /* number of blob fields */
223
 
  uint32_t timestamp_field_offset;              /* Field number for timestamp field */
224
 
  uint32_t varchar_fields;                  /* number of varchar fields */
225
 
  uint32_t db_create_options;           /* Create options from database */
226
 
  uint32_t db_options_in_use;           /* Options in use */
227
 
  uint32_t db_record_offset;            /* if HA_REC_IN_SEQ */
228
 
  uint32_t rowid_field_offset;          /* Field_nr +1 to rowid field */
229
 
  /* Index of auto-updated TIMESTAMP field in field array */
230
 
  uint32_t primary_key;
231
 
  uint32_t next_number_index;               /* autoincrement key number */
232
 
  uint32_t next_number_key_offset;          /* autoinc keypart offset in a key */
233
 
  uint32_t next_number_keypart;             /* autoinc keypart number in a key */
234
 
  uint32_t error, open_errno, errarg;       /* error from open_table_def() */
235
 
  uint32_t column_bitmap_size;
236
 
  unsigned char frm_version;
237
 
  bool null_field_first;
238
 
  bool db_low_byte_first;               /* Portable row format */
239
 
  bool crashed;
240
 
  bool name_lock, replace_with_name_lock;
241
 
  bool waiting_on_cond;                 /* Protection against free */
242
 
  uint32_t table_map_id;                   /* for row-based replication */
243
 
  uint64_t table_map_version;
244
 
 
245
 
  /*
246
 
    Cache for row-based replication table share checks that does not
247
 
    need to be repeated. Possible values are: -1 when cache value is
248
 
    not calculated yet, 0 when table *shall not* be replicated, 1 when
249
 
    table *may* be replicated.
250
 
  */
251
 
  int cached_row_logging_check;
252
 
 
253
 
  /*
254
 
    Set share's table cache key and update its db and table name appropriately.
255
 
 
256
 
    SYNOPSIS
257
 
      set_table_cache_key()
258
 
        key_buff    Buffer with already built table cache key to be
259
 
                    referenced from share.
260
 
        key_length  Key length.
261
 
 
262
 
    NOTES
263
 
      Since 'key_buff' buffer will be referenced from share it should has same
264
 
      life-time as share itself.
265
 
      This method automatically ensures that TABLE_SHARE::table_name/db have
266
 
      appropriate values by using table cache key as their source.
267
 
  */
268
 
 
269
 
  void set_table_cache_key(char *key_buff, uint32_t key_length)
270
 
  {
271
 
    table_cache_key.str= key_buff;
272
 
    table_cache_key.length= key_length;
273
 
    /*
274
 
      Let us use the fact that the key is "db/0/table_name/0" + optional
275
 
      part for temporary tables.
276
 
    */
277
 
    db.str=            table_cache_key.str;
278
 
    db.length=         strlen(db.str);
279
 
    table_name.str=    db.str + db.length + 1;
280
 
    table_name.length= strlen(table_name.str);
281
 
  }
282
 
 
283
 
 
284
 
  /*
285
 
    Set share's table cache key and update its db and table name appropriately.
286
 
 
287
 
    SYNOPSIS
288
 
      set_table_cache_key()
289
 
        key_buff    Buffer to be used as storage for table cache key
290
 
                    (should be at least key_length bytes).
291
 
        key         Value for table cache key.
292
 
        key_length  Key length.
293
 
 
294
 
    NOTE
295
 
      Since 'key_buff' buffer will be used as storage for table cache key
296
 
      it should has same life-time as share itself.
297
 
  */
298
 
 
299
 
  void set_table_cache_key(char *key_buff, const char *key, uint32_t key_length)
300
 
  {
301
 
    memcpy(key_buff, key, key_length);
302
 
    set_table_cache_key(key_buff, key_length);
303
 
  }
304
 
 
305
 
  inline bool honor_global_locks()
306
 
  {
307
 
    return (table_category == TABLE_CATEGORY_USER);
308
 
  }
309
 
 
310
 
  inline uint32_t get_table_def_version()
311
 
  {
312
 
    return table_map_id;
313
 
  }
314
 
 
315
 
} TABLE_SHARE;
316
 
 
317
 
 
318
 
extern uint32_t refresh_version;
319
 
 
320
 
/* Information for one open table */
321
 
enum index_hint_type
322
 
{
323
 
  INDEX_HINT_IGNORE,
324
 
  INDEX_HINT_USE,
325
 
  INDEX_HINT_FORCE
326
 
};
327
 
 
328
 
typedef struct st_table_field_w_type
329
 
{
330
 
  LEX_STRING name;
331
 
  LEX_STRING type;
332
 
  LEX_STRING cset;
333
 
} TABLE_FIELD_W_TYPE;
334
 
 
335
 
bool create_myisam_from_heap(THD *thd, Table *table,
 
54
bool create_myisam_from_heap(Session *session, Table *table,
336
55
                             MI_COLUMNDEF *start_recinfo,
337
 
                             MI_COLUMNDEF **recinfo, 
 
56
                             MI_COLUMNDEF **recinfo,
338
57
                             int error, bool ignore_last_dupp_key_error);
339
58
 
340
 
class Table {
341
 
 
 
59
/**
 
60
 * Class representing a set of records, either in a temporary, 
 
61
 * normal, or derived table.
 
62
 */
 
63
class Table 
 
64
{
342
65
public:
343
 
  TABLE_SHARE   *s;
344
 
  Table() {}                               /* Remove gcc warning */
345
 
 
346
 
  /* SHARE methods */
347
 
  inline TABLE_SHARE *getShare() { return s; } /* Get rid of this long term */
348
 
  inline void setShare(TABLE_SHARE *new_share) { s= new_share; } /* Get rid of this long term */
349
 
  inline uint32_t sizeKeys() { return s->keys; }
350
 
  inline uint32_t sizeFields() { return s->fields; }
351
 
  inline uint32_t getRecordLength() { return s->reclength; }
352
 
  inline uint32_t sizeBlobFields() { return s->blob_fields; }
353
 
  inline uint32_t *getBlobField() { return s->blob_field; }
354
 
  inline uint32_t getNullBytes() { return s->null_bytes; }
355
 
  inline uint32_t getNullFields() { return s->null_fields; }
356
 
  inline unsigned char *getDefaultValues() { return s->default_values; }
357
 
 
358
 
  inline bool isNullFieldFirst() { return s->null_field_first; }
359
 
  inline bool isDatabaseLowByteFirst() { return s->db_low_byte_first; }         /* Portable row format */
360
 
  inline bool isCrashed() { return s->crashed; }
361
 
  inline bool isNameLock() { return s->name_lock; } 
362
 
  inline bool isReplaceWithNameLock() { return s->replace_with_name_lock; }
363
 
  inline bool isWaitingOnCondition() { return s->waiting_on_cond; }                 /* Protection against free */
364
 
 
365
 
  /* For TMP tables, should be pulled out as a class */
366
 
  void updateCreateInfo(HA_CREATE_INFO *create_info);
367
 
  void setup_tmp_table_column_bitmaps(unsigned char *bitmaps);
368
 
  bool create_myisam_tmp_table(KEY *keyinfo, 
369
 
                               MI_COLUMNDEF *start_recinfo,
370
 
                               MI_COLUMNDEF **recinfo, 
371
 
                               uint64_t options);
372
 
  void free_tmp_table(THD *thd);
373
 
  bool open_tmp_table();
374
 
  size_t max_row_length(const unsigned char *data);
375
 
  uint32_t find_shortest_key(const key_map *usable_keys);
376
 
  bool compare_record(Field **ptr);
377
 
  bool compare_record();
378
 
 
379
 
  bool table_check_intact(const uint32_t table_f_count, const TABLE_FIELD_W_TYPE *table_def);
380
 
 
381
 
  /* See if this can be blown away */
382
 
  inline uint32_t getDBStat () { return db_stat; }
383
 
  inline uint32_t setDBStat () { return db_stat; }
384
 
  uint          db_stat;                /* mode of file as in handler.h */
385
 
 
386
 
  handler       *file;
387
 
  Table *next, *prev;
388
 
 
389
 
  THD   *in_use;                        /* Which thread uses this */
390
 
  Field **field;                        /* Pointer to fields */
391
 
 
392
 
  unsigned char *record[2];                     /* Pointer to records */
393
 
  unsigned char *write_row_record;              /* Used as optimisation in
394
 
                                           THD::write_row */
395
 
  unsigned char *insert_values;                  /* used by INSERT ... UPDATE */
396
 
  /* 
397
 
    Map of keys that can be used to retrieve all data from this table 
398
 
    needed by the query without reading the row.
399
 
  */
400
 
  key_map covering_keys;
401
 
  key_map quick_keys, merge_keys;
402
 
  /*
403
 
    A set of keys that can be used in the query that references this
404
 
    table.
405
 
 
406
 
    All indexes disabled on the table's TABLE_SHARE (see Table::s) will be 
407
 
    subtracted from this set upon instantiation. Thus for any Table t it holds
408
 
    that t.keys_in_use_for_query is a subset of t.s.keys_in_use. Generally we 
409
 
    must not introduce any new keys here (see setup_tables).
410
 
 
411
 
    The set is implemented as a bitmap.
412
 
  */
413
 
  key_map keys_in_use_for_query;
414
 
  /* Map of keys that can be used to calculate GROUP BY without sorting */
415
 
  key_map keys_in_use_for_group_by;
416
 
  /* Map of keys that can be used to calculate ORDER BY without sorting */
417
 
  key_map keys_in_use_for_order_by;
418
 
  KEY  *key_info;                       /* data of keys in database */
419
 
 
420
 
  Field *next_number_field;             /* Set if next_number is activated */
421
 
  Field *found_next_number_field;       /* Set on open */
422
 
  Field_timestamp *timestamp_field;
423
 
 
424
 
  TableList *pos_in_table_list;/* Element referring to this table */
 
66
 
 
67
  TableShare *s; /**< Pointer to the shared metadata about the table */
 
68
  Field **field; /**< Pointer to fields collection */
 
69
 
 
70
  handler *file; /**< Pointer to the storage engine's handler managing this table */
 
71
  Table *next;
 
72
  Table *prev;
 
73
 
 
74
  MyBitmap *read_set; /* Active column sets */
 
75
  MyBitmap *write_set; /* Active column sets */
 
76
 
 
77
  uint32_t tablenr;
 
78
  uint32_t db_stat; /**< information about the file as in handler.h */
 
79
 
 
80
  MyBitmap def_read_set; /**< Default read set of columns */
 
81
  MyBitmap def_write_set; /**< Default write set of columns */
 
82
  MyBitmap tmp_set; /* Not sure about this... */
 
83
 
 
84
  Session       *in_use; /**< Pointer to the current session using this object */
 
85
 
 
86
  unsigned char *record[2]; /**< Pointer to "records" */
 
87
  unsigned char *insert_values; /* used by INSERT ... UPDATE */
 
88
  KEY  *key_info; /**< data of keys in database */
 
89
  Field *next_number_field; /**< Set if next_number is activated. @TODO What the heck is the difference between this and the next member? */
 
90
  Field *found_next_number_field; /**< Points to the "next-number" field (autoincrement field) */
 
91
  Field_timestamp *timestamp_field; /**< Points to the auto-setting timestamp field, if any */
 
92
 
 
93
  TableList *pos_in_table_list; /* Element referring to this table */
425
94
  order_st *group;
426
 
  const char    *alias;                   /* alias or table name */
427
 
  unsigned char         *null_flags;
428
 
  my_bitmap_map *bitmap_init_value;
429
 
  MY_BITMAP     def_read_set, def_write_set, tmp_set; /* containers */
430
 
  MY_BITMAP     *read_set, *write_set;          /* Active column sets */
431
 
  /*
432
 
   The ID of the query that opened and is using this table. Has different
433
 
   meanings depending on the table type.
434
 
 
435
 
   Temporary tables:
436
 
 
437
 
   table->query_id is set to thd->query_id for the duration of a statement
438
 
   and is reset to 0 once it is closed by the same statement. A non-zero
439
 
   table->query_id means that a statement is using the table even if it's
440
 
   not the current statement (table is in use by some outer statement).
441
 
 
442
 
   Non-temporary tables:
443
 
 
444
 
   Under pre-locked or LOCK TABLES mode: query_id is set to thd->query_id
445
 
   for the duration of a statement and is reset to 0 once it is closed by
446
 
   the same statement. A non-zero query_id is used to control which tables
447
 
   in the list of pre-opened and locked tables are actually being used.
448
 
  */
449
 
  query_id_t    query_id;
450
 
 
451
 
  /* 
452
 
    For each key that has quick_keys.is_set(key) == true: estimate of #records
453
 
    and max #key parts that range access would use.
454
 
  */
455
 
  ha_rows       quick_rows[MAX_KEY];
456
 
 
457
 
  /* Bitmaps of key parts that =const for the entire join. */
458
 
  key_part_map  const_key_parts[MAX_KEY];
459
 
 
460
 
  uint          quick_key_parts[MAX_KEY];
461
 
  uint          quick_n_ranges[MAX_KEY];
462
 
 
463
 
  /* 
464
 
    Estimate of number of records that satisfy SARGable part of the table
465
 
    condition, or table->file->records if no SARGable condition could be
466
 
    constructed.
467
 
    This value is used by join optimizer as an estimate of number of records
468
 
    that will pass the table condition (condition that depends on fields of 
469
 
    this table and constants)
470
 
  */
471
 
  ha_rows       quick_condition_rows;
472
 
 
473
 
  /*
474
 
    If this table has TIMESTAMP field with auto-set property (pointed by
475
 
    timestamp_field member) then this variable indicates during which
476
 
    operations (insert only/on update/in both cases) we should set this
477
 
    field to current timestamp. If there are no such field in this table
478
 
    or we should not automatically set its value during execution of current
479
 
    statement then the variable contains TIMESTAMP_NO_AUTO_SET (i.e. 0).
480
 
 
481
 
    Value of this variable is set for each statement in open_table() and
482
 
    if needed cleared later in statement processing code (see mysql_update()
483
 
    as example).
484
 
  */
485
 
  timestamp_auto_set_type timestamp_field_type;
486
 
  table_map     map;                    /* ID bit of table (1,2,4,8,16...) */
487
 
 
488
 
  uint32_t          lock_position;          /* Position in DRIZZLE_LOCK.table */
489
 
  uint32_t          lock_data_start;        /* Start pos. in DRIZZLE_LOCK.locks */
490
 
  uint32_t          lock_count;             /* Number of locks */
491
 
  uint          tablenr,used_fields;
492
 
  uint32_t          temp_pool_slot;             /* Used by intern temp tables */
493
 
  uint          status;                 /* What's in record[0] */
 
95
  const char *alias; /**< alias or table name if no alias */
 
96
  unsigned char *null_flags;
 
97
 
 
98
  uint32_t lock_position; /**< Position in DRIZZLE_LOCK.table */
 
99
  uint32_t lock_data_start; /**< Start pos. in DRIZZLE_LOCK.locks */
 
100
  uint32_t lock_count; /**< Number of locks */
 
101
  uint32_t used_fields;
 
102
  uint32_t status; /* What's in record[0] */
494
103
  /* number of select if it is derived table */
495
 
  uint32_t          derived_select_number;
496
 
  int           current_lock;           /* Type of lock on table */
497
 
  bool copy_blobs;                      /* copy_blobs when storing */
 
104
  uint32_t derived_select_number;
 
105
  int   current_lock; /**< Type of lock on table */
 
106
  bool copy_blobs; /**< Should blobs by copied when storing? */
498
107
 
499
108
  /*
500
109
    0 or JOIN_TYPE_{LEFT|RIGHT}. Currently this is only compared to 0.
504
113
  bool maybe_null;
505
114
 
506
115
  /*
507
 
    If true, the current table row is considered to have all columns set to 
 
116
    If true, the current table row is considered to have all columns set to
508
117
    NULL, including columns declared as "not null" (see maybe_null).
509
118
  */
510
119
  bool null_row;
511
120
 
512
121
  bool force_index;
513
122
  bool distinct,const_table,no_rows;
514
 
  bool key_read, no_keyread;
 
123
  bool key_read;
 
124
  bool no_keyread;
515
125
  /*
516
126
    Placeholder for an open table which prevents other connections
517
127
    from taking name-locks on this table. Typically used with
518
 
    TABLE_SHARE::version member to take an exclusive name-lock on
 
128
    TableShare::version member to take an exclusive name-lock on
519
129
    this table name -- a name lock that not only prevents other
520
130
    threads from opening the table, but also blocks other name
521
131
    locks. This is achieved by:
530
140
    not rely on that.
531
141
  */
532
142
  bool open_placeholder;
533
 
  bool locked_by_logger;
534
 
  bool no_replicate;
535
143
  bool locked_by_name;
536
144
  bool no_cache;
537
 
  /* To signal that the table is associated with a HANDLER statement */
538
 
  bool open_by_handler;
539
145
  /*
540
146
    To indicate that a non-null value of the auto_increment field
541
147
    was provided by the user or retrieved from the current record.
542
148
    Used only in the MODE_NO_AUTO_VALUE_ON_ZERO mode.
543
149
  */
544
150
  bool auto_increment_field_not_null;
545
 
  bool insert_or_update;             /* Can be used by the handler */
546
 
  bool alias_name_used;         /* true if table_name is alias */
547
 
  bool get_fields_in_item_tree;      /* Signal to fix_field */
548
 
 
549
 
  REGINFO reginfo;                      /* field connections */
 
151
  bool alias_name_used; /* true if table_name is alias */
 
152
 
 
153
  /*
 
154
   The ID of the query that opened and is using this table. Has different
 
155
   meanings depending on the table type.
 
156
 
 
157
   Temporary tables:
 
158
 
 
159
   table->query_id is set to session->query_id for the duration of a statement
 
160
   and is reset to 0 once it is closed by the same statement. A non-zero
 
161
   table->query_id means that a statement is using the table even if it's
 
162
   not the current statement (table is in use by some outer statement).
 
163
 
 
164
   Non-temporary tables:
 
165
 
 
166
   Under pre-locked or LOCK TABLES mode: query_id is set to session->query_id
 
167
   for the duration of a statement and is reset to 0 once it is closed by
 
168
   the same statement. A non-zero query_id is used to control which tables
 
169
   in the list of pre-opened and locked tables are actually being used.
 
170
  */
 
171
  query_id_t    query_id;
 
172
 
 
173
  /*
 
174
    Estimate of number of records that satisfy SARGable part of the table
 
175
    condition, or table->file->records if no SARGable condition could be
 
176
    constructed.
 
177
    This value is used by join optimizer as an estimate of number of records
 
178
    that will pass the table condition (condition that depends on fields of
 
179
    this table and constants)
 
180
  */
 
181
  ha_rows quick_condition_rows;
 
182
 
 
183
  /*
 
184
    If this table has TIMESTAMP field with auto-set property (pointed by
 
185
    timestamp_field member) then this variable indicates during which
 
186
    operations (insert only/on update/in both cases) we should set this
 
187
    field to current timestamp. If there are no such field in this table
 
188
    or we should not automatically set its value during execution of current
 
189
    statement then the variable contains TIMESTAMP_NO_AUTO_SET (i.e. 0).
 
190
 
 
191
    Value of this variable is set for each statement in open_table() and
 
192
    if needed cleared later in statement processing code (see mysql_update()
 
193
    as example).
 
194
  */
 
195
  timestamp_auto_set_type timestamp_field_type;
 
196
  table_map     map; /* ID bit of table (1,2,4,8,16...) */
 
197
 
 
198
  RegInfo reginfo; /* field connections */
 
199
 
 
200
  /*
 
201
    Map of keys that can be used to retrieve all data from this table
 
202
    needed by the query without reading the row.
 
203
  */
 
204
  key_map covering_keys;
 
205
  key_map quick_keys;
 
206
  key_map merge_keys;
 
207
 
 
208
  /*
 
209
    A set of keys that can be used in the query that references this
 
210
    table.
 
211
 
 
212
    All indexes disabled on the table's TableShare (see Table::s) will be
 
213
    subtracted from this set upon instantiation. Thus for any Table t it holds
 
214
    that t.keys_in_use_for_query is a subset of t.s.keys_in_use. Generally we
 
215
    must not introduce any new keys here (see setup_tables).
 
216
 
 
217
    The set is implemented as a bitmap.
 
218
  */
 
219
  key_map keys_in_use_for_query;
 
220
  /* Map of keys that can be used to calculate GROUP BY without sorting */
 
221
  key_map keys_in_use_for_group_by;
 
222
  /* Map of keys that can be used to calculate ORDER BY without sorting */
 
223
  key_map keys_in_use_for_order_by;
 
224
 
 
225
  /*
 
226
    For each key that has quick_keys.test(key) == true: estimate of #records
 
227
    and max #key parts that range access would use.
 
228
  */
 
229
  ha_rows       quick_rows[MAX_KEY];
 
230
 
 
231
  /* Bitmaps of key parts that =const for the entire join. */
 
232
  key_part_map  const_key_parts[MAX_KEY];
 
233
 
 
234
  uint32_t quick_key_parts[MAX_KEY];
 
235
  uint32_t quick_n_ranges[MAX_KEY];
 
236
 
550
237
  MEM_ROOT mem_root;
551
238
  filesort_info_st sort;
552
239
 
 
240
  Table() : 
 
241
    s(NULL), 
 
242
    field(NULL),
 
243
    file(NULL),
 
244
    next(NULL),
 
245
    prev(NULL),
 
246
    read_set(NULL),
 
247
    write_set(NULL),
 
248
    tablenr(0),
 
249
    db_stat(0),
 
250
    in_use(NULL),
 
251
    insert_values(NULL),
 
252
    key_info(NULL),
 
253
    next_number_field(NULL),
 
254
    found_next_number_field(NULL),
 
255
    timestamp_field(NULL),
 
256
    pos_in_table_list(NULL),
 
257
    group(NULL),
 
258
    alias(NULL),
 
259
    null_flags(NULL),
 
260
    lock_position(0),
 
261
    lock_data_start(0),
 
262
    lock_count(0),
 
263
    used_fields(0),
 
264
    status(0),
 
265
    derived_select_number(0),
 
266
    current_lock(F_UNLCK),
 
267
    copy_blobs(false),
 
268
    maybe_null(false),
 
269
    null_row(false),
 
270
    force_index(false),
 
271
    distinct(false),
 
272
    const_table(false),
 
273
    no_rows(false),
 
274
    key_read(false),
 
275
    no_keyread(false),
 
276
    open_placeholder(false),
 
277
    locked_by_name(false),
 
278
    no_cache(false),
 
279
    auto_increment_field_not_null(false),
 
280
    alias_name_used(false),
 
281
    query_id(0), 
 
282
    quick_condition_rows(0),
 
283
    timestamp_field_type(TIMESTAMP_NO_AUTO_SET),
 
284
    map(0)
 
285
  {
 
286
    record[0]= (unsigned char *) 0;
 
287
    record[1]= (unsigned char *) 0;
 
288
 
 
289
    covering_keys.reset();
 
290
 
 
291
    quick_keys.reset();
 
292
    merge_keys.reset();
 
293
 
 
294
    keys_in_use_for_query.reset();
 
295
    keys_in_use_for_group_by.reset();
 
296
    keys_in_use_for_order_by.reset();
 
297
 
 
298
    memset(quick_rows, 0, sizeof(query_id_t) * MAX_KEY);
 
299
    memset(const_key_parts, 0, sizeof(ha_rows) * MAX_KEY);
 
300
 
 
301
    memset(quick_key_parts, 0, sizeof(unsigned int) * MAX_KEY);
 
302
    memset(quick_n_ranges, 0, sizeof(unsigned int) * MAX_KEY);
 
303
 
 
304
    init_sql_alloc(&mem_root, TABLE_ALLOC_BLOCK_SIZE, 0);
 
305
    memset(&sort, 0, sizeof(filesort_info_st));
 
306
  }
 
307
 
 
308
  int report_error(int error);
 
309
  int closefrm(bool free_share);
 
310
 
 
311
  void resetTable(Session *session, TableShare *share, uint32_t db_stat_arg)
 
312
  {
 
313
    s= share;
 
314
    field= NULL;
 
315
 
 
316
    file= NULL;
 
317
    next= NULL;
 
318
    prev= NULL;
 
319
 
 
320
    read_set= NULL;
 
321
    write_set= NULL;
 
322
 
 
323
    tablenr= 0;
 
324
    db_stat= db_stat_arg;
 
325
 
 
326
    in_use= session;
 
327
    record[0]= (unsigned char *) 0;
 
328
    record[1]= (unsigned char *) 0;
 
329
 
 
330
    insert_values= NULL;
 
331
    key_info= NULL;
 
332
    next_number_field= NULL;
 
333
    found_next_number_field= NULL;
 
334
    timestamp_field= NULL;
 
335
 
 
336
    pos_in_table_list= NULL;
 
337
    group= NULL;
 
338
    alias= NULL;
 
339
    null_flags= NULL;
 
340
     
 
341
    lock_position= 0;
 
342
    lock_data_start= 0;
 
343
    lock_count= 0;
 
344
    used_fields= 0;
 
345
    status= 0;
 
346
    derived_select_number= 0;
 
347
    current_lock= F_UNLCK;
 
348
    copy_blobs= false;
 
349
 
 
350
    maybe_null= false;
 
351
 
 
352
    null_row= false;
 
353
 
 
354
    force_index= false;
 
355
    distinct= false;
 
356
    const_table= false;
 
357
    no_rows= false;
 
358
    key_read= false;
 
359
    no_keyread= false;
 
360
 
 
361
    open_placeholder= false;
 
362
    locked_by_name= false;
 
363
    no_cache= false;
 
364
 
 
365
    auto_increment_field_not_null= false;
 
366
    alias_name_used= false;
 
367
    
 
368
    query_id= 0;
 
369
    quick_condition_rows= 0;
 
370
     
 
371
    timestamp_field_type= TIMESTAMP_NO_AUTO_SET;
 
372
    map= 0;
 
373
 
 
374
    reginfo.reset();
 
375
 
 
376
    covering_keys.reset();
 
377
 
 
378
    quick_keys.reset();
 
379
    merge_keys.reset();
 
380
 
 
381
    keys_in_use_for_query.reset();
 
382
    keys_in_use_for_group_by.reset();
 
383
    keys_in_use_for_order_by.reset();
 
384
 
 
385
    memset(quick_rows, 0, sizeof(query_id_t) * MAX_KEY);
 
386
    memset(const_key_parts, 0, sizeof(ha_rows) * MAX_KEY);
 
387
 
 
388
    memset(quick_key_parts, 0, sizeof(unsigned int) * MAX_KEY);
 
389
    memset(quick_n_ranges, 0, sizeof(unsigned int) * MAX_KEY);
 
390
 
 
391
    init_sql_alloc(&mem_root, TABLE_ALLOC_BLOCK_SIZE, 0);
 
392
    memset(&sort, 0, sizeof(filesort_info_st));
 
393
  }
 
394
 
 
395
  /* SHARE methods */
 
396
  inline TableShare *getShare() { return s; } /* Get rid of this long term */
 
397
  inline void setShare(TableShare *new_share) { s= new_share; } /* Get rid of this long term */
 
398
  inline uint32_t sizeKeys() { return s->keys; }
 
399
  inline uint32_t sizeFields() { return s->fields; }
 
400
  inline uint32_t getRecordLength() { return s->reclength; }
 
401
  inline uint32_t sizeBlobFields() { return s->blob_fields; }
 
402
  inline uint32_t *getBlobField() { return s->blob_field; }
 
403
  inline uint32_t getNullBytes() { return s->null_bytes; }
 
404
  inline uint32_t getNullFields() { return s->null_fields; }
 
405
  inline unsigned char *getDefaultValues() { return s->default_values; }
 
406
 
 
407
  inline bool isDatabaseLowByteFirst() { return s->db_low_byte_first; } /* Portable row format */
 
408
  inline bool isCrashed() { return s->crashed; }
 
409
  inline bool isNameLock() { return s->name_lock; }
 
410
  inline bool isReplaceWithNameLock() { return s->replace_with_name_lock; }
 
411
  inline bool isWaitingOnCondition() { return s->waiting_on_cond; } /* Protection against free */
 
412
 
 
413
  /* For TMP tables, should be pulled out as a class */
 
414
  void updateCreateInfo(HA_CREATE_INFO *create_info,
 
415
                        drizzled::message::Table *table_proto);
 
416
  void setup_tmp_table_column_bitmaps(unsigned char *bitmaps);
 
417
  bool create_myisam_tmp_table(KEY *keyinfo,
 
418
                               MI_COLUMNDEF *start_recinfo,
 
419
                               MI_COLUMNDEF **recinfo,
 
420
                               uint64_t options);
 
421
  void free_tmp_table(Session *session);
 
422
  bool open_tmp_table();
 
423
  size_t max_row_length(const unsigned char *data);
 
424
  uint32_t find_shortest_key(const key_map *usable_keys);
 
425
  bool compare_record(Field **ptr);
 
426
  bool compare_record();
 
427
  /* TODO: the (re)storeRecord's may be able to be further condensed */
 
428
  void storeRecord();
 
429
  void storeRecordAsInsert();
 
430
  void storeRecordAsDefault();
 
431
  void restoreRecord();
 
432
  void restoreRecordAsDefault();
 
433
  void emptyRecord();
 
434
 
 
435
  /* See if this can be blown away */
 
436
  inline uint32_t getDBStat () { return db_stat; }
 
437
  inline uint32_t setDBStat () { return db_stat; }
553
438
  bool fill_item_list(List<Item> *item_list) const;
554
 
  void reset_item_list(List<Item> *item_list) const;
555
439
  void clear_column_bitmaps(void);
556
440
  void prepare_for_position(void);
557
 
  void mark_columns_used_by_index_no_reset(uint32_t index, MY_BITMAP *map);
 
441
  void mark_columns_used_by_index_no_reset(uint32_t index, MyBitmap *map);
 
442
  void mark_columns_used_by_index_no_reset(uint32_t index);
558
443
  void mark_columns_used_by_index(uint32_t index);
559
444
  void restore_column_maps_after_mark_index();
560
445
  void mark_auto_increment_column(void);
561
446
  void mark_columns_needed_for_update(void);
562
447
  void mark_columns_needed_for_delete(void);
563
448
  void mark_columns_needed_for_insert(void);
564
 
  inline void column_bitmaps_set(MY_BITMAP *read_set_arg,
565
 
                                 MY_BITMAP *write_set_arg)
566
 
  {
567
 
    read_set= read_set_arg;
568
 
    write_set= write_set_arg;
569
 
    if (file)
570
 
      file->column_bitmaps_signal();
571
 
  }
572
 
  inline void column_bitmaps_set_no_signal(MY_BITMAP *read_set_arg,
573
 
                                           MY_BITMAP *write_set_arg)
574
 
  {
575
 
    read_set= read_set_arg;
576
 
    write_set= write_set_arg;
577
 
  }
 
449
  inline void column_bitmaps_set(MyBitmap *read_set_arg,
 
450
                                 MyBitmap *write_set_arg)
 
451
  {
 
452
    read_set= read_set_arg;
 
453
    write_set= write_set_arg;
 
454
  }
 
455
  /**
 
456
   * Find field in table, no side effects, only purpose is to check for field
 
457
   * in table object and get reference to the field if found.
 
458
   *
 
459
   * @param Name of field searched for
 
460
   *
 
461
   * @retval
 
462
   *  0 field is not found
 
463
   * @retval
 
464
   *  non-0 pointer to field
 
465
   */
 
466
  Field *find_field_in_table_sef(const char *name);
578
467
 
579
468
  void restore_column_map(my_bitmap_map *old);
580
469
 
581
 
  my_bitmap_map *use_all_columns(MY_BITMAP *bitmap);
 
470
  my_bitmap_map *use_all_columns(MyBitmap *bitmap);
582
471
  inline void use_all_columns()
583
472
  {
584
473
    column_bitmaps_set(&s->all_set, &s->all_set);
590
479
    write_set= &def_write_set;
591
480
  }
592
481
 
 
482
  /* Both of the below should go away once we can move this bit to the field objects */
 
483
  inline bool isReadSet(uint32_t index)
 
484
  {
 
485
    return read_set->isBitSet(index);
 
486
  }
 
487
 
 
488
  inline void setReadSet(uint32_t index)
 
489
  {
 
490
    read_set->setBit(index);
 
491
  }
 
492
 
 
493
  inline void setReadSet()
 
494
  {
 
495
    read_set->setAll();
 
496
  }
 
497
 
 
498
  inline void clearReadSet(uint32_t index)
 
499
  {
 
500
    read_set->clearBit(index);
 
501
  }
 
502
 
 
503
  inline void clearReadSet()
 
504
  {
 
505
    read_set->clearAll();
 
506
  }
 
507
 
 
508
  inline bool isWriteSet(uint32_t index)
 
509
  {
 
510
    return write_set->isBitSet(index);
 
511
  }
 
512
 
 
513
  inline void setWriteSet(uint32_t index)
 
514
  {
 
515
    write_set->setBit(index);
 
516
  }
 
517
 
 
518
  inline void setWriteSet()
 
519
  {
 
520
    write_set->setAll();
 
521
  }
 
522
 
 
523
  inline void clearWriteSet(uint32_t index)
 
524
  {
 
525
    write_set->clearBit(index);
 
526
  }
 
527
 
 
528
  inline void clearWriteSet()
 
529
  {
 
530
    write_set->clearAll();
 
531
  }
 
532
 
593
533
  /* Is table open or should be treated as such by name-locking? */
594
 
  inline bool is_name_opened() { return db_stat || open_placeholder; }
 
534
  inline bool is_name_opened()
 
535
  {
 
536
    return db_stat || open_placeholder;
 
537
  }
595
538
  /*
596
539
    Is this instance of the table should be reopen or represents a name-lock?
597
540
  */
598
541
  inline bool needs_reopen_or_name_lock()
599
 
  { return s->version != refresh_version; }
600
 
 
601
 
  int report_error(int error);
 
542
  { 
 
543
    return s->version != refresh_version;
 
544
  }
 
545
 
 
546
  /**
 
547
    clean/setup table fields and map.
 
548
 
 
549
    @param table        Table structure pointer (which should be setup)
 
550
    @param table_list   TableList structure pointer (owner of Table)
 
551
    @param tablenr     table number
 
552
  */
 
553
  void setup_table_map(TableList *table_list, uint32_t tablenr);
 
554
  inline void mark_as_null_row()
 
555
  {
 
556
    null_row= 1;
 
557
    status|= STATUS_NULL_ROW;
 
558
    memset(null_flags, 255, s->null_bytes);
 
559
  }
 
560
 
 
561
  bool rename_temporary_table(const char *db, const char *table_name);
 
562
  void free_io_cache();
 
563
  void filesort_free_buffers(bool full= false);
 
564
  void intern_close_table();
602
565
};
603
566
 
 
567
Table *create_virtual_tmp_table(Session *session, List<CreateField> &field_list);
 
568
 
604
569
typedef struct st_foreign_key_info
605
570
{
606
571
  LEX_STRING *forein_id;
613
578
  List<LEX_STRING> referenced_fields;
614
579
} FOREIGN_KEY_INFO;
615
580
 
616
 
/*
617
 
  Make sure that the order of schema_tables and enum_schema_tables are the same.
618
 
*/
619
 
 
620
 
enum enum_schema_tables
621
 
{
622
 
  SCH_CHARSETS= 0,
623
 
  SCH_COLLATIONS,
624
 
  SCH_COLLATION_CHARACTER_SET_APPLICABILITY,
625
 
  SCH_COLUMNS,
626
 
  SCH_GLOBAL_STATUS,
627
 
  SCH_GLOBAL_VARIABLES,
628
 
  SCH_KEY_COLUMN_USAGE,
629
 
  SCH_OPEN_TABLES,
630
 
  SCH_PLUGINS,
631
 
  SCH_PROCESSLIST,
632
 
  SCH_REFERENTIAL_CONSTRAINTS,
633
 
  SCH_SCHEMATA,
634
 
  SCH_SESSION_STATUS,
635
 
  SCH_SESSION_VARIABLES,
636
 
  SCH_STATISTICS,
637
 
  SCH_STATUS,
638
 
  SCH_TABLES,
639
 
  SCH_TABLE_CONSTRAINTS,
640
 
  SCH_TABLE_NAMES,
641
 
  SCH_VARIABLES
642
 
};
643
 
 
644
 
 
645
 
#define MY_I_S_MAYBE_NULL 1
646
 
#define MY_I_S_UNSIGNED   2
647
 
 
648
 
 
649
 
#define SKIP_OPEN_TABLE 0                // do not open table
650
 
#define OPEN_FRM_ONLY   1                // open FRM file only
651
 
#define OPEN_FULL_TABLE 2                // open FRM,MYD, MYI files
652
 
 
653
 
typedef struct st_field_info
654
 
{
655
 
  /** 
656
 
      This is used as column name. 
657
 
  */
658
 
  const char* field_name;
659
 
  /**
660
 
     For string-type columns, this is the maximum number of
661
 
     characters. Otherwise, it is the 'display-length' for the column.
662
 
  */
663
 
  uint32_t field_length;
664
 
  /**
665
 
     This denotes data type for the column. For the most part, there seems to
666
 
     be one entry in the enum for each SQL data type, although there seem to
667
 
     be a number of additional entries in the enum.
668
 
  */
669
 
  enum enum_field_types field_type;
670
 
  int value;
671
 
  /**
672
 
     This is used to set column attributes. By default, columns are @c NOT
673
 
     @c NULL and @c SIGNED, and you can deviate from the default
674
 
     by setting the appopriate flags. You can use either one of the flags
675
 
     @c MY_I_S_MAYBE_NULL and @cMY_I_S_UNSIGNED or
676
 
     combine them using the bitwise or operator @c |. Both flags are
677
 
     defined in table.h.
678
 
   */
679
 
  uint32_t field_flags;        // Field atributes(maybe_null, signed, unsigned etc.)
680
 
  const char* old_name;
681
 
  /**
682
 
     This should be one of @c SKIP_OPEN_TABLE,
683
 
     @c OPEN_FRM_ONLY or @c OPEN_FULL_TABLE.
684
 
  */
685
 
  uint32_t open_method;
686
 
} ST_FIELD_INFO;
687
581
 
688
582
 
689
583
class TableList;
690
 
typedef class Item COND;
691
 
 
692
 
struct ST_SCHEMA_TABLE
693
 
{
694
 
  const char* table_name;
695
 
  ST_FIELD_INFO *fields_info;
696
 
  /* Create information_schema table */
697
 
  Table *(*create_table)  (THD *thd, TableList *table_list);
698
 
  /* Fill table with data */
699
 
  int (*fill_table) (THD *thd, TableList *tables, COND *cond);
700
 
  /* Handle fileds for old SHOW */
701
 
  int (*old_format) (THD *thd, struct ST_SCHEMA_TABLE *schema_table);
702
 
  int (*process_table) (THD *thd, TableList *tables, Table *table,
703
 
                        bool res, LEX_STRING *db_name, LEX_STRING *table_name);
704
 
  int idx_field1, idx_field2; 
705
 
  bool hidden;
706
 
  uint32_t i_s_requested_object;  /* the object we need to open(Table | VIEW) */
707
 
};
708
 
 
709
584
 
710
585
#define JOIN_TYPE_LEFT  1
711
586
#define JOIN_TYPE_RIGHT 2
712
587
 
713
588
struct st_lex;
714
589
class select_union;
715
 
class TMP_TABLE_PARAM;
716
 
 
717
 
struct Field_translator
718
 
{
719
 
  Item *item;
720
 
  const char *name;
721
 
};
722
 
 
 
590
class Tmp_Table_Param;
723
591
 
724
592
typedef struct st_changed_table_list
725
593
{
726
594
  struct        st_changed_table_list *next;
727
595
  char          *key;
728
 
  uint32_t        key_length;
 
596
  uint32_t key_length;
729
597
} CHANGED_TableList;
730
598
 
731
 
 
732
 
typedef struct st_open_table_list
 
599
struct open_table_list_st
733
600
{
734
 
  struct st_open_table_list *next;
735
 
  char  *db,*table;
736
 
  uint32_t in_use,locked;
737
 
} OPEN_TableList;
738
 
 
 
601
  string        db;
 
602
  string        table;
 
603
  uint32_t in_use;
 
604
  uint32_t locked;
 
605
 
 
606
  open_table_list_st() :
 
607
    in_use(0),
 
608
    locked(0)
 
609
  { }
 
610
 
 
611
};
739
612
 
740
613
#endif /* DRIZZLED_TABLE_H */