← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/plugin/storage_engine.h

  • Committer: Mats Kindahl
  • Date: 2008-08-26 07:32:59 UTC
  • mto: (489.1.2 codestyle)
  • mto: This revision was merged to the branch mainline in revision 491.
  • Revision ID: mats@mysql.com-20080826073259-9k4evtajgldgolli
Replaced use of thd_proc_info() macro with calls to
set_proc_info() and get_proc_info() internally.  Introduced
functions set_thd_proc_info() and get_thd_proc_info() for
external users, i.e., plug-ins.

The set_thd_proc_info() accepted callers info that can be used to
print debug output, but the information was not used. The return
value was changed to void and the old value is not fetched any
more. To be able to get the value of proc_info for external
users, the function get_thd_proc_info() was introduced.

The thd_proc_info() macro called set_thd_proc_info() but almost
never used the return value of set_thd_proc_info() so the macro
was replaced with a call of THD::set_proc_info().

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/plugin/storage_engine.h
1
 
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
 
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
 
 *
4
 
 *  Copyright (C) 2008 Sun Microsystems
5
 
 *
6
 
 *  This program is free software; you can redistribute it and/or modify
7
 
 *  it under the terms of the GNU General Public License as published by
8
 
 *  the Free Software Foundation; version 2 of the License.
9
 
 *
10
 
 *  This program is distributed in the hope that it will be useful,
11
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
 
 *  GNU General Public License for more details.
14
 
 *
15
 
 *  You should have received a copy of the GNU General Public License
16
 
 *  along with this program; if not, write to the Free Software
17
 
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18
 
 */
19
 
 
20
 
#ifndef DRIZZLED_PLUGIN_STORAGE_ENGINE_H
21
 
#define DRIZZLED_PLUGIN_STORAGE_ENGINE_H
22
 
 
23
 
 
24
 
#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
 
{
42
 
 
43
 
class TableList;
44
 
class Session;
45
 
class Cursor;
46
 
typedef struct st_hash HASH;
47
 
 
48
 
class TableShare;
49
 
typedef drizzle_lex_string LEX_STRING;
50
 
typedef bool (stat_print_fn)(Session *session, const char *type, uint32_t type_len,
51
 
                             const char *file, uint32_t file_len,
52
 
                             const char *status, uint32_t status_len);
53
 
 
54
 
/* Possible flags of a StorageEngine (there can be 32 of them) */
55
 
enum engine_flag_bits {
56
 
  HTON_BIT_ALTER_NOT_SUPPORTED,       // Engine does not support alter
57
 
  HTON_BIT_HIDDEN,                    // Engine does not appear in lists
58
 
  HTON_BIT_NOT_USER_SELECTABLE,
59
 
  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,
82
 
  HTON_BIT_SIZE
83
 
};
84
 
 
85
 
static const std::bitset<HTON_BIT_SIZE> HTON_NO_FLAGS(0);
86
 
static const std::bitset<HTON_BIT_SIZE> HTON_ALTER_NOT_SUPPORTED(1 << HTON_BIT_ALTER_NOT_SUPPORTED);
87
 
static const std::bitset<HTON_BIT_SIZE> HTON_HIDDEN(1 << HTON_BIT_HIDDEN);
88
 
static const std::bitset<HTON_BIT_SIZE> HTON_NOT_USER_SELECTABLE(1 << HTON_BIT_NOT_USER_SELECTABLE);
89
 
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;
126
 
 
127
 
/*
128
 
  StorageEngine is a singleton structure - one instance per storage engine -
129
 
  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;
135
 
*/
136
 
class StorageEngine : public Plugin,
137
 
                      public MonitoredInTransaction
138
 
{
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
 
  }
428
 
};
429
 
 
430
 
} /* namespace plugin */
431
 
} /* namespace drizzled */
432
 
 
433
 
#endif /* DRIZZLED_PLUGIN_STORAGE_ENGINE_H */