← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/table_share.h

  • Committer: Padraig O'Sullivan
  • Date: 2009-03-30 18:27:35 UTC
  • mto: (968.2.5 mordred)
  • mto: This revision was merged to the branch mainline in revision 971.
  • Revision ID: osullivan.padraig@gmail.com-20090330182735-8tor89czwodcv77s
Removing the last of LIST from the MyISAM storage engine.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/table_share.h
22
22
  This class is shared between different table objects. There is one
23
23
  instance of table share per one table in the database.
24
24
*/
25
 
 
26
 
#ifndef DRIZZLED_DEFINITION_TABLE_H
27
 
#define DRIZZLED_DEFINITION_TABLE_H
28
 
 
29
 
#include <string>
30
 
 
31
 
#include <boost/unordered_map.hpp>
32
 
#include <boost/thread/condition_variable.hpp>
33
 
#include <boost/dynamic_bitset.hpp>
34
 
#include <boost/shared_ptr.hpp>
35
 
 
36
 
#include "drizzled/typelib.h"
37
 
#include "drizzled/memory/root.h"
38
 
#include "drizzled/message/table.pb.h"
39
 
#include "drizzled/util/string.h"
40
 
 
41
 
#include "drizzled/table/cache.h"
42
 
 
43
 
namespace drizzled
44
 
{
45
 
 
46
 
extern uint64_t refresh_version;
47
 
 
48
 
const static std::string STANDARD_STRING("STANDARD");
49
 
const static std::string TEMPORARY_STRING("TEMPORARY");
50
 
const static std::string INTERNAL_STRING("INTERNAL");
51
 
const static std::string FUNCTION_STRING("FUNCTION");
52
 
const static std::string NO_PROTOBUFFER_AVAILABLE("NO PROTOBUFFER AVAILABLE");
53
 
 
54
 
namespace plugin
55
 
{
56
 
class EventObserverList;
57
 
}
58
 
 
59
 
class Field_blob;
60
 
 
61
 
class TableShare
62
 
{
63
 
  typedef std::vector<std::string> StringVector;
64
 
 
 
25
class TABLE_SHARE
 
26
{
65
27
public:
66
 
  typedef boost::shared_ptr<TableShare> shared_ptr;
67
 
  typedef std::vector <shared_ptr> vector;
68
 
 
69
 
  TableShare(const TableIdentifier::Type type_arg);
70
 
 
71
 
  TableShare(const TableIdentifier &identifier, const TableIdentifier::Key &key); // Used by placeholder
72
 
 
73
 
  TableShare(const TableIdentifier &identifier); // Just used during createTable()
74
 
 
75
 
  TableShare(const TableIdentifier::Type type_arg,
76
 
             const TableIdentifier &identifier,
77
 
             char *path_arg= NULL, uint32_t path_length_arg= 0); // Shares for cache
78
 
 
79
 
  ~TableShare();
80
 
 
81
 
private:
 
28
  TABLE_SHARE() {}                    /* Remove gcc warning */
 
29
 
82
30
  /** Category of this table. */
83
31
  enum_table_category table_category;
84
32
 
85
 
public:
86
 
 
87
 
  bool isTemporaryCategory() const
88
 
  {
89
 
    return (table_category == TABLE_CATEGORY_TEMPORARY);
90
 
  }
91
 
 
92
 
  void setTableCategory(enum_table_category arg)
93
 
  {
94
 
    table_category= arg;
95
 
  }
 
33
  /* hash of field names (contains pointers to elements of field array) */
 
34
  HASH  name_hash;                      /* hash of field names */
 
35
  MEM_ROOT mem_root;
 
36
  TYPELIB keynames;                     /* Pointers to keynames */
 
37
  TYPELIB fieldnames;                   /* Pointer to fieldnames */
 
38
  TYPELIB *intervals;                   /* pointer to interval info */
 
39
  pthread_mutex_t mutex;                /* For locking the share  */
 
40
  pthread_cond_t cond;                  /* To signal that share is ready */
 
41
  TABLE_SHARE *next,            /* Link to unused shares */
 
42
    **prev;
96
43
 
97
44
  /* The following is copied to each Table on OPEN */
98
 
  typedef std::vector<Field *> Fields;
99
 
private:
100
 
  Fields field;
101
 
public:
102
 
  const Fields getFields() const
103
 
  {
104
 
    return field;
105
 
  }
106
 
 
107
 
  Field ** getFields(bool)
108
 
  {
109
 
    return &field[0];
110
 
  }
111
 
 
112
 
  void setFields(uint32_t arg)
113
 
  {
114
 
    field.resize(arg);
115
 
  }
116
 
 
117
 
  uint32_t positionFields(Field **arg) const
118
 
  {
119
 
    return (arg - (Field **)&field[0]);
120
 
  }
121
 
 
122
 
  void pushField(Field *arg)
123
 
  {
124
 
    fields++;
125
 
    field.push_back(arg);
126
 
  }
127
 
 
128
 
 
 
45
  Field **field;
129
46
  Field **found_next_number_field;
130
 
private:
131
47
  Field *timestamp_field;               /* Used only during open */
132
 
public:
133
 
 
134
 
  Field *getTimestampField() const               /* Used only during open */
135
 
  {
136
 
    return timestamp_field;
137
 
  }
138
 
 
139
 
  void setTimestampField(Field *arg) /* Used only during open */
140
 
  {
141
 
    timestamp_field= arg;
142
 
  }
143
 
 
144
 
 
145
 
private:
146
 
  KeyInfo  *key_info;                   /* data of keys in database */
147
 
public:
148
 
  KeyInfo &getKeyInfo(uint32_t arg) const
149
 
  {
150
 
    return key_info[arg];
151
 
  }
152
 
  std::vector<uint>     blob_field;                     /* Index to blobs in Field arrray*/
153
 
 
154
 
  /* hash of field names (contains pointers to elements of field array) */
155
 
private:
156
 
  typedef boost::unordered_map < std::string, Field **, util::insensitive_hash, util::insensitive_equal_to> FieldMap;
157
 
  typedef std::pair< std::string, Field ** > FieldMapPair;
158
 
  FieldMap name_hash; /* hash of field names */
159
 
public:
160
 
  size_t getNamedFieldSize() const
161
 
  {
162
 
    return name_hash.size();
163
 
  }
164
 
 
165
 
  Field **getNamedField(const std::string &arg)
166
 
  {
167
 
    FieldMap::iterator iter= name_hash.find(arg);
168
 
 
169
 
    if (iter == name_hash.end())
170
 
        return 0;
171
 
 
172
 
    return (*iter).second;
173
 
  }
174
 
 
175
 
private:
176
 
  memory::Root mem_root;
177
 
 
178
 
  void *alloc_root(size_t arg)
179
 
  {
180
 
    return mem_root.alloc_root(arg);
181
 
  }
182
 
 
183
 
  char *strmake_root(const char *str_arg, size_t len_arg)
184
 
  {
185
 
    return mem_root.strmake_root(str_arg, len_arg);
186
 
  }
187
 
 
188
 
  memory::Root *getMemRoot()
189
 
  {
190
 
    return &mem_root;
191
 
  }
192
 
 
193
 
  std::vector<std::string> _keynames;
194
 
 
195
 
  void addKeyName(std::string arg)
196
 
  {
197
 
    std::transform(arg.begin(), arg.end(),
198
 
                   arg.begin(), ::toupper);
199
 
    _keynames.push_back(arg);
200
 
  }
201
 
public:
202
 
  bool doesKeyNameExist(const char *name_arg, uint32_t name_length, uint32_t &position) const
203
 
  {
204
 
    return doesKeyNameExist(std::string(name_arg, name_length), position);
205
 
  }
206
 
 
207
 
  bool doesKeyNameExist(std::string arg, uint32_t &position) const
208
 
  {
209
 
    std::transform(arg.begin(), arg.end(),
210
 
                   arg.begin(), ::toupper);
211
 
 
212
 
    std::vector<std::string>::const_iterator iter= std::find(_keynames.begin(), _keynames.end(), arg);
213
 
 
214
 
    if (iter == _keynames.end())
215
 
    {
216
 
      position= UINT32_MAX; //historical, required for finding primary key from unique
217
 
      return false;
218
 
    }
219
 
 
220
 
    position= iter -  _keynames.begin();
221
 
 
222
 
    return true;
223
 
  }
224
 
 
225
 
private:
226
 
  std::vector<TYPELIB> intervals;                       /* pointer to interval info */
227
 
 
228
 
  boost::mutex mutex;                /* For locking the share  */
229
 
  boost::condition_variable cond;                       /* To signal that share is ready */
230
 
 
231
 
 
232
 
  void lock()
233
 
  {
234
 
    mutex.lock();
235
 
  }
236
 
 
237
 
  void unlock()
238
 
  {
239
 
    mutex.unlock();
240
 
  }
241
 
 
242
 
  std::vector<unsigned char> default_values;            /* row with default values */
243
 
public:
244
 
  // @note This needs to be made to be const in the future
245
 
  unsigned char *getDefaultValues()
246
 
  {
247
 
    return &default_values[0];
248
 
  }
249
 
  void resizeDefaultValues(size_t arg)
250
 
  {
251
 
    default_values.resize(arg);
252
 
  }
253
 
 
 
48
  KEY  *key_info;                       /* data of keys in database */
 
49
  uint  *blob_field;                    /* Index to blobs in Field arrray*/
 
50
 
 
51
  unsigned char *default_values;                /* row with default values */
 
52
  LEX_STRING comment;                   /* Comment about table */
254
53
  const CHARSET_INFO *table_charset; /* Default charset of string fields */
255
54
 
256
 
  boost::dynamic_bitset<> all_set;
257
 
 
 
55
  MY_BITMAP all_set;
258
56
  /*
259
57
    Key which is used for looking-up table in table cache and in the list
260
58
    of thread's temporary tables. Has the form of:
261
 
    "database_name\0table_name\0" + optional part for temporary tables.
 
59
      "database_name\0table_name\0" + optional part for temporary tables.
262
60
 
263
61
    Note that all three 'table_cache_key', 'db' and 'table_name' members
264
62
    must be set (and be non-zero) for tables in table cache. They also
265
63
    should correspond to each other.
266
64
    To ensure this one can use set_table_cache() methods.
267
65
  */
268
 
private:
269
 
  TableIdentifier::Key private_key_for_cache; // This will not exist in the final design.
270
 
  std::vector<char> private_normalized_path; // This will not exist in the final design.
 
66
  LEX_STRING table_cache_key;
271
67
  LEX_STRING db;                        /* Pointer to db */
272
68
  LEX_STRING table_name;                /* Table name (for open) */
273
 
  LEX_STRING path;      /* Path to table (from datadir) */
 
69
  LEX_STRING path;      /* Path to .frm file (from datadir) */
274
70
  LEX_STRING normalized_path;           /* unpack_filename(path) */
275
 
public:
276
 
 
277
 
  const char *getNormalizedPath() const
278
 
  {
279
 
    return normalized_path.str;
280
 
  }
281
 
 
282
 
  const char *getPath() const
283
 
  {
284
 
    return path.str;
285
 
  }
286
 
 
287
 
  const TableIdentifier::Key& getCacheKey() const // This should never be called when we aren't looking at a cache.
288
 
  {
289
 
    assert(private_key_for_cache.size());
290
 
    return private_key_for_cache;
291
 
  }
292
 
 
293
 
  size_t getCacheKeySize() const
294
 
  {
295
 
    return private_key_for_cache.size();
296
 
  }
297
 
 
298
 
private:
299
 
  void setPath(char *str_arg, uint32_t size_arg)
300
 
  {
301
 
    path.str= str_arg;
302
 
    path.length= size_arg;
303
 
  }
304
 
 
305
 
  void setNormalizedPath(char *str_arg, uint32_t size_arg)
306
 
  {
307
 
    normalized_path.str= str_arg;
308
 
    normalized_path.length= size_arg;
309
 
  }
310
 
public:
311
 
 
312
 
  const char *getTableName() const
313
 
  {
314
 
    return table_name.str;
315
 
  }
316
 
 
317
 
  uint32_t getTableNameSize() const
318
 
  {
319
 
    return table_name.length;
320
 
  }
321
 
 
322
 
  const std::string &getTableName(std::string &name_arg) const
323
 
  {
324
 
    name_arg.clear();
325
 
    name_arg.append(table_name.str, table_name.length);
326
 
 
327
 
    return name_arg;
328
 
  }
329
 
 
330
 
  const char *getSchemaName() const
331
 
  {
332
 
    return db.str;
333
 
  }
334
 
 
335
 
  const std::string &getSchemaName(std::string &schema_name_arg) const
336
 
  {
337
 
    schema_name_arg.clear();
338
 
    schema_name_arg.append(db.str, db.length);
339
 
 
340
 
    return schema_name_arg;
341
 
  }
342
 
 
 
71
  LEX_STRING connect_string;
 
72
 
 
73
  /*
 
74
     Set of keys in use, implemented as a Bitmap.
 
75
     Excludes keys disabled by ALTER Table ... DISABLE KEYS.
 
76
  */
 
77
  key_map keys_in_use;
 
78
  key_map keys_for_keyread;
 
79
  ha_rows min_rows, max_rows;           /* create information */
 
80
  uint32_t   avg_row_length;            /* create information */
343
81
  uint32_t   block_size;                   /* create information */
344
 
 
345
 
private:
346
 
  uint64_t   version;
347
 
public:
348
 
  uint64_t getVersion() const
349
 
  {
350
 
    return version;
351
 
  }
352
 
 
353
 
  void refreshVersion()
354
 
  {
355
 
   version= refresh_version;
356
 
  }
357
 
 
358
 
  void resetVersion()
359
 
  {
360
 
    version= 0;
361
 
  }
362
 
 
 
82
  uint32_t   version, mysql_version;
363
83
  uint32_t   timestamp_offset;          /* Set to offset+1 of record */
364
 
private:
365
84
  uint32_t   reclength;                 /* Recordlength */
366
 
public:
367
 
  uint32_t   stored_rec_length;         /* Stored record length*/
368
 
 
369
 
  uint32_t getRecordLength() const
370
 
  {
371
 
    return reclength;
372
 
  }
373
 
 
374
 
  void setRecordLength(uint32_t arg)
375
 
  {
376
 
    reclength= arg;
377
 
  }
378
 
 
379
 
  const Field_blob *getBlobFieldAt(uint32_t arg) const
380
 
  {
381
 
    if (arg < blob_fields)
382
 
      return (Field_blob*) field[blob_field[arg]];
383
 
 
384
 
    return NULL;
385
 
  }
386
 
 
387
 
private:
388
 
  /* Max rows is a hint to HEAP during a create tmp table */
389
 
  uint64_t max_rows;
390
 
 
391
 
  message::Table *table_proto;
392
 
public:
393
 
 
394
 
  /*
395
 
    @note Without a table_proto, we assume we are building a STANDARD table.
396
 
    This will be modified once we use Identifiers in the Share itself.
397
 
  */
398
 
  message::Table::TableType getTableType() const
399
 
  {
400
 
    return table_proto ? table_proto->type() : message::Table::STANDARD;
401
 
  }
402
 
 
403
 
  const std::string &getTableTypeAsString() const
404
 
  {
405
 
    if (table_proto)
406
 
    {
407
 
      switch (table_proto->type())
408
 
      {
409
 
      default:
410
 
      case message::Table::STANDARD:
411
 
        return STANDARD_STRING;
412
 
      case message::Table::TEMPORARY:
413
 
        return TEMPORARY_STRING;
414
 
      case message::Table::INTERNAL:
415
 
        return INTERNAL_STRING;
416
 
      case message::Table::FUNCTION:
417
 
        return FUNCTION_STRING;
418
 
      }
419
 
    }
420
 
    else
421
 
    {
422
 
      return NO_PROTOBUFFER_AVAILABLE;
423
 
    }
424
 
  }
425
 
 
426
 
  /* This is only used in one location currently */
427
 
  inline message::Table *getTableProto() const
428
 
  {
429
 
    return table_proto;
430
 
  }
431
 
 
432
 
  inline void setTableProto(message::Table *arg)
433
 
  {
434
 
    assert(table_proto == NULL);
435
 
    table_proto= arg;
436
 
  }
437
 
 
438
 
  inline bool hasComment() const
439
 
  {
440
 
    return (table_proto) ?  table_proto->options().has_comment() : false; 
441
 
  }
442
 
 
443
 
  inline const char *getComment()
444
 
  {
445
 
    return (table_proto && table_proto->has_options()) ?  table_proto->options().comment().c_str() : NULL; 
446
 
  }
447
 
 
448
 
  inline uint32_t getCommentLength() const
449
 
  {
450
 
    return (table_proto) ? table_proto->options().comment().length() : 0; 
451
 
  }
452
 
 
453
 
  inline uint64_t getMaxRows() const
454
 
  {
455
 
    return max_rows;
456
 
  }
457
 
 
458
 
  inline void setMaxRows(uint64_t arg)
459
 
  {
460
 
    max_rows= arg;
461
 
  }
462
 
 
463
 
  /**
464
 
   * Returns true if the supplied Field object
465
 
   * is part of the table's primary key.
466
 
 */
467
 
  bool fieldInPrimaryKey(Field *field) const;
468
 
 
469
 
  plugin::StorageEngine *storage_engine;                        /* storage engine plugin */
470
 
  inline plugin::StorageEngine *db_type() const /* table_type for handler */
471
 
  {
472
 
    return storage_engine;
473
 
  }
474
 
  inline plugin::StorageEngine *getEngine() const       /* table_type for handler */
475
 
  {
476
 
    return storage_engine;
477
 
  }
478
 
 
479
 
private:
480
 
  TableIdentifier::Type tmp_table;
481
 
public:
482
 
 
483
 
  TableIdentifier::Type getType() const
484
 
  {
485
 
    return tmp_table;
486
 
  }
487
 
 
488
 
private:
 
85
  uint32_t   stored_rec_length;         /* Stored record length
 
86
                                           (no generated-only virtual fields) */
 
87
 
 
88
  plugin_ref db_plugin;                 /* storage engine plugin */
 
89
  inline StorageEngine *db_type() const /* table_type for handler */
 
90
  {
 
91
    // assert(db_plugin);
 
92
    return db_plugin ? plugin_data(db_plugin, StorageEngine*) : NULL;
 
93
  }
 
94
  enum row_type row_type;               /* How rows are stored */
 
95
  enum tmp_table_type tmp_table;
 
96
  enum ha_choice page_checksum;
 
97
 
489
98
  uint32_t ref_count;       /* How many Table objects uses this */
490
 
 
491
 
public:
492
 
  uint32_t getTableCount() const
493
 
  {
494
 
    return ref_count;
495
 
  }
496
 
 
497
 
  void incrementTableCount()
498
 
  {
499
 
    lock();
500
 
    ref_count++;
501
 
    unlock();
502
 
  }
503
 
 
 
99
  uint32_t open_count;                  /* Number of tables in open list */
 
100
  uint32_t blob_ptr_size;                       /* 4 or 8 */
 
101
  uint32_t key_block_size;                      /* create key_block_size, if used */
504
102
  uint32_t null_bytes;
505
103
  uint32_t last_null_bit_pos;
506
104
  uint32_t fields;                              /* Number of fields */
507
 
 
508
 
  uint32_t sizeFields() const
509
 
  {
510
 
    return fields;
511
 
  }
512
 
 
 
105
  uint32_t stored_fields;                   /* Number of stored fields
 
106
                                           (i.e. without generated-only ones) */
513
107
  uint32_t rec_buff_length;                 /* Size of table->record[] buffer */
514
 
  uint32_t keys;
515
 
 
516
 
  uint32_t sizeKeys() const
517
 
  {
518
 
    return keys;
519
 
  }
520
 
  uint32_t key_parts;
 
108
  uint32_t keys, key_parts;
521
109
  uint32_t max_key_length, max_unique_length, total_key_length;
522
110
  uint32_t uniques;                         /* Number of UNIQUE index */
523
111
  uint32_t null_fields;                 /* number of null fields */
524
112
  uint32_t blob_fields;                 /* number of blob fields */
525
 
private:
526
 
  bool has_variable_width;                  /* number of varchar fields */
527
 
public:
528
 
  bool hasVariableWidth() const
529
 
  {
530
 
    return has_variable_width; // We should calculate this.
531
 
  }
532
 
  void setVariableWidth()
533
 
  {
534
 
    has_variable_width= true;
535
 
  }
 
113
  uint32_t timestamp_field_offset;              /* Field number for timestamp field */
 
114
  uint32_t varchar_fields;                  /* number of varchar fields */
536
115
  uint32_t db_create_options;           /* Create options from database */
537
116
  uint32_t db_options_in_use;           /* Options in use */
538
117
  uint32_t db_record_offset;            /* if HA_REC_IN_SEQ */
539
118
  uint32_t rowid_field_offset;          /* Field_nr +1 to rowid field */
540
 
  /**
541
 
   * @TODO 
542
 
   *
543
 
   * Currently the replication services component uses
544
 
   * the primary_key member to determine which field is the table's
545
 
   * primary key.  However, as it exists, because this member is scalar, it
546
 
   * only supports a single-column primary key. Is there a better way
547
 
   * to ask for the fields which are in a primary key?
548
 
 */
549
 
private:
 
119
  /* Index of auto-updated TIMESTAMP field in field array */
550
120
  uint32_t primary_key;
551
 
public:
552
 
 
553
 
  uint32_t getPrimaryKey() const
554
 
  {
555
 
    return primary_key;
556
 
  }
557
 
 
558
 
  bool hasPrimaryKey() const
559
 
  {
560
 
    return primary_key != MAX_KEY;
561
 
  }
562
 
 
563
 
  /* Index of auto-updated TIMESTAMP field in field array */
564
121
  uint32_t next_number_index;               /* autoincrement key number */
565
122
  uint32_t next_number_key_offset;          /* autoinc keypart offset in a key */
566
123
  uint32_t next_number_keypart;             /* autoinc keypart number in a key */
567
124
  uint32_t error, open_errno, errarg;       /* error from open_table_def() */
 
125
  uint32_t column_bitmap_size;
568
126
 
569
 
  uint8_t blob_ptr_size;                        /* 4 or 8 */
 
127
  uint32_t vfields;                         /* Number of virtual fields */
570
128
  bool db_low_byte_first;               /* Portable row format */
571
 
 
572
 
  /*
573
 
    Set of keys in use, implemented as a Bitmap.
574
 
    Excludes keys disabled by ALTER Table ... DISABLE KEYS.
575
 
  */
576
 
  key_map keys_in_use;
577
 
  key_map keys_for_keyread;
578
 
 
579
 
  /* 
580
 
    event_observers is a class containing all the event plugins that have 
581
 
    registered an interest in this table.
582
 
  */
583
 
  private:
584
 
  plugin::EventObserverList *event_observers;
585
 
  public:
586
 
  plugin::EventObserverList *getTableObservers() 
587
 
  { 
588
 
    return event_observers;
589
 
  }
590
 
  
591
 
  void setTableObservers(plugin::EventObserverList *observers) 
592
 
  { 
593
 
    event_observers= observers;
594
 
  }
595
 
  
596
 
  /*
597
 
    Set share's identifier information.
598
 
 
599
 
    SYNOPSIS
600
 
    setIdentifier()
601
 
 
602
 
    NOTES
603
 
  */
604
 
 
605
 
  void setIdentifier(const TableIdentifier &identifier_arg);
606
 
 
607
 
  /*
608
 
    Initialize share for temporary tables
609
 
 
610
 
    SYNOPSIS
611
 
    init()
612
 
    share       Share to fill
613
 
    key         Table_cache_key, as generated from create_table_def_key.
614
 
    must start with db name.
615
 
    key_length  Length of key
616
 
    table_name  Table name
617
 
    path        Path to table (possible in lower case)
618
 
 
619
 
    NOTES
620
 
    
621
 
  */
622
 
 
623
 
private:
624
 
  void init(const char *new_table_name,
625
 
            const char *new_path);
626
 
public:
627
 
 
628
 
  void open_table_error(int pass_error, int db_errno, int pass_errarg);
629
 
 
630
 
  static void release(TableShare *share);
631
 
  static void release(TableShare::shared_ptr &share);
632
 
  static void release(const TableIdentifier &identifier);
633
 
  static TableShare::shared_ptr getShareCreate(Session *session, 
634
 
                                               const TableIdentifier &identifier,
635
 
                                               int &error);
636
 
 
637
 
  friend std::ostream& operator<<(std::ostream& output, const TableShare &share)
638
 
  {
639
 
    output << "TableShare:(";
640
 
    output <<  share.getSchemaName();
641
 
    output << ", ";
642
 
    output << share.getTableName();
643
 
    output << ", ";
644
 
    output << share.getTableTypeAsString();
645
 
    output << ", ";
646
 
    output << share.getPath();
647
 
    output << ")";
648
 
 
649
 
    return output;  // for multiple << operators.
650
 
  }
651
 
 
652
 
  Field *make_field(unsigned char *ptr,
653
 
                    uint32_t field_length,
654
 
                    bool is_nullable,
655
 
                    unsigned char *null_pos,
656
 
                    unsigned char null_bit,
657
 
                    uint8_t decimals,
658
 
                    enum_field_types field_type,
659
 
                    const CHARSET_INFO * field_charset,
660
 
                    Field::utype unireg_check,
661
 
                    TYPELIB *interval,
662
 
                    const char *field_name);
663
 
 
664
 
  int open_table_def(Session& session, const TableIdentifier &identifier);
665
 
 
666
 
  int open_table_from_share(Session *session,
667
 
                            const TableIdentifier &identifier,
668
 
                            const char *alias,
669
 
                            uint32_t db_stat, uint32_t ha_open_flags,
670
 
                            Table &outparam);
671
 
private:
672
 
  int open_table_from_share_inner(Session *session,
673
 
                                  const char *alias,
674
 
                                  uint32_t db_stat,
675
 
                                  Table &outparam);
676
 
  int open_table_cursor_inner(const TableIdentifier &identifier,
677
 
                              uint32_t db_stat, uint32_t ha_open_flags,
678
 
                              Table &outparam,
679
 
                              bool &error_reported);
680
 
public:
681
 
  int parse_table_proto(Session& session, message::Table &table);
682
 
private:
683
 
  int inner_parse_table_proto(Session& session, message::Table &table);
 
129
  bool crashed;
 
130
  bool name_lock, replace_with_name_lock;
 
131
  bool waiting_on_cond;                 /* Protection against free */
 
132
  uint32_t table_map_id;                   /* for row-based replication */
 
133
  uint64_t table_map_version;
 
134
 
 
135
  /*
 
136
    Cache for row-based replication table share checks that does not
 
137
    need to be repeated. Possible values are: -1 when cache value is
 
138
    not calculated yet, 0 when table *shall not* be replicated, 1 when
 
139
    table *may* be replicated.
 
140
  */
 
141
  int cached_row_logging_check;
 
142
 
 
143
  /*
 
144
    Set share's table cache key and update its db and table name appropriately.
 
145
 
 
146
    SYNOPSIS
 
147
      set_table_cache_key()
 
148
        key_buff    Buffer with already built table cache key to be
 
149
                    referenced from share.
 
150
        key_length  Key length.
 
151
 
 
152
    NOTES
 
153
      Since 'key_buff' buffer will be referenced from share it should has same
 
154
      life-time as share itself.
 
155
      This method automatically ensures that TABLE_SHARE::table_name/db have
 
156
      appropriate values by using table cache key as their source.
 
157
  */
 
158
 
 
159
  void set_table_cache_key(char *key_buff, uint32_t key_length)
 
160
  {
 
161
    table_cache_key.str= key_buff;
 
162
    table_cache_key.length= key_length;
 
163
    /*
 
164
      Let us use the fact that the key is "db/0/table_name/0" + optional
 
165
      part for temporary tables.
 
166
    */
 
167
    db.str=            table_cache_key.str;
 
168
    db.length=         strlen(db.str);
 
169
    table_name.str=    db.str + db.length + 1;
 
170
    table_name.length= strlen(table_name.str);
 
171
  }
 
172
 
 
173
 
 
174
  /*
 
175
    Set share's table cache key and update its db and table name appropriately.
 
176
 
 
177
    SYNOPSIS
 
178
      set_table_cache_key()
 
179
        key_buff    Buffer to be used as storage for table cache key
 
180
                    (should be at least key_length bytes).
 
181
        key         Value for table cache key.
 
182
        key_length  Key length.
 
183
 
 
184
    NOTE
 
185
      Since 'key_buff' buffer will be used as storage for table cache key
 
186
      it should has same life-time as share itself.
 
187
  */
 
188
 
 
189
  void set_table_cache_key(char *key_buff, const char *key, uint32_t key_length)
 
190
  {
 
191
    memcpy(key_buff, key, key_length);
 
192
    set_table_cache_key(key_buff, key_length);
 
193
  }
 
194
 
 
195
  inline bool honor_global_locks()
 
196
  {
 
197
    return (table_category == TABLE_CATEGORY_USER);
 
198
  }
 
199
 
 
200
  inline uint32_t get_table_def_version()
 
201
  {
 
202
    return table_map_id;
 
203
  }
 
204
 
684
205
};
685
 
 
686
 
} /* namespace drizzled */
687
 
 
688
 
#endif /* DRIZZLED_DEFINITION_TABLE_H */