← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/schema_engine/schema.cc

  • Committer: Brian Aker
  • Date: 2010-08-18 16:12:58 UTC
  • mto: This revision was merged to the branch mainline in revision 1720.
  • Revision ID: brian@tangent.org-20100818161258-1vm71da888dfvwsx
Remove the code surrounding stack trace.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/schema_engine/schema.cc
44
44
using namespace std;
45
45
using namespace drizzled;
46
46
 
47
 
static SchemaIdentifier TEMPORARY_IDENTIFIER("TEMPORARY");
 
47
// This should always be the same value as GLOBAL_TEMPORARY_EXT but be
 
48
// CASE_UP. --Brian
 
49
static SchemaIdentifier TEMPORARY_IDENTIFIER(".TEMPORARY");
48
50
 
49
51
#define MY_DB_OPT_FILE "db.opt"
50
52
#define DEFAULT_FILE_EXTENSION ".dfe" // Deep Fried Elephant
69
71
 
70
72
void Schema::prime()
71
73
{
72
 
  CachedDirectory directory(drizzle_data_home, CachedDirectory::DIRECTORY);
 
74
  CachedDirectory directory(data_home, CachedDirectory::DIRECTORY);
73
75
  CachedDirectory::Entries files= directory.getEntries();
74
76
 
75
77
  pthread_rwlock_wrlock(&schema_lock);
80
82
    CachedDirectory::Entry *entry= *fileIter;
81
83
    message::Schema schema_message;
82
84
 
 
85
    if (not entry->filename.compare(GLOBAL_TEMPORARY_EXT))
 
86
      continue;
 
87
 
83
88
    if (readSchemaFile(entry->filename, schema_message))
84
89
    {
85
90
      SchemaIdentifier schema_identifier(schema_message.name());
96
101
  pthread_rwlock_unlock(&schema_lock);
97
102
}
98
103
 
99
 
void Schema::doGetSchemaIdentifiers(SchemaIdentifierList &set_of_names)
 
104
void Schema::doGetSchemaIdentifiers(SchemaIdentifiers &set_of_names)
100
105
{
101
106
  if (not pthread_rwlock_rdlock(&schema_lock))
102
107
  {
113
118
 
114
119
  // If for some reason getting a lock should fail, we resort to disk
115
120
 
116
 
  CachedDirectory directory(drizzle_data_home, CachedDirectory::DIRECTORY);
 
121
  CachedDirectory directory(data_home, CachedDirectory::DIRECTORY);
117
122
 
118
123
  CachedDirectory::Entries files= directory.getEntries();
119
124
 
125
130
  }
126
131
}
127
132
 
128
 
bool Schema::doGetSchemaDefinition(SchemaIdentifier &schema_identifier, message::Schema &schema_message)
 
133
bool Schema::doGetSchemaDefinition(const SchemaIdentifier &schema_identifier, message::Schema &schema_message)
129
134
{
130
135
  if (not pthread_rwlock_rdlock(&schema_lock))
131
136
  {
176
181
  return true;
177
182
}
178
183
 
179
 
bool Schema::doDropSchema(SchemaIdentifier &schema_identifier)
 
184
bool Schema::doDropSchema(const SchemaIdentifier &schema_identifier)
180
185
{
181
186
  message::Schema schema_message;
182
187
 
255
260
 
256
261
  @note we do the rename to make it crash safe.
257
262
*/
258
 
bool Schema::writeSchemaFile(SchemaIdentifier &schema_identifier, const message::Schema &db)
 
263
bool Schema::writeSchemaFile(const SchemaIdentifier &schema_identifier, const message::Schema &db)
259
264
{
260
265
  char schema_file_tmp[FN_REFLEN];
261
266
  string schema_file(schema_identifier.getPath());
275
280
    return false;
276
281
  }
277
282
 
278
 
  if (not db.SerializeToFileDescriptor(fd))
279
 
  {
280
 
    my_error(ER_CORRUPT_TABLE_DEFINITION, MYF(0),
281
 
             db.InitializationErrorString().c_str());
 
283
  bool success;
 
284
 
 
285
  try {
 
286
    success= db.SerializeToFileDescriptor(fd);
 
287
  }
 
288
  catch (...)
 
289
  {
 
290
    success= false;
 
291
  }
 
292
 
 
293
  if (not success)
 
294
  {
 
295
    my_error(ER_CORRUPT_SCHEMA_DEFINITION, MYF(0), schema_file.c_str(),
 
296
             db.InitializationErrorString().empty() ? "unknown" :  db.InitializationErrorString().c_str());
282
297
 
283
298
    if (close(fd) == -1)
284
299
      perror(schema_file_tmp);
336
351
      return true;
337
352
    }
338
353
 
339
 
    my_error(ER_CORRUPT_TABLE_DEFINITION, MYF(0),
340
 
             schema_message.InitializationErrorString().c_str());
 
354
    my_error(ER_CORRUPT_SCHEMA_DEFINITION, MYF(0), db_opt_path.c_str(),
 
355
             schema_message.InitializationErrorString().empty() ? "unknown" :  schema_message.InitializationErrorString().c_str());
341
356
  }
342
357
  else
343
358
  {
347
362
  return false;
348
363
}
349
364
 
350
 
bool Schema::doCanCreateTable(drizzled::TableIdentifier &identifier)
 
365
bool Schema::doCanCreateTable(const drizzled::TableIdentifier &identifier)
351
366
{
352
 
  if (static_cast<SchemaIdentifier&>(identifier) == TEMPORARY_IDENTIFIER)
 
367
  if (static_cast<const SchemaIdentifier&>(identifier) == TEMPORARY_IDENTIFIER)
353
368
  {
354
369
    return false;
355
370
  }
358
373
}
359
374
 
360
375
void Schema::doGetTableIdentifiers(drizzled::CachedDirectory&,
361
 
                                   drizzled::SchemaIdentifier&,
 
376
                                   const drizzled::SchemaIdentifier&,
362
377
                                   drizzled::TableIdentifiers&)
363
378
{
364
379
}