← 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-05-23 17:13:03 UTC
  • mfrom: (1034.1.8 merge)
  • Revision ID: brian@gaz-20090523171303-d28xhutqic0xe2b4
Merge 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
bool create_myisam_from_heap(Session *session, Table *table,
 
67
                             MI_COLUMNDEF *start_recinfo,
 
68
                             MI_COLUMNDEF **recinfo,
 
69
                             int error, bool ignore_last_dupp_key_error);
 
70
 
 
71
class Table {
65
72
public:
66
 
 
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:
 
73
  Table() {}                               /* Remove gcc warning */
 
74
 
 
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);
 
166
  uint32_t tmpkeyval();
243
167
 
244
168
  /*
245
169
   The ID of the query that opened and is using this table. Has different
259
183
   the same statement. A non-zero query_id is used to control which tables
260
184
   in the list of pre-opened and locked tables are actually being used.
261
185
  */
262
 
  query_id_t query_id;
 
186
  query_id_t    query_id;
263
187
 
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;
 
188
  /*
 
189
    Estimate of number of records that satisfy SARGable part of the table
 
190
    condition, or table->file->records if no SARGable condition could be
 
191
    constructed.
 
192
    This value is used by join optimizer as an estimate of number of records
 
193
    that will pass the table condition (condition that depends on fields of
 
194
    this table and constants)
 
195
  */
 
196
  ha_rows       quick_condition_rows;
273
197
 
274
198
  /*
275
199
    If this table has TIMESTAMP field with auto-set property (pointed by
284
208
    as example).
285
209
  */
286
210
  timestamp_auto_set_type timestamp_field_type;
287
 
  table_map map; ///< ID bit of table (1,2,4,8,16...)
 
211
  table_map     map;                    /* ID bit of table (1,2,4,8,16...) */
288
212
 
289
 
  RegInfo reginfo; /* field connections */
 
213
  REGINFO reginfo;                      /* field connections */
290
214
 
291
215
  /*
292
216
    Map of keys that can be used to retrieve all data from this table
293
217
    needed by the query without reading the row.
294
218
  */
295
219
  key_map covering_keys;
 
220
 
 
221
 
296
222
  key_map quick_keys;
297
223
  key_map merge_keys;
298
224
 
317
243
    For each key that has quick_keys.test(key) == true: estimate of #records
318
244
    and max #key parts that range access would use.
319
245
  */
320
 
  ha_rows quick_rows[MAX_KEY];
 
246
  ha_rows       quick_rows[MAX_KEY];
321
247
 
322
248
  /* Bitmaps of key parts that =const for the entire join. */
323
249
  key_part_map  const_key_parts[MAX_KEY];
324
250
 
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);
 
251
  uint32_t              quick_key_parts[MAX_KEY];
 
252
  uint32_t              quick_n_ranges[MAX_KEY];
 
253
 
 
254
  MEM_ROOT mem_root;
 
255
  filesort_info_st sort;
 
256
 
 
257
 
381
258
 
382
259
  /* 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
 
 
 
260
  inline TableShare *getShare() { return s; } /* Get rid of this long term */
 
261
  inline void setShare(TableShare *new_share) { s= new_share; } /* Get rid of this long term */
 
262
  inline uint32_t sizeKeys() { return s->keys; }
 
263
  inline uint32_t sizeFields() { return s->fields; }
 
264
  inline uint32_t getRecordLength() { return s->reclength; }
 
265
  inline uint32_t sizeBlobFields() { return s->blob_fields; }
 
266
  inline uint32_t *getBlobField() { return s->blob_field; }
 
267
  inline uint32_t getNullBytes() { return s->null_bytes; }
 
268
  inline uint32_t getNullFields() { return s->null_fields; }
 
269
  inline unsigned char *getDefaultValues() { return s->default_values; }
 
270
 
 
271
  inline bool isDatabaseLowByteFirst() { return s->db_low_byte_first; }         /* Portable row format */
 
272
  inline bool isCrashed() { return s->crashed; }
 
273
  inline bool isNameLock() { return s->name_lock; }
 
274
  inline bool isReplaceWithNameLock() { return s->replace_with_name_lock; }
 
275
  inline bool isWaitingOnCondition() { return s->waiting_on_cond; }                 /* Protection against free */
 
276
 
 
277
  /* For TMP tables, should be pulled out as a class */
 
278
  void updateCreateInfo(HA_CREATE_INFO *create_info);
 
279
  void setup_tmp_table_column_bitmaps(unsigned char *bitmaps);
 
280
  bool create_myisam_tmp_table(KEY *keyinfo,
 
281
                               MI_COLUMNDEF *start_recinfo,
 
282
                               MI_COLUMNDEF **recinfo,
 
283
                               uint64_t options);
 
284
  void free_tmp_table(Session *session);
 
285
  bool open_tmp_table();
437
286
  size_t max_row_length(const unsigned char *data);
438
287
  uint32_t find_shortest_key(const key_map *usable_keys);
439
288
  bool compare_record(Field **ptr);
440
 
  bool records_are_comparable();
441
 
  bool compare_records();
 
289
  bool compare_record();
442
290
  /* TODO: the (re)storeRecord's may be able to be further condensed */
443
291
  void storeRecord();
444
292
  void storeRecordAsInsert();
446
294
  void restoreRecord();
447
295
  void restoreRecordAsDefault();
448
296
  void emptyRecord();
449
 
 
 
297
  bool table_check_intact(const uint32_t table_f_count, const TABLE_FIELD_W_TYPE *table_def);
450
298
 
451
299
  /* See if this can be blown away */
452
300
  inline uint32_t getDBStat () { return db_stat; }
453
301
  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
302
  bool fill_item_list(List<Item> *item_list) const;
 
303
  void reset_item_list(List<Item> *item_list) const;
471
304
  void clear_column_bitmaps(void);
472
305
  void prepare_for_position(void);
473
 
  void mark_columns_used_by_index_no_reset(uint32_t index, boost::dynamic_bitset<>& bitmap);
 
306
  void mark_columns_used_by_index_no_reset(uint32_t index, MY_BITMAP *map);
474
307
  void mark_columns_used_by_index_no_reset(uint32_t index);
475
308
  void mark_columns_used_by_index(uint32_t index);
476
309
  void restore_column_maps_after_mark_index();
478
311
  void mark_columns_needed_for_update(void);
479
312
  void mark_columns_needed_for_delete(void);
480
313
  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);
 
314
  inline void column_bitmaps_set(MY_BITMAP *read_set_arg,
 
315
                                 MY_BITMAP *write_set_arg)
 
316
  {
 
317
    read_set= read_set_arg;
 
318
    write_set= write_set_arg;
 
319
  }
 
320
 
 
321
  void restore_column_map(my_bitmap_map *old);
 
322
 
 
323
  my_bitmap_map *use_all_columns(MY_BITMAP *bitmap);
487
324
  inline void use_all_columns()
488
325
  {
489
 
    column_bitmaps_set(getMutableShare()->all_set, getMutableShare()->all_set);
 
326
    column_bitmaps_set(&s->all_set, &s->all_set);
490
327
  }
491
328
 
492
329
  inline void default_column_bitmaps()
498
335
  /* Both of the below should go away once we can move this bit to the field objects */
499
336
  inline bool isReadSet(uint32_t index)
500
337
  {
501
 
    return read_set->test(index);
 
338
    return bitmap_is_set(read_set, index);
502
339
  }
503
340
 
504
341
  inline void setReadSet(uint32_t index)
505
342
  {
506
 
    read_set->set(index);
 
343
    bitmap_set_bit(read_set, index);
507
344
  }
508
345
 
509
346
  inline void setReadSet()
510
347
  {
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();
 
348
    bitmap_set_all(read_set);
522
349
  }
523
350
 
524
351
  inline bool isWriteSet(uint32_t index)
525
352
  {
526
 
    return write_set->test(index);
 
353
    return bitmap_is_set(write_set, index);
527
354
  }
528
355
 
529
356
  inline void setWriteSet(uint32_t index)
530
357
  {
531
 
    write_set->set(index);
 
358
    bitmap_set_bit(write_set, index);
532
359
  }
533
360
 
534
361
  inline void setWriteSet()
535
362
  {
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();
 
363
    bitmap_set_all(write_set);
547
364
  }
548
365
 
549
366
  /* 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
 
  }
 
367
  inline bool is_name_opened() { return db_stat || open_placeholder; }
554
368
  /*
555
369
    Is this instance of the table should be reopen or represents a name-lock?
556
370
  */
557
371
  inline bool needs_reopen_or_name_lock()
558
 
  { 
559
 
    return getShare()->getVersion() != refresh_version;
560
 
  }
 
372
  { return s->version != refresh_version; }
561
373
 
562
374
  /**
563
375
    clean/setup table fields and map.
569
381
  void setup_table_map(TableList *table_list, uint32_t tablenr);
570
382
  inline void mark_as_null_row()
571
383
  {
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
 
};
 
384
    null_row=1;
 
385
    status|=STATUS_NULL_ROW;
 
386
    memset(null_flags, 255, s->null_bytes);
 
387
  }
 
388
 
 
389
};
 
390
 
 
391
Table *create_virtual_tmp_table(Session *session,
 
392
                                List<Create_field> &field_list);
 
393
 
 
394
typedef struct st_foreign_key_info
 
395
{
 
396
  LEX_STRING *forein_id;
 
397
  LEX_STRING *referenced_db;
 
398
  LEX_STRING *referenced_table;
 
399
  LEX_STRING *update_method;
 
400
  LEX_STRING *delete_method;
 
401
  LEX_STRING *referenced_key_name;
 
402
  List<LEX_STRING> foreign_fields;
 
403
  List<LEX_STRING> referenced_fields;
 
404
} FOREIGN_KEY_INFO;
 
405
 
 
406
typedef struct st_field_info
 
407
{
 
408
  /**
 
409
      This is used as column name.
 
410
  */
 
411
  const char* field_name;
 
412
  /**
 
413
     For string-type columns, this is the maximum number of
 
414
     characters. Otherwise, it is the 'display-length' for the column.
 
415
  */
 
416
  uint32_t field_length;
 
417
  /**
 
418
     This denotes data type for the column. For the most part, there seems to
 
419
     be one entry in the enum for each SQL data type, although there seem to
 
420
     be a number of additional entries in the enum.
 
421
  */
 
422
  enum enum_field_types field_type;
 
423
  int value;
 
424
  /**
 
425
     This is used to set column attributes. By default, columns are @c NOT
 
426
     @c NULL and @c SIGNED, and you can deviate from the default
 
427
     by setting the appopriate flags. You can use either one of the flags
 
428
     @c MY_I_S_MAYBE_NULL and @cMY_I_S_UNSIGNED or
 
429
     combine them using the bitwise or operator @c |. Both flags are
 
430
     defined in table.h.
 
431
   */
 
432
  uint32_t field_flags;        // Field atributes(maybe_null, signed, unsigned etc.)
 
433
  const char* old_name;
 
434
  /**
 
435
     This should be one of @c SKIP_OPEN_TABLE,
 
436
     @c OPEN_FRM_ONLY or @c OPEN_FULL_TABLE.
 
437
  */
 
438
  uint32_t open_method;
 
439
} ST_FIELD_INFO;
 
440
 
813
441
 
814
442
class TableList;
815
 
 
816
 
#define JOIN_TYPE_LEFT  1
817
 
#define JOIN_TYPE_RIGHT 2
 
443
typedef class Item COND;
 
444
 
 
445
struct InfoSchemaTable
 
446
{
 
447
  const char* table_name;
 
448
  ST_FIELD_INFO *fields_info;
 
449
  /* Create information_schema table */
 
450
  Table *(*create_table)  (Session *session, TableList *table_list);
 
451
  /* Fill table with data */
 
452
  int (*fill_table) (Session *session, TableList *tables, COND *cond);
 
453
  /* Handle fileds for old SHOW */
 
454
  int (*old_format) (Session *session, struct InfoSchemaTable *schema_table);
 
455
  int (*process_table) (Session *session, TableList *tables, Table *table,
 
456
                        bool res, LEX_STRING *db_name, LEX_STRING *table_name);
 
457
  int idx_field1, idx_field2;
 
458
  bool hidden;
 
459
  uint32_t i_s_requested_object;  /* the object we need to open(Table | VIEW) */
 
460
};
 
461
 
 
462
 
 
463
#define JOIN_TYPE_LEFT  1
 
464
#define JOIN_TYPE_RIGHT 2
818
465
 
819
466
struct st_lex;
820
467
class select_union;
821
468
class Tmp_Table_Param;
822
469
 
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"
 
470
typedef struct st_changed_table_list
 
471
{
 
472
  struct        st_changed_table_list *next;
 
473
  char          *key;
 
474
  uint32_t        key_length;
 
475
} CHANGED_TableList;
 
476
 
 
477
 
 
478
typedef struct st_open_table_list
 
479
{
 
480
  struct st_open_table_list *next;
 
481
  char  *db,*table;
 
482
  uint32_t in_use,locked;
 
483
} OPEN_TableList;
 
484
 
853
485
 
854
486
#endif /* DRIZZLED_TABLE_H */