← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/plugin/schema_engine.cc

  • Committer: Brian Aker
  • Date: 2010-12-18 10:14:05 UTC
  • mfrom: (2008.1.3 clean)
  • Revision ID: brian@tangent.org-20101218101405-qjbse29shi9coklg
Merge of user identifier work

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/plugin/schema_engine.cc
23
23
 
24
24
#include "drizzled/global_charset_info.h"
25
25
#include "drizzled/charset.h"
 
26
#include "drizzled/transaction_services.h"
26
27
 
27
28
#include "drizzled/plugin/storage_engine.h"
28
29
#include "drizzled/plugin/authorization.h"
29
30
 
30
 
using namespace std;
31
 
 
32
31
namespace drizzled
33
32
{
34
33
 
36
35
{
37
36
 
38
37
class AddSchemaNames : 
39
 
  public unary_function<StorageEngine *, void>
 
38
  public std::unary_function<StorageEngine *, void>
40
39
{
41
40
  SchemaIdentifier::vector &schemas;
42
41
 
56
55
void StorageEngine::getIdentifiers(Session &session, SchemaIdentifier::vector &schemas)
57
56
{
58
57
  // Add hook here for engines to register schema.
59
 
  for_each(StorageEngine::getSchemaEngines().begin(), StorageEngine::getSchemaEngines().end(),
 
58
  std::for_each(StorageEngine::getSchemaEngines().begin(), StorageEngine::getSchemaEngines().end(),
60
59
           AddSchemaNames(schemas));
61
60
 
62
 
  plugin::Authorization::pruneSchemaNames(session.getSecurityContext(), schemas);
 
61
  plugin::Authorization::pruneSchemaNames(session.user(), schemas);
63
62
}
64
63
 
65
 
class StorageEngineGetSchemaDefinition: public unary_function<StorageEngine *, bool>
 
64
class StorageEngineGetSchemaDefinition: public std::unary_function<StorageEngine *, bool>
66
65
{
67
66
  const SchemaIdentifier &identifier;
68
67
  message::schema::shared_ptr &schema_proto;
92
91
bool StorageEngine::getSchemaDefinition(const SchemaIdentifier &identifier, message::schema::shared_ptr &proto)
93
92
{
94
93
  EngineVector::iterator iter=
95
 
    find_if(StorageEngine::getSchemaEngines().begin(), StorageEngine::getSchemaEngines().end(),
96
 
            StorageEngineGetSchemaDefinition(identifier, proto));
 
94
    std::find_if(StorageEngine::getSchemaEngines().begin(), StorageEngine::getSchemaEngines().end(),
 
95
                 StorageEngineGetSchemaDefinition(identifier, proto));
97
96
 
98
97
  if (iter != StorageEngine::getSchemaEngines().end())
99
98
  {
120
119
 
121
120
  if (found && schmema_proto->has_collation())
122
121
  {
123
 
    const string buffer= schmema_proto->collation();
 
122
    const std::string buffer= schmema_proto->collation();
124
123
    const CHARSET_INFO* cs= get_charset_by_name(buffer.c_str());
125
124
 
126
125
    if (not cs)
142
141
}
143
142
 
144
143
class CreateSchema : 
145
 
  public unary_function<StorageEngine *, void>
 
144
  public std::unary_function<StorageEngine *, void>
146
145
{
147
146
  const drizzled::message::Schema &schema_message;
148
147
 
156
155
  result_type operator() (argument_type engine)
157
156
  {
158
157
    // @todo eomeday check that at least one engine said "true"
159
 
    (void)engine->doCreateSchema(schema_message);
 
158
    bool success= engine->doCreateSchema(schema_message);
 
159
 
 
160
    if (success) 
 
161
    {
 
162
      TransactionServices &transaction_services= TransactionServices::singleton();
 
163
      transaction_services.allocateNewTransactionId();
 
164
    }
160
165
  }
161
166
};
162
167
 
163
168
bool StorageEngine::createSchema(const drizzled::message::Schema &schema_message)
164
169
{
165
170
  // Add hook here for engines to register schema.
166
 
  for_each(StorageEngine::getSchemaEngines().begin(), StorageEngine::getSchemaEngines().end(),
167
 
           CreateSchema(schema_message));
 
171
  std::for_each(StorageEngine::getSchemaEngines().begin(), StorageEngine::getSchemaEngines().end(),
 
172
                CreateSchema(schema_message));
168
173
 
169
174
  return true;
170
175
}
171
176
 
172
177
class DropSchema : 
173
 
  public unary_function<StorageEngine *, void>
 
178
  public std::unary_function<StorageEngine *, void>
174
179
{
175
180
  uint64_t &success_count;
176
181
  const SchemaIdentifier &identifier;
189
194
    bool success= engine->doDropSchema(identifier);
190
195
 
191
196
    if (success)
 
197
    {
192
198
      success_count++;
 
199
      TransactionServices &transaction_services= TransactionServices::singleton();
 
200
      transaction_services.allocateNewTransactionId();
 
201
    }
193
202
  }
194
203
};
195
204
 
197
206
{
198
207
  uint64_t counter= 0;
199
208
  // Add hook here for engines to register schema.
200
 
  for_each(StorageEngine::getSchemaEngines().begin(), StorageEngine::getSchemaEngines().end(),
201
 
           DropSchema(identifier, counter));
 
209
  std::for_each(StorageEngine::getSchemaEngines().begin(), StorageEngine::getSchemaEngines().end(),
 
210
                DropSchema(identifier, counter));
202
211
 
203
212
  return counter ? true : false;
204
213
}
205
214
 
206
215
class AlterSchema : 
207
 
  public unary_function<StorageEngine *, void>
 
216
  public std::unary_function<StorageEngine *, void>
208
217
{
209
218
  uint64_t &success_count;
210
219
  const drizzled::message::Schema &schema_message;
224
233
 
225
234
 
226
235
    if (success)
 
236
    {
227
237
      success_count++;
 
238
      TransactionServices &transaction_services= TransactionServices::singleton();
 
239
      transaction_services.allocateNewTransactionId();
 
240
    }
228
241
  }
229
242
};
230
243
 
232
245
{
233
246
  uint64_t success_count= 0;
234
247
 
235
 
  for_each(StorageEngine::getSchemaEngines().begin(), StorageEngine::getSchemaEngines().end(),
236
 
           AlterSchema(schema_message, success_count));
 
248
  std::for_each(StorageEngine::getSchemaEngines().begin(), StorageEngine::getSchemaEngines().end(),
 
249
                AlterSchema(schema_message, success_count));
237
250
 
238
251
  return success_count ? true : false;
239
252
}