« back to all changes in this revision
Viewing changes to drizzled/sql_base.cc
- browse files at revision 1114
- compare with another revision
- compare with revision 2187.1.1
- download diff
- download tarball
- view history from revision 1114
- Committer: Brian Aker
- Date: 2009-08-11 03:03:58 UTC
- mfrom: (1113.1.2 merge)
- Revision ID: brian@gaz-20090811030358-dn0mzaj7n94zrheg
lcov dead code removal (merge)
added
removed
drizzled/sql_base.cc
868
868
}
869
869
870
870
871
/**
872
Exclusively name-lock a table that is already write-locked by the
873
current thread.
874
875
@param session current thread context
876
@param tables table list containing one table to open.
877
878
@return false on success, true otherwise.
879
*/
880
881
bool name_lock_locked_table(Session *session, TableList *tables)
882
{
883
/* Under LOCK TABLES we must only accept write locked tables. */
884
tables->table= find_locked_table(session, tables->db, tables->table_name);
885
886
if (!tables->table)
887
my_error(ER_TABLE_NOT_LOCKED, MYF(0), tables->alias);
888
else if (tables->table->reginfo.lock_type <= TL_WRITE_DEFAULT)
889
my_error(ER_TABLE_NOT_LOCKED_FOR_WRITE, MYF(0), tables->alias);
890
else
891
{
892
/*
893
Ensures that table is opened only by this thread and that no
894
other statement will open this table.
895
*/
896
wait_while_table_is_used(session, tables->table, HA_EXTRA_FORCE_REOPEN);
897
return false;
898
}
899
900
return true;
901
}
902
903
904
871
/*
905
872
Open table which is already name-locked by this thread.
906
873
1442
1409
}
1443
1410
1444
1411
1445
Table *find_locked_table(Session *session, const char *db,const char *table_name)
1446
{
1447
char key[MAX_DBKEY_LENGTH];
1448
char *key_pos= key;
1449
uint32_t key_length;
1450
1451
key_pos= strcpy(key_pos, db) + strlen(db);
1452
key_pos= strcpy(key_pos+1, table_name) + strlen(table_name);
1453
key_length= (uint32_t)(key_pos-key)+1;
1454
1455
for (Table *table=session->open_tables; table ; table=table->next)
1456
{
1457
if (table->s->table_cache_key.length == key_length &&
1458
!memcmp(table->s->table_cache_key.str, key, key_length))
1459
return table;
1460
}
1461
return 0;
1462
}
1463
1464
1465
1412
/*
1466
1413
Reopen an table because the definition has changed.
1467
1414
1753
1700
lock on it. This will also give them a chance to close their
1754
1701
instances of this table.
1755
1702
*/
1756
mysql_lock_abort(this, ulcktbl, true);
1757
mysql_lock_remove(this, NULL, ulcktbl, true);
1703
mysql_lock_abort(this, ulcktbl);
1704
mysql_lock_remove(this, ulcktbl);
1758
1705
ulcktbl->lock_count= 0;
1759
1706
}
1760
1707
if ((ulcktbl != table) && ulcktbl->db_stat)
1910
1857
if (!strcmp(table->s->table_name.str, table_name) &&
1911
1858
!strcmp(table->s->db.str, db))
1912
1859
{
1913
mysql_lock_remove(session, NULL, table, true);
1860
mysql_lock_remove(session, table);
1914
1861
1915
1862
if (!found)
1916
1863
{
1957
1904
!strcmp(table->s->db.str, db))
1958
1905
{
1959
1906
/* If MERGE child, forward lock handling to parent. */
1960
mysql_lock_abort(session, table, true);
1907
mysql_lock_abort(session, table);
1961
1908
break;
1962
1909
}
1963
1910
}
2269
2216
Open and lock one table
2270
2217
2271
2218
SYNOPSIS
2272
open_ltable()
2219
openTableLock()
2273
2220
session Thread handler
2274
2221
table_list Table to open is first table in this list
2275
2222
lock_type Lock to use for open
2488
2435
Field *not_found_field= (Field*) 0x1;
2489
2436
Field *view_ref_found= (Field*) 0x2;
2490
2437
2491
#define WRONG_GRANT (Field*) -1
2492
2493
2438
static void update_field_dependencies(Session *session, Field *field, Table *table)
2494
2439
{
2495
2440
if (session->mark_used_columns != MARK_COLUMNS_NONE)
2551
2496
2552
2497
RETURN
2553
2498
NULL if the field was not found
2554
WRONG_GRANT if no access rights to the found field
2555
# Pointer to the found Field
2499
PTR Pointer to the found Field
2556
2500
*/
2557
2501
2558
2502
static Field *
2664
2608
2665
2609
update_field_dependencies(session, field, table);
2666
2610
2667
return(field);
2611
return field;
2668
2612
}
2669
2613
2670
2614
2682
2626
table_name [in] optional table name that qualifies the field
2683
2627
ref [in/out] if 'name' is resolved to a view field, ref
2684
2628
is set to point to the found view field
2685
check_privileges [in] check privileges
2686
2629
allow_rowid [in] do allow finding of "_rowid" field?
2687
2630
cached_field_index_ptr [in] cached position in field list (used to
2688
2631
speedup lookup for fields in prepared tables)
2715
2658
const char *name, uint32_t length,
2716
2659
const char *item_name, const char *db_name,
2717
2660
const char *table_name, Item **ref,
2718
bool check_privileges, bool allow_rowid,
2661
bool allow_rowid,
2719
2662
uint32_t *cached_field_index_ptr,
2720
2663
bool register_tree_change, TableList **actual_table)
2721
2664
{
2783
2726
{
2784
2727
if ((fld= find_field_in_table_ref(session, table, name, length, item_name,
2785
2728
db_name, table_name, ref,
2786
check_privileges, allow_rowid,
2729
allow_rowid,
2787
2730
cached_field_index_ptr,
2788
2731
register_tree_change, actual_table)))
2789
return(fld);
2732
return fld;
2790
2733
}
2791
return 0;
2734
return NULL;
2792
2735
}
2793
2736
/*
2794
2737
Non-qualified field, search directly in the result columns of the
2856
2799
- REPORT_EXCEPT_NON_UNIQUE report all other errors
2857
2800
except when non-unique fields were found
2858
2801
- REPORT_ALL_ERRORS
2859
check_privileges need to check privileges
2860
2802
register_tree_change true if ref is not a stack variable and we
2861
2803
to need register changes in item tree
2862
2804
2875
2817
find_field_in_tables(Session *session, Item_ident *item,
2876
2818
TableList *first_table, TableList *last_table,
2877
2819
Item **ref, find_item_error_report_type report_error,
2878
bool check_privileges, bool register_tree_change)
2820
bool register_tree_change)
2879
2821
{
2880
2822
Field *found=0;
2881
2823
const char *db= item->db_name;
2917
2859
true, &(item->cached_field_index));
2918
2860
else
2919
2861
found= find_field_in_table_ref(session, table_ref, name, length, item->name,
2920
NULL, NULL, ref, check_privileges,
2862
NULL, NULL, ref,
2921
2863
true, &(item->cached_field_index),
2922
2864
register_tree_change,
2923
2865
&actual_table);
2924
2866
if (found)
2925
2867
{
2926
if (found == WRONG_GRANT)
2927
return (Field*) 0;
2928
2929
2868
/*
2930
2869
Only views fields should be marked as dependent, not an underlying
2931
2870
fields.
2965
2904
{
2966
2905
Field *cur_field= find_field_in_table_ref(session, cur_table, name, length,
2967
2906
item->name, db, table_name, ref,
2968
(session->lex->sql_command ==
2969
SQLCOM_SHOW_FIELDS)
2970
? false : check_privileges,
2971
2907
allow_rowid,
2972
2908
&(item->cached_field_index),
2973
2909
register_tree_change,
2974
2910
&actual_table);
2975
2911
if (cur_field)
2976
2912
{
2977
if (cur_field == WRONG_GRANT)
2978
{
2979
if (session->lex->sql_command != SQLCOM_SHOW_FIELDS)
2980
return (Field*) 0;
2981
2982
session->clear_error();
2983
cur_field= find_field_in_table_ref(session, cur_table, name, length,
2984
item->name, db, table_name, ref,
2985
false,
2986
allow_rowid,
2987
&(item->cached_field_index),
2988
register_tree_change,
2989
&actual_table);
2990
if (cur_field)
2991
{
2992
Field *nf=new Field_null(NULL,0,Field::NONE,
2993
cur_field->field_name,
2994
&my_charset_bin);
2995
nf->init(cur_table->table);
2996
cur_field= nf;
2997
}
2998
}
2999
3000
2913
/*
3001
2914
Store the original table of the field, which may be different from
3002
2915
cur_table in the case of NATURAL/USING join.
3980
3893
session->lex->current_select->cur_pos_in_select_list++;
3981
3894
}
3982
3895
session->lex->current_select->cur_pos_in_select_list= UNDEF_POS;
3896
3983
3897
return 0;
3984
3898
}
3985
3899
4190
4104
4191
4105
4192
4106
/*
4193
Create a key_map from a list of index names
4194
4195
SYNOPSIS
4196
get_key_map_from_key_list()
4197
map key_map to fill in
4198
table Table
4199
index_list List of index names
4200
4201
RETURN
4202
0 ok; In this case *map will includes the choosed index
4203
1 error
4204
*/
4205
4206
bool get_key_map_from_key_list(key_map *map, Table *table,
4207
List<String> *index_list)
4208
{
4209
List_iterator_fast<String> it(*index_list);
4210
String *name;
4211
uint32_t pos;
4212
4213
map->reset();
4214
while ((name=it++))
4215
{
4216
if (table->s->keynames.type_names == 0 ||
4217
(pos= find_type(&table->s->keynames, name->ptr(),
4218
name->length(), 1)) <=
4219
0)
4220
{
4221
my_error(ER_KEY_DOES_NOT_EXITS, MYF(0), name->c_ptr(),
4222
table->pos_in_table_list->alias);
4223
map->set();
4224
return 1;
4225
}
4226
map->set(pos-1);
4227
}
4228
return 0;
4229
}
4230
4231
4232
/*
4233
4107
Drops in all fields instead of current '*' field
4234
4108
4235
4109
SYNOPSIS
4885
4759
}
4886
4760
4887
4761
4888
bool is_equal(const LEX_STRING *a, const LEX_STRING *b)
4889
{
4890
return a->length == b->length && !strncmp(a->str, b->str, a->length);
4891
}
4892
4762
/**
4893
4763
@} (end of group Data_Dictionary)
4894
4764
*/
Loggerhead is a web-based interface for Breezy
Version: 2.0.1