« back to all changes in this revision
Viewing changes to drizzled/sql_base.cc
- browse files at revision 1039.2.8
- compare with another revision
- compare with revision 2465.1.2
- download diff
- download tarball
- view history from revision 1039.2.8
- Committer: Jay Pipes
- Date: 2009-05-31 21:21:44 UTC
- mto: This revision was merged to the branch mainline in revision 1046.
- Revision ID: jpipes@serialcoder-20090531212144-dn18058mx55azhms
Yet more indentation and style cleanup
- files modified:
- drizzled/records.cc
added
removed
drizzled/sql_base.cc
194
194
return table_def_cache.records;
195
195
}
196
196
197
198
197
/*
199
198
Get TableShare for a table.
200
199
217
216
0 Error
218
217
# Share for table
219
218
*/
220
221
TableShare *get_table_share(Session *session, TableList *table_list, char *key,
222
uint32_t key_length, uint32_t, int *error)
219
TableShare *get_table_share(Session *session,
220
TableList *table_list,
221
char *key,
222
uint32_t key_length,
223
uint32_t,
224
int *error)
223
225
{
224
226
TableShare *share;
225
227
298
300
return(share);
299
301
}
300
302
301
302
303
/*
303
304
Get a table share. If it didn't exist, try creating it from engine
304
305
305
306
For arguments and return values, see get_table_from_share()
306
307
*/
307
308
static TableShare
309
*get_table_share_with_create(Session *session, TableList *table_list,
310
char *key, uint32_t key_length,
311
uint32_t db_flags, int *error)
308
static TableShare *get_table_share_with_create(Session *session,
309
TableList *table_list,
310
char *key,
311
uint32_t key_length,
312
uint32_t db_flags,
313
int *error)
312
314
{
313
315
TableShare *share;
314
316
333
335
@todo Rework alternative ways to deal with ER_NO_SUCH Table.
334
336
*/
335
337
if (share || (session->is_error() && (session->main_da.sql_errno() != ER_NO_SUCH_TABLE)))
336
337
338
return(share);
338
339
339
340
return 0;
340
341
}
341
342
342
343
343
/*
344
344
Mark that we are not using table share anymore.
345
345
360
360
If type == RELEASE_WAIT_FOR_DROP then don't return until we get a signal
361
361
that the table is deleted or the thread is killed.
362
362
*/
363
364
void release_table_share(TableShare *share,
365
enum release_type )
363
void release_table_share(TableShare *share, enum release_type)
366
364
{
367
365
bool to_be_deleted= 0;
368
366
383
381
end_of_unused_share.prev= &share->next;
384
382
share->next= &end_of_unused_share;
385
383
pthread_mutex_unlock(&LOCK_table_share);
386
387
384
to_be_deleted= (table_def_cache.records > table_def_size);
388
385
}
389
386
}
397
394
return;
398
395
}
399
396
400
401
397
/*
402
398
Check if table definition exits in cache
403
399
410
406
0 Not cached
411
407
# TableShare for table
412
408
*/
413
414
409
TableShare *get_cached_table_share(const char *db, const char *table_name)
415
410
{
416
411
char key[NAME_LEN*2+2];
424
419
return (TableShare*) hash_search(&table_def_cache,(unsigned char*) key, key_length);
425
420
}
426
421
427
428
422
/*
429
423
Close file handle, but leave the table in the table cache
430
424
441
435
If closing a MERGE child, the calling function has to take care for
442
436
closing the parent too, if necessary.
443
437
*/
444
445
446
438
void close_handle_and_leave_table_as_lock(Table *table)
447
439
{
448
440
TableShare *share, *old_share= table->s;
476
468
return;
477
469
}
478
470
479
480
481
471
/*
482
472
Create a list for all open tables matching SQL expression
483
473
494
484
NULL Error (Probably OOM)
495
485
# Pointer to list of names of open tables.
496
486
*/
497
498
487
OPEN_TableList *list_open_tables(const char *db, const char *wild)
499
488
{
500
489
int result = 0;
525
514
for (table= open_list ; table ; table=table->next)
526
515
{
527
516
if (!strcmp(table->table, share->table_name.str) &&
528
!strcmp(table->db, share->db.str))
517
!strcmp(table->db, share->db.str))
529
518
{
530
if (entry->in_use)
531
table->in_use++;
532
if (entry->locked_by_name)
533
table->locked++;
534
break;
519
if (entry->in_use)
520
table->in_use++;
521
if (entry->locked_by_name)
522
table->locked++;
523
break;
535
524
}
536
525
}
537
526
if (table)
559
548
* Functions to free open table cache
560
549
****************************************************************************/
561
550
562
563
551
void intern_close_table(Table *table)
564
552
{ // Free all structures
565
553
free_io_cache(table);
578
566
NOTE
579
567
We need to have a lock on LOCK_open when calling this
580
568
*/
581
582
569
void free_cache_entry(void *entry)
583
570
{
584
571
Table *table= static_cast<Table *>(entry);
591
578
{
592
579
unused_tables=unused_tables->next;
593
580
if (table == unused_tables)
594
unused_tables=0;
581
unused_tables=0;
595
582
}
596
583
}
597
584
free(table);
599
586
}
600
587
601
588
/* Free resources allocated by filesort() and read_record() */
602
603
589
void free_io_cache(Table *table)
604
590
{
605
591
if (table->sort.io_cache)
611
597
return;
612
598
}
613
599
614
615
600
/*
616
601
Close all tables which aren't in use by any thread
617
602
626
611
@remark Session can be NULL, but then wait_for_refresh must be false
627
612
and tables must be NULL.
628
613
*/
629
630
bool close_cached_tables(Session *session, TableList *tables, bool have_lock,
631
bool wait_for_refresh, bool wait_for_placeholders)
614
bool close_cached_tables(Session *session,
615
TableList *tables,
616
bool have_lock,
617
bool wait_for_refresh,
618
bool wait_for_placeholders)
632
619
{
633
620
bool result=0;
634
621
assert(session || (!wait_for_refresh && !tables));
642
629
{
643
630
#ifdef EXTRA_DEBUG
644
631
if (hash_delete(&open_cache,(unsigned char*) unused_tables))
645
printf("Warning: Couldn't delete open table from hash\n");
632
printf("Warning: Couldn't delete open table from hash\n");
646
633
#else
647
634
hash_delete(&open_cache,(unsigned char*) unused_tables);
648
635
#endif
707
694
{
708
695
if (remove_table_from_cache(session, table->db, table->table_name,
709
696
RTFC_OWNED_BY_Session_FLAG))
710
found=1;
697
found= 1;
711
698
}
712
699
if (!found)
713
700
wait_for_refresh=0; // Nothing to wait for
732
719
found=0;
733
720
for (uint32_t idx=0 ; idx < open_cache.records ; idx++)
734
721
{
735
Table *table=(Table*) hash_element(&open_cache,idx);
722
Table *table=(Table*) hash_element(&open_cache,idx);
736
723
/* Avoid a self-deadlock. */
737
724
if (table->in_use == session)
738
725
continue;
750
737
are employed by CREATE TABLE as in this case table simply does not
751
738
exist yet.
752
739
*/
753
if (table->needs_reopen_or_name_lock() && (table->db_stat ||
754
(table->open_placeholder && wait_for_placeholders)))
755
{
756
found=1;
757
pthread_cond_wait(&COND_refresh,&LOCK_open);
758
break;
759
}
740
if (table->needs_reopen_or_name_lock() && (table->db_stat ||
741
(table->open_placeholder && wait_for_placeholders)))
742
{
743
found=1;
744
pthread_cond_wait(&COND_refresh,&LOCK_open);
745
break;
746
}
760
747
}
761
748
}
762
749
/*
791
778
return(result);
792
779
}
793
780
794
795
781
/*
796
782
Close all tables which match specified connection string or
797
783
if specified string is NULL, then any table with a connection string.
798
784
*/
799
800
bool close_cached_connection_tables(Session *session, bool if_wait_for_refresh,
801
LEX_STRING *connection, bool have_lock)
785
bool close_cached_connection_tables(Session *session,
786
bool if_wait_for_refresh,
787
LEX_STRING *connection,
788
bool have_lock)
802
789
{
803
790
uint32_t idx;
804
791
TableList tmp, *tables= NULL;
853
840
return(result);
854
841
}
855
842
856
857
843
/**
858
844
Mark all temporary tables which were used by the current statement or
859
845
substatement as free for reuse, but only if the query_id can be cleared.
863
849
@remark For temp tables associated with a open SQL HANDLER the query_id
864
850
is not reset until the HANDLER is closed.
865
851
*/
866
867
852
static void mark_temp_tables_as_free_for_reuse(Session *session)
868
853
{
869
854
for (Table *table= session->temporary_tables ; table ; table= table->next)
876
861
}
877
862
}
878
863
879
880
864
/*
881
865
Mark all tables in the list which were used by current substatement
882
866
as free for reuse.
899
883
In f1_that_uses_t1() we will see one instance of t1 where query_id is
900
884
set to query_id of original query.
901
885
*/
902
903
886
static void mark_used_tables_as_free_for_reuse(Session *session, Table *table)
904
887
{
905
888
for (; table ; table= table->next)
912
895
}
913
896
}
914
897
915
916
898
/**
917
899
Auxiliary function to close all tables in the open_tables list.
918
900
920
902
921
903
@remark It should not ordinarily be called directly.
922
904
*/
923
924
905
static void close_open_tables(Session *session)
925
906
{
926
907
bool found_old_table= 0;
945
926
pthread_mutex_unlock(&LOCK_open);
946
927
}
947
928
948
949
929
/*
950
930
Close all tables used by the current substatement, or all tables
951
931
used by this thread if we are on the upper level.
963
943
execution of complete query (i.e. we are on upper level) and will
964
944
leave prelocked mode if needed.
965
945
*/
966
967
946
void close_thread_tables(Session *session)
968
947
{
969
948
Table *table;
1053
1032
return;
1054
1033
}
1055
1034
1056
1057
1035
/* move one table to free list */
1058
1059
1036
bool close_thread_table(Session *session, Table **table_ptr)
1060
1037
{
1061
1038
bool found_old_table= 0;
1114
1091
NULL Table not found
1115
1092
# Pointer to found table.
1116
1093
*/
1117
1118
1094
TableList *find_table_in_list(TableList *table,
1119
1095
TableList *TableList::*link,
1120
1096
const char *db_name,
1166
1142
found duplicate
1167
1143
0 if table is unique
1168
1144
*/
1169
1170
TableList* unique_table(Session *session, TableList *table, TableList *table_list,
1171
bool check_alias)
1145
TableList* unique_table(Session *session,
1146
TableList *table,
1147
TableList *table_list,
1148
bool check_alias)
1172
1149
{
1173
1150
TableList *res;
1174
1151
const char *d_name, *t_name, *t_alias;
1219
1196
return(res);
1220
1197
}
1221
1198
1222
1223
1199
/*
1224
1200
Issue correct error message in case we found 2 duplicate tables which
1225
1201
prevent some update operation
1233
1209
NOTE:
1234
1210
here we hide view underlying tables if we have them
1235
1211
*/
1236
1237
1212
void update_non_unique_table_error(TableList *update,
1238
1213
const char *,
1239
1214
TableList *)
1241
1216
my_error(ER_UPDATE_TABLE_USED, MYF(0), update->alias);
1242
1217
}
1243
1218
1244
1245
1219
Table *find_temporary_table(Session *session, const char *db, const char *table_name)
1246
1220
{
1247
1221
TableList table_list;
1251
1225
return find_temporary_table(session, &table_list);
1252
1226
}
1253
1227
1254
1255
1228
Table *find_temporary_table(Session *session, TableList *table_list)
1256
1229
{
1257
1230
char key[MAX_DBKEY_LENGTH];
1268
1241
return(0); // Not a temporary table
1269
1242
}
1270
1243
1271
1272
1244
/**
1273
1245
Drop a temporary table.
1274
1246
1294
1266
of this thread
1295
1267
@retval -1 the table is in use by a outer query
1296
1268
*/
1297
1298
1269
int drop_temporary_table(Session *session, TableList *table_list)
1299
1270
{
1300
1271
Table *table;
1321
1292
/*
1322
1293
unlink from session->temporary tables and close temporary table
1323
1294
*/
1324
1325
void close_temporary_table(Session *session, Table *table,
1326
bool free_share, bool delete_table)
1295
void close_temporary_table(Session *session,
1296
Table *table,
1297
bool free_share,
1298
bool delete_table)
1327
1299
{
1328
1300
if (table->prev)
1329
1301
{
1348
1320
return;
1349
1321
}
1350
1322
1351
1352
1323
/*
1353
1324
Close and delete a temporary table
1354
1325
1356
1327
This dosn't unlink table from session->temporary
1357
1328
If this is needed, use close_temporary_table()
1358
1329
*/
1359
1360
1330
void close_temporary(Table *table, bool free_share, bool delete_table)
1361
1331
{
1362
1332
StorageEngine *table_type= table->s->db_type();
1375
1345
return;
1376
1346
}
1377
1347
1378
1379
1348
/*
1380
1349
Used by ALTER Table when the table is a temporary one. It changes something
1381
1350
only if the ALTER contained a RENAME clause (otherwise, table_name is the old
1383
1352
Prepares a table cache key, which is the concatenation of db, table_name and
1384
1353
session->slave_proxy_id, separated by '\0'.
1385
1354
*/
1386
1387
1355
bool rename_temporary_table(Table *table, const char *db, const char *table_name)
1388
1356
{
1389
1357
char *key;
1402
1370
return false;
1403
1371
}
1404
1372
1405
1406
/* move table first in unused links */
1407
1373
/* move table first in unused links */
1408
1374
static void relink_unused(Table *table)
1409
1375
{
1410
1376
if (table != unused_tables)
1419
1385
}
1420
1386
}
1421
1387
1422
1423
1388
/**
1424
1389
Remove all instances of table from thread's open list and
1425
1390
table cache.
1434
1399
any tables locked with LOCK TABLES, tables are assumed to be
1435
1400
not locked (for example already unlocked).
1436
1401
*/
1437
1438
1402
void unlink_open_table(Session *session, Table *find, bool unlock)
1439
1403
{
1440
1404
char key[MAX_DBKEY_LENGTH];
1478
1442
return;
1479
1443
}
1480
1444
1481
1482
1445
/**
1483
1446
Auxiliary routine which closes and drops open table.
1484
1447
1497
1460
Currently, however, this function is never called for a
1498
1461
table that was locked with LOCK TABLES.
1499
1462
*/
1500
1501
void drop_open_table(Session *session, Table *table, const char *db_name,
1463
void drop_open_table(Session *session, Table *table,
1464
const char *db_name,
1502
1465
const char *table_name)
1503
1466
{
1504
1467
if (table->s->tmp_table)
1517
1480
}
1518
1481
}
1519
1482
1520
1521
1483
/*
1522
1484
Wait for condition but allow the user to send a kill to mysqld
1523
1485
1528
1490
Will be unlocked on return
1529
1491
cond Condition to wait for
1530
1492
*/
1531
1532
1493
void wait_for_condition(Session *session, pthread_mutex_t *mutex, pthread_cond_t *cond)
1533
1494
{
1534
1495
/* Wait until the current table is up to date */
1560
1521
return;
1561
1522
}
1562
1523
1563
1564
1524
/**
1565
1525
Exclusively name-lock a table that is already write-locked by the
1566
1526
current thread.
1570
1530
1571
1531
@return false on success, true otherwise.
1572
1532
*/
1573
1574
1533
bool name_lock_locked_table(Session *session, TableList *tables)
1575
1534
{
1576
1535
/* Under LOCK TABLES we must only accept write locked tables. */
1593
1552
return(true);
1594
1553
}
1595
1554
1596
1597
1555
/*
1598
1556
Open table which is already name-locked by this thread.
1599
1557
1616
1574
false - Success
1617
1575
true - Error
1618
1576
*/
1619
1620
1577
bool reopen_name_locked_table(Session* session, TableList* table_list, bool link_in)
1621
1578
{
1622
1579
Table *table= table_list->table;
1682
1639
return false;
1683
1640
}
1684
1641
1685
1686
1642
/**
1687
1643
Create and insert into table cache placeholder for table
1688
1644
which will prevent its opening (or creation) (a.k.a lock
1695
1651
@return Pointer to Table object used for name locking or 0 in
1696
1652
case of failure.
1697
1653
*/
1698
1699
Table *table_cache_insert_placeholder(Session *session, const char *key,
1654
Table *table_cache_insert_placeholder(Session *session,
1655
const char *key,
1700
1656
uint32_t key_length)
1701
1657
{
1702
1658
Table *table;
1732
1688
return(table);
1733
1689
}
1734
1690
1735
1736
1691
/**
1737
1692
Obtain an exclusive name lock on the table if it is not cached
1738
1693
in the table cache.
1754
1709
@retval true Error occured (OOM)
1755
1710
@retval false Success. 'table' parameter set according to above rules.
1756
1711
*/
1757
1758
bool lock_table_name_if_not_cached(Session *session, const char *db,
1759
const char *table_name, Table **table)
1712
bool lock_table_name_if_not_cached(Session *session,
1713
const char *db,
1714
const char *table_name,
1715
Table **table)
1760
1716
{
1761
1717
char key[MAX_DBKEY_LENGTH];
1762
1718
char *key_pos= key;
1817
1773
all other tables and retry the open.
1818
1774
# Success. Pointer to Table object for open table.
1819
1775
*/
1820
1821
1822
1776
Table *open_table(Session *session, TableList *table_list, bool *refresh, uint32_t flags)
1823
1777
{
1824
1778
register Table *table;
2208
2162
return(table);
2209
2163
}
2210
2164
2211
2212
2165
Table *find_locked_table(Session *session, const char *db,const char *table_name)
2213
2166
{
2214
2167
char key[MAX_DBKEY_LENGTH];
2228
2181
return(0);
2229
2182
}
2230
2183
2231
2232
2184
/*
2233
2185
Reopen an table because the definition has changed.
2234
2186
2244
2196
0 ok
2245
2197
1 error. The old table object is not changed.
2246
2198
*/
2247
2248
2199
bool reopen_table(Table *table)
2249
2200
{
2250
2201
Table tmp;
2322
2273
return(error);
2323
2274
}
2324
2275
2325
2326
2276
/**
2327
2277
Close all instances of a table open by this thread and replace
2328
2278
them with exclusive name-locks.
2339
2289
@note Must not use TableShare::table_name/db of the table being closed,
2340
2290
the strings are used in a loop even after the share may be freed.
2341
2291
*/
2342
2343
void close_data_files_and_morph_locks(Session *session, const char *db,
2292
void close_data_files_and_morph_locks(Session *session,
2293
const char *db,
2344
2294
const char *table_name)
2345
2295
{
2346
2296
Table *table;
2365
2315
for (table=session->open_tables; table ; table=table->next)
2366
2316
{
2367
2317
if (!strcmp(table->s->table_name.str, table_name) &&
2368
!strcmp(table->s->db.str, db))
2318
!strcmp(table->s->db.str, db))
2369
2319
{
2370
2320
if (session->locked_tables)
2371
2321
{
2378
2328
return;
2379
2329
}
2380
2330
2381
2382
2331
/**
2383
2332
Reopen all tables with closed data files.
2384
2333
2398
2347
2399
2348
@return false in case of success, true - otherwise.
2400
2349
*/
2401
2402
2350
bool reopen_tables(Session *session, bool get_locks, bool mark_share_as_old)
2403
2351
{
2404
2352
Table *table,*next,**prev;
2486
2434
return(error);
2487
2435
}
2488
2436
2489
2490
2437
/**
2491
2438
Close handlers for tables in list, but leave the Table structure
2492
2439
intact so that we can re-open these quickly.
2500
2447
false - otherwise
2501
2448
@param send_refresh Should we awake waiters even if we didn't close any tables?
2502
2449
*/
2503
2504
static void close_old_data_files(Session *session, Table *table, bool morph_locks,
2450
static void close_old_data_files(Session *session,
2451
Table *table,
2452
bool morph_locks,
2505
2453
bool send_refresh)
2506
2454
{
2507
2455
bool found= send_refresh;
2516
2464
found=1;
2517
2465
if (table->db_stat)
2518
2466
{
2519
if (morph_locks)
2520
{
2467
if (morph_locks)
2468
{
2521
2469
Table *ulcktbl= table;
2522
2470
if (ulcktbl->lock_count)
2523
2471
{
2546
2494
We want to protect the table from concurrent DDL operations
2547
2495
(like RENAME Table) until we will re-open and re-lock it.
2548
2496
*/
2549
table->open_placeholder= 1;
2550
}
2497
table->open_placeholder= 1;
2498
}
2551
2499
close_handle_and_leave_table_as_lock(table);
2552
2500
}
2553
2501
else if (table->open_placeholder && !morph_locks)
2578
2526
We have also to wait if there is thread that has a lock on this table even
2579
2527
if the table is closed
2580
2528
*/
2581
2582
2529
bool table_is_used(Table *table, bool wait_for_name_lock)
2583
2530
{
2584
2531
do
2610
2557
return(0);
2611
2558
}
2612
2559
2613
2614
2560
/* Wait until all used tables are refreshed */
2615
2616
2561
bool wait_for_tables(Session *session)
2617
2562
{
2618
2563
bool result;
2641
2586
return(result);
2642
2587
}
2643
2588
2644
2645
2589
/*
2646
2590
drop tables from locked list
2647
2591
2664
2608
# If table existed, return table
2665
2609
0 Table was not locked
2666
2610
*/
2667
2668
2669
2611
Table *drop_locked_tables(Session *session,const char *db, const char *table_name)
2670
2612
{
2671
2613
Table *table,*next,**prev, *found= 0;
2682
2624
{
2683
2625
next=table->next;
2684
2626
if (!strcmp(table->s->table_name.str, table_name) &&
2685
!strcmp(table->s->db.str, db))
2627
!strcmp(table->s->db.str, db))
2686
2628
{
2687
2629
mysql_lock_remove(session, session->locked_tables, table, true);
2688
2630
2725
2667
done on the table, change the lock type to a lock that will abort all
2726
2668
other threads trying to get the lock.
2727
2669
*/
2728
2729
2670
void abort_locked_tables(Session *session,const char *db, const char *table_name)
2730
2671
{
2731
2672
Table *table;
2761
2702
0 ok
2762
2703
# Error
2763
2704
*/
2764
2765
static int open_unireg_entry(Session *session, Table *entry, TableList *table_list,
2705
static int open_unireg_entry(Session *session,
2706
Table *entry,
2707
TableList *table_list,
2766
2708
const char *alias,
2767
char *cache_key, uint32_t cache_key_length)
2709
char *cache_key,
2710
uint32_t cache_key_length)
2768
2711
{
2769
2712
int error;
2770
2713
TableShare *share;
2825
2768
}
2826
2769
if (!entry->s || !entry->s->crashed)
2827
2770
goto err;
2828
// Code below is for repairing a crashed file
2829
if ((error= lock_table_name(session, table_list, true)))
2830
{
2831
if (error < 0)
2832
goto err;
2833
if (wait_for_locked_table_names(session, table_list))
2834
{
2835
unlock_table_name(table_list);
2836
goto err;
2837
}
2838
}
2839
pthread_mutex_unlock(&LOCK_open);
2840
session->clear_error(); // Clear error message
2841
error= 0;
2842
if (open_table_from_share(session, share, alias,
2843
(uint32_t) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE |
2844
HA_GET_INDEX |
2845
HA_TRY_READ_ONLY),
2846
EXTRA_RECORD,
2847
ha_open_options | HA_OPEN_FOR_REPAIR,
2848
entry, OTM_OPEN) || ! entry->file ||
2849
(entry->file->is_crashed() && entry->file->ha_check_and_repair(session)))
2850
{
2851
/* Give right error message */
2852
session->clear_error();
2853
my_error(ER_NOT_KEYFILE, MYF(0), share->table_name.str, my_errno);
2854
errmsg_printf(ERRMSG_LVL_ERROR, _("Couldn't repair table: %s.%s"), share->db.str,
2855
share->table_name.str);
2856
if (entry->file)
2857
entry->closefrm(false);
2858
error=1;
2859
}
2860
else
2861
session->clear_error(); // Clear error message
2862
pthread_mutex_lock(&LOCK_open);
2863
unlock_table_name(table_list);
2771
// Code below is for repairing a crashed file
2772
if ((error= lock_table_name(session, table_list, true)))
2773
{
2774
if (error < 0)
2775
goto err;
2776
if (wait_for_locked_table_names(session, table_list))
2777
{
2778
unlock_table_name(table_list);
2779
goto err;
2780
}
2781
}
2782
pthread_mutex_unlock(&LOCK_open);
2783
session->clear_error(); // Clear error message
2784
error= 0;
2785
if (open_table_from_share(session, share, alias,
2786
(uint32_t) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE |
2787
HA_GET_INDEX |
2788
HA_TRY_READ_ONLY),
2789
EXTRA_RECORD,
2790
ha_open_options | HA_OPEN_FOR_REPAIR,
2791
entry, OTM_OPEN) || ! entry->file ||
2792
(entry->file->is_crashed() && entry->file->ha_check_and_repair(session)))
2793
{
2794
/* Give right error message */
2795
session->clear_error();
2796
my_error(ER_NOT_KEYFILE, MYF(0), share->table_name.str, my_errno);
2797
errmsg_printf(ERRMSG_LVL_ERROR, _("Couldn't repair table: %s.%s"), share->db.str,
2798
share->table_name.str);
2799
if (entry->file)
2800
entry->closefrm(false);
2801
error=1;
2802
}
2803
else
2804
session->clear_error(); // Clear error message
2805
pthread_mutex_lock(&LOCK_open);
2806
unlock_table_name(table_list);
2864
2807
2865
if (error)
2866
goto err;
2867
break;
2868
}
2808
if (error)
2809
goto err;
2810
break;
2811
}
2869
2812
2870
2813
/*
2871
2814
If we are here, there was no fatal error (but error may be still
2909
2852
return(1);
2910
2853
}
2911
2854
2912
2913
2855
/*
2914
2856
Open all tables in list
2915
2857
2937
2879
0 - OK
2938
2880
-1 - error
2939
2881
*/
2940
2941
2882
int open_tables(Session *session, TableList **start, uint32_t *counter, uint32_t flags)
2942
2883
{
2943
2884
TableList *tables= NULL;
2954
2895
init_sql_alloc(&new_frm_mem, 8024, 8024);
2955
2896
2956
2897
session->current_tablenr= 0;
2957
restart:
2898
restart:
2958
2899
*counter= 0;
2959
2900
session->set_proc_info("Opening tables");
2960
2901
3018
2959
currently.
3019
2960
*/
3020
2961
close_tables_for_reopen(session, start);
3021
goto restart;
2962
goto restart;
3022
2963
}
3023
2964
3024
2965
if (safe_to_ignore_table)
3050
2991
return(result);
3051
2992
}
3052
2993
3053
3054
2994
/*
3055
2995
Check that lock is ok for tables; Call start stmt if ok
3056
2996
3064
3004
0 ok
3065
3005
1 error
3066
3006
*/
3067
3068
static bool check_lock_and_start_stmt(Session *session, Table *table,
3069
thr_lock_type lock_type)
3007
static bool check_lock_and_start_stmt(Session *session, Table *table, thr_lock_type lock_type)
3070
3008
{
3071
3009
int error;
3072
3010
3084
3022
return(0);
3085
3023
}
3086
3024
3087
3088
3025
/**
3089
3026
@brief Open and lock one table
3090
3027
3114
3051
neither call decide_logging_format() nor handle some other logging
3115
3052
and locking issues because it does not call lock_tables().
3116
3053
*/
3117
3118
Table *open_n_lock_single_table(Session *session, TableList *table_l,
3054
Table *open_n_lock_single_table(Session *session,
3055
TableList *table_l,
3119
3056
thr_lock_type lock_type)
3120
3057
{
3121
3058
TableList *save_next_global;
3138
3075
return table_l->table;
3139
3076
}
3140
3077
3141
3142
3078
/*
3143
3079
Open and lock one table
3144
3080
3162
3098
table_list->lock_type lock_type
3163
3099
table_list->table table
3164
3100
*/
3165
3166
Table *open_ltable(Session *session, TableList *table_list, thr_lock_type lock_type,
3101
Table *open_ltable(Session *session,
3102
TableList *table_list,
3103
thr_lock_type lock_type,
3167
3104
uint32_t lock_flags)
3168
3105
{
3169
3106
Table *table;
3173
3110
session->current_tablenr= 0;
3174
3111
while (!(table= open_table(session, table_list, &refresh, 0)) &&
3175
3112
refresh)
3176
;
3113
{}
3177
3114
3178
3115
if (table)
3179
3116
{
3182
3119
if (session->locked_tables)
3183
3120
{
3184
3121
if (check_lock_and_start_stmt(session, table, lock_type))
3185
table= 0;
3122
table= 0;
3186
3123
}
3187
3124
else
3188
3125
{
3189
3126
assert(session->lock == 0); // You must lock everything at once
3190
3127
if ((table->reginfo.lock_type= lock_type) != TL_UNLOCK)
3191
if (! (session->lock= mysql_lock_tables(session, &table_list->table, 1,
3192
lock_flags, &refresh)))
3193
table= 0;
3128
if (! (session->lock= mysql_lock_tables(session, &table_list->table, 1, lock_flags, &refresh)))
3129
table= 0;
3194
3130
}
3195
3131
}
3196
3132
3198
3134
return(table);
3199
3135
}
3200
3136
3201
3202
3137
/*
3203
3138
Open all tables in list, locks them and optionally process derived tables.
3204
3139
3222
3157
Both inline functions call open_and_lock_tables_derived() with
3223
3158
the third argument set appropriately.
3224
3159
*/
3225
3226
3160
int open_and_lock_tables_derived(Session *session, TableList *tables, bool derived)
3227
3161
{
3228
3162
uint32_t counter;
3247
3181
return(0);
3248
3182
}
3249
3183
3250
3251
3184
/*
3252
3185
Open all tables in list and process derived tables
3253
3186
3267
3200
This is to be used on prepare stage when you don't read any
3268
3201
data from the tables.
3269
3202
*/
3270
3271
3203
bool open_normal_and_derived_tables(Session *session, TableList *tables, uint32_t flags)
3272
3204
{
3273
3205
uint32_t counter;
3305
3237
0 ok
3306
3238
-1 Error
3307
3239
*/
3308
3309
3240
int lock_tables(Session *session, TableList *tables, uint32_t count, bool *need_reopen)
3310
3241
{
3311
3242
TableList *table;
3330
3261
for (table= tables; table; table= table->next_global)
3331
3262
{
3332
3263
if (!table->placeholder())
3333
*(ptr++)= table->table;
3264
*(ptr++)= table->table;
3334
3265
}
3335
3266
3336
3267
if (!(session->lock= mysql_lock_tables(session, start, (uint32_t) (ptr - start),
3355
3286
table= table->next_global)
3356
3287
{
3357
3288
if (!table->placeholder() &&
3358
check_lock_and_start_stmt(session, table->table, table->lock_type))
3289
check_lock_and_start_stmt(session, table->table, table->lock_type))
3359
3290
{
3360
return(-1);
3291
return(-1);
3361
3292
}
3362
3293
}
3363
3294
}
3365
3296
return 0;
3366
3297
}
3367
3298
3368
3369
3299
/*
3370
3300
Prepare statement for reopening of tables and recalculation of set of
3371
3301
prelocked tables.
3376
3306
tables in/out List of tables which we were trying to open and lock
3377
3307
3378
3308
*/
3379
3380
3309
void close_tables_for_reopen(Session *session, TableList **tables)
3381
3310
{
3382
3311
/*
3391
3320
close_thread_tables(session);
3392
3321
}
3393
3322
3394
3395
3323
/*
3396
3324
Open a single table without table caching and don't set it in open_list
3397
3325
3411
3339
0 Error
3412
3340
# Table object
3413
3341
*/
3414
3415
Table *open_temporary_table(Session *session, const char *path, const char *db,
3416
const char *table_name, bool link_in_list,
3342
Table *open_temporary_table(Session *session,
3343
const char *path,
3344
const char *db,
3345
const char *table_name,
3346
bool link_in_list,
3417
3347
open_table_mode open_mode)
3418
3348
{
3419
3349
Table *tmp_table;
3482
3412
return(tmp_table);
3483
3413
}
3484
3414
3485
3486
3415
bool rm_temporary_table(StorageEngine *base, char *path)
3487
3416
{
3488
3417
bool error=0;
3502
3431
return(error);
3503
3432
}
3504
3433
3505
3506
3434
/*****************************************************************************
3507
3435
* The following find_field_in_XXX procedures implement the core of the
3508
3436
* name resolution functionality. The entry point to resolve a column name in a
3558
3486
return;
3559
3487
}
3560
3488
3561
3562
3489
/*
3563
3490
Find field by name in a NATURAL/USING join table reference.
3564
3491
3587
3514
WRONG_GRANT if no access rights to the found field
3588
3515
# Pointer to the found Field
3589
3516
*/
3590
3591
static Field *
3592
find_field_in_natural_join(Session *session, TableList *table_ref,
3593
const char *name, uint32_t , Item **,
3594
bool, TableList **actual_table)
3517
static Field *find_field_in_natural_join(Session *session,
3518
TableList *table_ref,
3519
const char *name,
3520
uint32_t ,
3521
Item **,
3522
bool,
3523
TableList **actual_table)
3595
3524
{
3596
List_iterator_fast<Natural_join_column>
3597
field_it(*(table_ref->join_columns));
3525
List_iterator_fast<Natural_join_column> field_it(*(table_ref->join_columns));
3598
3526
Natural_join_column *nj_col, *curr_nj_col;
3599
3527
Field *found_field;
3600
3528
3628
3556
return(found_field);
3629
3557
}
3630
3558
3631
3632
3559
/*
3633
3560
Find field by name in a base table or a view with temp table algorithm.
3634
3561
3646
3573
0 field is not found
3647
3574
# pointer to field
3648
3575
*/
3649
3650
Field *
3651
find_field_in_table(Session *session, Table *table, const char *name, uint32_t length,
3652
bool allow_rowid, uint32_t *cached_field_index_ptr)
3576
Field *find_field_in_table(Session *session,
3577
Table *table,
3578
const char *name,
3579
uint32_t length,
3580
bool allow_rowid,
3581
uint32_t *cached_field_index_ptr)
3653
3582
{
3654
3583
Field **field_ptr, *field;
3655
3584
uint32_t cached_field_index= *cached_field_index_ptr;
3700
3629
return(field);
3701
3630
}
3702
3631
3703
3704
3632
/*
3705
3633
Find field in a table reference.
3706
3634
3742
3670
view_ref_found found value in VIEW (real result is in *ref)
3743
3671
# pointer to field
3744
3672
*/
3745
3746
Field *
3747
find_field_in_table_ref(Session *session, TableList *table_list,
3748
const char *name, uint32_t length,
3749
const char *item_name, const char *db_name,
3750
const char *table_name, Item **ref,
3751
bool check_privileges, bool allow_rowid,
3752
uint32_t *cached_field_index_ptr,
3753
bool register_tree_change, TableList **actual_table)
3673
Field *find_field_in_table_ref(Session *session,
3674
TableList *table_list,
3675
const char *name,
3676
uint32_t length,
3677
const char *item_name,
3678
const char *db_name,
3679
const char *table_name,
3680
Item **ref,
3681
bool check_privileges,
3682
bool allow_rowid,
3683
uint32_t *cached_field_index_ptr,
3684
bool register_tree_change,
3685
TableList **actual_table)
3754
3686
{
3755
3687
Field *fld= NULL;
3756
3688
3869
3801
return(fld);
3870
3802
}
3871
3803
3872
3873
3804
/*
3874
3805
Find field in table, no side effects, only purpose is to check for field
3875
3806
in table object and get reference to the field if found.
3884
3815
0 field is not found
3885
3816
# pointer to field
3886
3817
*/
3887
3888
3818
Field *find_field_in_table_sef(Table *table, const char *name)
3889
3819
{
3890
3820
Field **field_ptr;
3915
3845
return (Field *)0;
3916
3846
}
3917
3847
3918
3919
3848
/*
3920
3849
Find field in table list.
3921
3850
3949
3878
view_ref_found View field is found, item passed through ref parameter
3950
3879
found field If a item was resolved to some field
3951
3880
*/
3952
3953
Field *
3954
find_field_in_tables(Session *session, Item_ident *item,
3955
TableList *first_table, TableList *last_table,
3956
Item **ref, find_item_error_report_type report_error,
3957
bool check_privileges, bool register_tree_change)
3881
Field *find_field_in_tables(Session *session,
3882
Item_ident *item,
3883
TableList *first_table,
3884
TableList *last_table,
3885
Item **ref,
3886
find_item_error_report_type report_error,
3887
bool check_privileges,
3888
bool register_tree_change)
3958
3889
{
3959
3890
Field *found=0;
3960
3891
const char *db= item->db_name;
4003
3934
if (found)
4004
3935
{
4005
3936
if (found == WRONG_GRANT)
4006
return (Field*) 0;
3937
return (Field*) 0;
4007
3938
4008
3939
/*
4009
3940
Only views fields should be marked as dependent, not an underlying
4068
3999
&actual_table);
4069
4000
if (cur_field)
4070
4001
{
4071
Field *nf=new Field_null(NULL,0,Field::NONE,
4002
Field *nf= new Field_null(NULL,0,Field::NONE,
4072
4003
cur_field->field_name,
4073
4004
&my_charset_bin);
4074
4005
nf->init(cur_table->table);
4141
4072
return found;
4142
4073
}
4143
4074
4144
4145
4075
/*
4146
4076
Find Item in list of items (find_field_in_tables analog)
4147
4077
4178
4108
/* Special Item pointer to serve as a return value from find_item_in_list(). */
4179
4109
Item **not_found_item= (Item**) 0x1;
4180
4110
4181
4182
Item **
4183
find_item_in_list(Item *find, List<Item> &items, uint32_t *counter,
4184
find_item_error_report_type report_error,
4185
enum_resolution_type *resolution)
4111
Item **find_item_in_list(Item *find,
4112
List<Item> &items,
4113
uint32_t *counter,
4114
find_item_error_report_type report_error,
4115
enum_resolution_type *resolution)
4186
4116
{
4187
4117
List_iterator<Item> li(items);
4188
4118
Item **found=0, **found_unaliased= 0, *item;
4215
4145
Item_ident *item_field= (Item_ident*) item;
4216
4146
4217
4147
/*
4218
In case of group_concat() with ORDER BY condition in the QUERY
4219
item_field can be field of temporary table without item name
4220
(if this field created from expression argument of group_concat()),
4221
=> we have to check presence of name before compare
4148
In case of group_concat() with ORDER BY condition in the QUERY
4149
item_field can be field of temporary table without item name
4150
(if this field created from expression argument of group_concat()),
4151
=> we have to check presence of name before compare
4222
4152
*/
4223
4153
if (!item_field->name)
4224
4154
continue;
4238
4168
case sensitive. In cases where they are not case sensitive, they
4239
4169
are always in lower case.
4240
4170
4241
item_field->field_name and item_field->table_name can be 0x0 if
4242
item is not fix_field()'ed yet.
4171
item_field->field_name and item_field->table_name can be 0x0 if
4172
item is not fix_field()'ed yet.
4243
4173
*/
4244
4174
if (item_field->field_name && item_field->table_name &&
4245
!my_strcasecmp(system_charset_info, item_field->field_name,
4246
field_name) &&
4247
!my_strcasecmp(table_alias_charset, item_field->table_name,
4248
table_name) &&
4175
!my_strcasecmp(system_charset_info, item_field->field_name, field_name) &&
4176
!my_strcasecmp(table_alias_charset, item_field->table_name, table_name) &&
4249
4177
(!db_name || (item_field->db_name &&
4250
4178
!strcmp(item_field->db_name, db_name))))
4251
4179
{
4259
4187
unaliased names only and will have duplicate error anyway.
4260
4188
*/
4261
4189
if (report_error != IGNORE_ERRORS)
4262
my_error(ER_NON_UNIQ_ERROR, MYF(0),
4263
find->full_name(), current_session->where);
4190
my_error(ER_NON_UNIQ_ERROR, MYF(0), find->full_name(), current_session->where);
4264
4191
return (Item**) 0;
4265
4192
}
4266
4193
found_unaliased= li.ref();
4321
4248
else if (!table_name)
4322
4249
{
4323
4250
if (is_ref_by_name && find->name && item->name &&
4324
!my_strcasecmp(system_charset_info,item->name,find->name))
4251
!my_strcasecmp(system_charset_info,item->name,find->name))
4325
4252
{
4326
4253
found= li.ref();
4327
4254
*counter= i;
4366
4293
return (Item **) not_found_item;
4367
4294
}
4368
4295
4369
4370
4296
/*
4371
4297
Test if a string is a member of a list of strings.
4372
4298
4383
4309
true if find is in str_list
4384
4310
false otherwise
4385
4311
*/
4386
4387
static bool
4388
test_if_string_in_list(const char *find, List<String> *str_list)
4312
static bool test_if_string_in_list(const char *find, List<String> *str_list)
4389
4313
{
4390
4314
List_iterator<String> str_list_it(*str_list);
4391
4315
String *curr_str;
4400
4324
return false;
4401
4325
}
4402
4326
4403
4404
4327
/*
4405
4328
Create a new name resolution context for an item so that it is
4406
4329
being resolved in a specific table reference.
4419
4342
false if all OK
4420
4343
true otherwise
4421
4344
*/
4422
4423
static bool
4424
set_new_item_local_context(Session *session, Item_ident *item, TableList *table_ref)
4345
static bool set_new_item_local_context(Session *session, Item_ident *item, TableList *table_ref)
4425
4346
{
4426
4347
Name_resolution_context *context;
4427
4348
if (!(context= new (session->mem_root) Name_resolution_context))
4433
4354
return false;
4434
4355
}
4435
4356
4436
4437
4357
/*
4438
4358
Find and mark the common columns of two table references.
4439
4359
4464
4384
true error when some common column is non-unique, or out of memory
4465
4385
false OK
4466
4386
*/
4467
4468
static bool
4469
mark_common_columns(Session *session, TableList *table_ref_1, TableList *table_ref_2,
4470
List<String> *using_fields, uint32_t *found_using_fields)
4387
static bool mark_common_columns(Session *session,
4388
TableList *table_ref_1,
4389
TableList *table_ref_2,
4390
List<String> *using_fields,
4391
uint32_t *found_using_fields)
4471
4392
{
4472
4393
Field_iterator_table_ref it_1, it_2;
4473
4394
Natural_join_column *nj_col_1, *nj_col_2;
4642
4563
return(result);
4643
4564
}
4644
4565
4645
4646
4647
4566
/*
4648
4567
Materialize and store the row type of NATURAL/USING join.
4649
4568
4678
4597
true error: Some common column is ambiguous
4679
4598
false OK
4680
4599
*/
4681
4682
static bool
4683
store_natural_using_join_columns(Session *,
4684
TableList *natural_using_join,
4685
TableList *table_ref_1,
4686
TableList *table_ref_2,
4687
List<String> *using_fields,
4688
uint32_t found_using_fields)
4600
static bool store_natural_using_join_columns(Session *,
4601
TableList *natural_using_join,
4602
TableList *table_ref_1,
4603
TableList *table_ref_2,
4604
List<String> *using_fields,
4605
uint32_t found_using_fields)
4689
4606
{
4690
4607
Field_iterator_table_ref it_1, it_2;
4691
4608
Natural_join_column *nj_col_1, *nj_col_2;
4767
4684
return(result);
4768
4685
}
4769
4686
4770
4771
4687
/*
4772
4688
Precompute and store the row types of the top-most NATURAL/USING joins.
4773
4689
4797
4713
true Error
4798
4714
false OK
4799
4715
*/
4800
4801
static bool
4802
store_top_level_join_columns(Session *session, TableList *table_ref,
4803
TableList *left_neighbor,
4804
TableList *right_neighbor)
4716
static bool store_top_level_join_columns(Session *session,
4717
TableList *table_ref,
4718
TableList *left_neighbor,
4719
TableList *right_neighbor)
4805
4720
{
4806
4721
bool result= true;
4807
4722
4930
4845
return(result);
4931
4846
}
4932
4847
4933
4934
4848
/*
4935
4849
Compute and store the row types of the top-most NATURAL/USING joins
4936
4850
in a FROM clause.
5005
4919
** Expand all '*' in given fields
5006
4920
****************************************************************************/
5007
4921
5008
int setup_wild(Session *session, List<Item> &fields,
4922
int setup_wild(Session *session,
4923
List<Item> &fields,
5009
4924
List<Item> *sum_func_list,
5010
4925
uint32_t wild_num)
5011
4926
{
5020
4935
{
5021
4936
if (item->type() == Item::FIELD_ITEM &&
5022
4937
((Item_field*) item)->field_name &&
5023
((Item_field*) item)->field_name[0] == '*' &&
5024
!((Item_field*) item)->field)
4938
((Item_field*) item)->field_name[0] == '*' &&
4939
!((Item_field*) item)->field)
5025
4940
{
5026
4941
uint32_t elem= fields.elements;
5027
4942
bool any_privileges= ((Item_field *) item)->any_privileges;
5042
4957
((Item_field*) item)->table_name, &it,
5043
4958
any_privileges))
5044
4959
{
5045
return(-1);
4960
return(-1);
5046
4961
}
5047
4962
if (sum_func_list)
5048
4963
{
5049
/*
5050
sum_func_list is a list that has the fields list as a tail.
5051
Because of this we have to update the element count also for this
5052
list after expanding the '*' entry.
5053
*/
5054
sum_func_list->elements+= fields.elements - elem;
4964
/*
4965
sum_func_list is a list that has the fields list as a tail.
4966
Because of this we have to update the element count also for this
4967
list after expanding the '*' entry.
4968
*/
4969
sum_func_list->elements+= fields.elements - elem;
5055
4970
}
5056
4971
wild_num--;
5057
4972
}
5066
4981
** Check that all given fields exists and fill struct with current data
5067
4982
****************************************************************************/
5068
4983
5069
bool setup_fields(Session *session, Item **ref_pointer_array,
5070
List<Item> &fields, enum_mark_columns mark_used_columns,
5071
List<Item> *sum_func_list, bool allow_sum_func)
4984
bool setup_fields(Session *session,
4985
Item **ref_pointer_array,
4986
List<Item> &fields,
4987
enum_mark_columns mark_used_columns,
4988
List<Item> *sum_func_list,
4989
bool allow_sum_func)
5072
4990
{
5073
4991
register Item *item;
5074
4992
enum_mark_columns save_mark_used_columns= session->mark_used_columns;
5124
5042
return(test(session->is_error()));
5125
5043
}
5126
5044
5127
5128
5045
/*
5129
5046
make list of leaves of join table tree
5130
5047
5135
5052
5136
5053
RETURN pointer on pointer to next_leaf of last element
5137
5054
*/
5138
5139
5055
TableList **make_leaves_list(TableList **list, TableList *tables)
5140
5056
{
5141
5057
for (TableList *table= tables; table; table= table->next_local)
5175
5091
false ok; In this case *map will includes the chosen index
5176
5092
true error
5177
5093
*/
5178
5179
bool setup_tables(Session *session, Name_resolution_context *context,
5180
List<TableList> *from_clause, TableList *tables,
5181
TableList **leaves, bool select_insert)
5094
bool setup_tables(Session *session,
5095
Name_resolution_context *context,
5096
List<TableList> *from_clause,
5097
TableList *tables,
5098
TableList **leaves,
5099
bool select_insert)
5182
5100
{
5183
5101
uint32_t tablenr= 0;
5184
5102
5224
5142
return(0);
5225
5143
}
5226
5144
5227
5228
5145
/*
5229
5146
prepare tables and check access for the view tables
5230
5147
5272
5189
return false;
5273
5190
}
5274
5191
5275
5276
5192
/*
5277
5193
Create a key_map from a list of index names
5278
5194
5286
5202
0 ok; In this case *map will includes the choosed index
5287
5203
1 error
5288
5204
*/
5289
5290
bool get_key_map_from_key_list(key_map *map, Table *table,
5291
List<String> *index_list)
5205
bool get_key_map_from_key_list(key_map *map, Table *table, List<String> *index_list)
5292
5206
{
5293
5207
List_iterator_fast<String> it(*index_list);
5294
5208
String *name;
5312
5226
return 0;
5313
5227
}
5314
5228
5315
5316
5229
/*
5317
5230
Drops in all fields instead of current '*' field
5318
5231
5330
5243
0 ok 'it' is updated to point at last inserted
5331
5244
1 error. Error message is generated but not sent to client
5332
5245
*/
5333
5334
bool
5335
insert_fields(Session *session, Name_resolution_context *context, const char *db_name,
5336
const char *table_name, List_iterator<Item> *it,
5337
bool )
5246
bool insert_fields(Session *session,
5247
Name_resolution_context *context,
5248
const char *db_name,
5249
const char *table_name,
5250
List_iterator<Item> *it,
5251
bool)
5338
5252
{
5339
5253
Field_iterator_table_ref field_iterator;
5340
5254
bool found;
5464
5378
return(true);
5465
5379
}
5466
5380
5467
5468
5381
/*
5469
5382
Fix all conditions and outer join expressions.
5470
5383
5482
5395
true if some error occured (e.g. out of memory)
5483
5396
false if all is OK
5484
5397
*/
5485
5486
5398
int setup_conds(Session *session, TableList *leaves, COND **conds)
5487
5399
{
5488
5400
Select_Lex *select_lex= session->lex->current_select;
5531
5443
session->session_marker= (void*)embedded;
5532
5444
session->where="on clause";
5533
5445
if ((!embedded->on_expr->fixed && embedded->on_expr->fix_fields(session, &embedded->on_expr)) ||
5534
embedded->on_expr->check_cols(1))
5535
goto err_no_arena;
5446
embedded->on_expr->check_cols(1))
5447
goto err_no_arena;
5536
5448
select_lex->cond_count++;
5537
5449
}
5538
5450
embedding= embedded->embedding;
5551
5463
return(1);
5552
5464
}
5553
5465
5554
5555
5466
/******************************************************************************
5556
5467
** Fill a record with data (for INSERT or UPDATE)
5557
5468
** Returns : 1 if some field has wrong type
5558
5469
******************************************************************************/
5559
5470
5560
5561
5471
/*
5562
5472
Fill fields with given items.
5563
5473
5577
5487
false OK
5578
5488
true error occured
5579
5489
*/
5580
5581
bool
5582
fill_record(Session * session, List<Item> &fields, List<Item> &values, bool ignore_errors)
5490
bool fill_record(Session * session, List<Item> &fields, List<Item> &values, bool ignore_errors)
5583
5491
{
5584
5492
List_iterator_fast<Item> f(fields),v(values);
5585
5493
Item *value, *fld;
5653
5561
return(true);
5654
5562
}
5655
5563
5656
5657
5564
/*
5658
5565
Fill field buffer with values from Field list
5659
5566
5673
5580
false OK
5674
5581
true error occured
5675
5582
*/
5676
5677
bool
5678
fill_record(Session *session, Field **ptr, List<Item> &values,
5679
bool )
5583
bool fill_record(Session *session, Field **ptr, List<Item> &values, bool)
5680
5584
{
5681
5585
List_iterator_fast<Item> v(values);
5682
5586
Item *value;
5737
5641
return(true);
5738
5642
}
5739
5643
5740
5741
5644
bool drizzle_rm_tmp_tables(void)
5742
5645
{
5743
5646
uint32_t idx;
5807
5710
return false;
5808
5711
}
5809
5712
5810
5811
5812
5713
/*****************************************************************************
5813
5714
unireg support functions
5814
5715
*****************************************************************************/
5825
5726
We can't use hash_delete when looping hash_elements. We mark them first
5826
5727
and afterwards delete those marked unused.
5827
5728
*/
5828
5829
5729
void remove_db_from_cache(const char *db)
5830
5730
{
5831
5731
for (uint32_t idx=0 ; idx < open_cache.records ; idx++)
5835
5735
{
5836
5736
table->s->version= 0L; /* Free when thread is ready */
5837
5737
if (!table->in_use)
5838
relink_unused(table);
5738
relink_unused(table);
5839
5739
}
5840
5740
}
5841
5741
while (unused_tables && !unused_tables->s->version)
5842
5742
hash_delete(&open_cache,(unsigned char*) unused_tables);
5843
5743
}
5844
5744
5845
5846
5745
/*
5847
5746
free all unused tables
5848
5747
5850
5749
This is called by 'handle_manager' when one wants to periodicly flush
5851
5750
all not used tables.
5852
5751
*/
5853
5854
5752
void flush_tables()
5855
5753
{
5856
5754
(void) pthread_mutex_lock(&LOCK_open);
5859
5757
(void) pthread_mutex_unlock(&LOCK_open);
5860
5758
}
5861
5759
5862
5863
5760
/*
5864
5761
Mark all entries with the table as deleted to force an reopen of the table
5865
5762
5874
5771
can access the table until close_thread_tables() is called.
5875
5772
1 Table is in use by another thread
5876
5773
*/
5877
5878
bool remove_table_from_cache(Session *session, const char *db, const char *table_name,
5774
bool remove_table_from_cache(Session *session,
5775
const char *db,
5776
const char *table_name,
5879
5777
uint32_t flags)
5880
5778
{
5881
5779
char key[MAX_DBKEY_LENGTH];
5920
5818
result=1;
5921
5819
}
5922
5820
/*
5923
Now we must abort all tables locks used by this thread
5924
as the thread may be waiting to get a lock for another table.
5821
Now we must abort all tables locks used by this thread
5822
as the thread may be waiting to get a lock for another table.
5925
5823
Note that we need to hold LOCK_open while going through the
5926
5824
list. So that the other thread cannot change it. The other
5927
5825
thread must also hold LOCK_open whenever changing the
5929
5827
closed and before the parent is closed would be fatal.
5930
5828
*/
5931
5829
for (Table *session_table= in_use->open_tables;
5932
session_table ;
5933
session_table= session_table->next)
5830
session_table ;
5831
session_table= session_table->next)
5934
5832
{
5935
5833
/* Do not handle locks of MERGE children. */
5936
if (session_table->db_stat) // If table is open
5937
signalled|= mysql_lock_abort_for_thread(session, session_table);
5834
if (session_table->db_stat) // If table is open
5835
signalled|= mysql_lock_abort_for_thread(session, session_table);
5938
5836
}
5939
5837
}
5940
5838
else
5992
5890
return(result);
5993
5891
}
5994
5892
5995
5996
5893
bool is_equal(const LEX_STRING *a, const LEX_STRING *b)
5997
5894
{
5998
5895
return a->length == b->length && !strncmp(a->str, b->str, a->length);
5999
5896
}
5897
6000
5898
/**
6001
5899
@} (end of group Data_Dictionary)
6002
5900
*/
Loggerhead is a web-based interface for Breezy
Version: 2.0.1