← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/schema_engine/schema.h

  • Committer: Brian Aker
  • Date: 2010-06-05 00:15:57 UTC
  • mfrom: (1589.1.1 drizzle_events)
  • Revision ID: brian@gaz-20100605001557-j1k41ni5k9mis891
Merge in Barry.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/schema_engine/schema.h
23
23
 
24
24
#include <assert.h>
25
25
#include <drizzled/plugin/storage_engine.h>
26
 
#include <boost/unordered_map.hpp>
27
 
#include <boost/thread/shared_mutex.hpp>
 
26
#include <drizzled/data_home.h>
 
27
#include <drizzled/unordered_map.h>
 
28
 
 
29
#include <pthread.h>
28
30
 
29
31
extern const drizzled::CHARSET_INFO *default_charset_info;
30
32
 
34
36
 
35
37
class Schema : public drizzled::plugin::StorageEngine
36
38
{
37
 
  bool writeSchemaFile(const drizzled::identifier::Schema &schema_identifier, const drizzled::message::Schema &db);
38
 
  bool readSchemaFile(const drizzled::identifier::Schema &schema_identifier, drizzled::message::Schema &schema);
39
 
  bool readSchemaFile(std::string filename, drizzled::message::Schema &schema);
 
39
  bool writeSchemaFile(drizzled::SchemaIdentifier &schema_identifier, const drizzled::message::Schema &db);
 
40
  bool readSchemaFile(const std::string &schema_file_name, drizzled::message::Schema &schema);
40
41
 
41
42
  void prime();
42
 
  void startup(drizzled::Session &session);
43
43
 
44
 
  typedef boost::unordered_map<std::string, drizzled::message::schema::shared_ptr> SchemaCache;
 
44
  typedef drizzled::unordered_map<std::string, drizzled::message::Schema> SchemaCache;
45
45
  SchemaCache schema_cache;
46
46
  bool schema_cache_filled;
47
47
 
48
 
  boost::shared_mutex mutex;
 
48
  pthread_rwlock_t schema_lock;
49
49
 
50
50
public:
51
51
  Schema();
53
53
  ~Schema();
54
54
 
55
55
 
56
 
  drizzled::Cursor *create(drizzled::Table &)
 
56
  bool doCanCreateTable(drizzled::TableIdentifier &identifier);
 
57
 
 
58
  drizzled::Cursor *create(drizzled::TableShare &,
 
59
                           drizzled::memory::Root *)
57
60
  {
58
61
    return NULL;
59
62
  }
60
63
 
61
 
  void doGetSchemaIdentifiers(drizzled::identifier::Schema::vector &set_of_names);
62
 
  drizzled::message::schema::shared_ptr doGetSchemaDefinition(const drizzled::identifier::Schema&);
 
64
  void doGetSchemaIdentifiers(drizzled::SchemaIdentifierList &set_of_names);
 
65
  bool doGetSchemaDefinition(drizzled::SchemaIdentifier&, drizzled::message::Schema &proto);
63
66
 
64
67
  bool doCreateSchema(const drizzled::message::Schema &schema_message);
65
68
 
66
69
  bool doAlterSchema(const drizzled::message::Schema &schema_message);
67
70
 
68
 
  bool doDropSchema(const drizzled::identifier::Schema&);
 
71
  bool doDropSchema(drizzled::SchemaIdentifier&);
69
72
 
70
73
  // Below are table methods that we don't implement (and don't need)
71
74
 
72
75
  int doGetTableDefinition(drizzled::Session&,
73
 
                           const drizzled::identifier::Table&,
 
76
                           drizzled::TableIdentifier&,
74
77
                           drizzled::message::Table&)
75
78
  {
76
79
    return ENOENT;
77
80
  }
78
81
 
79
 
  bool doDoesTableExist(drizzled::Session&, const drizzled::identifier::Table&)
 
82
 
 
83
  void doGetTableNames(drizzled::CachedDirectory&,
 
84
                       drizzled::SchemaIdentifier&,
 
85
                       std::set<std::string>&)
 
86
  {
 
87
  }
 
88
 
 
89
  bool doDoesTableExist(drizzled::Session&, drizzled::TableIdentifier&)
80
90
  {
81
91
    return false;
82
92
  }
83
93
 
84
 
  int doRenameTable(drizzled::Session&, const drizzled::identifier::Table&, const drizzled::identifier::Table&)
 
94
  int doRenameTable(drizzled::Session&, drizzled::TableIdentifier&, drizzled::TableIdentifier&)
85
95
  {
86
 
    return drizzled::HA_ERR_NO_SUCH_TABLE;
 
96
    return EPERM;
87
97
  }
88
98
 
89
99
  int doCreateTable(drizzled::Session&,
90
100
                    drizzled::Table&,
91
 
                    const drizzled::identifier::Table&,
 
101
                    drizzled::TableIdentifier&,
92
102
                    drizzled::message::Table&)
93
103
  {
94
 
    return drizzled::ER_TABLE_PERMISSION_DENIED;
 
104
    return EPERM;
95
105
  }
96
106
 
97
 
  int doDropTable(drizzled::Session&, const drizzled::identifier::Table&)
 
107
  int doDropTable(drizzled::Session&, drizzled::TableIdentifier&)
98
108
  {
99
 
    return drizzled::HA_ERR_NO_SUCH_TABLE;
 
109
    return 0;
100
110
  }
101
111
 
102
112
  const char **bas_ext() const 
109
119
                          uint64_t *,
110
120
                          uint64_t *)
111
121
  {}
112
 
 
113
122
  void doGetTableIdentifiers(drizzled::CachedDirectory &directory,
114
 
                             const drizzled::identifier::Schema &schema_identifier,
115
 
                             drizzled::identifier::Table::vector &set_of_identifiers);
 
123
                             drizzled::SchemaIdentifier &schema_identifier,
 
124
                             drizzled::TableIdentifiers &set_of_identifiers);
116
125
};
117
126
 
118
127
#endif /* PLUGIN_SCHEMA_ENGINE_SCHEMA_H */