← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/plugin/storage_engine.h

  • Committer: Brian Aker
  • Date: 2010-03-31 05:53:34 UTC
  • Revision ID: brian@gaz-20100331055334-yqqmzlgqb2xq1p5b
Mass overhaul to use schema_identifier.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/plugin/storage_engine.h
28
28
#include <drizzled/message/table.pb.h>
29
29
#include "drizzled/plugin/plugin.h"
30
30
#include "drizzled/sql_string.h"
 
31
#include "drizzled/schema_identifier.h"
31
32
#include "drizzled/table_identifier.h"
32
33
#include "drizzled/cached_directory.h"
33
34
#include "drizzled/plugin/monitored_in_transaction.h"
127
128
typedef std::vector<StorageEngine *> EngineVector;
128
129
 
129
130
typedef std::set<std::string> TableNameList;
130
 
typedef std::set<std::string> SchemaNameList;
131
131
 
132
132
extern const std::string UNKNOWN_STRING;
133
133
extern const std::string DEFAULT_DEFINITION_FILE_EXT;
150
150
private:
151
151
  const std::bitset<HTON_BIT_SIZE> flags; /* global Cursor flags */
152
152
 
 
153
  static EngineVector &getSchemaEngines();
 
154
 
153
155
  virtual void setTransactionReadWrite(Session& session);
154
156
 
155
157
  /*
294
296
 
295
297
  // @todo move these to protected
296
298
  virtual void doGetTableNames(CachedDirectory &directory,
297
 
                               std::string& db_name,
 
299
                               drizzled::SchemaIdentifier &schema_identifier,
298
300
                               TableNameList &set_of_names);
299
301
 
300
302
  virtual int doDropTable(Session &session,
325
327
  static int dropTable(Session& session,
326
328
                       StorageEngine &engine,
327
329
                       TableIdentifier &identifier);
328
 
  static void getTableNames(Session &session, const std::string& db_name, TableNameList &set_of_names);
 
330
  static void getTableNames(Session &session, drizzled::SchemaIdentifier& schema_identifier, TableNameList &set_of_names);
329
331
 
330
332
  // Check to see if any SE objects to creation.
331
333
  static bool canCreateTable(drizzled::TableIdentifier &identifier);
332
 
  virtual bool doCanCreateTable(const drizzled::TableIdentifier &identifier)
 
334
  virtual bool doCanCreateTable(drizzled::TableIdentifier &identifier)
333
335
  { (void)identifier;  return true; }
334
336
 
335
337
  // @note All schema methods defined here
336
 
  static void getSchemaNames(Session &session, SchemaNameList &set_of_names);
 
338
  static void getSchemaIdentifiers(Session &session, SchemaIdentifierList &schemas);
337
339
  static bool getSchemaDefinition(TableIdentifier &identifier, message::Schema &proto);
338
 
  static bool getSchemaDefinition(const std::string &schema_name, message::Schema &proto);
339
 
  static bool doesSchemaExist(const std::string &schema_name);
340
 
  static bool doesSchemaExist(TableIdentifier &identifier);
341
 
  static const CHARSET_INFO *getSchemaCollation(const std::string &schema_name);
 
340
  static bool getSchemaDefinition(drizzled::SchemaIdentifier &identifier, message::Schema &proto);
 
341
  static bool doesSchemaExist(drizzled::SchemaIdentifier &identifier);
 
342
  static const CHARSET_INFO *getSchemaCollation(drizzled::SchemaIdentifier &identifier);
342
343
  static bool createSchema(const drizzled::message::Schema &schema_message);
343
 
  static bool dropSchema(const std::string &schema_name);
 
344
  static bool dropSchema(drizzled::SchemaIdentifier &identifier);
344
345
  static bool alterSchema(const drizzled::message::Schema &schema_message);
345
346
 
346
347
  // @note make private/protected
347
 
  virtual void doGetSchemaNames(SchemaNameList &set_of_names)
348
 
  { (void)set_of_names; }
 
348
  virtual void doGetSchemaIdentifiers(SchemaIdentifierList&)
 
349
  { }
349
350
 
350
 
  virtual bool doGetSchemaDefinition(const std::string &schema_name, drizzled::message::Schema &proto)
 
351
  virtual bool doGetSchemaDefinition(drizzled::SchemaIdentifier&, drizzled::message::Schema&)
351
352
  { 
352
 
    (void)schema_name;
353
 
    (void)proto; 
354
 
 
355
353
    return false; 
356
354
  }
357
355
 
358
 
  virtual bool doCreateSchema(const drizzled::message::Schema &schema_message)
359
 
  { (void)schema_message; return false; }
360
 
 
361
 
  virtual bool doAlterSchema(const drizzled::message::Schema &schema_message)
362
 
  { (void)schema_message; return false; }
363
 
 
364
 
  virtual bool doDropSchema(const std::string &schema_name)
365
 
  { (void)schema_name; return false; }
 
356
  virtual bool doCreateSchema(const drizzled::message::Schema&)
 
357
  { return false; }
 
358
 
 
359
  virtual bool doAlterSchema(const drizzled::message::Schema&)
 
360
  { return false; }
 
361
 
 
362
  virtual bool doDropSchema(drizzled::SchemaIdentifier&)
 
363
  { return false; }
366
364
 
367
365
  static inline const std::string &resolveName(const StorageEngine *engine)
368
366
  {