← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/definition/table.cc

  • Committer: Brian Aker
  • Date: 2010-10-28 17:12:01 UTC
  • mfrom: (1887.1.3 merge)
  • Revision ID: brian@tangent.org-20101028171201-baj6l1bnntn1s4ad
Merge in POTFILES changes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/definition/table.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())
144
 
    {
145
 
      table_def_cache.erase(iter);
146
 
    }
 
119
    definition::Cache::singleton().erase(identifier);
147
120
    return;
148
121
  }
149
122
  share->unlock();
165
138
    TableIdentifier identifier(share->getSchemaName(), share->getTableName());
166
139
    plugin::EventObserver::deregisterTableEvents(*share);
167
140
   
168
 
    TableDefinitionCache::iterator iter= table_def_cache.find(identifier.getKey());
169
 
    if (iter != table_def_cache.end())
170
 
    {
171
 
      table_def_cache.erase(iter);
172
 
    }
 
141
    definition::Cache::singleton().erase(identifier);
173
142
    return;
174
143
  }
175
144
  share->unlock();
177
146
 
178
147
void TableShare::release(TableIdentifier &identifier)
179
148
{
180
 
  TableDefinitionCache::iterator iter= table_def_cache.find(identifier.getKey());
181
 
  if (iter != table_def_cache.end())
 
149
  TableSharePtr share= definition::Cache::singleton().find(identifier);
 
150
  if (share)
182
151
  {
183
 
    TableSharePtr share= (*iter).second;
184
152
    share->version= 0;                          // Mark for delete
185
153
    if (share->ref_count == 0)
186
154
    {
187
155
      share->lock();
188
156
      plugin::EventObserver::deregisterTableEvents(*share);
189
 
      table_def_cache.erase(identifier.getKey());
 
157
      definition::Cache::singleton().erase(identifier);
190
158
    }
191
159
  }
192
160
}
245
213
  *error= 0;
246
214
 
247
215
  /* Read table definition from cache */
248
 
  TableDefinitionCache::iterator iter= table_def_cache.find(identifier.getKey());
249
 
  if (iter != table_def_cache.end())
250
 
  {
251
 
    share= (*iter).second;
 
216
  if ((share= definition::Cache::singleton().find(identifier)))
252
217
    return foundTableShare(share);
253
 
  }
254
218
 
255
219
  share.reset(new TableShare(message::Table::STANDARD, identifier));
256
220
  
260
224
  */
261
225
  share->lock();
262
226
 
263
 
  pair<TableDefinitionCache::iterator, bool> ret=
264
 
    table_def_cache.insert(make_pair(identifier.getKey(), share));
265
 
  if (ret.second == false)
266
 
  {
 
227
  bool ret= definition::Cache::singleton().insert(identifier, share);
 
228
 
 
229
  if (not ret)
267
230
    return TableSharePtr();
268
 
  }
269
231
 
270
232
  if (share->open_table_def(*session, identifier))
271
233
  {
272
234
    *error= share->error;
273
 
    table_def_cache.erase(identifier.getKey());
 
235
    definition::Cache::singleton().erase(identifier);
274
236
 
275
237
    return TableSharePtr();
276
238
  }
300
262
{
301
263
  safe_mutex_assert_owner(LOCK_open.native_handle);
302
264
 
303
 
  TableDefinitionCache::iterator iter= table_def_cache.find(identifier.getKey());
304
 
  if (iter != table_def_cache.end())
305
 
  {
306
 
    return (*iter).second;
307
 
  }
308
 
 
309
 
  return TableSharePtr();
 
265
  return definition::Cache::singleton().find(identifier);
310
266
}
311
267
 
312
268
static enum_field_types proto_field_type_to_drizzle_type(uint32_t proto_field_type)
444
400
  return false;
445
401
}
446
402
 
447
 
const TableDefinitionCache &TableShare::getCache()
448
 
{
449
 
  return table_def_cache;
450
 
}
451
 
 
452
403
TableShare::TableShare(TableIdentifier::Type type_arg) :
453
404
  table_category(TABLE_UNKNOWN_CATEGORY),
454
 
  open_count(0),
455
405
  found_next_number_field(NULL),
456
406
  timestamp_field(NULL),
457
407
  key_info(NULL),
521
471
 
522
472
TableShare::TableShare(TableIdentifier &identifier, const TableIdentifier::Key &key) :// Used by placeholder
523
473
  table_category(TABLE_UNKNOWN_CATEGORY),
524
 
  open_count(0),
525
474
  found_next_number_field(NULL),
526
475
  timestamp_field(NULL),
527
476
  key_info(NULL),
597
546
 
598
547
TableShare::TableShare(const TableIdentifier &identifier) : // Just used during createTable()
599
548
  table_category(TABLE_UNKNOWN_CATEGORY),
600
 
  open_count(0),
601
549
  found_next_number_field(NULL),
602
550
  timestamp_field(NULL),
603
551
  key_info(NULL),
680
628
                       char *path_arg,
681
629
                       uint32_t path_length_arg) :
682
630
  table_category(TABLE_UNKNOWN_CATEGORY),
683
 
  open_count(0),
684
631
  found_next_number_field(NULL),
685
632
  timestamp_field(NULL),
686
633
  key_info(NULL),
1745
1692
 
1746
1693
  NOTES
1747
1694
  This function is called when the table definition is not cached in
1748
 
  table_def_cache
 
1695
  definition::Cache::singleton().getCache()
1749
1696
  The data is returned in 'share', which is alloced by
1750
1697
  alloc_table_share().. The code assumes that share is initialized.
1751
1698