1
/* Copyright (C) 2000-2006 MySQL AB
3
This program is free software; you can redistribute it and/or modify
4
it under the terms of the GNU General Public License as published by
5
the Free Software Foundation; version 2 of the License.
7
This program is distributed in the hope that it will be useful,
8
but WITHOUT ANY WARRANTY; without even the implied warranty of
9
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10
GNU General Public License for more details.
12
You should have received a copy of the GNU General Public License
13
along with this program; if not, write to the Free Software
14
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
17
/* Structs that defines the TABLE */
19
class Item; /* Needed by ORDER */
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
4
* Copyright (C) 2008 Sun Microsystems
6
* This program is free software; you can redistribute it and/or modify
7
* it under the terms of the GNU General Public License as published by
8
* the Free Software Foundation; either version 2 of the License, or
9
* (at your option) any later version.
11
* This program is distributed in the hope that it will be useful,
12
* but WITHOUT ANY WARRANTY; without even the implied warranty of
13
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14
* GNU General Public License for more details.
16
* You should have received a copy of the GNU General Public License
17
* along with this program; if not, write to the Free Software
18
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
21
/* Structs that defines the Table */
23
#ifndef DRIZZLED_TABLE_H
24
#define DRIZZLED_TABLE_H
26
#include <storage/myisam/myisam.h>
27
#include <drizzled/order.h>
28
#include <drizzled/filesort_info.h>
29
#include <drizzled/natural_join_column.h>
30
#include <drizzled/nested_join.h>
31
#include <drizzled/field_iterator.h>
33
class Item; /* Needed by order_st */
20
34
class Item_subselect;
21
35
class st_select_lex_unit;
22
36
class st_select_lex;
24
38
class Security_context;
26
41
/*************************************************************************/
28
/* Order clause list element */
30
typedef struct st_order {
31
struct st_order *next;
32
Item **item; /* Point at item in select fields */
33
Item *item_ptr; /* Storage for initial item */
34
Item **item_copy; /* For SPs; the original item ptr */
35
int counter; /* position in SELECT list, correct
36
only if counter_used is true*/
37
bool asc; /* true if ascending */
38
bool free_me; /* true if item isn't shared */
39
bool in_field_list; /* true if in select field list */
40
bool counter_used; /* parameter was counter of columns */
41
Field *field; /* If tmp-table group */
42
char *buff; /* If tmp-table group */
43
table_map used, depend_map;
46
43
enum tmp_table_type
48
45
NO_TMP_TABLE, NON_TRANSACTIONAL_TMP_TABLE, TRANSACTIONAL_TMP_TABLE,
49
46
INTERNAL_TMP_TABLE, SYSTEM_TMP_TABLE, TMP_TABLE_FRM_FILE_ONLY
58
frm_type_enum mysql_frm_type(THD *thd, char *path, enum legacy_db_type *dbt);
49
bool mysql_frm_type(THD *thd, char *path, enum legacy_db_type *dbt);
61
52
enum release_type { RELEASE_NORMAL, RELEASE_WAIT_FOR_DROP };
63
typedef struct st_filesort_info
65
IO_CACHE *io_cache; /* If sorted through filesort */
66
uchar **sort_keys; /* Buffer for sorting keys */
67
uchar *buffpek; /* Buffer for buffpek structures */
68
uint buffpek_len; /* Max number of buffpeks in the buffer */
69
uchar *addon_buf; /* Pointer to a buffer if sorted with fields */
70
size_t addon_length; /* Length of the buffer */
71
struct st_sort_addon_field *addon_field; /* Pointer to the fields info */
72
void (*unpack)(struct st_sort_addon_field *, uchar *); /* To unpack back */
73
uchar *record_pointers; /* If sorted in memory */
74
ha_rows found_records; /* How many records in sort */
79
55
Values in this enum are used to indicate how a tables TIMESTAMP field
80
56
should be treated. It can be set to the current timestamp on insert or
217
180
LEX_STRING table_cache_key;
218
181
LEX_STRING db; /* Pointer to db */
219
182
LEX_STRING table_name; /* Table name (for open) */
220
LEX_STRING path; /* Path to .frm file (from datadir) */
183
LEX_STRING path; /* Path to .frm file (from datadir) */
221
184
LEX_STRING normalized_path; /* unpack_filename(path) */
222
185
LEX_STRING connect_string;
225
188
Set of keys in use, implemented as a Bitmap.
226
Excludes keys disabled by ALTER TABLE ... DISABLE KEYS.
189
Excludes keys disabled by ALTER Table ... DISABLE KEYS.
228
191
key_map keys_in_use;
229
192
key_map keys_for_keyread;
230
193
ha_rows min_rows, max_rows; /* create information */
231
ulong avg_row_length; /* create information */
232
ulong version, mysql_version;
233
ulong timestamp_offset; /* Set to offset+1 of record */
234
ulong reclength; /* Recordlength */
194
uint32_t avg_row_length; /* create information */
195
uint32_t block_size; /* create information */
196
uint32_t version, mysql_version;
197
uint32_t timestamp_offset; /* Set to offset+1 of record */
198
uint32_t reclength; /* Recordlength */
199
uint32_t stored_rec_length; /* Stored record length
200
(no generated-only virtual fields) */
236
202
plugin_ref db_plugin; /* storage engine plugin */
237
203
inline handlerton *db_type() const /* table_type for handler */
239
// DBUG_ASSERT(db_plugin);
205
// assert(db_plugin);
240
206
return db_plugin ? plugin_data(db_plugin, handlerton*) : NULL;
242
208
enum row_type row_type; /* How rows are stored */
243
enum ha_storage_media default_storage_media;
245
209
enum tmp_table_type tmp_table;
246
210
enum ha_choice transactional;
247
211
enum ha_choice page_checksum;
249
uint ref_count; /* How many TABLE objects uses this */
250
uint open_count; /* Number of tables in open list */
251
uint blob_ptr_size; /* 4 or 8 */
252
uint key_block_size; /* create key_block_size, if used */
253
uint null_bytes, last_null_bit_pos;
254
uint fields; /* Number of fields */
255
uint rec_buff_length; /* Size of table->record[] buffer */
256
uint keys, key_parts;
257
uint max_key_length, max_unique_length, total_key_length;
258
uint uniques; /* Number of UNIQUE index */
259
uint null_fields; /* number of null fields */
260
uint blob_fields; /* number of blob fields */
261
uint timestamp_field_offset; /* Field number for timestamp field */
262
uint varchar_fields; /* number of varchar fields */
263
uint db_create_options; /* Create options from database */
264
uint db_options_in_use; /* Options in use */
265
uint db_record_offset; /* if HA_REC_IN_SEQ */
266
uint raid_type, raid_chunks;
267
uint rowid_field_offset; /* Field_nr +1 to rowid field */
213
uint32_t ref_count; /* How many Table objects uses this */
214
uint32_t open_count; /* Number of tables in open list */
215
uint32_t blob_ptr_size; /* 4 or 8 */
216
uint32_t key_block_size; /* create key_block_size, if used */
217
uint32_t null_bytes, last_null_bit_pos;
218
uint32_t fields; /* Number of fields */
219
uint32_t stored_fields; /* Number of stored fields
220
(i.e. without generated-only ones) */
221
uint32_t rec_buff_length; /* Size of table->record[] buffer */
222
uint32_t keys, key_parts;
223
uint32_t max_key_length, max_unique_length, total_key_length;
224
uint32_t uniques; /* Number of UNIQUE index */
225
uint32_t null_fields; /* number of null fields */
226
uint32_t blob_fields; /* number of blob fields */
227
uint32_t timestamp_field_offset; /* Field number for timestamp field */
228
uint32_t varchar_fields; /* number of varchar fields */
229
uint32_t db_create_options; /* Create options from database */
230
uint32_t db_options_in_use; /* Options in use */
231
uint32_t db_record_offset; /* if HA_REC_IN_SEQ */
232
uint32_t rowid_field_offset; /* Field_nr +1 to rowid field */
268
233
/* Index of auto-updated TIMESTAMP field in field array */
270
uint next_number_index; /* autoincrement key number */
271
uint next_number_key_offset; /* autoinc keypart offset in a key */
272
uint next_number_keypart; /* autoinc keypart number in a key */
273
uint error, open_errno, errarg; /* error from open_table_def() */
274
uint column_bitmap_size;
234
uint32_t primary_key;
235
uint32_t next_number_index; /* autoincrement key number */
236
uint32_t next_number_key_offset; /* autoinc keypart offset in a key */
237
uint32_t next_number_keypart; /* autoinc keypart number in a key */
238
uint32_t error, open_errno, errarg; /* error from open_table_def() */
239
uint32_t column_bitmap_size;
240
unsigned char frm_version;
241
uint32_t vfields; /* Number of virtual fields */
276
242
bool null_field_first;
277
bool system; /* Set if system table (one record) */
278
bool crypted; /* If .frm file is crypted */
279
243
bool db_low_byte_first; /* Portable row format */
281
245
bool name_lock, replace_with_name_lock;
282
246
bool waiting_on_cond; /* Protection against free */
283
ulong table_map_id; /* for row-based replication */
247
uint32_t table_map_id; /* for row-based replication */
284
248
uint64_t table_map_version;
723
Column reference of a NATURAL/USING join. Since column references in
724
joins can be both from views and stored tables, may point to either a
725
Field (for tables), or a Field_translator (for views).
728
class Natural_join_column: public Sql_alloc
731
Field_translator *view_field; /* Column reference of merge view. */
732
Field *table_field; /* Column reference of table or temp view. */
733
TABLE_LIST *table_ref; /* Original base table/view reference. */
735
True if a common join column of two NATURAL/USING join operands. Notice
736
that when we have a hierarchy of nested NATURAL/USING joins, a column can
737
be common at some level of nesting but it may not be common at higher
738
levels of nesting. Thus this flag may change depending on at which level
739
we are looking at some column.
743
Natural_join_column(Field_translator *field_param, TABLE_LIST *tab);
744
Natural_join_column(Field *field_param, TABLE_LIST *tab);
746
Item *create_item(THD *thd);
748
const char *table_name();
749
const char *db_name();
754
Table reference in the FROM clause.
756
These table references can be of several types that correspond to
757
different SQL elements. Below we list all types of TABLE_LISTs with
758
the necessary conditions to determine when a TABLE_LIST instance
759
belongs to a certain type.
761
1) table (TABLE_LIST::view == NULL)
763
(TABLE_LIST::derived == NULL)
764
- subquery - TABLE_LIST::table is a temp table
765
(TABLE_LIST::derived != NULL)
766
- information schema table
767
(TABLE_LIST::schema_table != NULL)
768
NOTICE: for schema tables TABLE_LIST::field_translation may be != NULL
769
2) view (TABLE_LIST::view != NULL)
770
- merge (TABLE_LIST::effective_algorithm == VIEW_ALGORITHM_MERGE)
771
also (TABLE_LIST::field_translation != NULL)
772
- tmptable (TABLE_LIST::effective_algorithm == VIEW_ALGORITHM_TMPTABLE)
773
also (TABLE_LIST::field_translation == NULL)
774
3) nested table reference (TABLE_LIST::nested_join != NULL)
775
- table sequence - e.g. (t1, t2, t3)
776
TODO: how to distinguish from a JOIN?
778
TODO: how to distinguish from a table sequence?
780
(TABLE_LIST::natural_join != NULL)
782
(TABLE_LIST::join_using_fields != NULL)
790
TABLE_LIST() {} /* Remove gcc warning */
793
Prepare TABLE_LIST that consists of one table instance to use in
794
simple_open_and_lock_tables
796
inline void init_one_table(const char *db_name_arg,
797
const char *table_name_arg,
798
enum thr_lock_type lock_type_arg)
800
bzero((char*) this, sizeof(*this));
801
db= (char*) db_name_arg;
802
table_name= alias= (char*) table_name_arg;
803
lock_type= lock_type_arg;
807
List of tables local to a subquery (used by SQL_LIST). Considers
808
views as leaves (unlike 'next_leaf' below). Created at parse time
809
in st_select_lex::add_table_to_list() -> table_list.link_in_list().
811
TABLE_LIST *next_local;
812
/* link in a global list of all queries tables */
813
TABLE_LIST *next_global, **prev_global;
814
char *db, *alias, *table_name, *schema_table_name;
815
char *option; /* Used by cache index */
816
Item *on_expr; /* Used with outer join */
819
(Valid only for semi-join nests) Bitmap of tables that are within the
820
semi-join (this is different from bitmap of all nest's children because
821
tables that were pulled out of the semi-join nest remain listed as
824
table_map sj_inner_tables;
825
/* Number of IN-compared expressions */
828
The structure of ON expression presented in the member above
829
can be changed during certain optimizations. This member
830
contains a snapshot of AND-OR structure of the ON expression
831
made after permanent transformations of the parse tree, and is
832
used to restore ON clause before every reexecution of a prepared
833
statement or stored procedure.
836
COND_EQUAL *cond_equal; /* Used with outer join */
838
During parsing - left operand of NATURAL/USING join where 'this' is
839
the right operand. After parsing (this->natural_join == this) iff
840
'this' represents a NATURAL or USING join operation. Thus after
841
parsing 'this' is a NATURAL/USING join iff (natural_join != NULL).
843
TABLE_LIST *natural_join;
845
True if 'this' represents a nested join that is a NATURAL JOIN.
846
For one of the operands of 'this', the member 'natural_join' points
847
to the other operand of 'this'.
849
bool is_natural_join;
850
/* Field names in a USING clause for JOIN ... USING. */
851
List<String> *join_using_fields;
853
Explicitly store the result columns of either a NATURAL/USING join or
854
an operand of such a join.
856
List<Natural_join_column> *join_columns;
857
/* TRUE if join_columns contains all columns of this table reference. */
858
bool is_join_columns_complete;
861
List of nodes in a nested join tree, that should be considered as
862
leaves with respect to name resolution. The leaves are: views,
863
top-most nodes representing NATURAL/USING joins, subqueries, and
864
base tables. All of these TABLE_LIST instances contain a
865
materialized list of columns. The list is local to a subquery.
867
TABLE_LIST *next_name_resolution_table;
868
/* Index names in a "... JOIN ... USE/IGNORE INDEX ..." clause. */
869
List<Index_hint> *index_hints;
870
TABLE *table; /* opened table */
871
uint table_id; /* table id (from binlog) for opened table */
873
select_result for derived table to pass it from table creation to table
876
select_union *derived_result;
878
Reference from aux_tables to local list entry of main select of
879
multi-delete statement:
880
delete t1 from t2,t1 where t1.a<'B' and t2.b=t1.b;
881
here it will be reference of first occurrence of t1 to second (as you
882
can see this lists can't be merged)
884
TABLE_LIST *correspondent_table;
885
st_select_lex_unit *derived; /* SELECT_LEX_UNIT of derived table */
886
ST_SCHEMA_TABLE *schema_table; /* Information_schema table */
887
st_select_lex *schema_select_lex;
889
True when the view field translation table is used to convert
890
schema table fields for backwards compatibility with SHOW command.
892
bool schema_table_reformed;
893
TMP_TABLE_PARAM *schema_table_param;
894
/* link to select_lex where this table was used */
895
st_select_lex *select_lex;
896
Field_translator *field_translation; /* array of VIEW fields */
897
/* pointer to element after last one in translation table above */
898
Field_translator *field_translation_end;
900
List (based on next_local) of underlying tables of this view. I.e. it
901
does not include the tables of subqueries used in the view. Is set only
904
TABLE_LIST *merge_underlying_list;
907
- in case of the view it is the list of all (not only underlying
908
tables but also used in subquery ones) tables of the view.
910
List<TABLE_LIST> *view_tables;
911
/* most upper view this table belongs to */
912
TABLE_LIST *belong_to_view;
913
/* Ptr to parent MERGE table list item. See top comment in ha_myisammrg.cc */
914
TABLE_LIST *parent_l;
916
List of all base tables local to a subquery including all view
917
tables. Unlike 'next_local', this in this list views are *not*
918
leaves. Created in setup_tables() -> make_leaves_list().
920
TABLE_LIST *next_leaf;
921
/* data need by some engines in query cache*/
922
uint64_t engine_data;
923
/* call back function for asking handler about caching in query cache */
924
qc_engine_callback callback_func;
925
thr_lock_type lock_type;
926
uint outer_join; /* Which join type */
927
uint shared; /* Used in multi-upd */
929
size_t table_name_length;
930
bool straight; /* optimize with prev table */
931
bool updating; /* for replicate-do/ignore table */
932
bool force_index; /* prefer index over table scan */
933
bool ignore_leaves; /* preload only non-leaf nodes */
934
table_map dep_tables; /* tables the table depends on */
935
table_map on_expr_dep_tables; /* tables on expression depends on */
936
struct st_nested_join *nested_join; /* if the element is a nested join */
937
TABLE_LIST *embedding; /* nested join containing the table */
938
List<TABLE_LIST> *join_list;/* join list the table belongs to */
939
bool cacheable_table; /* stop PS caching */
940
/* FRMTYPE_ERROR if any type is acceptable */
941
enum frm_type_enum required_type;
942
handlerton *db_type; /* table_type for handler */
943
char timestamp_buffer[20]; /* buffer for timestamp (19+1) */
945
This TABLE_LIST object corresponds to the table to be created
946
so it is possible that it does not exist (used in CREATE TABLE
947
... SELECT implementation).
950
/* For transactional locking. */
951
int lock_timeout; /* NOWAIT or WAIT [X] */
952
bool lock_transactional; /* If transactional lock requested. */
953
bool internal_tmp_table;
954
/** TRUE if an alias for this table was specified in the SQL. */
956
/** TRUE if the table is referred to in the statement using a fully
957
qualified name (<db_name>.<table_name>).
961
uint i_s_requested_object;
962
bool has_db_lookup_value;
963
bool has_table_lookup_value;
964
uint table_open_method;
965
enum enum_schema_table_state schema_table_state;
966
void set_underlying_merge();
967
bool setup_underlying(THD *thd);
968
void cleanup_items();
970
If you change placeholder(), please check the condition in
971
check_transactional_lock() too.
975
return derived || schema_table || (create && !table->db_stat) || !table;
977
void print(THD *thd, String *str, enum_query_type query_type);
978
bool set_insert_values(MEM_ROOT *mem_root);
979
TABLE_LIST *find_underlying_table(TABLE *table);
980
TABLE_LIST *first_leaf_for_name_resolution();
981
TABLE_LIST *last_leaf_for_name_resolution();
982
bool is_leaf_for_name_resolution();
983
inline TABLE_LIST *top_table()
984
{ return belong_to_view ? belong_to_view : this; }
987
Cleanup for re-execution in a prepared statement or a stored
990
void reinit_before_use(THD *thd);
991
Item_subselect *containing_subselect();
994
Compiles the tagged hints list and fills up st_table::keys_in_use_for_query,
995
st_table::keys_in_use_for_group_by, st_table::keys_in_use_for_order_by,
996
st_table::force_index and st_table::covering_keys.
998
bool process_index_hints(TABLE *table);
1001
bool prep_where(THD *thd, Item **conds, bool no_where_clause);
1003
Cleanup for re-execution in a prepared statement or a stored
1011
Iterator over the fields of a generic table reference.
1014
class Field_iterator: public Sql_alloc
1017
Field_iterator() {} /* Remove gcc warning */
1018
virtual ~Field_iterator() {}
1019
virtual void set(TABLE_LIST *)= 0;
1020
virtual void next()= 0;
1021
virtual bool end_of_fields()= 0; /* Return 1 at end of list */
1022
virtual const char *name()= 0;
1023
virtual Item *create_item(THD *)= 0;
1024
virtual Field *field()= 0;
1029
Iterator over the fields of a base table, view with temporary
1033
class Field_iterator_table: public Field_iterator
1037
Field_iterator_table() :ptr(0) {}
1038
void set(TABLE_LIST *table) { ptr= table->table->field; }
1039
void set_table(TABLE *table) { ptr= table->field; }
1040
void next() { ptr++; }
1041
bool end_of_fields() { return *ptr == 0; }
1043
Item *create_item(THD *thd);
1044
Field *field() { return *ptr; }
1048
/* Iterator over the fields of a merge view. */
1050
class Field_iterator_view: public Field_iterator
1052
Field_translator *ptr, *array_end;
1055
Field_iterator_view() :ptr(0), array_end(0) {}
1056
void set(TABLE_LIST *table);
1057
void next() { ptr++; }
1058
bool end_of_fields() { return ptr == array_end; }
1060
Item *create_item(THD *thd);
1061
Item **item_ptr() {return &ptr->item; }
1062
Field *field() { return 0; }
1063
inline Item *item() { return ptr->item; }
1064
Field_translator *field_translator() { return ptr; }
1069
Field_iterator interface to the list of materialized fields of a
1073
class Field_iterator_natural_join: public Field_iterator
1075
List_iterator_fast<Natural_join_column> column_ref_it;
1076
Natural_join_column *cur_column_ref;
1078
Field_iterator_natural_join() :cur_column_ref(NULL) {}
1079
~Field_iterator_natural_join() {}
1080
void set(TABLE_LIST *table);
1082
bool end_of_fields() { return !cur_column_ref; }
1083
const char *name() { return cur_column_ref->name(); }
1084
Item *create_item(THD *thd) { return cur_column_ref->create_item(thd); }
1085
Field *field() { return cur_column_ref->field(); }
1086
Natural_join_column *column_ref() { return cur_column_ref; }
1091
Generic iterator over the fields of an arbitrary table reference.
1094
This class unifies the various ways of iterating over the columns
1095
of a table reference depending on the type of SQL entity it
1096
represents. If such an entity represents a nested table reference,
1097
this iterator encapsulates the iteration over the columns of the
1098
members of the table reference.
1101
The implementation assumes that all underlying NATURAL/USING table
1102
references already contain their result columns and are linked into
1103
the list TABLE_LIST::next_name_resolution_table.
1106
class Field_iterator_table_ref: public Field_iterator
1108
TABLE_LIST *table_ref, *first_leaf, *last_leaf;
1109
Field_iterator_table table_field_it;
1110
Field_iterator_view view_field_it;
1111
Field_iterator_natural_join natural_join_it;
1112
Field_iterator *field_it;
1113
void set_field_iterator();
1115
Field_iterator_table_ref() :field_it(NULL) {}
1116
void set(TABLE_LIST *table);
1118
bool end_of_fields()
1119
{ return (table_ref == last_leaf && field_it->end_of_fields()); }
1120
const char *name() { return field_it->name(); }
1121
const char *table_name();
1122
const char *db_name();
1123
Item *create_item(THD *thd) { return field_it->create_item(thd); }
1124
Field *field() { return field_it->field(); }
1125
Natural_join_column *get_or_create_column_ref(TABLE_LIST *parent_table_ref);
1126
Natural_join_column *get_natural_column_ref();
1130
typedef struct st_nested_join
1132
List<TABLE_LIST> join_list; /* list of elements in the nested join */
1133
table_map used_tables; /* bitmap of tables in the nested join */
1134
table_map not_null_tables; /* tables that rejects nulls */
1135
struct st_join_table *first_nested;/* the first nested table in the plan */
1137
Used to count tables in the nested join in 2 isolated places:
1138
1. In make_outerjoin_info().
1139
2. check_interleaving_with_nj/restore_prev_nj_state (these are called
1140
by the join optimizer.
1141
Before each use the counters are zeroed by reset_nj_counters.
1144
nested_join_map nj_map; /* Bit used to identify this nested join*/
1146
(Valid only for semi-join nests) Bitmap of tables outside the semi-join
1147
that are used within the semi-join's ON condition.
1149
table_map sj_depends_on;
1150
/* Outer non-trivially correlated tables */
1151
table_map sj_corr_tables;
1152
List<Item> sj_outer_expr_list;
1156
731
typedef struct st_changed_table_list
1158
733
struct st_changed_table_list *next;
1161
} CHANGED_TABLE_LIST;
1164
typedef struct st_open_table_list{
739
typedef struct st_open_table_list
1165
741
struct st_open_table_list *next;
1166
742
char *db,*table;
1167
uint32 in_use,locked;
1170
typedef struct st_table_field_w_type
1175
} TABLE_FIELD_W_TYPE;
1179
table_check_intact(TABLE *table, const uint table_f_count,
1180
const TABLE_FIELD_W_TYPE *table_def);
1182
static inline my_bitmap_map *tmp_use_all_columns(TABLE *table,
1185
my_bitmap_map *old= bitmap->bitmap;
1186
bitmap->bitmap= table->s->all_set.bitmap;
1191
static inline void tmp_restore_column_map(MY_BITMAP *bitmap,
1194
bitmap->bitmap= old;
1197
/* The following is only needed for debugging */
1199
static inline my_bitmap_map *dbug_tmp_use_all_columns(TABLE *table,
1203
return tmp_use_all_columns(table, bitmap);
1209
static inline void dbug_tmp_restore_column_map(MY_BITMAP *bitmap,
1213
tmp_restore_column_map(bitmap, old);
1217
size_t max_row_length(TABLE *table, const uchar *data);
743
uint32_t in_use,locked;
747
#endif /* DRIZZLED_TABLE_H */
added
removed
drizzled/table.h
