← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/table.h

  • Committer: Brian Aker
  • Date: 2009-06-03 19:30:45 UTC
  • mfrom: (1046.1.6 merge)
  • Revision ID: brian@gaz-20090603193045-4xgeczyfixh07beg
Merge for Brian

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 <string>
27
 
#include <boost/dynamic_bitset.hpp>
28
 
 
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/cursor.h"
34
 
#include "drizzled/lex_string.h"
35
 
#include "drizzled/table_list.h"
36
 
#include "drizzled/definition/table.h"
37
 
#include "drizzled/atomics.h"
38
 
#include "drizzled/query_id.h"
39
 
 
40
 
namespace drizzled
41
 
{
 
26
#include <plugin/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
#include <drizzled/table_share.h>
42
36
 
43
37
class Item;
44
38
class Item_subselect;
45
39
class Select_Lex_Unit;
46
40
class Select_Lex;
47
41
class COND_EQUAL;
48
 
class SecurityContext;
 
42
class Security_context;
49
43
class TableList;
 
44
 
 
45
/*************************************************************************/
 
46
 
 
47
 
50
48
class Field_timestamp;
51
49
class Field_blob;
52
50
 
53
 
extern uint64_t refresh_version;
54
 
 
55
51
typedef enum enum_table_category TABLE_CATEGORY;
56
 
typedef struct st_columndef MI_COLUMNDEF;
57
 
 
58
 
/**
59
 
 * Class representing a set of records, either in a temporary, 
60
 
 * normal, or derived table.
61
 
 */
62
 
class Table 
 
52
 
 
53
TABLE_CATEGORY get_table_category(const LEX_STRING *db,
 
54
                                  const LEX_STRING *name);
 
55
 
 
56
 
 
57
extern uint32_t refresh_version;
 
58
 
 
59
typedef struct st_table_field_w_type
63
60
{
64
 
  Field **field; /**< Pointer to fields collection */
 
61
  LEX_STRING name;
 
62
  LEX_STRING type;
 
63
  LEX_STRING cset;
 
64
} TABLE_FIELD_W_TYPE;
 
65
 
 
66
 
 
67
bool create_myisam_from_heap(Session *session, Table *table,
 
68
                             MI_COLUMNDEF *start_recinfo,
 
69
                             MI_COLUMNDEF **recinfo,
 
70
                             int error, bool ignore_last_dupp_key_error);
 
71
 
 
72
class Table {
65
73
public:
66
74
 
67
 
  Field **getFields() const
68
 
  {
69
 
    return field;
70
 
  }
71
 
 
72
 
  Field *getField(uint32_t arg) const
73
 
  {
74
 
    return field[arg];
75
 
  }
76
 
 
77
 
  void setFields(Field **arg)
78
 
  {
79
 
    field= arg;
80
 
  }
81
 
 
82
 
  void setFieldAt(Field *arg, uint32_t arg_pos)
83
 
  {
84
 
    field[arg_pos]= arg;
85
 
  }
86
 
 
87
 
  Cursor *cursor; /**< Pointer to the storage engine's Cursor managing this table */
88
 
private:
 
75
  TableShare    *s;
 
76
  Field **field;                        /* Pointer to fields */
 
77
 
 
78
  handler       *file;
89
79
  Table *next;
90
 
public:
91
 
  Table *getNext() const
92
 
  {
93
 
    return next;
94
 
  }
95
 
 
96
 
  Table **getNextPtr()
97
 
  {
98
 
    return &next;
99
 
  }
100
 
 
101
 
  void setNext(Table *arg)
102
 
  {
103
 
    next= arg;
104
 
  }
105
 
 
106
 
  void unlink()
107
 
  {
108
 
    getNext()->setPrev(getPrev());              /* remove from used chain */
109
 
    getPrev()->setNext(getNext());
110
 
  }
111
 
 
112
 
private:
113
80
  Table *prev;
114
 
public:
115
 
  Table *getPrev() const
116
 
  {
117
 
    return prev;
118
 
  }
119
 
 
120
 
  Table **getPrevPtr()
121
 
  {
122
 
    return &prev;
123
 
  }
124
 
 
125
 
  void setPrev(Table *arg)
126
 
  {
127
 
    prev= arg;
128
 
  }
129
 
 
130
 
  boost::dynamic_bitset<> *read_set; /* Active column sets */
131
 
  boost::dynamic_bitset<> *write_set; /* Active column sets */
132
 
 
133
 
  uint32_t tablenr;
134
 
  uint32_t db_stat; /**< information about the cursor as in Cursor.h */
135
 
 
136
 
  boost::dynamic_bitset<> def_read_set; /**< Default read set of columns */
137
 
  boost::dynamic_bitset<> def_write_set; /**< Default write set of columns */
138
 
  boost::dynamic_bitset<> tmp_set; /* Not sure about this... */
139
 
 
140
 
  Session *in_use; /**< Pointer to the current session using this object */
141
 
  Session *getSession()
142
 
  {
143
 
    return in_use;
144
 
  }
145
 
 
146
 
  unsigned char *getInsertRecord()
147
 
  {
148
 
    return record[0];
149
 
  }
150
 
 
151
 
  unsigned char *getUpdateRecord()
152
 
  {
153
 
    return record[1];
154
 
  }
155
 
 
156
 
  unsigned char *record[2]; /**< Pointer to "records" */
157
 
  std::vector<unsigned char> insert_values; /* used by INSERT ... UPDATE */
158
 
  KeyInfo  *key_info; /**< data of keys in database */
159
 
  Field *next_number_field; /**< Set if next_number is activated. @TODO What the heck is the difference between this and the next member? */
160
 
  Field *found_next_number_field; /**< Points to the "next-number" field (autoincrement field) */
161
 
  Field_timestamp *timestamp_field; /**< Points to the auto-setting timestamp field, if any */
162
 
 
163
 
  TableList *pos_in_table_list; /* Element referring to this table */
164
 
  Order *group;
165
 
  
166
 
  const char *getAlias() const
167
 
  {
168
 
    return _alias.c_str();
169
 
  }
170
 
 
171
 
  void clearAlias()
172
 
  {
173
 
    _alias.clear();
174
 
  }
175
 
 
176
 
  void setAlias(const char *arg)
177
 
  {
178
 
    _alias= arg;
179
 
  }
180
 
 
181
 
private:
182
 
  std::string _alias; /**< alias or table name if no alias */
183
 
public:
184
 
 
185
 
  unsigned char *null_flags;
186
 
 
187
 
  uint32_t lock_position; /**< Position in DRIZZLE_LOCK.table */
188
 
  uint32_t lock_data_start; /**< Start pos. in DRIZZLE_LOCK.locks */
189
 
  uint32_t lock_count; /**< Number of locks */
 
81
 
 
82
  MY_BITMAP     *read_set;          /* Active column sets */
 
83
  MY_BITMAP     *write_set;          /* Active column sets */
 
84
 
 
85
  uint32_t              tablenr;
 
86
  uint32_t db_stat;             /* mode of file as in handler.h */
 
87
 
 
88
  my_bitmap_map *bitmap_init_value;
 
89
  MY_BITMAP     def_read_set, def_write_set, tmp_set; /* containers */
 
90
 
 
91
  Session       *in_use;                        /* Which thread uses this */
 
92
 
 
93
  unsigned char *record[2];                     /* Pointer to records */
 
94
  unsigned char *write_row_record;              /* Used as optimisation in
 
95
                                           Session::write_row */
 
96
  unsigned char *insert_values;                  /* used by INSERT ... UPDATE */
 
97
  KEY  *key_info;                       /* data of keys in database */
 
98
  Field *next_number_field;             /* Set if next_number is activated */
 
99
  Field *found_next_number_field;       /* Set on open */
 
100
  Field_timestamp *timestamp_field;
 
101
 
 
102
  TableList *pos_in_table_list;/* Element referring to this table */
 
103
  order_st *group;
 
104
  const char    *alias;                   /* alias or table name */
 
105
  unsigned char         *null_flags;
 
106
 
 
107
  uint32_t          lock_position;          /* Position in DRIZZLE_LOCK.table */
 
108
  uint32_t          lock_data_start;        /* Start pos. in DRIZZLE_LOCK.locks */
 
109
  uint32_t          lock_count;             /* Number of locks */
190
110
  uint32_t used_fields;
191
 
  uint32_t status; /* What's in getInsertRecord() */
 
111
  uint32_t          temp_pool_slot;             /* Used by intern temp tables */
 
112
  uint32_t              status;                 /* What's in record[0] */
192
113
  /* number of select if it is derived table */
193
 
  uint32_t derived_select_number;
194
 
  int current_lock; /**< Type of lock on table */
195
 
  bool copy_blobs; /**< Should blobs by copied when storing? */
 
114
  uint32_t          derived_select_number;
 
115
  int           current_lock;           /* Type of lock on table */
 
116
  bool copy_blobs;                      /* copy_blobs when storing */
196
117
 
197
118
  /*
198
119
    0 or JOIN_TYPE_{LEFT|RIGHT}. Currently this is only compared to 0.
208
129
  bool null_row;
209
130
 
210
131
  bool force_index;
211
 
  bool distinct;
212
 
  bool const_table;
213
 
  bool no_rows;
 
132
  bool distinct,const_table,no_rows;
214
133
  bool key_read;
215
134
  bool no_keyread;
216
135
  /*
226
145
    - setting version to 0 - this will force other threads to close
227
146
      the instance of this table and wait (this is the same approach
228
147
      as used for usual name locks).
229
 
    An exclusively name-locked table currently can have no Cursor
 
148
    An exclusively name-locked table currently can have no handler
230
149
    object associated with it (db_stat is always 0), but please do
231
150
    not rely on that.
232
151
  */
239
158
    Used only in the MODE_NO_AUTO_VALUE_ON_ZERO mode.
240
159
  */
241
160
  bool auto_increment_field_not_null;
242
 
  bool alias_name_used; /* true if table_name is alias */
 
161
  bool insert_or_update;             /* Can be used by the handler */
 
162
  bool alias_name_used;         /* true if table_name is alias */
 
163
  bool get_fields_in_item_tree;      /* Signal to fix_field */
 
164
  int report_error(int error);
 
165
  int closefrm(bool free_share);
243
166
 
244
167
  /*
245
168
   The ID of the query that opened and is using this table. Has different
259
182
   the same statement. A non-zero query_id is used to control which tables
260
183
   in the list of pre-opened and locked tables are actually being used.
261
184
  */
262
 
  query_id_t query_id;
 
185
  query_id_t    query_id;
263
186
 
264
 
  /**
265
 
   * Estimate of number of records that satisfy SARGable part of the table
266
 
   * condition, or table->cursor->records if no SARGable condition could be
267
 
   * constructed.
268
 
   * This value is used by join optimizer as an estimate of number of records
269
 
   * that will pass the table condition (condition that depends on fields of
270
 
   * this table and constants)
271
 
   */
272
 
  ha_rows quick_condition_rows;
 
187
  /*
 
188
    Estimate of number of records that satisfy SARGable part of the table
 
189
    condition, or table->file->records if no SARGable condition could be
 
190
    constructed.
 
191
    This value is used by join optimizer as an estimate of number of records
 
192
    that will pass the table condition (condition that depends on fields of
 
193
    this table and constants)
 
194
  */
 
195
  ha_rows       quick_condition_rows;
273
196
 
274
197
  /*
275
198
    If this table has TIMESTAMP field with auto-set property (pointed by
284
207
    as example).
285
208
  */
286
209
  timestamp_auto_set_type timestamp_field_type;
287
 
  table_map map; ///< ID bit of table (1,2,4,8,16...)
 
210
  table_map     map;                    /* ID bit of table (1,2,4,8,16...) */
288
211
 
289
 
  RegInfo reginfo; /* field connections */
 
212
  RegInfo reginfo;                      /* field connections */
290
213
 
291
214
  /*
292
215
    Map of keys that can be used to retrieve all data from this table
293
216
    needed by the query without reading the row.
294
217
  */
295
218
  key_map covering_keys;
 
219
 
 
220
 
296
221
  key_map quick_keys;
297
222
  key_map merge_keys;
298
223
 
317
242
    For each key that has quick_keys.test(key) == true: estimate of #records
318
243
    and max #key parts that range access would use.
319
244
  */
320
 
  ha_rows quick_rows[MAX_KEY];
 
245
  ha_rows       quick_rows[MAX_KEY];
321
246
 
322
247
  /* Bitmaps of key parts that =const for the entire join. */
323
248
  key_part_map  const_key_parts[MAX_KEY];
324
249
 
325
 
  uint32_t quick_key_parts[MAX_KEY];
326
 
  uint32_t quick_n_ranges[MAX_KEY];
327
 
 
328
 
private:
329
 
  memory::Root mem_root;
330
 
 
331
 
  void init_mem_root()
332
 
  {
333
 
    init_sql_alloc(&mem_root, TABLE_ALLOC_BLOCK_SIZE, 0);
334
 
  }
335
 
public:
336
 
  memory::Root *getMemRoot()
337
 
  {
338
 
    if (not mem_root.alloc_root_inited())
339
 
    {
340
 
      init_mem_root();
341
 
    }
342
 
 
343
 
    return &mem_root;
344
 
  }
345
 
 
346
 
  void *alloc_root(size_t arg)
347
 
  {
348
 
    if (not mem_root.alloc_root_inited())
349
 
    {
350
 
      init_mem_root();
351
 
    }
352
 
 
353
 
    return mem_root.alloc_root(arg);
354
 
  }
355
 
 
356
 
  char *strmake_root(const char *str_arg, size_t len_arg)
357
 
  {
358
 
    if (not mem_root.alloc_root_inited())
359
 
    {
360
 
      init_mem_root();
361
 
    }
362
 
 
363
 
    return mem_root.strmake_root(str_arg, len_arg);
364
 
  }
365
 
 
366
 
  filesort_info sort;
367
 
 
368
 
  Table();
369
 
  virtual ~Table();
370
 
 
371
 
  int report_error(int error);
372
 
  /**
373
 
   * Free information allocated by openfrm
374
 
   *
375
 
   * @param If true if we also want to free table_share
376
 
   * @note this should all be the destructor
377
 
   */
378
 
  int delete_table(bool free_share= false);
379
 
 
380
 
  void resetTable(Session *session, TableShare *share, uint32_t db_stat_arg);
 
250
  uint32_t              quick_key_parts[MAX_KEY];
 
251
  uint32_t              quick_n_ranges[MAX_KEY];
 
252
 
 
253
  MEM_ROOT mem_root;
 
254
  filesort_info_st sort;
 
255
 
 
256
 
 
257
  Table()
 
258
    : s(NULL), field(NULL), 
 
259
      file(NULL), next(NULL), prev(NULL),
 
260
      read_set(NULL), write_set(NULL),
 
261
      tablenr(0), db_stat(0),
 
262
      bitmap_init_value(NULL),
 
263
/* TODO: ensure that MY_BITMAP has a constructor for def_read_set, def_write_set and tmp_set */
 
264
      in_use(NULL),
 
265
      write_row_record(NULL), insert_values(NULL), key_info(NULL),
 
266
      next_number_field(NULL), found_next_number_field(NULL),
 
267
      timestamp_field(NULL),
 
268
      pos_in_table_list(NULL), group(NULL), alias(NULL), null_flags(NULL),
 
269
      lock_position(0), lock_data_start(0), lock_count(0),
 
270
      used_fields(0), temp_pool_slot(0),
 
271
      status(0), derived_select_number(0), current_lock(F_UNLCK),
 
272
      copy_blobs(false), maybe_null(false), null_row(false),
 
273
      force_index(false), distinct(false), const_table(false),
 
274
      no_rows(false), key_read(false), no_keyread(false),
 
275
      open_placeholder(false), locked_by_name(false), no_cache(false),
 
276
      auto_increment_field_not_null(false), insert_or_update(false),
 
277
      alias_name_used(false), get_fields_in_item_tree(false),
 
278
      query_id(0), quick_condition_rows(0),
 
279
      timestamp_field_type(TIMESTAMP_NO_AUTO_SET), map(0)
 
280
  {
 
281
    memset(record, 0, sizeof(unsigned char *) * 2);
 
282
 
 
283
    covering_keys.reset();
 
284
 
 
285
    quick_keys.reset();
 
286
    merge_keys.reset();
 
287
 
 
288
    keys_in_use_for_query.reset();
 
289
    keys_in_use_for_group_by.reset();
 
290
    keys_in_use_for_order_by.reset();
 
291
 
 
292
    memset(quick_rows, 0, sizeof(query_id_t) * MAX_KEY);
 
293
    memset(const_key_parts, 0, sizeof(ha_rows) * MAX_KEY);
 
294
 
 
295
    memset(quick_key_parts, 0, sizeof(unsigned int) * MAX_KEY);
 
296
    memset(quick_n_ranges, 0, sizeof(unsigned int) * MAX_KEY);
 
297
 
 
298
    init_sql_alloc(&mem_root, TABLE_ALLOC_BLOCK_SIZE, 0);
 
299
    memset(&sort, 0, sizeof(filesort_info_st));
 
300
  }
 
301
 
 
302
  void resetTable(Session *session, TableShare *share, uint32_t db_stat_arg)
 
303
  {
 
304
 
 
305
    s= share;
 
306
    field= NULL;
 
307
 
 
308
    file= NULL;
 
309
    next= NULL;
 
310
    prev= NULL;
 
311
 
 
312
    read_set= NULL;
 
313
    write_set= NULL;
 
314
 
 
315
    tablenr= 0;
 
316
    db_stat= db_stat_arg;
 
317
 
 
318
    bitmap_init_value= NULL;
 
319
 
 
320
    in_use= session;
 
321
    memset(record, 0, sizeof(unsigned char *) * 2);
 
322
 
 
323
    write_row_record= NULL;
 
324
    insert_values= NULL;
 
325
    key_info= NULL;
 
326
    next_number_field= NULL;
 
327
    found_next_number_field= NULL;
 
328
    timestamp_field= NULL;
 
329
 
 
330
    pos_in_table_list= NULL;
 
331
    group= NULL;
 
332
    alias= NULL;
 
333
    null_flags= NULL;
 
334
     
 
335
    lock_position= 0;
 
336
    lock_data_start= 0;
 
337
    lock_count= 0;
 
338
    used_fields= 0;
 
339
    temp_pool_slot= 0;
 
340
    status= 0;
 
341
    derived_select_number= 0;
 
342
    current_lock= F_UNLCK;
 
343
    copy_blobs= false;
 
344
 
 
345
    maybe_null= false;
 
346
 
 
347
    null_row= false;
 
348
 
 
349
    force_index= false;
 
350
    distinct= false;
 
351
    const_table= false;
 
352
    no_rows= false;
 
353
    key_read= false;
 
354
    no_keyread= false;
 
355
 
 
356
    open_placeholder= false;
 
357
    locked_by_name= false;
 
358
    no_cache= false;
 
359
 
 
360
    auto_increment_field_not_null= false;
 
361
    insert_or_update= false;
 
362
    alias_name_used= false;
 
363
    get_fields_in_item_tree= false;
 
364
    
 
365
    query_id= 0;
 
366
    quick_condition_rows= 0;
 
367
     
 
368
    timestamp_field_type= TIMESTAMP_NO_AUTO_SET;
 
369
    map= 0;
 
370
 
 
371
    reginfo.reset();
 
372
 
 
373
    covering_keys.reset();
 
374
 
 
375
    quick_keys.reset();
 
376
    merge_keys.reset();
 
377
 
 
378
    keys_in_use_for_query.reset();
 
379
    keys_in_use_for_group_by.reset();
 
380
    keys_in_use_for_order_by.reset();
 
381
 
 
382
    memset(quick_rows, 0, sizeof(query_id_t) * MAX_KEY);
 
383
    memset(const_key_parts, 0, sizeof(ha_rows) * MAX_KEY);
 
384
 
 
385
    memset(quick_key_parts, 0, sizeof(unsigned int) * MAX_KEY);
 
386
    memset(quick_n_ranges, 0, sizeof(unsigned int) * MAX_KEY);
 
387
 
 
388
    init_sql_alloc(&mem_root, TABLE_ALLOC_BLOCK_SIZE, 0);
 
389
    memset(&sort, 0, sizeof(filesort_info_st));
 
390
 
 
391
 
 
392
  }
381
393
 
382
394
  /* SHARE methods */
383
 
  virtual const TableShare *getShare() const= 0; /* Get rid of this long term */
384
 
  virtual TableShare *getMutableShare()= 0; /* Get rid of this long term */
385
 
  virtual bool hasShare() const= 0; /* Get rid of this long term */
386
 
  virtual void setShare(TableShare *new_share)= 0; /* Get rid of this long term */
387
 
 
388
 
  virtual void release(void)= 0;
389
 
 
390
 
  uint32_t sizeKeys() { return getMutableShare()->sizeKeys(); }
391
 
  uint32_t sizeFields() { return getMutableShare()->sizeFields(); }
392
 
  uint32_t getRecordLength() const { return getShare()->getRecordLength(); }
393
 
  uint32_t sizeBlobFields() { return getMutableShare()->blob_fields; }
394
 
  uint32_t *getBlobField() { return &getMutableShare()->blob_field[0]; }
395
 
 
396
 
public:
397
 
  virtual bool hasVariableWidth() const
398
 
  {
399
 
    return getShare()->hasVariableWidth(); // We should calculate this.
400
 
  }
401
 
 
402
 
  virtual void setVariableWidth(void);
403
 
 
404
 
  Field_blob *getBlobFieldAt(uint32_t arg) const
405
 
  {
406
 
    if (arg < getShare()->blob_fields)
407
 
      return (Field_blob*) field[getShare()->blob_field[arg]]; /*NOTE: Using 'Table.field' NOT SharedTable.field. */
408
 
 
409
 
    return NULL;
410
 
  }
411
 
  inline uint8_t getBlobPtrSize() { return getShare()->blob_ptr_size; }
412
 
  inline uint32_t getNullBytes() { return getShare()->null_bytes; }
413
 
  inline uint32_t getNullFields() { return getShare()->null_fields; }
414
 
  inline unsigned char *getDefaultValues() { return  getMutableShare()->getDefaultValues(); }
415
 
  inline const char *getSchemaName()  const { return getShare()->getSchemaName(); }
416
 
  inline const char *getTableName()  const { return getShare()->getTableName(); }
417
 
 
418
 
  inline bool isDatabaseLowByteFirst() { return getShare()->db_low_byte_first; } /* Portable row format */
419
 
  inline bool isNameLock() const { return open_placeholder; }
420
 
 
421
 
  uint32_t index_flags(uint32_t idx) const
422
 
  {
423
 
    return getShare()->storage_engine->index_flags(getShare()->getKeyInfo(idx).algorithm);
424
 
  }
425
 
 
426
 
  inline plugin::StorageEngine *getEngine() const   /* table_type for handler */
427
 
  {
428
 
    return getShare()->storage_engine;
429
 
  }
430
 
 
431
 
  Cursor &getCursor() const /* table_type for handler */
432
 
  {
433
 
    assert(cursor);
434
 
    return *cursor;
435
 
  }
436
 
 
 
395
  inline TableShare *getShare() { return s; } /* Get rid of this long term */
 
396
  inline void setShare(TableShare *new_share) { s= new_share; } /* Get rid of this long term */
 
397
  inline uint32_t sizeKeys() { return s->keys; }
 
398
  inline uint32_t sizeFields() { return s->fields; }
 
399
  inline uint32_t getRecordLength() { return s->reclength; }
 
400
  inline uint32_t sizeBlobFields() { return s->blob_fields; }
 
401
  inline uint32_t *getBlobField() { return s->blob_field; }
 
402
  inline uint32_t getNullBytes() { return s->null_bytes; }
 
403
  inline uint32_t getNullFields() { return s->null_fields; }
 
404
  inline unsigned char *getDefaultValues() { return s->default_values; }
 
405
 
 
406
  inline bool isDatabaseLowByteFirst() { return s->db_low_byte_first; }         /* Portable row format */
 
407
  inline bool isCrashed() { return s->crashed; }
 
408
  inline bool isNameLock() { return s->name_lock; }
 
409
  inline bool isReplaceWithNameLock() { return s->replace_with_name_lock; }
 
410
  inline bool isWaitingOnCondition() { return s->waiting_on_cond; }                 /* Protection against free */
 
411
 
 
412
  /* For TMP tables, should be pulled out as a class */
 
413
  void updateCreateInfo(HA_CREATE_INFO *create_info);
 
414
  void setup_tmp_table_column_bitmaps(unsigned char *bitmaps);
 
415
  bool create_myisam_tmp_table(KEY *keyinfo,
 
416
                               MI_COLUMNDEF *start_recinfo,
 
417
                               MI_COLUMNDEF **recinfo,
 
418
                               uint64_t options);
 
419
  void free_tmp_table(Session *session);
 
420
  bool open_tmp_table();
437
421
  size_t max_row_length(const unsigned char *data);
438
422
  uint32_t find_shortest_key(const key_map *usable_keys);
439
423
  bool compare_record(Field **ptr);
440
 
  bool records_are_comparable();
441
 
  bool compare_records();
 
424
  bool compare_record();
442
425
  /* TODO: the (re)storeRecord's may be able to be further condensed */
443
426
  void storeRecord();
444
427
  void storeRecordAsInsert();
446
429
  void restoreRecord();
447
430
  void restoreRecordAsDefault();
448
431
  void emptyRecord();
449
 
 
 
432
  bool table_check_intact(const uint32_t table_f_count, const TABLE_FIELD_W_TYPE *table_def);
450
433
 
451
434
  /* See if this can be blown away */
452
435
  inline uint32_t getDBStat () { return db_stat; }
453
436
  inline uint32_t setDBStat () { return db_stat; }
454
 
  /**
455
 
   * Create Item_field for each column in the table.
456
 
   *
457
 
   * @param[out] a pointer to an empty list used to store items
458
 
   *
459
 
   * @details
460
 
   *
461
 
   * Create Item_field object for each column in the table and
462
 
   * initialize it with the corresponding Field. New items are
463
 
   * created in the current Session memory root.
464
 
   *
465
 
   * @retval
466
 
   *  false on success
467
 
   * @retval
468
 
   *  true when out of memory
469
 
   */
470
437
  bool fill_item_list(List<Item> *item_list) const;
471
438
  void clear_column_bitmaps(void);
472
439
  void prepare_for_position(void);
473
 
  void mark_columns_used_by_index_no_reset(uint32_t index, boost::dynamic_bitset<>& bitmap);
 
440
  void mark_columns_used_by_index_no_reset(uint32_t index, MY_BITMAP *map);
474
441
  void mark_columns_used_by_index_no_reset(uint32_t index);
475
442
  void mark_columns_used_by_index(uint32_t index);
476
443
  void restore_column_maps_after_mark_index();
478
445
  void mark_columns_needed_for_update(void);
479
446
  void mark_columns_needed_for_delete(void);
480
447
  void mark_columns_needed_for_insert(void);
481
 
  void column_bitmaps_set(boost::dynamic_bitset<>& read_set_arg,
482
 
                          boost::dynamic_bitset<>& write_set_arg);
483
 
 
484
 
  void restore_column_map(const boost::dynamic_bitset<>& old);
485
 
 
486
 
  const boost::dynamic_bitset<> use_all_columns(boost::dynamic_bitset<>& map);
 
448
  inline void column_bitmaps_set(MY_BITMAP *read_set_arg,
 
449
                                 MY_BITMAP *write_set_arg)
 
450
  {
 
451
    read_set= read_set_arg;
 
452
    write_set= write_set_arg;
 
453
  }
 
454
 
 
455
  void restore_column_map(my_bitmap_map *old);
 
456
 
 
457
  my_bitmap_map *use_all_columns(MY_BITMAP *bitmap);
487
458
  inline void use_all_columns()
488
459
  {
489
 
    column_bitmaps_set(getMutableShare()->all_set, getMutableShare()->all_set);
 
460
    column_bitmaps_set(&s->all_set, &s->all_set);
490
461
  }
491
462
 
492
463
  inline void default_column_bitmaps()
498
469
  /* Both of the below should go away once we can move this bit to the field objects */
499
470
  inline bool isReadSet(uint32_t index)
500
471
  {
501
 
    return read_set->test(index);
 
472
    return bitmap_is_set(read_set, index);
502
473
  }
503
474
 
504
475
  inline void setReadSet(uint32_t index)
505
476
  {
506
 
    read_set->set(index);
 
477
    bitmap_set_bit(read_set, index);
507
478
  }
508
479
 
509
480
  inline void setReadSet()
510
481
  {
511
 
    read_set->set();
512
 
  }
513
 
 
514
 
  inline void clearReadSet(uint32_t index)
515
 
  {
516
 
    read_set->reset(index);
517
 
  }
518
 
 
519
 
  inline void clearReadSet()
520
 
  {
521
 
    read_set->reset();
 
482
    bitmap_set_all(read_set);
522
483
  }
523
484
 
524
485
  inline bool isWriteSet(uint32_t index)
525
486
  {
526
 
    return write_set->test(index);
 
487
    return bitmap_is_set(write_set, index);
527
488
  }
528
489
 
529
490
  inline void setWriteSet(uint32_t index)
530
491
  {
531
 
    write_set->set(index);
 
492
    bitmap_set_bit(write_set, index);
532
493
  }
533
494
 
534
495
  inline void setWriteSet()
535
496
  {
536
 
    write_set->set();
537
 
  }
538
 
 
539
 
  inline void clearWriteSet(uint32_t index)
540
 
  {
541
 
    write_set->reset(index);
542
 
  }
543
 
 
544
 
  inline void clearWriteSet()
545
 
  {
546
 
    write_set->reset();
 
497
    bitmap_set_all(write_set);
547
498
  }
548
499
 
549
500
  /* Is table open or should be treated as such by name-locking? */
550
 
  inline bool is_name_opened()
551
 
  {
552
 
    return db_stat || open_placeholder;
553
 
  }
 
501
  inline bool is_name_opened() { return db_stat || open_placeholder; }
554
502
  /*
555
503
    Is this instance of the table should be reopen or represents a name-lock?
556
504
  */
557
505
  inline bool needs_reopen_or_name_lock()
558
 
  { 
559
 
    return getShare()->getVersion() != refresh_version;
560
 
  }
 
506
  { return s->version != refresh_version; }
561
507
 
562
508
  /**
563
509
    clean/setup table fields and map.
569
515
  void setup_table_map(TableList *table_list, uint32_t tablenr);
570
516
  inline void mark_as_null_row()
571
517
  {
572
 
    null_row= 1;
573
 
    status|= STATUS_NULL_ROW;
574
 
    memset(null_flags, 255, getShare()->null_bytes);
575
 
  }
576
 
 
577
 
  void free_io_cache();
578
 
  void filesort_free_buffers(bool full= false);
579
 
  void intern_close_table();
580
 
 
581
 
  void print_error(int error, myf errflag)
582
 
  {
583
 
    getShare()->storage_engine->print_error(error, errflag, *this);
584
 
  }
585
 
 
586
 
  /**
587
 
    @return
588
 
    key if error because of duplicated keys
589
 
  */
590
 
  uint32_t get_dup_key(int error)
591
 
  {
592
 
    cursor->errkey  = (uint32_t) -1;
593
 
    if (error == HA_ERR_FOUND_DUPP_KEY || error == HA_ERR_FOREIGN_DUPLICATE_KEY ||
594
 
        error == HA_ERR_FOUND_DUPP_UNIQUE ||
595
 
        error == HA_ERR_DROP_INDEX_FK)
596
 
      cursor->info(HA_STATUS_ERRKEY | HA_STATUS_NO_LOCK);
597
 
 
598
 
    return(cursor->errkey);
599
 
  }
600
 
 
601
 
  /*
602
 
    This is a short term fix. Long term we will used the TableIdentifier to do the actual comparison.
603
 
  */
604
 
  bool operator<(const Table &right) const
605
 
  {
606
 
    return getShare()->getCacheKey() < right.getShare()->getCacheKey();
607
 
  }
608
 
 
609
 
  static bool compare(const Table *a, const Table *b)
610
 
  {
611
 
    return *a < *b;
612
 
  }
613
 
 
614
 
  friend std::ostream& operator<<(std::ostream& output, const Table &table)
615
 
  {
616
 
    if (table.getShare())
617
 
    {
618
 
      output << "Table:(";
619
 
      output << table.getShare()->getSchemaName();
620
 
      output << ", ";
621
 
      output <<  table.getShare()->getTableName();
622
 
      output << ", ";
623
 
      output <<  table.getShare()->getTableTypeAsString();
624
 
      output << ")";
625
 
    }
626
 
    else
627
 
    {
628
 
      output << "Table:(has no share)";
629
 
    }
630
 
 
631
 
    return output;  // for multiple << operators.
632
 
  }
633
 
 
634
 
public:
635
 
  virtual bool isPlaceHolder(void) const
636
 
  {
637
 
    return false;
638
 
  }
639
 
};
640
 
 
641
 
/**
642
 
 * @class
643
 
 *  ForeignKeyInfo
644
 
 *
645
 
 * @brief
646
 
 *  This class defines the information for foreign keys.
647
 
 */
648
 
class ForeignKeyInfo
649
 
{
650
 
public:
651
 
    /**
652
 
     * @brief
653
 
     *  This is the constructor with all properties set.
654
 
     *
655
 
     * @param[in] in_foreign_id The id of the foreign key
656
 
     * @param[in] in_referenced_db The referenced database name of the foreign key
657
 
     * @param[in] in_referenced_table The referenced table name of the foreign key
658
 
     * @param[in] in_update_method The update method of the foreign key.
659
 
     * @param[in] in_delete_method The delete method of the foreign key.
660
 
     * @param[in] in_referenced_key_name The name of referenced key
661
 
     * @param[in] in_foreign_fields The foreign fields
662
 
     * @param[in] in_referenced_fields The referenced fields
663
 
     */
664
 
    ForeignKeyInfo(LEX_STRING *in_foreign_id,
665
 
                   LEX_STRING *in_referenced_db,
666
 
                   LEX_STRING *in_referenced_table,
667
 
                   LEX_STRING *in_update_method,
668
 
                   LEX_STRING *in_delete_method,
669
 
                   LEX_STRING *in_referenced_key_name,
670
 
                   List<LEX_STRING> in_foreign_fields,
671
 
                   List<LEX_STRING> in_referenced_fields)
672
 
    :
673
 
      foreign_id(in_foreign_id),
674
 
      referenced_db(in_referenced_db),
675
 
      referenced_table(in_referenced_table),
676
 
      update_method(in_update_method),
677
 
      delete_method(in_delete_method),
678
 
      referenced_key_name(in_referenced_key_name),
679
 
      foreign_fields(in_foreign_fields),
680
 
      referenced_fields(in_referenced_fields)
681
 
    {}
682
 
 
683
 
    /**
684
 
     * @brief
685
 
     *  This is the default constructor. All properties are set to default values for their types.
686
 
     */
687
 
    ForeignKeyInfo()
688
 
    : foreign_id(NULL), referenced_db(NULL), referenced_table(NULL),
689
 
      update_method(NULL), delete_method(NULL), referenced_key_name(NULL)
690
 
    {}
691
 
 
692
 
    /**
693
 
     * @brief
694
 
     *  Gets the foreign id.
695
 
     *
696
 
     * @ retval  the foreign id
697
 
     */
698
 
    const LEX_STRING *getForeignId() const
699
 
    {
700
 
        return foreign_id;
701
 
    }
702
 
 
703
 
    /**
704
 
     * @brief
705
 
     *  Gets the name of the referenced database.
706
 
     *
707
 
     * @ retval  the name of the referenced database
708
 
     */
709
 
    const LEX_STRING *getReferencedDb() const
710
 
    {
711
 
        return referenced_db;
712
 
    }
713
 
 
714
 
    /**
715
 
     * @brief
716
 
     *  Gets the name of the referenced table.
717
 
     *
718
 
     * @ retval  the name of the referenced table
719
 
     */
720
 
    const LEX_STRING *getReferencedTable() const
721
 
    {
722
 
        return referenced_table;
723
 
    }
724
 
 
725
 
    /**
726
 
     * @brief
727
 
     *  Gets the update method.
728
 
     *
729
 
     * @ retval  the update method
730
 
     */
731
 
    const LEX_STRING *getUpdateMethod() const
732
 
    {
733
 
        return update_method;
734
 
    }
735
 
 
736
 
    /**
737
 
     * @brief
738
 
     *  Gets the delete method.
739
 
     *
740
 
     * @ retval  the delete method
741
 
     */
742
 
    const LEX_STRING *getDeleteMethod() const
743
 
    {
744
 
        return delete_method;
745
 
    }
746
 
 
747
 
    /**
748
 
     * @brief
749
 
     *  Gets the name of the referenced key.
750
 
     *
751
 
     * @ retval  the name of the referenced key
752
 
     */
753
 
    const LEX_STRING *getReferencedKeyName() const
754
 
    {
755
 
        return referenced_key_name;
756
 
    }
757
 
 
758
 
    /**
759
 
     * @brief
760
 
     *  Gets the foreign fields.
761
 
     *
762
 
     * @ retval  the foreign fields
763
 
     */
764
 
    const List<LEX_STRING> &getForeignFields() const
765
 
    {
766
 
        return foreign_fields;
767
 
    }
768
 
 
769
 
    /**
770
 
     * @brief
771
 
     *  Gets the referenced fields.
772
 
     *
773
 
     * @ retval  the referenced fields
774
 
     */
775
 
    const List<LEX_STRING> &getReferencedFields() const
776
 
    {
777
 
        return referenced_fields;
778
 
    }
779
 
private:
780
 
    /**
781
 
     * The foreign id.
782
 
     */
783
 
    LEX_STRING *foreign_id;
784
 
    /**
785
 
     * The name of the reference database.
786
 
     */
787
 
    LEX_STRING *referenced_db;
788
 
    /**
789
 
     * The name of the reference table.
790
 
     */
791
 
    LEX_STRING *referenced_table;
792
 
    /**
793
 
     * The update method.
794
 
     */
795
 
    LEX_STRING *update_method;
796
 
    /**
797
 
     * The delete method.
798
 
     */
799
 
    LEX_STRING *delete_method;
800
 
    /**
801
 
     * The name of the referenced key.
802
 
     */
803
 
    LEX_STRING *referenced_key_name;
804
 
    /**
805
 
     * The foreign fields.
806
 
     */
807
 
    List<LEX_STRING> foreign_fields;
808
 
    /**
809
 
     * The referenced fields.
810
 
     */
811
 
    List<LEX_STRING> referenced_fields;
812
 
};
 
518
    null_row=1;
 
519
    status|=STATUS_NULL_ROW;
 
520
    memset(null_flags, 255, s->null_bytes);
 
521
  }
 
522
 
 
523
};
 
524
 
 
525
Table *create_virtual_tmp_table(Session *session,
 
526
                                List<Create_field> &field_list);
 
527
 
 
528
typedef struct st_foreign_key_info
 
529
{
 
530
  LEX_STRING *forein_id;
 
531
  LEX_STRING *referenced_db;
 
532
  LEX_STRING *referenced_table;
 
533
  LEX_STRING *update_method;
 
534
  LEX_STRING *delete_method;
 
535
  LEX_STRING *referenced_key_name;
 
536
  List<LEX_STRING> foreign_fields;
 
537
  List<LEX_STRING> referenced_fields;
 
538
} FOREIGN_KEY_INFO;
 
539
 
 
540
typedef struct st_field_info
 
541
{
 
542
  /**
 
543
      This is used as column name.
 
544
  */
 
545
  const char* field_name;
 
546
  /**
 
547
     For string-type columns, this is the maximum number of
 
548
     characters. Otherwise, it is the 'display-length' for the column.
 
549
  */
 
550
  uint32_t field_length;
 
551
  /**
 
552
     This denotes data type for the column. For the most part, there seems to
 
553
     be one entry in the enum for each SQL data type, although there seem to
 
554
     be a number of additional entries in the enum.
 
555
  */
 
556
  enum enum_field_types field_type;
 
557
  int value;
 
558
  /**
 
559
     This is used to set column attributes. By default, columns are @c NOT
 
560
     @c NULL and @c SIGNED, and you can deviate from the default
 
561
     by setting the appopriate flags. You can use either one of the flags
 
562
     @c MY_I_S_MAYBE_NULL and @cMY_I_S_UNSIGNED or
 
563
     combine them using the bitwise or operator @c |. Both flags are
 
564
     defined in table.h.
 
565
   */
 
566
  uint32_t field_flags;        // Field atributes(maybe_null, signed, unsigned etc.)
 
567
  const char* old_name;
 
568
  /**
 
569
     This should be one of @c SKIP_OPEN_TABLE,
 
570
     @c OPEN_FRM_ONLY or @c OPEN_FULL_TABLE.
 
571
  */
 
572
  uint32_t open_method;
 
573
} ST_FIELD_INFO;
 
574
 
813
575
 
814
576
class TableList;
815
 
 
816
 
#define JOIN_TYPE_LEFT  1
817
 
#define JOIN_TYPE_RIGHT 2
 
577
typedef class Item COND;
 
578
 
 
579
struct InfoSchemaTable
 
580
{
 
581
  const char* table_name;
 
582
  ST_FIELD_INFO *fields_info;
 
583
  /* Create information_schema table */
 
584
  Table *(*create_table)  (Session *session, TableList *table_list);
 
585
  /* Fill table with data */
 
586
  int (*fill_table) (Session *session, TableList *tables, COND *cond);
 
587
  /* Handle fileds for old SHOW */
 
588
  int (*old_format) (Session *session, struct InfoSchemaTable *schema_table);
 
589
  int (*process_table) (Session *session, TableList *tables, Table *table,
 
590
                        bool res, LEX_STRING *db_name, LEX_STRING *table_name);
 
591
  int idx_field1, idx_field2;
 
592
  bool hidden;
 
593
  uint32_t i_s_requested_object;  /* the object we need to open(Table | VIEW) */
 
594
};
 
595
 
 
596
 
 
597
#define JOIN_TYPE_LEFT  1
 
598
#define JOIN_TYPE_RIGHT 2
818
599
 
819
600
struct st_lex;
820
601
class select_union;
821
602
class Tmp_Table_Param;
822
603
 
823
 
void free_blobs(Table *table);
824
 
int set_zone(int nr,int min_zone,int max_zone);
825
 
uint32_t convert_period_to_month(uint32_t period);
826
 
uint32_t convert_month_to_period(uint32_t month);
827
 
 
828
 
int test_if_number(char *str,int *res,bool allow_wildcards);
829
 
void change_byte(unsigned char *,uint,char,char);
830
 
 
831
 
namespace optimizer { class SqlSelect; }
832
 
 
833
 
void change_double_for_sort(double nr,unsigned char *to);
834
 
double my_double_round(double value, int64_t dec, bool dec_unsigned,
835
 
                       bool truncate);
836
 
int get_quick_record(optimizer::SqlSelect *select);
837
 
 
838
 
void find_date(char *pos,uint32_t *vek,uint32_t flag);
839
 
TYPELIB *convert_strings_to_array_type(char * *typelibs, char * *end);
840
 
TYPELIB *typelib(memory::Root *mem_root, List<String> &strings);
841
 
ulong get_form_pos(int file, unsigned char *head, TYPELIB *save_names);
842
 
void append_unescaped(String *res, const char *pos, uint32_t length);
843
 
 
844
 
int rename_file_ext(const char * from,const char * to,const char * ext);
845
 
bool check_column_name(const char *name);
846
 
bool check_db_name(Session *session, SchemaIdentifier &schema);
847
 
bool check_table_name(const char *name, uint32_t length);
848
 
 
849
 
} /* namespace drizzled */
850
 
 
851
 
#include "drizzled/table/instance.h"
852
 
#include "drizzled/table/concurrent.h"
 
604
typedef struct st_changed_table_list
 
605
{
 
606
  struct        st_changed_table_list *next;
 
607
  char          *key;
 
608
  uint32_t key_length;
 
609
} CHANGED_TableList;
 
610
 
 
611
 
 
612
typedef struct st_open_table_list
 
613
{
 
614
  struct st_open_table_list *next;
 
615
  char  *db;
 
616
  char  *table;
 
617
  uint32_t in_use,locked;
 
618
} OPEN_TableList;
 
619
 
853
620
 
854
621
#endif /* DRIZZLED_TABLE_H */