← Back to branch summary

~thomir-deactivatedaccount/drizzle/drizzle-fix-bug653747

« back to all changes in this revision

Viewing changes to drizzled/table_share.cc

  • Committer: Brian Aker
  • Date: 2010-10-10 02:07:52 UTC
  • mfrom: (1827.2.3 staging)
  • Revision ID: brian@tangent.org-20101010020752-ktv73isay5dxtvp3
Merge in switch on table_share_instance inheritance.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/table_share.cc
140
140
    if (iter != table_def_cache.end())
141
141
    {
142
142
      table_def_cache.erase(iter);
143
 
    }
144
 
    return;
145
 
  }
146
 
  share->unlock();
147
 
}
148
 
 
149
 
void TableShare::release(TableSharePtr &share)
150
 
{
151
 
  bool to_be_deleted= false;
152
 
  safe_mutex_assert_owner(LOCK_open.native_handle);
153
 
 
154
 
  share->lock();
155
 
  if (!--share->ref_count)
156
 
  {
157
 
    to_be_deleted= true;
158
 
  }
159
 
 
160
 
  if (to_be_deleted)
161
 
  {
162
 
    TableIdentifier identifier(share->getSchemaName(), share->getTableName());
163
 
    plugin::EventObserver::deregisterTableEvents(*share);
164
 
   
165
 
    TableDefinitionCache::iterator iter= table_def_cache.find(identifier.getKey());
166
 
    if (iter != table_def_cache.end())
167
 
    {
168
 
      table_def_cache.erase(iter);
 
143
      delete share;
169
144
    }
170
145
    return;
171
146
  }
177
152
  TableDefinitionCache::iterator iter= table_def_cache.find(identifier.getKey());
178
153
  if (iter != table_def_cache.end())
179
154
  {
180
 
    TableSharePtr share= (*iter).second;
 
155
    TableShare *share= (*iter).second;
181
156
    share->version= 0;                          // Mark for delete
182
157
    if (share->ref_count == 0)
183
158
    {
184
159
      share->lock();
185
160
      plugin::EventObserver::deregisterTableEvents(*share);
186
161
      table_def_cache.erase(identifier.getKey());
 
162
      delete share;
187
163
    }
188
164
  }
189
165
}
190
166
 
191
167
 
192
 
static TableSharePtr foundTableShare(TableSharePtr share)
 
168
static TableShare *foundTableShare(TableShare *share)
193
169
{
194
170
  /*
195
171
    We found an existing table definition. Return it if we didn't get
202
178
    /* Table definition contained an error */
203
179
    share->open_table_error(share->error, share->open_errno, share->errarg);
204
180
 
205
 
    return TableSharePtr();
 
181
    return NULL;
206
182
  }
207
183
 
208
184
  share->incrementTableCount();
233
209
#  Share for table
234
210
*/
235
211
 
236
 
TableSharePtr TableShare::getShareCreate(Session *session, 
237
 
                                         TableIdentifier &identifier,
238
 
                                         int *error)
 
212
TableShare *TableShare::getShareCreate(Session *session, 
 
213
                                       TableIdentifier &identifier,
 
214
                                       int *error)
239
215
{
240
 
  TableSharePtr share;
 
216
  TableShare *share= NULL;
241
217
 
242
218
  *error= 0;
243
219
 
249
225
    return foundTableShare(share);
250
226
  }
251
227
 
252
 
  share.reset(new TableShare(message::Table::STANDARD, identifier));
253
 
  
 
228
  if (not (share= new TableShare(message::Table::STANDARD, identifier)))
 
229
  {
 
230
    return NULL;
 
231
  }
 
232
 
254
233
  /*
255
234
    Lock mutex to be able to read table definition from file without
256
235
    conflicts
257
236
  */
258
237
  share->lock();
259
238
 
 
239
  /**
 
240
   * @TODO: we need to eject something if we exceed table_def_size
 
241
 */
260
242
  pair<TableDefinitionCache::iterator, bool> ret=
261
243
    table_def_cache.insert(make_pair(identifier.getKey(), share));
262
244
  if (ret.second == false)
263
245
  {
264
 
    return TableSharePtr();
 
246
    delete share;
 
247
 
 
248
    return NULL;
265
249
  }
266
250
 
267
251
  if (share->open_table_def(*session, identifier))
268
252
  {
269
253
    *error= share->error;
270
254
    table_def_cache.erase(identifier.getKey());
 
255
    delete share;
271
256
 
272
 
    return TableSharePtr();
 
257
    return NULL;
273
258
  }
274
259
  share->ref_count++;                           // Mark in use
275
260
  
293
278
  0  Not cached
294
279
#  TableShare for table
295
280
*/
296
 
TableSharePtr TableShare::getShare(TableIdentifier &identifier)
 
281
TableShare *TableShare::getShare(TableIdentifier &identifier)
297
282
{
298
283
  safe_mutex_assert_owner(LOCK_open.native_handle);
299
284
 
302
287
  {
303
288
    return (*iter).second;
304
289
  }
305
 
 
306
 
  return TableSharePtr();
 
290
  else
 
291
  {
 
292
    return NULL;
 
293
  }
307
294
}
308
295
 
309
296
static enum_field_types proto_field_type_to_drizzle_type(uint32_t proto_field_type)
477
464
  null_fields(0),
478
465
  blob_fields(0),
479
466
  timestamp_field_offset(0),
480
 
  has_variable_width(false),
 
467
  varchar_fields(0),
481
468
  db_create_options(0),
482
469
  db_options_in_use(0),
483
470
  db_record_offset(0),
547
534
  null_fields(0),
548
535
  blob_fields(0),
549
536
  timestamp_field_offset(0),
550
 
  has_variable_width(false),
 
537
  varchar_fields(0),
551
538
  db_create_options(0),
552
539
  db_options_in_use(0),
553
540
  db_record_offset(0),
623
610
  null_fields(0),
624
611
  blob_fields(0),
625
612
  timestamp_field_offset(0),
626
 
  has_variable_width(false),
 
613
  varchar_fields(0),
627
614
  db_create_options(0),
628
615
  db_options_in_use(0),
629
616
  db_record_offset(0),
706
693
  null_fields(0),
707
694
  blob_fields(0),
708
695
  timestamp_field_offset(0),
709
 
  has_variable_width(false),
 
696
  varchar_fields(0),
710
697
  db_create_options(0),
711
698
  db_options_in_use(0),
712
699
  db_record_offset(0),
1337
1324
    }
1338
1325
 
1339
1326
 
1340
 
    db_low_byte_first= true; //Cursor->low_byte_first();
1341
 
    blob_ptr_size= portable_sizeof_char_ptr;
 
1327
    Table temp_table; /* Use this so that BLOB DEFAULT '' works */
 
1328
    temp_table.setShare(this);
 
1329
    temp_table.in_use= &session;
 
1330
    temp_table.getMutableShare()->db_low_byte_first= true; //Cursor->low_byte_first();
 
1331
    temp_table.getMutableShare()->blob_ptr_size= portable_sizeof_char_ptr;
1342
1332
 
1343
1333
    uint32_t field_length= 0; //Assignment is for compiler complaint.
1344
1334
 
1442
1432
 
1443
1433
    field[fieldnr]= f;
1444
1434
 
1445
 
    // This needs to go, we should be setting the "use" on the field so that
1446
 
    // it does not reference the share/table.
1447
 
    Table temp_table; /* Use this so that BLOB DEFAULT '' works */
1448
 
    temp_table.setShare(this);
1449
 
    temp_table.in_use= &session;
1450
 
 
1451
1435
    f->init(&temp_table); /* blob default values need table obj */
1452
1436
 
1453
1437
    if (! (f->flags & NOT_NULL_FLAG))
2128
2112
                                 interval,
2129
2113
                                 field_charset);
2130
2114
  case DRIZZLE_TYPE_VARCHAR:
2131
 
    setVariableWidth();
2132
2115
    return new (&mem_root) Field_varstring(ptr,field_length,
2133
2116
                                      HA_VARCHAR_PACKLENGTH(field_length),
2134
2117
                                      null_pos,null_bit,
2135
2118
                                      field_name,
 
2119
                                      this,
2136
2120
                                      field_charset);
2137
2121
  case DRIZZLE_TYPE_BLOB:
2138
2122
    return new (&mem_root) Field_blob(ptr,