← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/handlerton.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/handlerton.h
17
17
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18
18
 */
19
19
 
20
 
#ifndef DRIZZLED_PLUGIN_STORAGE_ENGINE_H
21
 
#define DRIZZLED_PLUGIN_STORAGE_ENGINE_H
 
20
#ifndef DRIZZLED_HANDLERTON_H
 
21
#define DRIZZLED_HANDLERTON_H
22
22
 
 
23
#include <stdint.h>
 
24
#include <bitset>
23
25
 
24
26
#include <drizzled/definitions.h>
25
 
#include <drizzled/plugin.h>
26
 
#include <drizzled/handler_structs.h>
27
 
#include <drizzled/message.h>
28
 
#include <drizzled/message/cache.h>
29
 
#include "drizzled/plugin/plugin.h"
30
 
#include "drizzled/sql_string.h"
31
 
#include "drizzled/identifier.h"
32
 
#include "drizzled/cached_directory.h"
33
 
#include "drizzled/plugin/monitored_in_transaction.h"
34
 
 
35
 
#include <bitset>
36
 
#include <string>
37
 
#include <vector>
38
 
#include <set>
39
 
 
40
 
namespace drizzled
41
 
{
 
27
#include <drizzled/sql_plugin.h>
42
28
 
43
29
class TableList;
44
30
class Session;
45
 
class Cursor;
46
 
typedef struct st_hash HASH;
 
31
class XID;
 
32
class handler;
47
33
 
48
 
class TableShare;
49
 
typedef drizzle_lex_string LEX_STRING;
 
34
class TABLE_SHARE;
 
35
typedef struct st_mysql_lex_string LEX_STRING;
50
36
typedef bool (stat_print_fn)(Session *session, const char *type, uint32_t type_len,
51
37
                             const char *file, uint32_t file_len,
52
38
                             const char *status, uint32_t status_len);
 
39
enum ha_stat_type { HA_ENGINE_STATUS, HA_ENGINE_LOGS, HA_ENGINE_MUTEX };
53
40
 
54
 
/* Possible flags of a StorageEngine (there can be 32 of them) */
55
 
enum engine_flag_bits {
 
41
/* Possible flags of a handlerton (there can be 32 of them) */
 
42
enum hton_flag_bits {
 
43
  HTON_BIT_CLOSE_CURSORS_AT_COMMIT,
56
44
  HTON_BIT_ALTER_NOT_SUPPORTED,       // Engine does not support alter
 
45
  HTON_BIT_CAN_RECREATE,              // Delete all is used for truncate
57
46
  HTON_BIT_HIDDEN,                    // Engine does not appear in lists
 
47
  HTON_BIT_FLUSH_AFTER_RENAME,
58
48
  HTON_BIT_NOT_USER_SELECTABLE,
59
49
  HTON_BIT_TEMPORARY_NOT_SUPPORTED,   // Having temporary tables not supported
60
 
  HTON_BIT_TEMPORARY_ONLY,
61
 
  HTON_BIT_DOES_TRANSACTIONS,
62
 
  HTON_BIT_STATS_RECORDS_IS_EXACT,
63
 
  HTON_BIT_NULL_IN_KEY,
64
 
  HTON_BIT_CAN_INDEX_BLOBS,
65
 
  HTON_BIT_PRIMARY_KEY_IN_READ_INDEX,
66
 
  HTON_BIT_PARTIAL_COLUMN_READ,
67
 
  HTON_BIT_TABLE_SCAN_ON_INDEX,
68
 
  HTON_BIT_FAST_KEY_READ,
69
 
  HTON_BIT_NO_BLOBS,
70
 
  HTON_BIT_HAS_RECORDS,
71
 
  HTON_BIT_NO_AUTO_INCREMENT,
72
 
  HTON_BIT_DUPLICATE_POS,
73
 
  HTON_BIT_AUTO_PART_KEY,
74
 
  HTON_BIT_REQUIRE_PRIMARY_KEY,
75
 
  HTON_BIT_REQUIRES_KEY_COLUMNS_FOR_DELETE,
76
 
  HTON_BIT_PRIMARY_KEY_REQUIRED_FOR_DELETE,
77
 
  HTON_BIT_NO_PREFIX_CHAR_KEYS,
78
 
  HTON_BIT_HAS_CHECKSUM,
79
 
  HTON_BIT_SKIP_STORE_LOCK,
80
 
  HTON_BIT_SCHEMA_DICTIONARY,
81
 
  HTON_BIT_FOREIGN_KEYS,
 
50
  HTON_BIT_SUPPORT_LOG_TABLES,        // Engine supports log tables
 
51
  HTON_BIT_NO_PARTITION,              // You can not partition these tables
82
52
  HTON_BIT_SIZE
83
53
};
84
54
 
85
55
static const std::bitset<HTON_BIT_SIZE> HTON_NO_FLAGS(0);
 
56
static const std::bitset<HTON_BIT_SIZE> HTON_CLOSE_CURSORS_AT_COMMIT(1 <<  HTON_BIT_CLOSE_CURSORS_AT_COMMIT);
86
57
static const std::bitset<HTON_BIT_SIZE> HTON_ALTER_NOT_SUPPORTED(1 << HTON_BIT_ALTER_NOT_SUPPORTED);
 
58
static const std::bitset<HTON_BIT_SIZE> HTON_CAN_RECREATE(1 << HTON_BIT_CAN_RECREATE);
87
59
static const std::bitset<HTON_BIT_SIZE> HTON_HIDDEN(1 << HTON_BIT_HIDDEN);
 
60
static const std::bitset<HTON_BIT_SIZE> HTON_FLUSH_AFTER_RENAME(1 << HTON_BIT_FLUSH_AFTER_RENAME);
88
61
static const std::bitset<HTON_BIT_SIZE> HTON_NOT_USER_SELECTABLE(1 << HTON_BIT_NOT_USER_SELECTABLE);
89
62
static const std::bitset<HTON_BIT_SIZE> HTON_TEMPORARY_NOT_SUPPORTED(1 << HTON_BIT_TEMPORARY_NOT_SUPPORTED);
90
 
static const std::bitset<HTON_BIT_SIZE> HTON_TEMPORARY_ONLY(1 << HTON_BIT_TEMPORARY_ONLY);
91
 
static const std::bitset<HTON_BIT_SIZE> HTON_HAS_DOES_TRANSACTIONS(1 << HTON_BIT_DOES_TRANSACTIONS);
92
 
static const std::bitset<HTON_BIT_SIZE> HTON_STATS_RECORDS_IS_EXACT(1 << HTON_BIT_STATS_RECORDS_IS_EXACT);
93
 
static const std::bitset<HTON_BIT_SIZE> HTON_NULL_IN_KEY(1 << HTON_BIT_NULL_IN_KEY);
94
 
static const std::bitset<HTON_BIT_SIZE> HTON_CAN_INDEX_BLOBS(1 << HTON_BIT_CAN_INDEX_BLOBS);
95
 
static const std::bitset<HTON_BIT_SIZE> HTON_PRIMARY_KEY_IN_READ_INDEX(1 << HTON_BIT_PRIMARY_KEY_IN_READ_INDEX);
96
 
static const std::bitset<HTON_BIT_SIZE> HTON_PARTIAL_COLUMN_READ(1 << HTON_BIT_PARTIAL_COLUMN_READ);
97
 
static const std::bitset<HTON_BIT_SIZE> HTON_TABLE_SCAN_ON_INDEX(1 << HTON_BIT_TABLE_SCAN_ON_INDEX);
98
 
static const std::bitset<HTON_BIT_SIZE> HTON_FAST_KEY_READ(1 << HTON_BIT_FAST_KEY_READ);
99
 
static const std::bitset<HTON_BIT_SIZE> HTON_NO_BLOBS(1 << HTON_BIT_NO_BLOBS);
100
 
static const std::bitset<HTON_BIT_SIZE> HTON_HAS_RECORDS(1 << HTON_BIT_HAS_RECORDS);
101
 
static const std::bitset<HTON_BIT_SIZE> HTON_NO_AUTO_INCREMENT(1 << HTON_BIT_NO_AUTO_INCREMENT);
102
 
static const std::bitset<HTON_BIT_SIZE> HTON_DUPLICATE_POS(1 << HTON_BIT_DUPLICATE_POS);
103
 
static const std::bitset<HTON_BIT_SIZE> HTON_AUTO_PART_KEY(1 << HTON_BIT_AUTO_PART_KEY);
104
 
static const std::bitset<HTON_BIT_SIZE> HTON_REQUIRE_PRIMARY_KEY(1 << HTON_BIT_REQUIRE_PRIMARY_KEY);
105
 
static const std::bitset<HTON_BIT_SIZE> HTON_REQUIRES_KEY_COLUMNS_FOR_DELETE(1 << HTON_BIT_REQUIRES_KEY_COLUMNS_FOR_DELETE);
106
 
static const std::bitset<HTON_BIT_SIZE> HTON_PRIMARY_KEY_REQUIRED_FOR_DELETE(1 << HTON_BIT_PRIMARY_KEY_REQUIRED_FOR_DELETE);
107
 
static const std::bitset<HTON_BIT_SIZE> HTON_NO_PREFIX_CHAR_KEYS(1 << HTON_BIT_NO_PREFIX_CHAR_KEYS);
108
 
static const std::bitset<HTON_BIT_SIZE> HTON_HAS_CHECKSUM(1 << HTON_BIT_HAS_CHECKSUM);
109
 
static const std::bitset<HTON_BIT_SIZE> HTON_SKIP_STORE_LOCK(1 << HTON_BIT_SKIP_STORE_LOCK);
110
 
static const std::bitset<HTON_BIT_SIZE> HTON_HAS_SCHEMA_DICTIONARY(1 << HTON_BIT_SCHEMA_DICTIONARY);
111
 
static const std::bitset<HTON_BIT_SIZE> HTON_HAS_FOREIGN_KEYS(1 << HTON_BIT_FOREIGN_KEYS);
112
 
 
113
 
 
114
 
class Table;
115
 
class NamedSavepoint;
116
 
 
117
 
namespace plugin
118
 
{
119
 
 
120
 
typedef std::vector<StorageEngine *> EngineVector;
121
 
 
122
 
typedef std::set<std::string> TableNameList;
123
 
 
124
 
extern const std::string UNKNOWN_STRING;
125
 
extern const std::string DEFAULT_DEFINITION_FILE_EXT;
 
63
static const std::bitset<HTON_BIT_SIZE> HTON_SUPPORT_LOG_TABLES(1 << HTON_BIT_SUPPORT_LOG_TABLES);
 
64
static const std::bitset<HTON_BIT_SIZE> HTON_NO_PARTITION(1 << HTON_BIT_NO_PARTITION);
126
65
 
127
66
/*
128
 
  StorageEngine is a singleton structure - one instance per storage engine -
 
67
  handlerton is a singleton structure - one instance per storage engine -
129
68
  to provide access to storage engine functionality that works on the
130
 
  "global" level (unlike Cursor class that works on a per-table basis)
131
 
 
132
 
  usually StorageEngine instance is defined statically in ha_xxx.cc as
133
 
 
134
 
  static StorageEngine { ... } xxx_engine;
 
69
  "global" level (unlike handler class that works on a per-table basis)
 
70
 
 
71
  usually handlerton instance is defined statically in ha_xxx.cc as
 
72
 
 
73
  static handlerton { ... } xxx_hton;
 
74
 
 
75
  savepoint_*, prepare, recover, and *_by_xid pointers can be 0.
135
76
*/
136
 
class StorageEngine : public Plugin,
137
 
                      public MonitoredInTransaction
 
77
struct handlerton
138
78
{
139
 
public:
140
 
  typedef uint64_t Table_flags;
141
 
 
142
 
private:
143
 
  const std::bitset<HTON_BIT_SIZE> flags; /* global Cursor flags */
144
 
 
145
 
  static EngineVector &getSchemaEngines();
146
 
 
147
 
  virtual void setTransactionReadWrite(Session& session);
148
 
 
149
 
  /*
150
 
   * Indicates to a storage engine the start of a
151
 
   * new SQL statement.
152
 
   */
153
 
  virtual void doStartStatement(Session *session)
154
 
  {
155
 
    (void) session;
156
 
  }
157
 
 
158
 
  /*
159
 
   * Indicates to a storage engine the end of
160
 
   * the current SQL statement in the supplied
161
 
   * Session.
162
 
   */
163
 
  virtual void doEndStatement(Session *session)
164
 
  {
165
 
    (void) session;
166
 
  }
167
 
 
168
 
protected:
169
 
  std::string table_definition_ext;
170
 
 
171
 
public:
172
 
  const std::string& getTableDefinitionFileExtension()
173
 
  {
174
 
    return table_definition_ext;
175
 
  }
176
 
 
177
 
private:
178
 
  std::vector<std::string> aliases;
179
 
 
180
 
public:
181
 
  const std::vector<std::string>& getAliases() const
182
 
  {
183
 
    return aliases;
184
 
  }
185
 
 
186
 
  void addAlias(std::string alias)
187
 
  {
188
 
    aliases.push_back(alias);
189
 
  }
190
 
 
191
 
protected:
192
 
 
193
 
  /**
194
 
    @brief
195
 
    Used as a protobuf storage currently by TEMP only engines.
196
 
  */
197
 
  typedef std::map <std::string, message::Table> ProtoCache;
198
 
  ProtoCache proto_cache;
199
 
  pthread_mutex_t proto_cache_mutex;
200
 
 
201
 
public:
202
 
 
203
 
  StorageEngine(const std::string name_arg,
204
 
                const std::bitset<HTON_BIT_SIZE> &flags_arg= HTON_NO_FLAGS);
205
 
 
206
 
  virtual ~StorageEngine();
207
 
 
208
 
  virtual int doGetTableDefinition(Session &session,
209
 
                                   const drizzled::TableIdentifier &identifier,
210
 
                                   message::Table &table_message)
211
 
  {
212
 
    (void)session;
213
 
    (void)identifier;
214
 
    (void)table_message;
215
 
 
216
 
    return ENOENT;
217
 
  }
218
 
 
219
 
  /* Old style cursor errors */
220
 
protected:
221
 
  void print_keydup_error(uint32_t key_nr, const char *msg, Table &table);
222
 
  void print_error(int error, myf errflag, Table *table= NULL);
223
 
  virtual bool get_error_message(int error, String *buf);
224
 
public:
225
 
  virtual void print_error(int error, myf errflag, Table& table);
226
 
 
227
 
  bool is_user_selectable() const
228
 
  {
229
 
    return not flags.test(HTON_BIT_NOT_USER_SELECTABLE);
230
 
  }
231
 
 
232
 
  bool check_flag(const engine_flag_bits flag) const
233
 
  {
234
 
    return flags.test(flag);
235
 
  }
236
 
 
237
 
  // @todo match check_flag interface
238
 
  virtual uint32_t index_flags(enum  ha_key_alg) const { return 0; }
239
 
  virtual void startStatement(Session *session)
240
 
  {
241
 
    doStartStatement(session);
242
 
  }
243
 
  virtual void endStatement(Session *session)
244
 
  {
245
 
    doEndStatement(session);
246
 
  }
247
 
 
248
 
  /*
249
 
   * Called during Session::cleanup() for all engines
250
 
   */
251
 
  virtual int close_connection(Session  *)
252
 
  {
253
 
    return 0;
254
 
  }
255
 
  virtual Cursor *create(Table &)= 0;
256
 
  /* args: path */
257
 
  virtual bool flush_logs() { return false; }
258
 
  virtual bool show_status(Session *, stat_print_fn *, enum ha_stat_type)
259
 
  {
260
 
    return false;
261
 
  }
262
 
 
263
 
  /**
264
 
    If frm_error() is called then we will use this to find out what file
265
 
    extentions exist for the storage engine. This is also used by the default
266
 
    rename_table and delete_table method in Cursor.cc.
267
 
 
268
 
    For engines that have two file name extentions (separate meta/index file
269
 
    and data file), the order of elements is relevant. First element of engine
270
 
    file name extentions array should be meta/index file extention. Second
271
 
    element - data file extention. This order is assumed by
272
 
    prepare_for_repair() when REPAIR Table ... USE_FRM is issued.
273
 
  */
274
 
  virtual const char **bas_ext() const =0;
275
 
 
276
 
protected:
277
 
  virtual int doCreateTable(Session &session,
278
 
                            Table &table_arg,
279
 
                            const drizzled::TableIdentifier &identifier,
280
 
                            message::Table &message)= 0;
281
 
 
282
 
  virtual int doRenameTable(Session &session,
283
 
                            const drizzled::TableIdentifier &from, const drizzled::TableIdentifier &to)= 0;
284
 
 
285
 
public:
286
 
 
287
 
  int renameTable(Session &session, const drizzled::TableIdentifier &from, const drizzled::TableIdentifier &to);
288
 
 
289
 
  virtual void doGetTableIdentifiers(CachedDirectory &directory,
290
 
                                     const drizzled::SchemaIdentifier &schema_identifier,
291
 
                                     TableIdentifier::vector &set_of_identifiers)= 0;
292
 
 
293
 
  virtual int doDropTable(Session &session,
294
 
                          const drizzled::TableIdentifier &identifier)= 0;
295
 
 
296
 
  /* Class Methods for operating on plugin */
297
 
  static bool addPlugin(plugin::StorageEngine *engine);
298
 
  static void removePlugin(plugin::StorageEngine *engine);
299
 
 
300
 
  static int getTableDefinition(Session& session,
301
 
                                const drizzled::TableIdentifier &identifier,
302
 
                                message::table::shared_ptr &table_proto,
303
 
                                bool include_temporary_tables= true);
304
 
  static bool doesTableExist(Session &session,
305
 
                             const drizzled::TableIdentifier &identifier,
306
 
                             bool include_temporary_tables= true);
307
 
 
308
 
  virtual bool doDoesTableExist(Session& session, const drizzled::TableIdentifier &identifier);
309
 
 
310
 
  static plugin::StorageEngine *findByName(const std::string &find_str);
311
 
  static plugin::StorageEngine *findByName(Session& session, const std::string &find_str);
312
 
 
313
 
  static void closeConnection(Session* session);
314
 
  static void dropDatabase(char* path);
315
 
  static bool flushLogs(plugin::StorageEngine *db_type);
316
 
  static int dropTable(Session& session,
317
 
                       const drizzled::TableIdentifier &identifier);
318
 
  static int dropTable(Session& session,
319
 
                       StorageEngine &engine,
320
 
                       const drizzled::TableIdentifier &identifier);
321
 
  static void getIdentifiers(Session &session,
322
 
                             const SchemaIdentifier &schema_identifier,
323
 
                             TableIdentifier::vector &set_of_identifiers);
324
 
 
325
 
  // Check to see if any SE objects to creation.
326
 
  static bool canCreateTable(const drizzled::TableIdentifier &identifier);
327
 
  virtual bool doCanCreateTable(const drizzled::TableIdentifier &identifier)
328
 
  { (void)identifier;  return true; }
329
 
 
330
 
  // @note All schema methods defined here
331
 
  static void getIdentifiers(Session &session, SchemaIdentifier::vector &schemas);
332
 
  static bool getSchemaDefinition(const drizzled::TableIdentifier &identifier, message::schema::shared_ptr &proto);
333
 
  static bool getSchemaDefinition(const drizzled::SchemaIdentifier &identifier, message::schema::shared_ptr &proto);
334
 
  static bool doesSchemaExist(const drizzled::SchemaIdentifier &identifier);
335
 
  static const CHARSET_INFO *getSchemaCollation(const drizzled::SchemaIdentifier &identifier);
336
 
  static bool createSchema(const drizzled::message::Schema &schema_message);
337
 
  static bool dropSchema(const drizzled::SchemaIdentifier &identifier);
338
 
  static bool alterSchema(const drizzled::message::Schema &schema_message);
339
 
 
340
 
  // @note make private/protected
341
 
  virtual void doGetSchemaIdentifiers(SchemaIdentifier::vector&)
342
 
  { }
343
 
 
344
 
  virtual bool doGetSchemaDefinition(const drizzled::SchemaIdentifier&, drizzled::message::schema::shared_ptr&)
345
 
  { 
346
 
    return false; 
347
 
  }
348
 
 
349
 
  virtual bool doCreateSchema(const drizzled::message::Schema&)
350
 
  { return false; }
351
 
 
352
 
  virtual bool doAlterSchema(const drizzled::message::Schema&)
353
 
  { return false; }
354
 
 
355
 
  virtual bool doDropSchema(const drizzled::SchemaIdentifier&)
356
 
  { return false; }
357
 
 
358
 
  static inline const std::string &resolveName(const StorageEngine *engine)
359
 
  {
360
 
    return engine == NULL ? UNKNOWN_STRING : engine->getName();
361
 
  }
362
 
 
363
 
  static int createTable(Session& session,
364
 
                         const drizzled::TableIdentifier &identifier,
365
 
                         message::Table& table_proto);
366
 
 
367
 
  static void removeLostTemporaryTables(Session &session, const char *directory);
368
 
 
369
 
  Cursor *getCursor(Table &share);
370
 
 
371
 
  uint32_t max_record_length() const
372
 
  { return std::min((unsigned int)HA_MAX_REC_LENGTH, max_supported_record_length()); }
373
 
  uint32_t max_keys() const
374
 
  { return std::min((unsigned int)MAX_KEY, max_supported_keys()); }
375
 
  uint32_t max_key_parts() const
376
 
  { return std::min((unsigned int)MAX_REF_PARTS, max_supported_key_parts()); }
377
 
  uint32_t max_key_length() const
378
 
  { return std::min((unsigned int)MAX_KEY_LENGTH, max_supported_key_length()); }
379
 
  uint32_t max_key_part_length(void) const
380
 
  { return std::min((unsigned int)MAX_KEY_LENGTH, max_supported_key_part_length()); }
381
 
 
382
 
  virtual uint32_t max_supported_record_length(void) const
383
 
  { return HA_MAX_REC_LENGTH; }
384
 
  virtual uint32_t max_supported_keys(void) const { return 0; }
385
 
  virtual uint32_t max_supported_key_parts(void) const { return MAX_REF_PARTS; }
386
 
  virtual uint32_t max_supported_key_length(void) const { return MAX_KEY_LENGTH; }
387
 
  virtual uint32_t max_supported_key_part_length(void) const { return 255; }
388
 
 
389
 
  /* TODO-> Make private */
390
 
  static int deleteDefinitionFromPath(const drizzled::TableIdentifier &identifier);
391
 
  static int renameDefinitionFromPath(const drizzled::TableIdentifier &dest, const drizzled::TableIdentifier &src);
392
 
  static int writeDefinitionFromPath(const drizzled::TableIdentifier &identifier, message::Table &proto);
393
 
  static bool readTableFile(const std::string &path, message::Table &table_message);
394
 
 
395
 
public:
396
 
  /* 
397
 
   * The below are simple virtual overrides for the plugin::MonitoredInTransaction
398
 
   * interface.
399
 
   */
400
 
  virtual bool participatesInSqlTransaction() const
401
 
  {
402
 
    return false; /* plugin::StorageEngine is non-transactional in terms of SQL */
403
 
  }
404
 
  virtual bool participatesInXaTransaction() const
405
 
  {
406
 
    return false; /* plugin::StorageEngine is non-transactional in terms of XA */
407
 
  }
408
 
  virtual bool alwaysRegisterForXaTransaction() const
409
 
  {
410
 
    return false;
411
 
  }
412
 
 
413
 
  virtual bool validateCreateTableOption(const std::string &key, const std::string &state)
414
 
  {
415
 
    (void)key;
416
 
    (void)state;
417
 
 
418
 
    return false;
419
 
  }
420
 
 
421
 
  virtual bool validateCreateSchemaOption(const std::string &key, const std::string &state)
422
 
  {
423
 
    (void)key;
424
 
    (void)state;
425
 
 
426
 
    return false;
427
 
  }
 
79
  /*
 
80
    Name used for storage engine.
 
81
  */
 
82
  const char *name;
 
83
 
 
84
  /*
 
85
    Historical marker for if the engine is available of not
 
86
  */
 
87
  SHOW_COMP_OPTION state;
 
88
 
 
89
  /*
 
90
    Historical number used for frm file to determine the correct storage engine.
 
91
    This is going away and new engines will just use "name" for this.
 
92
  */
 
93
  enum legacy_db_type db_type;
 
94
  /*
 
95
    each storage engine has it's own memory area (actually a pointer)
 
96
    in the session, for storing per-connection information.
 
97
    It is accessed as
 
98
 
 
99
      session->ha_data[xxx_hton.slot]
 
100
 
 
101
   slot number is initialized by MySQL after xxx_init() is called.
 
102
   */
 
103
   uint32_t slot;
 
104
   /*
 
105
     to store per-savepoint data storage engine is provided with an area
 
106
     of a requested size (0 is ok here).
 
107
     savepoint_offset must be initialized statically to the size of
 
108
     the needed memory to store per-savepoint information.
 
109
     After xxx_init it is changed to be an offset to savepoint storage
 
110
     area and need not be used by storage engine.
 
111
     see binlog_hton and binlog_savepoint_set/rollback for an example.
 
112
   */
 
113
   uint32_t savepoint_offset;
 
114
   /*
 
115
     handlerton methods:
 
116
 
 
117
     close_connection is only called if
 
118
     session->ha_data[xxx_hton.slot] is non-zero, so even if you don't need
 
119
     this storage area - set it to something, so that MySQL would know
 
120
     this storage engine was accessed in this connection
 
121
   */
 
122
   int  (*close_connection)(handlerton *hton, Session *session);
 
123
   /*
 
124
     sv points to an uninitialized storage area of requested size
 
125
     (see savepoint_offset description)
 
126
   */
 
127
   int  (*savepoint_set)(handlerton *hton, Session *session, void *sv);
 
128
   /*
 
129
     sv points to a storage area, that was earlier passed
 
130
     to the savepoint_set call
 
131
   */
 
132
   int  (*savepoint_rollback)(handlerton *hton, Session *session, void *sv);
 
133
   int  (*savepoint_release)(handlerton *hton, Session *session, void *sv);
 
134
   /*
 
135
     'all' is true if it's a real commit, that makes persistent changes
 
136
     'all' is false if it's not in fact a commit but an end of the
 
137
     statement that is part of the transaction.
 
138
     NOTE 'all' is also false in auto-commit mode where 'end of statement'
 
139
     and 'real commit' mean the same event.
 
140
   */
 
141
   int  (*commit)(handlerton *hton, Session *session, bool all);
 
142
   int  (*rollback)(handlerton *hton, Session *session, bool all);
 
143
   int  (*prepare)(handlerton *hton, Session *session, bool all);
 
144
   int  (*recover)(handlerton *hton, XID *xid_list, uint32_t len);
 
145
   int  (*commit_by_xid)(handlerton *hton, XID *xid);
 
146
   int  (*rollback_by_xid)(handlerton *hton, XID *xid);
 
147
   handler *(*create)(handlerton *hton, TABLE_SHARE *table, MEM_ROOT *mem_root);
 
148
   void (*drop_database)(handlerton *hton, char* path);
 
149
   int (*start_consistent_snapshot)(handlerton *hton, Session *session);
 
150
   bool (*flush_logs)(handlerton *hton);
 
151
   bool (*show_status)(handlerton *hton, Session *session, stat_print_fn *print, enum ha_stat_type stat);
 
152
   int (*fill_files_table)(handlerton *hton, Session *session,
 
153
                           TableList *tables,
 
154
                           class Item *cond);
 
155
   std::bitset<HTON_BIT_SIZE> flags; /* global handler flags */
 
156
   int (*release_temporary_latches)(handlerton *hton, Session *session);
 
157
 
 
158
   int (*table_exists_in_engine)(handlerton *hton, Session* session, const char *db,
 
159
                                 const char *name);
 
160
   uint32_t license; /* Flag for Engine License */
 
161
   void *data; /* Location for engines to keep personal structures */
428
162
};
429
163
 
430
 
} /* namespace plugin */
431
 
} /* namespace drizzled */
432
 
 
433
 
#endif /* DRIZZLED_PLUGIN_STORAGE_ENGINE_H */
 
164
 
 
165
/* lookups */
 
166
handlerton *ha_default_handlerton(Session *session);
 
167
plugin_ref ha_resolve_by_name(Session *session, const LEX_STRING *name);
 
168
plugin_ref ha_lock_engine(Session *session, handlerton *hton);
 
169
handlerton *ha_resolve_by_legacy_type(Session *session,
 
170
                                      enum legacy_db_type db_type);
 
171
handler *get_new_handler(TABLE_SHARE *share, MEM_ROOT *alloc,
 
172
                         handlerton *db_type);
 
173
handlerton *ha_checktype(Session *session, enum legacy_db_type database_type,
 
174
                         bool no_substitute, bool report_error);
 
175
 
 
176
enum legacy_db_type ha_legacy_type(const handlerton *db_type);
 
177
const char *ha_resolve_storage_engine_name(const handlerton *db_type);
 
178
bool ha_check_storage_engine_flag(const handlerton *db_type, const hton_flag_bits flag);
 
179
bool ha_storage_engine_is_enabled(const handlerton *db_type);
 
180
LEX_STRING *ha_storage_engine_name(const handlerton *hton);
 
181
 
 
182
#endif /* DRIZZLED_HANDLERTON_H */