← 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: 2011-01-13 22:55:57 UTC
  • mto: (2081.4.1 clean)
  • mto: This revision was merged to the branch mainline in revision 2107.
  • Revision ID: brian@tangent.org-20110113225557-340z4qlpmsvx79as
Merge in code to all plugins to do whatever they need to do once all other
plugins have been loaded/initialized/warmed up/etc.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/schema_engine/schema.cc
29
29
#include "drizzled/cursor.h"
30
30
#include "drizzled/data_home.h"
31
31
 
 
32
#include <drizzled/pthread_globals.h>
 
33
 
 
34
#include <drizzled/execute.h>
 
35
 
32
36
#include "drizzled/internal/my_sys.h"
33
37
 
34
38
#include <fcntl.h>
69
73
  CachedDirectory directory(getDataHomeCatalog().file_string(), CachedDirectory::DIRECTORY);
70
74
  CachedDirectory::Entries files= directory.getEntries();
71
75
 
72
 
  mutex.lock();
73
 
 
74
 
  for (CachedDirectory::Entries::iterator fileIter= files.begin();
75
 
       fileIter != files.end(); fileIter++)
76
76
  {
77
 
    CachedDirectory::Entry *entry= *fileIter;
78
 
    message::Schema schema_message;
79
 
 
80
 
    if (not entry->filename.compare(GLOBAL_TEMPORARY_EXT))
81
 
      continue;
82
 
 
83
 
    SchemaIdentifier filename(entry->filename);
84
 
    if (readSchemaFile(filename, schema_message))
 
77
    boost::unique_lock<boost::shared_mutex> scopedLock(mutex);
 
78
 
 
79
    for (CachedDirectory::Entries::iterator fileIter= files.begin();
 
80
         fileIter != files.end(); fileIter++)
85
81
    {
86
 
      SchemaIdentifier schema_identifier(schema_message.name());
87
 
 
88
 
      pair<SchemaCache::iterator, bool> ret=
89
 
        schema_cache.insert(make_pair(schema_identifier.getPath(), new message::Schema(schema_message)));
90
 
 
91
 
      if (ret.second == false)
92
 
     {
93
 
        abort(); // If this has happened, something really bad is going down.
 
82
      CachedDirectory::Entry *entry= *fileIter;
 
83
      message::Schema schema_message;
 
84
 
 
85
      if (not entry->filename.compare(GLOBAL_TEMPORARY_EXT))
 
86
        continue;
 
87
 
 
88
      SchemaIdentifier filename(entry->filename);
 
89
      if (readSchemaFile(filename, schema_message))
 
90
      {
 
91
        SchemaIdentifier schema_identifier(schema_message.name());
 
92
 
 
93
        pair<SchemaCache::iterator, bool> ret=
 
94
          schema_cache.insert(make_pair(schema_identifier.getPath(), new message::Schema(schema_message)));
 
95
 
 
96
        if (ret.second == false)
 
97
        {
 
98
          abort(); // If this has happened, something really bad is going down.
 
99
        }
94
100
      }
95
101
    }
96
102
  }
97
 
  mutex.unlock();
 
103
}
 
104
 
 
105
void Schema::startup(drizzled::Session &)
 
106
{
98
107
}
99
108
 
100
109
void Schema::doGetSchemaIdentifiers(SchemaIdentifier::vector &set_of_names)
142
151
    return false;
143
152
  }
144
153
 
145
 
  mutex.lock();
146
154
  {
 
155
    boost::unique_lock<boost::shared_mutex> scopedLock(mutex);
147
156
    pair<SchemaCache::iterator, bool> ret=
148
157
      schema_cache.insert(make_pair(schema_identifier.getPath(), new message::Schema(schema_message)));
149
158
 
153
162
      abort(); // If this has happened, something really bad is going down.
154
163
    }
155
164
  }
156
 
  mutex.unlock();
157
165
 
158
166
  return true;
159
167
}
191
199
    cerr << dir;
192
200
  }
193
201
 
194
 
  mutex.lock();
 
202
  boost::unique_lock<boost::shared_mutex> scopedLock(mutex);
195
203
  schema_cache.erase(schema_identifier.getPath());
196
 
  mutex.unlock();
197
204
 
198
205
  return true;
199
206
}
207
214
 
208
215
  if (writeSchemaFile(schema_identifier, schema_message))
209
216
  {
210
 
    mutex.lock();
 
217
    boost::unique_lock<boost::shared_mutex> scopedLock(mutex);
 
218
    schema_cache.erase(schema_identifier.getPath());
 
219
 
 
220
    pair<SchemaCache::iterator, bool> ret=
 
221
      schema_cache.insert(make_pair(schema_identifier.getPath(), new message::Schema(schema_message)));
 
222
 
 
223
    if (ret.second == false)
211
224
    {
212
 
      schema_cache.erase(schema_identifier.getPath());
213
 
 
214
 
      pair<SchemaCache::iterator, bool> ret=
215
 
        schema_cache.insert(make_pair(schema_identifier.getPath(), new message::Schema(schema_message)));
216
 
 
217
 
      if (ret.second == false)
218
 
      {
219
 
        abort(); // If this has happened, something really bad is going down.
220
 
      }
 
225
      abort(); // If this has happened, something really bad is going down.
221
226
    }
222
 
    mutex.unlock();
223
227
  }
224
228
 
225
229
  return true;