← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/table_share.h

  • Committer: Jay Pipes
  • Date: 2009-01-30 04:01:12 UTC
  • mto: This revision was merged to the branch mainline in revision 830.
  • Revision ID: jpipes@serialcoder-20090130040112-svbn774guj98pwi4
To remain in compatibility with MySQL, added ability to interpret
decimal arguments as datetime strings for temporal functions.

Fixed YEAR(), MONTH(), DAYOFMONTH(), DAYOFYEAR(), HOUR(), MINUTE(), SECOND(), and MICROSECOND()
to accept decimal parameters and interpret them the same way as MySQL.

Fixed an issue with the TemporalFormat::matches() method which was 
incorrectly assuming all microsecond arguments were specified as 6 digits.
Added power of 10 multiplier to usecond calculation. This fixes issues with
failures in type_date and func_sapdb test cases.

Show diffs side-by-side

added added

removed removed

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