← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/table_share.cc

  • Committer: Brian Aker
  • Date: 2010-10-26 21:34:15 UTC
  • mto: (1887.2.1 merge)
  • mto: This revision was merged to the branch mainline in revision 1888.
  • Revision ID: brian@tangent.org-20101026213415-666ezkzx542h8uf0
Adding cache.h for definition.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/table_share.cc
83
83
{
84
84
 
85
85
extern size_t table_def_size;
86
 
static TableDefinitionCache table_def_cache;
87
86
 
88
87
/*****************************************************************************
89
88
  Functions to handle table definition cach (TableShare)
90
89
 *****************************************************************************/
91
90
 
92
 
 
93
 
// @todo switch this a boost::thread one only call.
94
 
void TableShare::cacheStart(void)
95
 
{
96
 
  /* 
97
 
   * This is going to overalloc a bit - as rehash sets the number of
98
 
   * buckets, not the number of elements. BUT, it'll allow us to not need
99
 
   * to rehash later on as the unordered_map grows.
100
 
 */
101
 
  table_def_cache.rehash(table_def_size);
102
 
}
103
 
 
104
 
 
105
 
/**
106
 
 * @TODO This should return size_t
107
 
 */
108
 
uint32_t cached_table_definitions(void)
109
 
{
110
 
  return static_cast<uint32_t>(table_def_cache.size());
111
 
}
112
 
 
113
 
 
114
91
/*
115
92
  Mark that we are not using table share anymore.
116
93
 
139
116
    TableIdentifier identifier(share->getSchemaName(), share->getTableName());
140
117
    plugin::EventObserver::deregisterTableEvents(*share);
141
118
   
142
 
    TableDefinitionCache::iterator iter= table_def_cache.find(identifier.getKey());
143
 
    if (iter != table_def_cache.end())
 
119
    TableDefinitionCache::iterator iter= definition::Cache::singleton().getCache().find(identifier.getKey());
 
120
    if (iter != definition::Cache::singleton().getCache().end())
144
121
    {
145
 
      table_def_cache.erase(iter);
 
122
      definition::Cache::singleton().getCache().erase(iter);
146
123
    }
147
124
    return;
148
125
  }
165
142
    TableIdentifier identifier(share->getSchemaName(), share->getTableName());
166
143
    plugin::EventObserver::deregisterTableEvents(*share);
167
144
   
168
 
    TableDefinitionCache::iterator iter= table_def_cache.find(identifier.getKey());
169
 
    if (iter != table_def_cache.end())
 
145
    TableDefinitionCache::iterator iter= definition::Cache::singleton().getCache().find(identifier.getKey());
 
146
    if (iter != definition::Cache::singleton().getCache().end())
170
147
    {
171
 
      table_def_cache.erase(iter);
 
148
      definition::Cache::singleton().getCache().erase(iter);
172
149
    }
173
150
    return;
174
151
  }
177
154
 
178
155
void TableShare::release(TableIdentifier &identifier)
179
156
{
180
 
  TableDefinitionCache::iterator iter= table_def_cache.find(identifier.getKey());
181
 
  if (iter != table_def_cache.end())
 
157
  TableDefinitionCache::iterator iter= definition::Cache::singleton().getCache().find(identifier.getKey());
 
158
  if (iter != definition::Cache::singleton().getCache().end())
182
159
  {
183
160
    TableSharePtr share= (*iter).second;
184
161
    share->version= 0;                          // Mark for delete
186
163
    {
187
164
      share->lock();
188
165
      plugin::EventObserver::deregisterTableEvents(*share);
189
 
      table_def_cache.erase(identifier.getKey());
 
166
      definition::Cache::singleton().getCache().erase(identifier.getKey());
190
167
    }
191
168
  }
192
169
}
245
222
  *error= 0;
246
223
 
247
224
  /* Read table definition from cache */
248
 
  TableDefinitionCache::iterator iter= table_def_cache.find(identifier.getKey());
249
 
  if (iter != table_def_cache.end())
 
225
  TableDefinitionCache::iterator iter= definition::Cache::singleton().getCache().find(identifier.getKey());
 
226
  if (iter != definition::Cache::singleton().getCache().end())
250
227
  {
251
228
    share= (*iter).second;
252
229
    return foundTableShare(share);
261
238
  share->lock();
262
239
 
263
240
  pair<TableDefinitionCache::iterator, bool> ret=
264
 
    table_def_cache.insert(make_pair(identifier.getKey(), share));
 
241
    definition::Cache::singleton().getCache().insert(make_pair(identifier.getKey(), share));
265
242
  if (ret.second == false)
266
243
  {
267
244
    return TableSharePtr();
270
247
  if (share->open_table_def(*session, identifier))
271
248
  {
272
249
    *error= share->error;
273
 
    table_def_cache.erase(identifier.getKey());
 
250
    definition::Cache::singleton().getCache().erase(identifier.getKey());
274
251
 
275
252
    return TableSharePtr();
276
253
  }
300
277
{
301
278
  safe_mutex_assert_owner(LOCK_open.native_handle);
302
279
 
303
 
  TableDefinitionCache::iterator iter= table_def_cache.find(identifier.getKey());
304
 
  if (iter != table_def_cache.end())
 
280
  TableDefinitionCache::iterator iter= definition::Cache::singleton().getCache().find(identifier.getKey());
 
281
  if (iter != definition::Cache::singleton().getCache().end())
305
282
  {
306
283
    return (*iter).second;
307
284
  }
446
423
 
447
424
const TableDefinitionCache &TableShare::getCache()
448
425
{
449
 
  return table_def_cache;
 
426
  return definition::Cache::singleton().getCache();
450
427
}
451
428
 
452
429
TableShare::TableShare(TableIdentifier::Type type_arg) :
1746
1723
 
1747
1724
  NOTES
1748
1725
  This function is called when the table definition is not cached in
1749
 
  table_def_cache
 
1726
  definition::Cache::singleton().getCache()
1750
1727
  The data is returned in 'share', which is alloced by
1751
1728
  alloc_table_share().. The code assumes that share is initialized.
1752
1729