« back to all changes in this revision
Viewing changes to drizzled/sql_base.cc
- browse files at revision 1001
- compare with another revision
- download diff
- download tarball
- view history from revision 1001
- Committer: Brian Aker
- Date: 2009-04-29 01:45:36 UTC
- mfrom: (1000.1.6 merge)
- Revision ID: brian@gaz-20090429014536-pwu5m8ug6n8fvh68
Merge refactoring (mainly around TABLE_SHARE... one step forward...)
- files modified:
- drizzled/field.cc
added
removed
drizzled/sql_base.cc
58
58
Table *unused_tables; /* Used by mysql_test */
59
59
HASH open_cache; /* Used by mysql_test */
60
60
static HASH table_def_cache;
61
static TABLE_SHARE *oldest_unused_share, end_of_unused_share;
61
static TableShare *oldest_unused_share, end_of_unused_share;
62
62
static pthread_mutex_t LOCK_table_share;
63
63
static bool table_def_inited= 0;
64
64
150
150
151
151
152
152
/*****************************************************************************
153
Functions to handle table definition cach (TABLE_SHARE)
153
Functions to handle table definition cach (TableShare)
154
154
*****************************************************************************/
155
155
156
156
extern "C" unsigned char *table_def_key(const unsigned char *record, size_t *length,
157
157
bool )
158
158
{
159
TABLE_SHARE *entry=(TABLE_SHARE*) record;
159
TableShare *entry=(TableShare*) record;
160
160
*length= entry->table_cache_key.length;
161
161
return (unsigned char*) entry->table_cache_key.str;
162
162
}
163
163
164
164
165
static void table_def_free_entry(TABLE_SHARE *share)
165
static void table_def_free_entry(TableShare *share)
166
166
{
167
167
if (share->prev)
168
168
{
172
172
share->next->prev= share->prev;
173
173
pthread_mutex_unlock(&LOCK_table_share);
174
174
}
175
free_table_share(share);
175
share->free_table_share();
176
176
return;
177
177
}
178
178
209
209
210
210
211
211
/*
212
Get TABLE_SHARE for a table.
212
Get TableShare for a table.
213
213
214
214
get_table_share()
215
215
session Thread handle
216
216
table_list Table that should be opened
217
217
key Table cache key
218
218
key_length Length of key
219
db_flags Flags to open_table_def():
220
OPEN_VIEW
221
219
error out: Error code from open_table_def()
222
220
223
221
IMPLEMENTATION
233
231
# Share for table
234
232
*/
235
233
236
TABLE_SHARE *get_table_share(Session *session, TableList *table_list, char *key,
237
uint32_t key_length, uint32_t db_flags, int *error)
234
TableShare *get_table_share(Session *session, TableList *table_list, char *key,
235
uint32_t key_length, uint32_t, int *error)
238
236
{
239
TABLE_SHARE *share;
237
TableShare *share;
240
238
241
239
*error= 0;
242
240
243
241
/* Read table definition from cache */
244
if ((share= (TABLE_SHARE*) hash_search(&table_def_cache,(unsigned char*) key,
242
if ((share= (TableShare*) hash_search(&table_def_cache,(unsigned char*) key,
245
243
key_length)))
246
244
goto found;
247
245
256
254
*/
257
255
(void) pthread_mutex_lock(&share->mutex);
258
256
259
/*
260
We assign a new table id under the protection of the LOCK_open and
261
the share's own mutex. We do this insted of creating a new mutex
262
and using it for the sole purpose of serializing accesses to a
263
static variable, we assign the table id here. We assign it to the
264
share before inserting it into the table_def_cache to be really
265
sure that it cannot be read from the cache without having a table
266
id assigned.
267
268
CAVEAT. This means that the table cannot be used for
269
binlogging/replication purposes, unless get_table_share() has been
270
called directly or indirectly.
271
*/
272
assign_new_table_id(share);
273
274
257
if (my_hash_insert(&table_def_cache, (unsigned char*) share))
275
258
{
276
free_table_share(share);
259
share->free_table_share();
277
260
return(0); // return error
278
261
}
279
if (open_table_def(session, share, db_flags))
262
if (open_table_def(session, share))
280
263
{
281
264
*error= share->error;
282
265
(void) hash_delete(&table_def_cache, (unsigned char*) share);
335
318
For arguments and return values, see get_table_from_share()
336
319
*/
337
320
338
static TABLE_SHARE
321
static TableShare
339
322
*get_table_share_with_create(Session *session, TableList *table_list,
340
323
char *key, uint32_t key_length,
341
324
uint32_t db_flags, int *error)
342
325
{
343
TABLE_SHARE *share;
326
TableShare *share;
344
327
345
328
share= get_table_share(session, table_list, key, key_length, db_flags, error);
346
329
/*
391
374
that the table is deleted or the thread is killed.
392
375
*/
393
376
394
void release_table_share(TABLE_SHARE *share,
377
void release_table_share(TableShare *share,
395
378
enum release_type )
396
379
{
397
380
bool to_be_deleted= 0;
438
421
439
422
RETURN
440
423
0 Not cached
441
# TABLE_SHARE for table
424
# TableShare for table
442
425
*/
443
426
444
TABLE_SHARE *get_cached_table_share(const char *db, const char *table_name)
427
TableShare *get_cached_table_share(const char *db, const char *table_name)
445
428
{
446
429
char key[NAME_LEN*2+2];
447
430
TableList table_list;
451
434
table_list.db= (char*) db;
452
435
table_list.table_name= (char*) table_name;
453
436
key_length= create_table_def_key((Session*) 0, key, &table_list, 0);
454
return (TABLE_SHARE*) hash_search(&table_def_cache,(unsigned char*) key, key_length);
437
return (TableShare*) hash_search(&table_def_cache,(unsigned char*) key, key_length);
455
438
}
456
439
457
440
475
458
476
459
void close_handle_and_leave_table_as_lock(Table *table)
477
460
{
478
TABLE_SHARE *share, *old_share= table->s;
461
TableShare *share, *old_share= table->s;
479
462
char *key_buff;
480
463
MEM_ROOT *mem_root= &table->mem_root;
481
464
540
523
{
541
524
OPEN_TableList *table;
542
525
Table *entry=(Table*) hash_element(&open_cache,idx);
543
TABLE_SHARE *share= entry->s;
526
TableShare *share= entry->s;
544
527
545
528
if (db && my_strcasecmp(system_charset_info, db, share->db.str))
546
529
continue;
842
825
843
826
for (idx= 0; idx < table_def_cache.records; idx++)
844
827
{
845
TABLE_SHARE *share= (TABLE_SHARE *) hash_element(&table_def_cache, idx);
828
TableShare *share= (TableShare *) hash_element(&table_def_cache, idx);
846
829
847
830
/* Ignore if table is not open or does not have a connect_string */
848
831
if (!share->connect_string.length || !share->ref_count)
1401
1384
1402
1385
if (free_share)
1403
1386
{
1404
free_table_share(table->s);
1387
table->s->free_table_share();
1405
1388
free((char*) table);
1406
1389
}
1407
1390
return;
1421
1404
{
1422
1405
char *key;
1423
1406
uint32_t key_length;
1424
TABLE_SHARE *share= table->s;
1407
TableShare *share= table->s;
1425
1408
TableList table_list;
1426
1409
1427
1410
if (!(key=(char*) alloc_root(&share->mem_root, MAX_DBKEY_LENGTH)))
1653
1636
bool reopen_name_locked_table(Session* session, TableList* table_list, bool link_in)
1654
1637
{
1655
1638
Table *table= table_list->table;
1656
TABLE_SHARE *share;
1639
TableShare *share;
1657
1640
char *table_name= table_list->table_name;
1658
1641
Table orig_table;
1659
1642
1733
1716
uint32_t key_length)
1734
1717
{
1735
1718
Table *table;
1736
TABLE_SHARE *share;
1719
TableShare *share;
1737
1720
char *key_buff;
1738
1721
1739
1722
safe_mutex_assert_owner(&LOCK_open);
2321
2304
tmp.maybe_null= table->maybe_null;
2322
2305
tmp.status= table->status;
2323
2306
2324
tmp.s->table_map_id= table->s->table_map_id;
2325
2326
2307
/* Get state */
2327
2308
tmp.in_use= session;
2328
2309
tmp.reginfo.lock_type=table->reginfo.lock_type;
2376
2357
the function probably has to be adjusted before it can be used
2377
2358
anywhere outside ALTER Table.
2378
2359
2379
@note Must not use TABLE_SHARE::table_name/db of the table being closed,
2360
@note Must not use TableShare::table_name/db of the table being closed,
2380
2361
the strings are used in a loop even after the share may be freed.
2381
2362
*/
2382
2363
2781
2762
}
2782
2763
}
2783
2764
2784
2785
/*
2786
Function to assign a new table map id to a table share.
2787
2788
PARAMETERS
2789
2790
share - Pointer to table share structure
2791
2792
DESCRIPTION
2793
2794
We are intentionally not checking that share->mutex is locked
2795
since this function should only be called when opening a table
2796
share and before it is entered into the table_def_cache (meaning
2797
that it cannot be fetched by another thread, even accidentally).
2798
2799
PRE-CONDITION(S)
2800
2801
share is non-NULL
2802
The LOCK_open mutex is locked
2803
2804
POST-CONDITION(S)
2805
2806
share->table_map_id is given a value that with a high certainty is
2807
not used by any other table (the only case where a table id can be
2808
reused is on wrap-around, which means more than 4 billion table
2809
share opens have been executed while one table was open all the
2810
time).
2811
2812
share->table_map_id is not UINT32_MAX.
2813
*/
2814
void assign_new_table_id(TABLE_SHARE *share)
2815
{
2816
static uint32_t last_table_id= UINT32_MAX;
2817
2818
/* Preconditions */
2819
assert(share != NULL);
2820
safe_mutex_assert_owner(&LOCK_open);
2821
2822
ulong tid= ++last_table_id; /* get next id */
2823
/*
2824
There is one reserved number that cannot be used. Remember to
2825
change this when 6-byte global table id's are introduced.
2826
*/
2827
if (unlikely(tid == UINT32_MAX))
2828
tid= ++last_table_id;
2829
share->table_map_id= tid;
2830
2831
/* Post conditions */
2832
assert(share->table_map_id != UINT32_MAX);
2833
2834
return;
2835
}
2836
2837
2765
/*
2838
2766
Load a table definition from file and open unireg table
2839
2767
2860
2788
char *cache_key, uint32_t cache_key_length)
2861
2789
{
2862
2790
int error;
2863
TABLE_SHARE *share;
2791
TableShare *share;
2864
2792
uint32_t discover_retry_count= 0;
2865
2793
2866
2794
safe_mutex_assert_owner(&LOCK_open);
3510
3438
open_table_mode open_mode)
3511
3439
{
3512
3440
Table *tmp_table;
3513
TABLE_SHARE *share;
3441
TableShare *share;
3514
3442
char cache_key[MAX_DBKEY_LENGTH], *saved_cache_key, *tmp_path;
3515
3443
uint32_t key_length, path_length;
3516
3444
TableList table_list;
3525
3453
path_length + 1 + key_length)))
3526
3454
return NULL;
3527
3455
3528
share= (TABLE_SHARE*) (tmp_table+1);
3456
share= (TableShare*) (tmp_table+1);
3529
3457
tmp_path= (char*) (share+1);
3530
3458
saved_cache_key= strcpy(tmp_path, path)+path_length+1;
3531
3459
memcpy(saved_cache_key, cache_key, key_length);
3532
3460
3533
init_tmp_table_share(session, share, saved_cache_key, key_length,
3534
strchr(saved_cache_key, '\0')+1, tmp_path);
3461
share->init(saved_cache_key, key_length, strchr(saved_cache_key, '\0')+1, tmp_path);
3535
3462
3536
if (open_table_def(session, share, 0) ||
3463
if (open_table_def(session, share) ||
3537
3464
open_table_from_share(session, share, table_name,
3538
3465
(open_mode == OTM_ALTER) ? 0 :
3539
3466
(uint32_t) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE |
3545
3472
tmp_table, open_mode))
3546
3473
{
3547
3474
/* No need to lock share->mutex as this is not needed for tmp tables */
3548
free_table_share(share);
3475
share->free_table_share();
3549
3476
free((char*) tmp_table);
3550
3477
return(0);
3551
3478
}
3585
3512
if(delete_table_proto_file(path))
3586
3513
error=1; /* purecov: inspected */
3587
3514
3588
file= get_new_handler((TABLE_SHARE*) 0, current_session->mem_root, base);
3515
file= get_new_handler((TableShare*) 0, current_session->mem_root, base);
3589
3516
if (file && file->ha_delete_table(path))
3590
3517
{
3591
3518
error=1;
3773
3700
if (field_ptr)
3774
3701
{
3775
3702
/*
3776
field_ptr points to field in TABLE_SHARE. Convert it to the matching
3703
field_ptr points to field in TableShare. Convert it to the matching
3777
3704
field in table
3778
3705
*/
3779
3706
field_ptr= (table->field + (field_ptr - table->s->field));
4002
3929
if (field_ptr)
4003
3930
{
4004
3931
/*
4005
field_ptr points to field in TABLE_SHARE. Convert it to the matching
3932
field_ptr points to field in TableShare. Convert it to the matching
4006
3933
field in table
4007
3934
*/
4008
3935
field_ptr= (table->field + (field_ptr - table->s->field));
5857
5784
char filePath[FN_REFLEN], filePathCopy[FN_REFLEN];
5858
5785
MY_DIR *dirp;
5859
5786
FILEINFO *file;
5860
TABLE_SHARE share;
5787
TableShare share;
5861
5788
Session *session;
5862
5789
5863
5790
assert(drizzle_tmpdir);
5894
5821
/* We should cut file extention before deleting of table */
5895
5822
memcpy(filePathCopy, filePath, filePath_len - ext_len);
5896
5823
filePathCopy[filePath_len - ext_len]= 0;
5897
init_tmp_table_share(session, &share, "", 0, "", filePathCopy);
5898
if (!open_table_def(session, &share, 0) &&
5824
share.init(NULL, filePathCopy);
5825
if (!open_table_def(session, &share) &&
5899
5826
((handler_file= get_new_handler(&share, session->mem_root,
5900
5827
share.db_type()))))
5901
5828
{
5902
5829
handler_file->ha_delete_table(filePathCopy);
5903
5830
delete handler_file;
5904
5831
}
5905
free_table_share(&share);
5832
share.free_table_share();
5906
5833
}
5907
5834
/*
5908
5835
File can be already deleted by tmp_table.file->delete_table().
5995
5922
char *key_pos= key;
5996
5923
uint32_t key_length;
5997
5924
Table *table;
5998
TABLE_SHARE *share;
5925
TableShare *share;
5999
5926
bool result= 0, signalled= 0;
6000
5927
6001
5928
key_pos= strcpy(key_pos, db) + strlen(db);
6057
5984
hash_delete(&open_cache,(unsigned char*) unused_tables);
6058
5985
6059
5986
/* Remove table from table definition cache if it's not in use */
6060
if ((share= (TABLE_SHARE*) hash_search(&table_def_cache,(unsigned char*) key,
5987
if ((share= (TableShare*) hash_search(&table_def_cache,(unsigned char*) key,
6061
5988
key_length)))
6062
5989
{
6063
5990
share->version= 0; // Mark for delete
Loggerhead is a web-based interface for Breezy
Version: 2.0.1