← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/plugin/storage_engine.h

Merge Stewart's dead code removal

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/plugin/storage_engine.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) 2008 Sun Microsystems, Inc.
 
4
 *  Copyright (C) 2008 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
21
21
#define DRIZZLED_PLUGIN_STORAGE_ENGINE_H
22
22
 
23
23
 
24
 
#include <drizzled/cached_directory.h>
25
24
#include <drizzled/definitions.h>
26
 
#include <drizzled/error_t.h>
 
25
#include <drizzled/plugin.h>
27
26
#include <drizzled/handler_structs.h>
28
 
#include <drizzled/identifier.h>
29
 
#include <drizzled/message.h>
30
 
#include <drizzled/message/cache.h>
31
 
#include <drizzled/plugin.h>
32
 
#include <drizzled/plugin/monitored_in_transaction.h>
33
 
#include <drizzled/plugin/plugin.h>
34
 
#include <drizzled/sql_string.h>
 
27
#include <drizzled/message/table.pb.h>
 
28
#include "drizzled/plugin/plugin.h"
 
29
#include <drizzled/name_map.h>
35
30
 
36
31
#include <bitset>
37
32
#include <string>
38
33
#include <vector>
39
 
#include <set>
40
 
 
41
 
#include <drizzled/visibility.h>
42
 
 
43
 
namespace drizzled
44
 
{
45
34
 
46
35
class TableList;
47
36
class Session;
 
37
class XID;
48
38
class Cursor;
49
 
typedef struct st_hash HASH;
50
39
 
51
40
class TableShare;
 
41
typedef struct st_mysql_lex_string LEX_STRING;
52
42
typedef bool (stat_print_fn)(Session *session, const char *type, uint32_t type_len,
53
43
                             const char *file, uint32_t file_len,
54
44
                             const char *status, uint32_t status_len);
56
46
/* Possible flags of a StorageEngine (there can be 32 of them) */
57
47
enum engine_flag_bits {
58
48
  HTON_BIT_ALTER_NOT_SUPPORTED,       // Engine does not support alter
 
49
  HTON_BIT_CAN_RECREATE,              // Delete all is used for truncate
59
50
  HTON_BIT_HIDDEN,                    // Engine does not appear in lists
 
51
  HTON_BIT_FLUSH_AFTER_RENAME,
60
52
  HTON_BIT_NOT_USER_SELECTABLE,
61
53
  HTON_BIT_TEMPORARY_NOT_SUPPORTED,   // Having temporary tables not supported
62
54
  HTON_BIT_TEMPORARY_ONLY,
63
 
  HTON_BIT_DOES_TRANSACTIONS,
64
 
  HTON_BIT_STATS_RECORDS_IS_EXACT,
65
 
  HTON_BIT_NULL_IN_KEY,
66
 
  HTON_BIT_CAN_INDEX_BLOBS,
67
 
  HTON_BIT_PRIMARY_KEY_IN_READ_INDEX,
68
 
  HTON_BIT_PARTIAL_COLUMN_READ,
69
 
  HTON_BIT_TABLE_SCAN_ON_INDEX,
70
 
  HTON_BIT_FAST_KEY_READ,
71
 
  HTON_BIT_NO_BLOBS,
72
 
  HTON_BIT_HAS_RECORDS,
73
 
  HTON_BIT_NO_AUTO_INCREMENT,
74
 
  HTON_BIT_DUPLICATE_POS,
75
 
  HTON_BIT_AUTO_PART_KEY,
76
 
  HTON_BIT_REQUIRE_PRIMARY_KEY,
77
 
  HTON_BIT_REQUIRES_KEY_COLUMNS_FOR_DELETE,
78
 
  HTON_BIT_PRIMARY_KEY_REQUIRED_FOR_DELETE,
79
 
  HTON_BIT_NO_PREFIX_CHAR_KEYS,
80
 
  HTON_BIT_HAS_CHECKSUM,
81
 
  HTON_BIT_SKIP_STORE_LOCK,
82
 
  HTON_BIT_SCHEMA_DICTIONARY,
83
 
  HTON_BIT_FOREIGN_KEYS,
 
55
  HTON_BIT_FILE_BASED, // use for check_lowercase_names
 
56
  HTON_BIT_HAS_DATA_DICTIONARY,
84
57
  HTON_BIT_SIZE
85
58
};
86
59
 
87
60
static const std::bitset<HTON_BIT_SIZE> HTON_NO_FLAGS(0);
88
61
static const std::bitset<HTON_BIT_SIZE> HTON_ALTER_NOT_SUPPORTED(1 << HTON_BIT_ALTER_NOT_SUPPORTED);
 
62
static const std::bitset<HTON_BIT_SIZE> HTON_CAN_RECREATE(1 << HTON_BIT_CAN_RECREATE);
89
63
static const std::bitset<HTON_BIT_SIZE> HTON_HIDDEN(1 << HTON_BIT_HIDDEN);
 
64
static const std::bitset<HTON_BIT_SIZE> HTON_FLUSH_AFTER_RENAME(1 << HTON_BIT_FLUSH_AFTER_RENAME);
90
65
static const std::bitset<HTON_BIT_SIZE> HTON_NOT_USER_SELECTABLE(1 << HTON_BIT_NOT_USER_SELECTABLE);
91
66
static const std::bitset<HTON_BIT_SIZE> HTON_TEMPORARY_NOT_SUPPORTED(1 << HTON_BIT_TEMPORARY_NOT_SUPPORTED);
92
67
static const std::bitset<HTON_BIT_SIZE> HTON_TEMPORARY_ONLY(1 << HTON_BIT_TEMPORARY_ONLY);
93
 
static const std::bitset<HTON_BIT_SIZE> HTON_HAS_DOES_TRANSACTIONS(1 << HTON_BIT_DOES_TRANSACTIONS);
94
 
static const std::bitset<HTON_BIT_SIZE> HTON_STATS_RECORDS_IS_EXACT(1 << HTON_BIT_STATS_RECORDS_IS_EXACT);
95
 
static const std::bitset<HTON_BIT_SIZE> HTON_NULL_IN_KEY(1 << HTON_BIT_NULL_IN_KEY);
96
 
static const std::bitset<HTON_BIT_SIZE> HTON_CAN_INDEX_BLOBS(1 << HTON_BIT_CAN_INDEX_BLOBS);
97
 
static const std::bitset<HTON_BIT_SIZE> HTON_PRIMARY_KEY_IN_READ_INDEX(1 << HTON_BIT_PRIMARY_KEY_IN_READ_INDEX);
98
 
static const std::bitset<HTON_BIT_SIZE> HTON_PARTIAL_COLUMN_READ(1 << HTON_BIT_PARTIAL_COLUMN_READ);
99
 
static const std::bitset<HTON_BIT_SIZE> HTON_TABLE_SCAN_ON_INDEX(1 << HTON_BIT_TABLE_SCAN_ON_INDEX);
100
 
static const std::bitset<HTON_BIT_SIZE> HTON_FAST_KEY_READ(1 << HTON_BIT_FAST_KEY_READ);
101
 
static const std::bitset<HTON_BIT_SIZE> HTON_NO_BLOBS(1 << HTON_BIT_NO_BLOBS);
102
 
static const std::bitset<HTON_BIT_SIZE> HTON_HAS_RECORDS(1 << HTON_BIT_HAS_RECORDS);
103
 
static const std::bitset<HTON_BIT_SIZE> HTON_NO_AUTO_INCREMENT(1 << HTON_BIT_NO_AUTO_INCREMENT);
104
 
static const std::bitset<HTON_BIT_SIZE> HTON_DUPLICATE_POS(1 << HTON_BIT_DUPLICATE_POS);
105
 
static const std::bitset<HTON_BIT_SIZE> HTON_AUTO_PART_KEY(1 << HTON_BIT_AUTO_PART_KEY);
106
 
static const std::bitset<HTON_BIT_SIZE> HTON_REQUIRE_PRIMARY_KEY(1 << HTON_BIT_REQUIRE_PRIMARY_KEY);
107
 
static const std::bitset<HTON_BIT_SIZE> HTON_REQUIRES_KEY_COLUMNS_FOR_DELETE(1 << HTON_BIT_REQUIRES_KEY_COLUMNS_FOR_DELETE);
108
 
static const std::bitset<HTON_BIT_SIZE> HTON_PRIMARY_KEY_REQUIRED_FOR_DELETE(1 << HTON_BIT_PRIMARY_KEY_REQUIRED_FOR_DELETE);
109
 
static const std::bitset<HTON_BIT_SIZE> HTON_NO_PREFIX_CHAR_KEYS(1 << HTON_BIT_NO_PREFIX_CHAR_KEYS);
110
 
static const std::bitset<HTON_BIT_SIZE> HTON_HAS_CHECKSUM(1 << HTON_BIT_HAS_CHECKSUM);
111
 
static const std::bitset<HTON_BIT_SIZE> HTON_SKIP_STORE_LOCK(1 << HTON_BIT_SKIP_STORE_LOCK);
112
 
static const std::bitset<HTON_BIT_SIZE> HTON_HAS_SCHEMA_DICTIONARY(1 << HTON_BIT_SCHEMA_DICTIONARY);
113
 
static const std::bitset<HTON_BIT_SIZE> HTON_HAS_FOREIGN_KEYS(1 << HTON_BIT_FOREIGN_KEYS);
114
 
 
 
68
static const std::bitset<HTON_BIT_SIZE> HTON_FILE_BASED(1 << HTON_BIT_FILE_BASED);
 
69
static const std::bitset<HTON_BIT_SIZE> HTON_HAS_DATA_DICTIONARY(1 << HTON_BIT_HAS_DATA_DICTIONARY);
115
70
 
116
71
class Table;
117
 
class NamedSavepoint;
118
72
 
 
73
namespace drizzled
 
74
{
119
75
namespace plugin
120
76
{
121
77
 
122
 
typedef std::vector<StorageEngine *> EngineVector;
123
 
 
124
 
typedef std::set<std::string> TableNameList;
125
 
 
126
 
extern const std::string UNKNOWN_STRING;
127
 
extern DRIZZLED_API const std::string DEFAULT_DEFINITION_FILE_EXT;
128
 
 
129
 
 
 
78
const std::string UNKNOWN_STRING("UNKNOWN");
 
79
 
 
80
class TableNameIteratorImplementation;
130
81
/*
131
82
  StorageEngine is a singleton structure - one instance per storage engine -
132
83
  to provide access to storage engine functionality that works on the
135
86
  usually StorageEngine instance is defined statically in ha_xxx.cc as
136
87
 
137
88
  static StorageEngine { ... } xxx_engine;
 
89
 
 
90
  savepoint_*, prepare, recover, and *_by_xid pointers can be 0.
138
91
*/
139
 
class DRIZZLED_API StorageEngine :
140
 
  public Plugin,
141
 
  public MonitoredInTransaction
 
92
class StorageEngine : public Plugin
142
93
{
143
 
  friend class SEAPITester;
144
 
public:
145
 
  typedef uint64_t Table_flags;
 
94
  /*
 
95
    Name used for storage engine.
 
96
  */
 
97
  const bool two_phase_commit;
 
98
  bool enabled;
146
99
 
147
 
private:
148
 
  static EngineVector &getSchemaEngines();
149
100
  const std::bitset<HTON_BIT_SIZE> flags; /* global Cursor flags */
150
 
 
151
 
 
152
 
  virtual void setTransactionReadWrite(Session& session);
153
 
 
154
 
  /*
155
 
   * Indicates to a storage engine the start of a
156
 
   * new SQL statement.
157
 
   */
158
 
  virtual void doStartStatement(Session *session)
159
 
  {
160
 
    (void) session;
161
 
  }
162
 
 
163
 
  /*
164
 
   * Indicates to a storage engine the end of
165
 
   * the current SQL statement in the supplied
166
 
   * Session.
167
 
   */
168
 
  virtual void doEndStatement(Session *session)
169
 
  {
170
 
    (void) session;
171
 
  }
172
 
 
173
 
protected:
174
 
  std::string table_definition_ext;
175
 
 
176
 
public:
177
 
  const std::string& getTableDefinitionFileExtension()
178
 
  {
179
 
    return table_definition_ext;
180
 
  }
181
 
 
182
 
private:
183
 
  std::vector<std::string> aliases;
184
 
 
185
 
public:
186
 
  const std::vector<std::string>& getAliases() const
187
 
  {
188
 
    return aliases;
189
 
  }
190
 
 
191
 
  void addAlias(std::string alias)
192
 
  {
193
 
    aliases.push_back(alias);
194
 
  }
 
101
  /*
 
102
    to store per-savepoint data storage engine is provided with an area
 
103
    of a requested size (0 is ok here).
 
104
    savepoint_offset must be initialized statically to the size of
 
105
    the needed memory to store per-savepoint information.
 
106
    After xxx_init it is changed to be an offset to savepoint storage
 
107
    area and need not be used by storage engine.
 
108
    see binlog_engine and binlog_savepoint_set/rollback for an example.
 
109
  */
 
110
  size_t savepoint_offset;
 
111
  size_t orig_savepoint_offset;
 
112
 
 
113
  void setTransactionReadWrite(Session* session);
195
114
 
196
115
protected:
197
116
 
198
117
  /**
199
 
    @brief
200
 
    Used as a protobuf storage currently by TEMP only engines.
201
 
  */
202
 
  typedef std::map <std::string, message::Table> ProtoCache;
203
 
  ProtoCache proto_cache;
204
 
  pthread_mutex_t proto_cache_mutex;
 
118
   * Implementing classes should override these to provide savepoint
 
119
   * functionality.
 
120
   */
 
121
  virtual int savepoint_set_hook(Session *, void *) { return 0; }
 
122
 
 
123
  virtual int savepoint_rollback_hook(Session *, void *) { return 0; }
 
124
 
 
125
  virtual int savepoint_release_hook(Session *, void *) { return 0; }
205
126
 
206
127
public:
 
128
 
207
129
  StorageEngine(const std::string name_arg,
208
 
                const std::bitset<HTON_BIT_SIZE> &flags_arg= HTON_NO_FLAGS);
 
130
                const std::bitset<HTON_BIT_SIZE> &flags_arg= HTON_NO_FLAGS,
 
131
                size_t savepoint_offset_arg= 0,
 
132
                bool support_2pc= false);
209
133
 
210
134
  virtual ~StorageEngine();
211
135
 
212
 
protected:
213
 
  virtual int doGetTableDefinition(Session &session,
214
 
                                   const drizzled::identifier::Table &identifier,
215
 
                                   message::Table &table_message)
216
 
  {
217
 
    (void)session;
218
 
    (void)identifier;
219
 
    (void)table_message;
220
 
 
221
 
    return ENOENT;
222
 
  }
223
 
 
224
 
  /* Old style cursor errors */
225
 
  void print_keydup_error(uint32_t key_nr, const char *msg, const Table &table) const;
226
 
  virtual bool get_error_message(int error, String *buf) const;
227
 
 
228
 
public:
229
 
  virtual void print_error(int error, myf errflag, const Table& table) const;
 
136
  virtual int getTableProtoImplementation(const char* path,
 
137
                                          drizzled::message::Table *table_proto)
 
138
    {
 
139
      (void)path;
 
140
      (void)table_proto;
 
141
      return ENOENT;
 
142
    }
 
143
 
 
144
  /*
 
145
    each storage engine has it's own memory area (actually a pointer)
 
146
    in the session, for storing per-connection information.
 
147
    It is accessed as
 
148
 
 
149
      session->ha_data[xxx_engine.slot]
 
150
 
 
151
   slot number is initialized by MySQL after xxx_init() is called.
 
152
  */
 
153
  uint32_t slot;
 
154
 
 
155
  inline uint32_t getSlot (void) { return slot; }
 
156
  inline void setSlot (uint32_t value) { slot= value; }
 
157
 
 
158
  bool has_2pc()
 
159
  {
 
160
    return two_phase_commit;
 
161
  }
 
162
 
 
163
 
 
164
  bool is_enabled() const
 
165
  {
 
166
    return enabled;
 
167
  }
230
168
 
231
169
  bool is_user_selectable() const
232
170
  {
238
176
    return flags.test(flag);
239
177
  }
240
178
 
241
 
  // @todo match check_flag interface
242
 
  virtual uint32_t index_flags(enum  ha_key_alg) const { return 0; }
243
 
  virtual void startStatement(Session *session)
244
 
  {
245
 
    doStartStatement(session);
246
 
  }
247
 
  virtual void endStatement(Session *session)
248
 
  {
249
 
    doEndStatement(session);
250
 
  }
 
179
  void enable() { enabled= true; }
 
180
  void disable() { enabled= false; }
251
181
 
252
182
  /*
253
 
   * Called during Session::cleanup() for all engines
254
 
   */
 
183
    StorageEngine methods:
 
184
 
 
185
    close_connection is only called if
 
186
    session->ha_data[xxx_engine.slot] is non-zero, so even if you don't need
 
187
    this storage area - set it to something, so that MySQL would know
 
188
    this storage engine was accessed in this connection
 
189
  */
255
190
  virtual int close_connection(Session  *)
256
191
  {
257
192
    return 0;
258
193
  }
259
 
 
260
 
  virtual Cursor *create(Table &)= 0;
 
194
  /*
 
195
    'all' is true if it's a real commit, that makes persistent changes
 
196
    'all' is false if it's not in fact a commit but an end of the
 
197
    statement that is part of the transaction.
 
198
    NOTE 'all' is also false in auto-commit mode where 'end of statement'
 
199
    and 'real commit' mean the same event.
 
200
  */
 
201
  virtual int  commit(Session *, bool)
 
202
  {
 
203
    return 0;
 
204
  }
 
205
 
 
206
  virtual int  rollback(Session *, bool)
 
207
  {
 
208
    return 0;
 
209
  }
 
210
 
 
211
  /*
 
212
    The void * points to an uninitialized storage area of requested size
 
213
    (see savepoint_offset description)
 
214
  */
 
215
  int savepoint_set(Session *session, void *sp)
 
216
  {
 
217
    return savepoint_set_hook(session, (unsigned char *)sp+savepoint_offset);
 
218
  }
 
219
 
 
220
  /*
 
221
    The void * points to a storage area, that was earlier passed
 
222
    to the savepoint_set call
 
223
  */
 
224
  int savepoint_rollback(Session *session, void *sp)
 
225
  {
 
226
     return savepoint_rollback_hook(session,
 
227
                                    (unsigned char *)sp+savepoint_offset);
 
228
  }
 
229
 
 
230
  int savepoint_release(Session *session, void *sp)
 
231
  {
 
232
    return savepoint_release_hook(session,
 
233
                                  (unsigned char *)sp+savepoint_offset);
 
234
  }
 
235
 
 
236
  virtual int  prepare(Session *, bool) { return 0; }
 
237
  virtual int  recover(XID *, uint32_t) { return 0; }
 
238
  virtual int  commit_by_xid(XID *) { return 0; }
 
239
  virtual int  rollback_by_xid(XID *) { return 0; }
 
240
  virtual Cursor *create(TableShare *, MEM_ROOT *)= 0;
261
241
  /* args: path */
 
242
  virtual void drop_database(char*) { }
 
243
  virtual int start_consistent_snapshot(Session *) { return 0; }
262
244
  virtual bool flush_logs() { return false; }
263
245
  virtual bool show_status(Session *, stat_print_fn *, enum ha_stat_type)
264
246
  {
265
247
    return false;
266
248
  }
267
249
 
 
250
  /* args: current_session, tables, cond */
 
251
  virtual int fill_files_table(Session *, TableList *,
 
252
                               Item *) { return 0; }
 
253
  virtual int release_temporary_latches(Session *) { return false; }
 
254
 
268
255
  /**
269
256
    If frm_error() is called then we will use this to find out what file
270
257
    extentions exist for the storage engine. This is also used by the default
279
266
  virtual const char **bas_ext() const =0;
280
267
 
281
268
protected:
282
 
  virtual int doCreateTable(Session &session,
283
 
                            Table &table_arg,
284
 
                            const drizzled::identifier::Table &identifier,
285
 
                            message::Table &message)= 0;
286
 
 
287
 
  virtual int doRenameTable(Session &session,
288
 
                            const drizzled::identifier::Table &from, const drizzled::identifier::Table &to)= 0;
289
 
 
290
 
  virtual int doDropTable(Session &session,
291
 
                          const drizzled::identifier::Table &identifier)= 0;
292
 
 
293
 
  virtual void doGetTableIdentifiers(CachedDirectory &directory,
294
 
                                     const drizzled::identifier::Schema &schema_identifier,
295
 
                                     identifier::Table::vector &set_of_identifiers)= 0;
296
 
 
297
 
  virtual bool doDoesTableExist(Session& session, const drizzled::identifier::Table &identifier);
298
 
 
299
 
  virtual bool doCanCreateTable(const drizzled::identifier::Table &identifier)
300
 
  { (void)identifier;  return true; }
 
269
  virtual int createTableImplementation(Session *session,
 
270
                                        const char *table_name,
 
271
                                        Table *table_arg,
 
272
                                        HA_CREATE_INFO *create_info,
 
273
                                        drizzled::message::Table* proto)= 0;
 
274
 
 
275
  virtual int renameTableImplementation(Session* session,
 
276
                                        const char *from, const char *to);
 
277
 
 
278
  virtual int deleteTableImplementation(Session* session,
 
279
                                        const std::string table_path);
301
280
 
302
281
public:
303
 
 
304
 
  friend class AddSchemaNames;
305
 
  friend class AddTableIdentifier;
306
 
  friend class AlterSchema;
307
 
  friend class CanCreateTable;
308
 
  friend class CreateSchema;
309
 
  friend class DropSchema;
310
 
  friend class DropTable;
311
 
  friend class DropTables;
312
 
  friend class FindEngineByName;
313
 
  friend class Ha_delete_table_error_handler;
314
 
  friend class StorageEngineCloseConnection;
315
 
  friend class StorageEngineDoesTableExist;
316
 
  friend class StorageEngineGetSchemaDefinition;
317
 
  friend class StorageEngineGetTableDefinition;
318
 
  friend class DropTableByIdentifier;
319
 
 
320
 
  int renameTable(Session &session, const drizzled::identifier::Table &from, const drizzled::identifier::Table &to);
 
282
  int doCreateTable(Session *session, const char *path, 
 
283
                  Table *table_arg,
 
284
                  HA_CREATE_INFO *create_info,
 
285
                  drizzled::message::Table *proto) 
 
286
  {
 
287
    char name_buff[FN_REFLEN];
 
288
    const char *table_name;
 
289
 
 
290
    table_name= checkLowercaseNames(path, name_buff);
 
291
 
 
292
    setTransactionReadWrite(session);
 
293
 
 
294
    return createTableImplementation(session, table_name, table_arg,
 
295
                                     create_info, proto);
 
296
  }
 
297
 
 
298
  int renameTable(Session *session, const char *from, const char *to) 
 
299
  {
 
300
    setTransactionReadWrite(session);
 
301
 
 
302
    return renameTableImplementation(session, from, to);
 
303
  }
 
304
 
 
305
  int doDeleteTable(Session* session, const std::string table_path) 
 
306
  {
 
307
    setTransactionReadWrite(session);
 
308
 
 
309
    return deleteTableImplementation(session, table_path);
 
310
  }
 
311
 
 
312
  const char *checkLowercaseNames(const char *path, char *tmp_path);
 
313
 
 
314
  virtual TableNameIteratorImplementation* tableNameIterator(const std::string &database)
 
315
  {
 
316
    (void)database;
 
317
    return NULL;
 
318
  }
 
319
 
321
320
 
322
321
  /* Class Methods for operating on plugin */
323
322
  static bool addPlugin(plugin::StorageEngine *engine);
324
323
  static void removePlugin(plugin::StorageEngine *engine);
325
324
 
326
 
  static int getTableDefinition(Session& session,
327
 
                                const drizzled::identifier::Table &identifier,
328
 
                                message::table::shared_ptr &table_proto,
329
 
                                bool include_temporary_tables= true);
330
 
  static message::table::shared_ptr getTableMessage(Session& session,
331
 
                                                    const drizzled::identifier::Table &identifier,
332
 
                                                    drizzled::error_t &error,
333
 
                                                    bool include_temporary_tables= true);
334
 
  static bool doesTableExist(Session &session,
335
 
                             const drizzled::identifier::Table &identifier,
336
 
                             bool include_temporary_tables= true);
337
 
 
338
 
  static plugin::StorageEngine *findByName(const std::string &find_str);
339
 
  static plugin::StorageEngine *findByName(Session& session, const std::string &find_str);
340
 
 
 
325
  static int getTableProto(const char* path, message::Table *table_proto);
 
326
 
 
327
  static plugin::StorageEngine *findByName(Session *session,
 
328
                                           std::string find_str);
341
329
  static void closeConnection(Session* session);
342
330
  static void dropDatabase(char* path);
 
331
  static int commitOrRollbackByXID(XID *xid, bool commit);
 
332
  static int releaseTemporaryLatches(Session *session);
343
333
  static bool flushLogs(plugin::StorageEngine *db_type);
344
 
 
345
 
  static bool dropTable(Session& session,
346
 
                        const drizzled::identifier::Table &identifier);
347
 
  static bool dropTable(Session& session,
348
 
                        const drizzled::identifier::Table &identifier,
349
 
                        drizzled::error_t &error);
350
 
 
351
 
  static bool dropTable(Session& session,
352
 
                        StorageEngine &engine,
353
 
                        identifier::Table::const_reference identifier,
354
 
                        drizzled::error_t &error);
355
 
 
356
 
  static void getIdentifiers(Session &session,
357
 
                             const identifier::Schema &schema_identifier,
358
 
                             identifier::Table::vector &set_of_identifiers);
359
 
 
360
 
  // Check to see if any SE objects to creation.
361
 
  static bool canCreateTable(const drizzled::identifier::Table &identifier);
362
 
 
363
 
  // @note All schema methods defined here
364
 
  static void getIdentifiers(Session &session, identifier::Schema::vector &schemas);
365
 
  static bool getSchemaDefinition(const drizzled::identifier::Table &identifier, message::schema::shared_ptr &proto);
366
 
  static bool getSchemaDefinition(const drizzled::identifier::Schema &identifier, message::schema::shared_ptr &proto);
367
 
  static bool doesSchemaExist(const drizzled::identifier::Schema &identifier);
368
 
  static const CHARSET_INFO *getSchemaCollation(const drizzled::identifier::Schema &identifier);
369
 
  static bool createSchema(const drizzled::message::Schema &schema_message);
370
 
  static bool dropSchema(drizzled::Session& session, identifier::Schema::const_reference identifier);
371
 
  static bool alterSchema(const drizzled::message::Schema &schema_message);
372
 
 
373
 
  // @note make private/protected
374
 
protected:
375
 
  virtual void doGetSchemaIdentifiers(identifier::Schema::vector&)
376
 
  { }
377
 
 
378
 
  virtual bool doGetSchemaDefinition(const drizzled::identifier::Schema&, drizzled::message::schema::shared_ptr&)
379
 
  { 
380
 
    return false; 
381
 
  }
382
 
 
383
 
  virtual bool doCreateSchema(const drizzled::message::Schema&)
384
 
  { return false; }
385
 
 
386
 
  virtual bool doAlterSchema(const drizzled::message::Schema&)
387
 
  { return false; }
388
 
 
389
 
  virtual bool doDropSchema(const drizzled::identifier::Schema&)
390
 
  { return false; }
391
 
 
392
 
public:
 
334
  static int recover(HASH *commit_list);
 
335
  static int startConsistentSnapshot(Session *session);
 
336
  static int deleteTable(Session *session, const char *path, const char *db,
 
337
                         const char *alias, bool generate_warning);
393
338
  static inline const std::string &resolveName(const StorageEngine *engine)
394
339
  {
395
340
    return engine == NULL ? UNKNOWN_STRING : engine->getName();
396
341
  }
397
342
 
398
 
  static bool createTable(Session &session,
399
 
                          const identifier::Table &identifier,
400
 
                          message::Table& table_message);
401
 
 
402
 
  static void removeLostTemporaryTables(Session &session, const char *directory);
403
 
 
404
 
  Cursor *getCursor(Table &share);
405
 
 
406
 
  uint32_t max_record_length() const
407
 
  { return std::min((unsigned int)HA_MAX_REC_LENGTH, max_supported_record_length()); }
408
 
  uint32_t max_keys() const
409
 
  { return std::min((unsigned int)MAX_KEY, max_supported_keys()); }
410
 
  uint32_t max_key_parts() const
411
 
  { return std::min((unsigned int)MAX_REF_PARTS, max_supported_key_parts()); }
412
 
  uint32_t max_key_length() const
413
 
  { return std::min((unsigned int)MAX_KEY_LENGTH, max_supported_key_length()); }
414
 
  uint32_t max_key_part_length(void) const
415
 
  { return std::min((unsigned int)MAX_KEY_LENGTH, max_supported_key_part_length()); }
416
 
 
417
 
  virtual uint32_t max_supported_record_length(void) const
418
 
  { return HA_MAX_REC_LENGTH; }
419
 
  virtual uint32_t max_supported_keys(void) const { return 0; }
420
 
  virtual uint32_t max_supported_key_parts(void) const { return MAX_REF_PARTS; }
421
 
  virtual uint32_t max_supported_key_length(void) const { return MAX_KEY_LENGTH; }
422
 
  virtual uint32_t max_supported_key_part_length(void) const { return 255; }
423
 
 
424
 
  /* TODO-> Make private */
 
343
  /**
 
344
   * Return the default storage engine plugin::StorageEngine for thread
 
345
   *
 
346
   * defaultStorageEngine(session)
 
347
   * @param session         current thread
 
348
   *
 
349
   * @return
 
350
   *   pointer to plugin::StorageEngine
 
351
   */
 
352
  static StorageEngine *defaultStorageEngine(Session *session);
 
353
 
 
354
  static int createTable(Session *session, const char *path,
 
355
                         const char *db, const char *table_name,
 
356
                         HA_CREATE_INFO *create_info,
 
357
                         bool update_create_info,
 
358
                         drizzled::message::Table *table_proto);
 
359
 
 
360
  Cursor *getCursor(TableShare *share, MEM_ROOT *alloc);
 
361
};
 
362
 
 
363
class TableNameIteratorImplementation
 
364
{
425
365
protected:
426
 
  static int deleteDefinitionFromPath(const drizzled::identifier::Table &identifier);
427
 
  static int renameDefinitionFromPath(const drizzled::identifier::Table &dest, const drizzled::identifier::Table &src);
428
 
  static int writeDefinitionFromPath(const drizzled::identifier::Table &identifier, message::Table &proto);
429
 
  static bool readTableFile(const std::string &path, message::Table &table_message);
430
 
 
431
 
public:
432
 
  /* 
433
 
   * The below are simple virtual overrides for the plugin::MonitoredInTransaction
434
 
   * interface.
435
 
   */
436
 
  virtual bool participatesInSqlTransaction() const
437
 
  {
438
 
    return false; /* plugin::StorageEngine is non-transactional in terms of SQL */
439
 
  }
440
 
  virtual bool participatesInXaTransaction() const
441
 
  {
442
 
    return false; /* plugin::StorageEngine is non-transactional in terms of XA */
443
 
  }
444
 
  virtual bool alwaysRegisterForXaTransaction() const
445
 
  {
446
 
    return false;
447
 
  }
448
 
 
449
 
  virtual bool validateCreateTableOption(const std::string &key, const std::string &state)
450
 
  {
451
 
    (void)key;
452
 
    (void)state;
453
 
 
454
 
    return false;
455
 
  }
456
 
 
457
 
  virtual bool validateCreateSchemaOption(const std::string &key, const std::string &state)
458
 
  {
459
 
    (void)key;
460
 
    (void)state;
461
 
 
462
 
    return false;
463
 
  }
464
 
};
465
 
 
466
 
std::ostream& operator<<(std::ostream& output, const StorageEngine &engine);
 
366
  std::string db;
 
367
public:
 
368
  TableNameIteratorImplementation(const std::string &database) : db(database)
 
369
    {};
 
370
  virtual ~TableNameIteratorImplementation() {};
 
371
 
 
372
  virtual int next(std::string *name)= 0;
 
373
 
 
374
};
 
375
 
 
376
class TableNameIterator
 
377
{
 
378
private:
 
379
  NameMap<plugin::StorageEngine *>::iterator engine_iter;
 
380
  plugin::TableNameIteratorImplementation *current_implementation;
 
381
  plugin::TableNameIteratorImplementation *default_implementation;
 
382
  std::string database;
 
383
public:
 
384
  TableNameIterator(const std::string &db);
 
385
  ~TableNameIterator();
 
386
 
 
387
  int next(std::string *name);
 
388
};
 
389
 
467
390
 
468
391
} /* namespace plugin */
469
392
} /* namespace drizzled */