← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/server_includes.h

  • Committer: Monty Taylor
  • Date: 2008-09-16 00:00:48 UTC
  • mto: This revision was merged to the branch mainline in revision 391.
  • Revision ID: monty@inaugust.com-20080916000048-3rvrv3gv9l0ad3gs
Fixed copyright headers in drizzled/

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/server_includes.h
23
23
  @details
24
24
  Mostly this file is used in the server. But a little part of it is used in
25
25
  mysqlbinlog too (definition of SELECT_DISTINCT and others).
 
26
  The consequence is that 90% of the file is wrapped in \#ifndef DRIZZLE_CLIENT,
 
27
  except the part which must be in the server and in the client.
26
28
 
27
29
  @TODO Name this file better. "priv" could mean private, privileged, privileges.
 
30
 
 
31
  @TODO Get rid of the DRIZZLE_CLIENT and DRIZZLE_SERVER conditionals
28
32
*/
29
33
 
30
34
#ifndef DRIZZLE_SERVER_SERVER_INCLUDES_H
50
54
#include <drizzled/sql_table.h>
51
55
 
52
56
/* sql_db.cc */
53
 
int mysql_create_db(Session *session, char *db, HA_CREATE_INFO *create, bool silent);
54
 
bool mysql_alter_db(Session *session, const char *db, HA_CREATE_INFO *create);
55
 
bool mysql_rm_db(Session *session,char *db,bool if_exists, bool silent);
56
 
bool mysql_change_db(Session *session, const LEX_STRING *new_db_name,
 
57
int mysql_create_db(THD *thd, char *db, HA_CREATE_INFO *create, bool silent);
 
58
bool mysql_alter_db(THD *thd, const char *db, HA_CREATE_INFO *create);
 
59
bool mysql_rm_db(THD *thd,char *db,bool if_exists, bool silent);
 
60
bool mysql_change_db(THD *thd, const LEX_STRING *new_db_name,
57
61
                     bool force_switch);
58
 
bool mysql_opt_change_db(Session *session,
 
62
bool mysql_opt_change_db(THD *thd,
59
63
                         const LEX_STRING *new_db_name,
60
64
                         LEX_STRING *saved_db_name,
61
65
                         bool force_switch,
62
66
                         bool *cur_db_changed);
63
67
 
64
68
/* sql_repl.cc */
65
 
void write_bin_log(Session *session, bool clear_error,
 
69
void write_bin_log(THD *thd, bool clear_error,
66
70
                   char const *query, ulong query_length);
67
 
void mysql_binlog_send(Session* session, char* log_ident, my_off_t pos, uint16_t flags);
68
 
void mysql_client_binlog_statement(Session *session);
 
71
void mysql_binlog_send(THD* thd, char* log_ident, my_off_t pos, ushort flags);
 
72
void mysql_client_binlog_statement(THD *thd);
69
73
 
70
74
/* sql_rename.cc */
71
 
bool mysql_rename_tables(Session *session, TableList *table_list, bool silent);
72
 
bool do_rename(Session *session, TableList *ren_table, char *new_db,
 
75
bool mysql_rename_tables(THD *thd, TableList *table_list, bool silent);
 
76
bool do_rename(THD *thd, TableList *ren_table, char *new_db,
73
77
                      char *new_table_name, char *new_table_alias,
74
78
                      bool skip_error);
75
79
 
76
80
/* sql_parse.cc */
77
 
void mysql_parse(Session *session, const char *inBuf, uint32_t length,
 
81
void mysql_parse(THD *thd, const char *inBuf, uint length,
78
82
                 const char ** semicolon);
79
83
 
80
 
bool mysql_test_parse_for_slave(Session *session,char *inBuf,uint32_t length);
 
84
bool mysql_test_parse_for_slave(THD *thd,char *inBuf,uint length);
81
85
 
82
86
 
83
87
bool is_update_query(enum enum_sql_command command);
84
88
 
85
 
bool alloc_query(Session *session, const char *packet, uint32_t packet_length);
 
89
bool alloc_query(THD *thd, const char *packet, uint packet_length);
86
90
 
87
 
void mysql_reset_session_for_next_command(Session *session);
 
91
void mysql_reset_thd_for_next_command(THD *thd);
88
92
 
89
93
void create_select_for_variable(const char *var_name);
90
94
 
94
98
 
95
99
void init_update_queries(void);
96
100
 
97
 
bool do_command(Session *session);
98
 
 
99
 
bool dispatch_command(enum enum_server_command command, Session *session,
100
 
                      char* packet, uint32_t packet_length);
101
 
 
102
 
void log_slow_statement(Session *session);
103
 
 
104
 
bool append_file_to_dir(Session *session, const char **filename_ptr, 
 
101
bool do_command(THD *thd);
 
102
 
 
103
bool dispatch_command(enum enum_server_command command, THD *thd,
 
104
                      char* packet, uint packet_length);
 
105
 
 
106
void log_slow_statement(THD *thd);
 
107
 
 
108
bool append_file_to_dir(THD *thd, const char **filename_ptr, 
105
109
                        const char *table_name);
106
110
 
107
 
bool reload_cache(Session *session, ulong options, TableList *tables, bool *write_to_binlog);
 
111
bool reload_cache(THD *thd, ulong options, TableList *tables, bool *write_to_binlog);
108
112
 
109
113
bool check_simple_select();
110
114
 
 
115
/* @TODO <UNUSED> */
111
116
void mysql_init_select(LEX *lex);
112
117
bool mysql_new_select(LEX *lex, bool move_down);
 
118
void init_max_user_conn(void);
 
119
void free_max_user_conn(void);
 
120
pthread_handler_t handle_bootstrap(void *arg);
 
121
int mysql_execute_command(THD *thd);
 
122
bool check_dup(const char *db, const char *name, TableList *tables);
 
123
bool check_table_access(THD *thd, ulong want_access, TableList *tables,
 
124
                        bool no_errors,
 
125
                        bool any_combination_of_privileges_will_do,
 
126
                        uint number);
 
127
/*
 
128
  General routine to change field->ptr of a NULL-terminated array of Field
 
129
  objects. Useful when needed to call val_int, val_str or similar and the
 
130
  field data is not in table->record[0] but in some other structure.
 
131
  set_key_field_ptr changes all fields of an index using a key_info object.
 
132
  All methods presume that there is at least one field to change.
 
133
*/
 
134
void set_field_ptr(Field **ptr, const uchar *new_buf, const uchar *old_buf);
 
135
void set_key_field_ptr(KEY *key_info, const uchar *new_buf,
 
136
                       const uchar *old_buf);
 
137
/* </UNUSED> */
113
138
 
114
139
/* sql_base.cc */
115
140
void table_cache_free(void);
117
142
bool table_def_init(void);
118
143
void table_def_free(void);
119
144
void assign_new_table_id(TABLE_SHARE *share);
120
 
uint32_t cached_open_tables(void);
121
 
uint32_t cached_table_definitions(void);
 
145
uint cached_open_tables(void);
 
146
uint cached_table_definitions(void);
122
147
 
123
148
/* drizzled.cc */
124
149
void kill_mysql(void);
125
 
void close_connection(Session *session, uint32_t errcode, bool lock);
 
150
void close_connection(THD *thd, uint errcode, bool lock);
126
151
 
127
152
/* sql_select.cc */
128
 
Table *create_virtual_tmp_table(Session *session, List<Create_field> &field_list);
 
153
Table *create_virtual_tmp_table(THD *thd, List<Create_field> &field_list);
129
154
 
130
155
/* handler.cc */
131
 
bool mysql_xa_recover(Session *session);
 
156
bool mysql_xa_recover(THD *thd);
132
157
 
133
 
SORT_FIELD * make_unireg_sortorder(order_st *order, uint32_t *length,
 
158
SORT_FIELD * make_unireg_sortorder(order_st *order, uint *length,
134
159
                                  SORT_FIELD *sortorder);
135
 
int setup_order(Session *session, Item **ref_pointer_array, TableList *tables,
 
160
int setup_order(THD *thd, Item **ref_pointer_array, TableList *tables,
136
161
                List<Item> &fields, List <Item> &all_fields, order_st *order);
137
 
int setup_group(Session *session, Item **ref_pointer_array, TableList *tables,
 
162
int setup_group(THD *thd, Item **ref_pointer_array, TableList *tables,
138
163
                List<Item> &fields, List<Item> &all_fields, order_st *order,
139
164
                bool *hidden_group_fields);
140
 
bool fix_inner_refs(Session *session, List<Item> &all_fields, SELECT_LEX *select,
 
165
bool fix_inner_refs(THD *thd, List<Item> &all_fields, SELECT_LEX *select,
141
166
                   Item **ref_pointer_array);
142
167
 
143
 
bool handle_select(Session *session, LEX *lex, select_result *result,
 
168
bool handle_select(THD *thd, LEX *lex, select_result *result,
144
169
                   ulong setup_tables_done_option);
145
 
bool mysql_select(Session *session, Item ***rref_pointer_array,
146
 
                  TableList *tables, uint32_t wild_num,  List<Item> &list,
147
 
                  COND *conds, uint32_t og_num, order_st *order, order_st *group,
 
170
bool mysql_select(THD *thd, Item ***rref_pointer_array,
 
171
                  TableList *tables, uint wild_num,  List<Item> &list,
 
172
                  COND *conds, uint og_num, order_st *order, order_st *group,
148
173
                  Item *having, order_st *proc_param, uint64_t select_type, 
149
174
                  select_result *result, SELECT_LEX_UNIT *unit, 
150
175
                  SELECT_LEX *select_lex);
151
 
void free_underlaid_joins(Session *session, SELECT_LEX *select);
152
 
bool mysql_explain_union(Session *session, SELECT_LEX_UNIT *unit,
 
176
void free_underlaid_joins(THD *thd, SELECT_LEX *select);
 
177
bool mysql_explain_union(THD *thd, SELECT_LEX_UNIT *unit,
153
178
                         select_result *result);
154
 
int mysql_explain_select(Session *session, SELECT_LEX *sl, char const *type,
 
179
int mysql_explain_select(THD *thd, SELECT_LEX *sl, char const *type,
155
180
                         select_result *result);
156
 
bool mysql_union(Session *session, LEX *lex, select_result *result,
 
181
bool mysql_union(THD *thd, LEX *lex, select_result *result,
157
182
                 SELECT_LEX_UNIT *unit, ulong setup_tables_done_option);
158
 
bool mysql_handle_derived(LEX *lex, bool (*processor)(Session *session,
 
183
bool mysql_handle_derived(LEX *lex, bool (*processor)(THD *thd,
159
184
                                                      LEX *lex,
160
185
                                                      TableList *table));
161
 
bool mysql_derived_prepare(Session *session, LEX *lex, TableList *t);
162
 
bool mysql_derived_filling(Session *session, LEX *lex, TableList *t);
163
 
Field *create_tmp_field(Session *session, Table *table,Item *item, Item::Type type,
 
186
bool mysql_derived_prepare(THD *thd, LEX *lex, TableList *t);
 
187
bool mysql_derived_filling(THD *thd, LEX *lex, TableList *t);
 
188
Field *create_tmp_field(THD *thd, Table *table,Item *item, Item::Type type,
164
189
                        Item ***copy_func, Field **from_field,
165
190
                        Field **def_field,
166
191
                        bool group, bool modify_item,
167
192
                        bool table_cant_handle_bit_fields,
168
193
                        bool make_copy_field,
169
 
                        uint32_t convert_blob_length);
170
 
void sp_prepare_create_field(Session *session, Create_field *sql_field);
 
194
                        uint convert_blob_length);
 
195
void sp_prepare_create_field(THD *thd, Create_field *sql_field);
171
196
int prepare_create_field(Create_field *sql_field, 
172
 
                         uint32_t *blob_columns, 
 
197
                         uint *blob_columns, 
173
198
                         int *timestamps, int *timestamps_with_niladic,
174
199
                         int64_t table_flags);
175
 
bool mysql_create_table(Session *session,const char *db, const char *table_name,
 
200
bool mysql_create_table(THD *thd,const char *db, const char *table_name,
176
201
                        HA_CREATE_INFO *create_info,
177
202
                        Alter_info *alter_info,
178
 
                        bool tmp_table, uint32_t select_field_count);
179
 
bool mysql_create_table_no_lock(Session *session, const char *db,
 
203
                        bool tmp_table, uint select_field_count);
 
204
bool mysql_create_table_no_lock(THD *thd, const char *db,
180
205
                                const char *table_name,
181
206
                                HA_CREATE_INFO *create_info,
182
207
                                Alter_info *alter_info,
183
 
                                bool tmp_table, uint32_t select_field_count,
184
 
                                bool lock_open_lock);
 
208
                                bool tmp_table, uint select_field_count);
185
209
 
186
 
bool mysql_alter_table(Session *session, char *new_db, char *new_name,
 
210
bool mysql_alter_table(THD *thd, char *new_db, char *new_name,
187
211
                       HA_CREATE_INFO *create_info,
188
212
                       TableList *table_list,
189
213
                       Alter_info *alter_info,
190
 
                       uint32_t order_num, order_st *order, bool ignore);
191
 
bool mysql_recreate_table(Session *session, TableList *table_list);
192
 
bool mysql_create_like_table(Session *session, TableList *table,
 
214
                       uint order_num, order_st *order, bool ignore);
 
215
bool mysql_recreate_table(THD *thd, TableList *table_list);
 
216
bool mysql_create_like_table(THD *thd, TableList *table,
193
217
                             TableList *src_table,
194
218
                             HA_CREATE_INFO *create_info);
195
219
bool mysql_rename_table(handlerton *base, const char *old_db,
196
220
                        const char * old_name, const char *new_db,
197
 
                        const char * new_name, uint32_t flags);
198
 
bool mysql_prepare_update(Session *session, TableList *table_list,
199
 
                          Item **conds, uint32_t order_num, order_st *order);
200
 
int mysql_update(Session *session,TableList *tables,List<Item> &fields,
 
221
                        const char * new_name, uint flags);
 
222
bool mysql_prepare_update(THD *thd, TableList *table_list,
 
223
                          Item **conds, uint order_num, order_st *order);
 
224
int mysql_update(THD *thd,TableList *tables,List<Item> &fields,
201
225
                 List<Item> &values,COND *conds,
202
 
                 uint32_t order_num, order_st *order, ha_rows limit,
 
226
                 uint order_num, order_st *order, ha_rows limit,
203
227
                 enum enum_duplicates handle_duplicates, bool ignore);
204
 
bool mysql_multi_update(Session *session, TableList *table_list,
 
228
bool mysql_multi_update(THD *thd, TableList *table_list,
205
229
                        List<Item> *fields, List<Item> *values,
206
230
                        COND *conds, uint64_t options,
207
231
                        enum enum_duplicates handle_duplicates, bool ignore,
208
232
                        SELECT_LEX_UNIT *unit, SELECT_LEX *select_lex);
209
 
bool mysql_prepare_insert(Session *session, TableList *table_list, Table *table,
 
233
bool mysql_prepare_insert(THD *thd, TableList *table_list, Table *table,
210
234
                          List<Item> &fields, List_item *values,
211
235
                          List<Item> &update_fields,
212
236
                          List<Item> &update_values, enum_duplicates duplic,
213
237
                          COND **where, bool select_insert,
214
238
                          bool check_fields, bool abort_on_warning);
215
 
bool mysql_insert(Session *session,TableList *table,List<Item> &fields,
 
239
bool mysql_insert(THD *thd,TableList *table,List<Item> &fields,
216
240
                  List<List_item> &values, List<Item> &update_fields,
217
241
                  List<Item> &update_values, enum_duplicates flag,
218
242
                  bool ignore);
219
 
int check_that_all_fields_are_given_values(Session *session, Table *entry,
 
243
int check_that_all_fields_are_given_values(THD *thd, Table *entry,
220
244
                                           TableList *table_list);
221
245
void prepare_triggers_for_insert_stmt(Table *table);
222
 
int mysql_prepare_delete(Session *session, TableList *table_list, Item **conds);
223
 
bool mysql_delete(Session *session, TableList *table_list, COND *conds,
 
246
int mysql_prepare_delete(THD *thd, TableList *table_list, Item **conds);
 
247
bool mysql_delete(THD *thd, TableList *table_list, COND *conds,
224
248
                  SQL_LIST *order, ha_rows rows, uint64_t options,
225
249
                  bool reset_auto_increment);
226
 
bool mysql_truncate(Session *session, TableList *table_list, bool dont_send_ok);
227
 
uint32_t create_table_def_key(Session *session, char *key, TableList *table_list,
 
250
bool mysql_truncate(THD *thd, TableList *table_list, bool dont_send_ok);
 
251
uint create_table_def_key(THD *thd, char *key, TableList *table_list,
228
252
                          bool tmp_table);
229
 
TABLE_SHARE *get_table_share(Session *session, TableList *table_list, char *key,
230
 
                             uint32_t key_length, uint32_t db_flags, int *error);
 
253
TABLE_SHARE *get_table_share(THD *thd, TableList *table_list, char *key,
 
254
                             uint key_length, uint db_flags, int *error);
231
255
void release_table_share(TABLE_SHARE *share, enum release_type type);
232
256
TABLE_SHARE *get_cached_table_share(const char *db, const char *table_name);
233
 
Table *open_ltable(Session *session, TableList *table_list, thr_lock_type update,
234
 
                   uint32_t lock_flags);
235
 
Table *open_table(Session *session, TableList *table_list, bool *refresh, uint32_t flags);
236
 
bool name_lock_locked_table(Session *session, TableList *tables);
237
 
bool reopen_name_locked_table(Session* session, TableList* table_list, bool link_in);
238
 
Table *table_cache_insert_placeholder(Session *session, const char *key,
239
 
                                      uint32_t key_length);
240
 
bool lock_table_name_if_not_cached(Session *session, const char *db,
 
257
Table *open_ltable(THD *thd, TableList *table_list, thr_lock_type update,
 
258
                   uint lock_flags);
 
259
Table *open_table(THD *thd, TableList *table_list, bool *refresh, uint flags);
 
260
bool name_lock_locked_table(THD *thd, TableList *tables);
 
261
bool reopen_name_locked_table(THD* thd, TableList* table_list, bool link_in);
 
262
Table *table_cache_insert_placeholder(THD *thd, const char *key,
 
263
                                      uint key_length);
 
264
bool lock_table_name_if_not_cached(THD *thd, const char *db,
241
265
                                   const char *table_name, Table **table);
242
 
Table *find_locked_table(Session *session, const char *db,const char *table_name);
 
266
Table *find_locked_table(THD *thd, const char *db,const char *table_name);
243
267
void detach_merge_children(Table *table, bool clear_refs);
244
268
bool fix_merge_after_open(TableList *old_child_list, TableList **old_last,
245
269
                          TableList *new_child_list, TableList **new_last);
246
270
bool reopen_table(Table *table);
247
 
bool reopen_tables(Session *session,bool get_locks,bool in_refresh);
248
 
void close_data_files_and_morph_locks(Session *session, const char *db,
 
271
bool reopen_tables(THD *thd,bool get_locks,bool in_refresh);
 
272
void close_data_files_and_morph_locks(THD *thd, const char *db,
249
273
                                      const char *table_name);
250
274
void close_handle_and_leave_table_as_lock(Table *table);
251
 
bool open_new_frm(Session *session, TABLE_SHARE *share, const char *alias,
252
 
                  uint32_t db_stat, uint32_t prgflag,
253
 
                  uint32_t ha_open_flags, Table *outparam,
 
275
bool open_new_frm(THD *thd, TABLE_SHARE *share, const char *alias,
 
276
                  uint db_stat, uint prgflag,
 
277
                  uint ha_open_flags, Table *outparam,
254
278
                  TableList *table_desc, MEM_ROOT *mem_root);
255
 
bool wait_for_tables(Session *session);
 
279
bool wait_for_tables(THD *thd);
256
280
bool table_is_used(Table *table, bool wait_for_name_lock);
257
 
Table *drop_locked_tables(Session *session,const char *db, const char *table_name);
258
 
void abort_locked_tables(Session *session,const char *db, const char *table_name);
259
 
void execute_init_command(Session *session, sys_var_str *init_command_var,
 
281
Table *drop_locked_tables(THD *thd,const char *db, const char *table_name);
 
282
void abort_locked_tables(THD *thd,const char *db, const char *table_name);
 
283
void execute_init_command(THD *thd, sys_var_str *init_command_var,
260
284
                          rw_lock_t *var_mutex);
261
285
extern Field *not_found_field;
262
286
extern Field *view_ref_found;
265
289
                                  IGNORE_ERRORS, REPORT_EXCEPT_NON_UNIQUE,
266
290
                                  IGNORE_EXCEPT_NON_UNIQUE};
267
291
Field *
268
 
find_field_in_tables(Session *session, Item_ident *item,
 
292
find_field_in_tables(THD *thd, Item_ident *item,
269
293
                     TableList *first_table, TableList *last_table,
270
294
                     Item **ref, find_item_error_report_type report_error,
271
295
                     bool check_privileges, bool register_tree_change);
272
296
Field *
273
 
find_field_in_table_ref(Session *session, TableList *table_list,
274
 
                        const char *name, uint32_t length,
 
297
find_field_in_table_ref(THD *thd, TableList *table_list,
 
298
                        const char *name, uint length,
275
299
                        const char *item_name, const char *db_name,
276
300
                        const char *table_name, Item **ref,
277
301
                        bool check_privileges, bool allow_rowid,
278
 
                        uint32_t *cached_field_index_ptr,
 
302
                        uint *cached_field_index_ptr,
279
303
                        bool register_tree_change, TableList **actual_table);
280
304
Field *
281
 
find_field_in_table(Session *session, Table *table, const char *name, uint32_t length,
282
 
                    bool allow_rowid, uint32_t *cached_field_index_ptr);
 
305
find_field_in_table(THD *thd, Table *table, const char *name, uint length,
 
306
                    bool allow_rowid, uint *cached_field_index_ptr);
283
307
Field *
284
308
find_field_in_table_sef(Table *table, const char *name);
285
 
int update_virtual_fields_marked_for_write(Table *table,
286
 
                                           bool ignore_stored=true);
287
309
 
288
310
/* sql_do.cc */
289
 
bool mysql_do(Session *session, List<Item> &values);
 
311
bool mysql_do(THD *thd, List<Item> &values);
290
312
 
291
313
/* sql_analyse.h */
292
314
bool append_escaped(String *to_str, String *from_str);
301
323
extern LEX_STRING SLOW_LOG_NAME;
302
324
 
303
325
extern const LEX_STRING partition_keywords[];
304
 
ST_SCHEMA_TABLE *find_schema_table(Session *session, const char* table_name);
 
326
ST_SCHEMA_TABLE *find_schema_table(THD *thd, const char* table_name);
305
327
ST_SCHEMA_TABLE *get_schema_table(enum enum_schema_tables schema_table_idx);
306
 
int prepare_schema_table(Session *session, LEX *lex, Table_ident *table_ident,
 
328
int prepare_schema_table(THD *thd, LEX *lex, Table_ident *table_ident,
307
329
                         enum enum_schema_tables schema_table_idx);
308
 
int make_schema_select(Session *session,  SELECT_LEX *sel,
 
330
int make_schema_select(THD *thd,  SELECT_LEX *sel,
309
331
                       enum enum_schema_tables schema_table_idx);
310
 
int mysql_schema_table(Session *session, LEX *lex, TableList *table_list);
 
332
int mysql_schema_table(THD *thd, LEX *lex, TableList *table_list);
311
333
bool get_schema_tables_result(JOIN *join,
312
334
                              enum enum_schema_table_state executed_place);
313
335
enum enum_schema_tables get_schema_table_idx(ST_SCHEMA_TABLE *schema_table);
316
338
  !my_strcasecmp(system_charset_info, INFORMATION_SCHEMA_NAME.str, (X))
317
339
 
318
340
/* sql_handler.cc */
319
 
bool mysql_ha_open(Session *session, TableList *tables, bool reopen);
320
 
bool mysql_ha_close(Session *session, TableList *tables);
321
 
bool mysql_ha_read(Session *, TableList *,enum enum_ha_read_modes,char *,
 
341
bool mysql_ha_open(THD *thd, TableList *tables, bool reopen);
 
342
bool mysql_ha_close(THD *thd, TableList *tables);
 
343
bool mysql_ha_read(THD *, TableList *,enum enum_ha_read_modes,char *,
322
344
                   List<Item> *,enum ha_rkey_function,Item *,ha_rows,ha_rows);
323
 
void mysql_ha_flush(Session *session);
324
 
void mysql_ha_rm_tables(Session *session, TableList *tables, bool is_locked);
325
 
void mysql_ha_cleanup(Session *session);
 
345
void mysql_ha_flush(THD *thd);
 
346
void mysql_ha_rm_tables(THD *thd, TableList *tables, bool is_locked);
 
347
void mysql_ha_cleanup(THD *thd);
326
348
 
327
349
/* sql_base.cc */
328
350
#define TMP_TABLE_KEY_EXTRA 8
329
 
void set_item_name(Item *item,char *pos,uint32_t length);
330
 
bool add_field_to_list(Session *session, LEX_STRING *field_name, enum enum_field_types type,
 
351
void set_item_name(Item *item,char *pos,uint length);
 
352
bool add_field_to_list(THD *thd, LEX_STRING *field_name, enum enum_field_types type,
331
353
                       char *length, char *decimal,
332
 
                       uint32_t type_modifier,
 
354
                       uint type_modifier,
333
355
                       enum column_format_type column_format,
334
356
                       Item *default_value, Item *on_update_value,
335
357
                       LEX_STRING *comment,
336
358
                       char *change, List<String> *interval_list,
337
 
                       const CHARSET_INFO * const cs,
338
 
                       virtual_column_info *vcol_info);
339
 
Create_field * new_create_field(Session *session, char *field_name, enum_field_types type,
 
359
                       const CHARSET_INFO * const cs);
 
360
Create_field * new_create_field(THD *thd, char *field_name, enum_field_types type,
340
361
                                char *length, char *decimals,
341
 
                                uint32_t type_modifier, 
 
362
                                uint type_modifier, 
342
363
                                Item *default_value, Item *on_update_value,
343
364
                                LEX_STRING *comment, char *change, 
344
 
                                List<String> *interval_list, CHARSET_INFO *cs,
345
 
                                virtual_column_info *vcol_info);
 
365
                                List<String> *interval_list, CHARSET_INFO *cs);
346
366
void store_position_for_column(const char *name);
347
 
bool add_to_list(Session *session, SQL_LIST &list,Item *group,bool asc);
348
 
bool push_new_name_resolution_context(Session *session,
 
367
bool add_to_list(THD *thd, SQL_LIST &list,Item *group,bool asc);
 
368
bool push_new_name_resolution_context(THD *thd,
349
369
                                      TableList *left_op,
350
370
                                      TableList *right_op);
351
371
void add_join_on(TableList *b,Item *expr);
352
372
void add_join_natural(TableList *a,TableList *b,List<String> *using_fields,
353
373
                      SELECT_LEX *lex);
354
 
bool add_proc_to_list(Session *session, Item *item);
355
 
void unlink_open_table(Session *session, Table *find, bool unlock);
356
 
void drop_open_table(Session *session, Table *table, const char *db_name,
 
374
bool add_proc_to_list(THD *thd, Item *item);
 
375
void unlink_open_table(THD *thd, Table *find, bool unlock);
 
376
void drop_open_table(THD *thd, Table *table, const char *db_name,
357
377
                     const char *table_name);
358
378
void update_non_unique_table_error(TableList *update,
359
379
                                   const char *operation,
390
410
  RESOLVED_WITH_NO_ALIAS,
391
411
  RESOLVED_AGAINST_ALIAS
392
412
};
393
 
Item ** find_item_in_list(Item *item, List<Item> &items, uint32_t *counter,
 
413
Item ** find_item_in_list(Item *item, List<Item> &items, uint *counter,
394
414
                          find_item_error_report_type report_error,
395
415
                          enum_resolution_type *resolution);
396
416
bool get_key_map_from_key_list(key_map *map, Table *table,
397
417
                               List<String> *index_list);
398
 
bool insert_fields(Session *session, Name_resolution_context *context,
 
418
bool insert_fields(THD *thd, Name_resolution_context *context,
399
419
                   const char *db_name, const char *table_name,
400
420
                   List_iterator<Item> *it, bool any_privileges);
401
 
bool setup_tables(Session *session, Name_resolution_context *context,
 
421
bool setup_tables(THD *thd, Name_resolution_context *context,
402
422
                  List<TableList> *from_clause, TableList *tables,
403
423
                  TableList **leaves, bool select_insert);
404
 
bool setup_tables_and_check_access(Session *session, 
 
424
bool setup_tables_and_check_access(THD *thd, 
405
425
                                   Name_resolution_context *context,
406
426
                                   List<TableList> *from_clause, 
407
427
                                   TableList *tables, 
408
428
                                   TableList **leaves, 
409
429
                                   bool select_insert);
410
 
int setup_wild(Session *session, TableList *tables, List<Item> &fields,
411
 
               List<Item> *sum_func_list, uint32_t wild_num);
412
 
bool setup_fields(Session *session, Item** ref_pointer_array,
 
430
int setup_wild(THD *thd, TableList *tables, List<Item> &fields,
 
431
               List<Item> *sum_func_list, uint wild_num);
 
432
bool setup_fields(THD *thd, Item** ref_pointer_array,
413
433
                  List<Item> &item, enum_mark_columns mark_used_columns,
414
434
                  List<Item> *sum_func_list, bool allow_sum_func);
415
 
inline bool setup_fields_with_no_wrap(Session *session, Item **ref_pointer_array,
 
435
inline bool setup_fields_with_no_wrap(THD *thd, Item **ref_pointer_array,
416
436
                                      List<Item> &item,
417
437
                                      enum_mark_columns mark_used_columns,
418
438
                                      List<Item> *sum_func_list,
419
439
                                      bool allow_sum_func)
420
440
{
421
441
  bool res;
422
 
  res= setup_fields(session, ref_pointer_array, item, mark_used_columns, sum_func_list,
 
442
  res= setup_fields(thd, ref_pointer_array, item, mark_used_columns, sum_func_list,
423
443
                    allow_sum_func);
424
444
  return res;
425
445
}
426
 
int setup_conds(Session *session, TableList *tables, TableList *leaves,
 
446
int setup_conds(THD *thd, TableList *tables, TableList *leaves,
427
447
                COND **conds);
428
448
int setup_ftfuncs(SELECT_LEX* select);
429
 
int init_ftfuncs(Session *session, SELECT_LEX* select, bool no_order);
430
 
void wait_for_condition(Session *session, pthread_mutex_t *mutex,
 
449
int init_ftfuncs(THD *thd, SELECT_LEX* select, bool no_order);
 
450
void wait_for_condition(THD *thd, pthread_mutex_t *mutex,
431
451
                        pthread_cond_t *cond);
432
 
int open_tables(Session *session, TableList **tables, uint32_t *counter, uint32_t flags);
 
452
int open_tables(THD *thd, TableList **tables, uint *counter, uint flags);
433
453
/* open_and_lock_tables with optional derived handling */
434
 
int open_and_lock_tables_derived(Session *session, TableList *tables, bool derived);
 
454
int open_and_lock_tables_derived(THD *thd, TableList *tables, bool derived);
435
455
/* simple open_and_lock_tables without derived handling */
436
 
inline int simple_open_n_lock_tables(Session *session, TableList *tables)
 
456
inline int simple_open_n_lock_tables(THD *thd, TableList *tables)
437
457
{
438
 
  return open_and_lock_tables_derived(session, tables, false);
 
458
  return open_and_lock_tables_derived(thd, tables, false);
439
459
}
440
460
/* open_and_lock_tables with derived handling */
441
 
inline int open_and_lock_tables(Session *session, TableList *tables)
 
461
inline int open_and_lock_tables(THD *thd, TableList *tables)
442
462
{
443
 
  return open_and_lock_tables_derived(session, tables, true);
 
463
  return open_and_lock_tables_derived(thd, tables, true);
444
464
}
445
465
/* simple open_and_lock_tables without derived handling for single table */
446
 
Table *open_n_lock_single_table(Session *session, TableList *table_l,
 
466
Table *open_n_lock_single_table(THD *thd, TableList *table_l,
447
467
                                thr_lock_type lock_type);
448
 
bool open_normal_and_derived_tables(Session *session, TableList *tables, uint32_t flags);
449
 
int lock_tables(Session *session, TableList *tables, uint32_t counter, bool *need_reopen);
450
 
int decide_logging_format(Session *session, TableList *tables);
451
 
Table *open_temporary_table(Session *session, const char *path, const char *db,
 
468
bool open_normal_and_derived_tables(THD *thd, TableList *tables, uint flags);
 
469
int lock_tables(THD *thd, TableList *tables, uint counter, bool *need_reopen);
 
470
int decide_logging_format(THD *thd, TableList *tables);
 
471
Table *open_temporary_table(THD *thd, const char *path, const char *db,
452
472
                            const char *table_name, bool link_in_list,
453
473
                            open_table_mode open_mode);
454
474
bool rm_temporary_table(handlerton *base, char *path, bool frm_only);
455
475
void free_io_cache(Table *entry);
456
476
void intern_close_table(Table *entry);
457
 
bool close_thread_table(Session *session, Table **table_ptr);
458
 
void close_temporary_tables(Session *session);
459
 
void close_tables_for_reopen(Session *session, TableList **tables);
 
477
bool close_thread_table(THD *thd, Table **table_ptr);
 
478
void close_temporary_tables(THD *thd);
 
479
void close_tables_for_reopen(THD *thd, TableList **tables);
460
480
TableList *find_table_in_list(TableList *table,
461
481
                               TableList *TableList::*link,
462
482
                               const char *db_name,
463
483
                               const char *table_name);
464
 
TableList *unique_table(Session *session, TableList *table, TableList *table_list,
 
484
TableList *unique_table(THD *thd, TableList *table, TableList *table_list,
465
485
                         bool check_alias);
466
 
Table *find_temporary_table(Session *session, const char *db, const char *table_name);
467
 
Table *find_temporary_table(Session *session, TableList *table_list);
468
 
int drop_temporary_table(Session *session, TableList *table_list);
469
 
void close_temporary_table(Session *session, Table *table, bool free_share,
 
486
Table *find_temporary_table(THD *thd, const char *db, const char *table_name);
 
487
Table *find_temporary_table(THD *thd, TableList *table_list);
 
488
int drop_temporary_table(THD *thd, TableList *table_list);
 
489
void close_temporary_table(THD *thd, Table *table, bool free_share,
470
490
                           bool delete_table);
471
491
void close_temporary(Table *table, bool free_share, bool delete_table);
472
 
bool rename_temporary_table(Session* session, Table *table, const char *new_db,
 
492
bool rename_temporary_table(THD* thd, Table *table, const char *new_db,
473
493
                            const char *table_name);
474
494
void remove_db_from_cache(const char *db);
475
495
void flush_tables();
478
498
 
479
499
/* bits for last argument to remove_table_from_cache() */
480
500
#define RTFC_NO_FLAG                0x0000
481
 
#define RTFC_OWNED_BY_Session_FLAG      0x0001
 
501
#define RTFC_OWNED_BY_THD_FLAG      0x0001
482
502
#define RTFC_WAIT_OTHER_THREAD_FLAG 0x0002
483
503
#define RTFC_CHECK_KILLED_FLAG      0x0004
484
 
bool remove_table_from_cache(Session *session, const char *db, const char *table,
485
 
                             uint32_t flags);
 
504
bool remove_table_from_cache(THD *thd, const char *db, const char *table,
 
505
                             uint flags);
486
506
 
487
507
#define NORMAL_PART_NAME 0
488
508
#define TEMP_PART_NAME 1
495
515
#define WFRM_PACK_FRM 4
496
516
#define WFRM_KEEP_SHARE 8
497
517
 
498
 
bool close_cached_tables(Session *session, TableList *tables, bool have_lock,
 
518
bool close_cached_tables(THD *thd, TableList *tables, bool have_lock,
499
519
                         bool wait_for_refresh, bool wait_for_placeholders);
500
 
bool close_cached_connection_tables(Session *session, bool wait_for_refresh,
 
520
bool close_cached_connection_tables(THD *thd, bool wait_for_refresh,
501
521
                                    LEX_STRING *connect_string,
502
522
                                    bool have_lock= false);
503
523
void copy_field_from_tmp_record(Field *field,int offset);
504
 
bool fill_record(Session * session, List<Item> &fields, List<Item> &values, bool ignore_errors);
505
 
bool fill_record(Session *session, Field **field, List<Item> &values, bool ignore_errors);
506
 
OPEN_TableList *list_open_tables(Session *session, const char *db, const char *wild);
 
524
bool fill_record(THD * thd, List<Item> &fields, List<Item> &values, bool ignore_errors);
 
525
bool fill_record(THD *thd, Field **field, List<Item> &values, bool ignore_errors);
 
526
OPEN_TableList *list_open_tables(THD *thd, const char *db, const char *wild);
507
527
 
508
528
inline TableList *find_table_in_global_list(TableList *table,
509
529
                                             const char *db_name,
526
546
bool eval_const_cond(COND *cond);
527
547
 
528
548
/* sql_load.cc */
529
 
int mysql_load(Session *session, sql_exchange *ex, TableList *table_list,
 
549
int mysql_load(THD *thd, sql_exchange *ex, TableList *table_list,
530
550
                List<Item> &fields_vars, List<Item> &set_fields,
531
551
                List<Item> &set_values_list,
532
552
                enum enum_duplicates handle_duplicates, bool ignore,
533
553
                bool local_file);
534
 
int write_record(Session *session, Table *table, COPY_INFO *info);
 
554
int write_record(THD *thd, Table *table, COPY_INFO *info);
535
555
 
536
556
 
537
557
/* sql_test.cc */
538
558
void print_where(COND *cond,const char *info, enum_query_type query_type);
539
559
void print_cached_tables(void);
540
 
void TEST_filesort(SORT_FIELD *sortorder,uint32_t s_length);
541
 
void print_plan(JOIN* join,uint32_t idx, double record_count, double read_time,
 
560
void TEST_filesort(SORT_FIELD *sortorder,uint s_length);
 
561
void print_plan(JOIN* join,uint idx, double record_count, double read_time,
542
562
                double current_read_time, const char *info);
543
563
void print_keyuse_array(DYNAMIC_ARRAY *keyuse_array);
544
564
void dump_TableList_graph(SELECT_LEX *select_lex, TableList* tl);
545
565
void mysql_print_status();
546
566
 
547
567
/* key.cc */
548
 
int find_ref_key(KEY *key, uint32_t key_count, unsigned char *record, Field *field,
549
 
                 uint32_t *key_length, uint32_t *keypart);
550
 
void key_copy(unsigned char *to_key, unsigned char *from_record, KEY *key_info, uint32_t key_length);
551
 
void key_restore(unsigned char *to_record, unsigned char *from_key, KEY *key_info,
 
568
int find_ref_key(KEY *key, uint key_count, uchar *record, Field *field,
 
569
                 uint *key_length, uint *keypart);
 
570
void key_copy(uchar *to_key, uchar *from_record, KEY *key_info, uint key_length);
 
571
void key_restore(uchar *to_record, uchar *from_key, KEY *key_info,
552
572
                 uint16_t key_length);
553
 
void key_zero_nulls(unsigned char *tuple, KEY *key_info);
554
 
bool key_cmp_if_same(Table *form,const unsigned char *key,uint32_t index,uint32_t key_length);
555
 
void key_unpack(String *to,Table *form,uint32_t index);
556
 
bool is_key_used(Table *table, uint32_t idx, const MY_BITMAP *fields);
557
 
int key_cmp(KEY_PART_INFO *key_part, const unsigned char *key, uint32_t key_length);
558
 
extern "C" int key_rec_cmp(void *key_info, unsigned char *a, unsigned char *b);
 
573
void key_zero_nulls(uchar *tuple, KEY *key_info);
 
574
bool key_cmp_if_same(Table *form,const uchar *key,uint index,uint key_length);
 
575
void key_unpack(String *to,Table *form,uint index);
 
576
bool is_key_used(Table *table, uint idx, const MY_BITMAP *fields);
 
577
int key_cmp(KEY_PART_INFO *key_part, const uchar *key, uint key_length);
 
578
extern "C" int key_rec_cmp(void *key_info, uchar *a, uchar *b);
559
579
 
560
580
bool init_errmessage(void);
561
581
File open_binlog(IO_CACHE *log, const char *log_file_name,
562
582
                 const char **errmsg);
563
583
 
564
584
/* mysqld.cc */
565
 
void refresh_status(Session *session);
 
585
extern void MYSQLerror(const char*);
 
586
void refresh_status(THD *thd);
566
587
bool mysql_rm_tmp_tables(void);
567
 
void handle_connection_in_main_thread(Session *session);
568
 
void create_thread_to_handle_connection(Session *session);
569
 
void unlink_session(Session *session);
570
 
bool one_thread_per_connection_end(Session *session, bool put_in_cache);
 
588
void handle_connection_in_main_thread(THD *thd);
 
589
void create_thread_to_handle_connection(THD *thd);
 
590
void unlink_thd(THD *thd);
 
591
bool one_thread_per_connection_end(THD *thd, bool put_in_cache);
571
592
void flush_thread_cache();
572
593
 
573
594
/* item_func.cc */
574
595
extern bool check_reserved_words(LEX_STRING *name);
575
 
extern enum_field_types agg_field_type(Item **items, uint32_t nitems);
 
596
extern enum_field_types agg_field_type(Item **items, uint nitems);
576
597
 
577
598
/* strfunc.cc */
578
 
uint64_t find_set(TYPELIB *lib, const char *x, uint32_t length, const CHARSET_INFO * const cs,
579
 
                   char **err_pos, uint32_t *err_len, bool *set_warning);
580
 
uint32_t find_type(const TYPELIB *lib, const char *find, uint32_t length,
 
599
uint64_t find_set(TYPELIB *lib, const char *x, uint length, const CHARSET_INFO * const cs,
 
600
                   char **err_pos, uint *err_len, bool *set_warning);
 
601
uint find_type(const TYPELIB *lib, const char *find, uint length,
581
602
               bool part_match);
582
 
uint32_t find_type2(const TYPELIB *lib, const char *find, uint32_t length,
 
603
uint find_type2(const TYPELIB *lib, const char *find, uint length,
583
604
                const CHARSET_INFO *cs);
584
605
void unhex_type2(TYPELIB *lib);
585
 
uint32_t check_word(TYPELIB *lib, const char *val, const char *end,
 
606
uint check_word(TYPELIB *lib, const char *val, const char *end,
586
607
                const char **end_of_word);
587
608
int find_string_in_array(LEX_STRING * const haystack, LEX_STRING * const needle,
588
609
                         const CHARSET_INFO * const cs);
589
610
 
590
611
 
591
 
bool is_keyword(const char *name, uint32_t len);
 
612
bool is_keyword(const char *name, uint len);
592
613
 
593
614
#define MY_DB_OPT_FILE "db.opt"
594
615
bool my_database_names_init(void);
595
616
void my_database_names_free(void);
596
617
bool check_db_dir_existence(const char *db_name);
597
 
bool load_db_opt(Session *session, const char *path, HA_CREATE_INFO *create);
598
 
bool load_db_opt_by_name(Session *session, const char *db_name,
 
618
bool load_db_opt(THD *thd, const char *path, HA_CREATE_INFO *create);
 
619
bool load_db_opt_by_name(THD *thd, const char *db_name,
599
620
                         HA_CREATE_INFO *db_create_info);
600
 
const CHARSET_INFO *get_default_db_collation(Session *session, const char *db_name);
 
621
const CHARSET_INFO *get_default_db_collation(THD *thd, const char *db_name);
601
622
bool my_dbopt_init(void);
602
623
void my_dbopt_cleanup(void);
603
624
extern int creating_database; // How many database locks are made
631
652
extern const double log_10[309];
632
653
extern uint64_t log_10_int[20];
633
654
extern uint64_t keybuff_size;
634
 
extern uint64_t session_startup_options;
 
655
extern uint64_t thd_startup_options;
635
656
extern ulong thread_id;
636
657
extern ulong binlog_cache_use, binlog_cache_disk_use;
637
658
extern ulong aborted_threads,aborted_connects;
641
662
extern ulong max_connections,max_connect_errors, connect_timeout;
642
663
extern bool slave_allow_batching;
643
664
extern ulong slave_net_timeout, slave_trans_retries;
644
 
extern uint32_t max_user_connections;
 
665
extern uint max_user_connections;
645
666
extern ulong what_to_log,flush_time;
646
667
extern ulong binlog_cache_size, max_binlog_cache_size, open_files_limit;
647
668
extern ulong max_binlog_size, max_relay_log_size;
654
675
extern ulong tc_log_page_waits;
655
676
extern bool relay_log_purge;
656
677
extern bool opt_innodb_safe_binlog, opt_innodb;
657
 
extern uint32_t test_flags,select_errors,ha_open_options;
658
 
extern uint32_t protocol_version, drizzled_port, dropping_tables;
659
 
extern uint32_t delay_key_write_options;
 
678
extern uint test_flags,select_errors,ha_open_options;
 
679
extern uint protocol_version, mysqld_port, dropping_tables;
 
680
extern uint delay_key_write_options;
660
681
extern bool opt_endinfo, using_udf_functions;
661
682
extern bool locked_in_memory;
662
683
extern bool opt_using_transactions;
668
689
extern bool opt_log_queries_not_using_indexes;
669
690
extern bool opt_character_set_client_handshake;
670
691
extern bool volatile abort_loop, shutdown_in_progress;
671
 
extern uint32_t volatile thread_count, thread_running, global_read_lock;
672
 
extern uint32_t connection_count;
 
692
extern uint volatile thread_count, thread_running, global_read_lock;
 
693
extern uint connection_count;
673
694
extern bool opt_sql_bin_update;
674
695
extern bool opt_safe_user_create;
675
696
extern bool opt_no_mix_types;
679
700
extern bool use_temp_pool;
680
701
extern ulong slave_exec_mode_options;
681
702
extern bool opt_readonly;
 
703
extern bool opt_secure_auth;
682
704
extern char* opt_secure_file_priv;
 
705
extern bool opt_log_slow_admin_statements;
 
706
extern bool opt_log_slow_slave_statements;
683
707
extern bool opt_noacl;
684
708
extern bool opt_old_style_user_limits;
685
 
extern uint32_t opt_crash_binlog_innodb;
 
709
extern uint opt_crash_binlog_innodb;
686
710
extern char *default_tz_name;
687
711
extern char *opt_logname, *opt_slow_logname;
688
712
extern const char *log_output_str;
691
715
extern LOGGER logger;
692
716
extern TableList general_log, slow_log;
693
717
extern FILE *stderror_file;
694
 
extern pthread_key_t THR_MALLOC;
 
718
extern pthread_key(MEM_ROOT**,THR_MALLOC);
695
719
extern pthread_mutex_t LOCK_mysql_create_db,LOCK_open, LOCK_lock_db,
696
720
       LOCK_thread_count,LOCK_user_locks, LOCK_status,
697
721
       LOCK_error_log, LOCK_uuid_generator,
705
729
extern pthread_cond_t COND_refresh, COND_thread_count, COND_manager;
706
730
extern pthread_cond_t COND_global_read_lock;
707
731
extern pthread_attr_t connection_attrib;
708
 
extern I_List<Session> threads;
 
732
extern I_List<THD> threads;
709
733
extern I_List<NAMED_LIST> key_caches;
710
734
extern MY_BITMAP temp_pool;
711
735
extern String my_empty_string;
723
747
extern const char* any_db;
724
748
extern struct my_option my_long_options[];
725
749
extern const LEX_STRING view_type;
 
750
extern scheduler_functions thread_scheduler;
726
751
extern TYPELIB thread_handling_typelib;
727
752
extern uint8_t uc_update_queries[SQLCOM_END+1];
728
 
extern uint32_t sql_command_flags[];
 
753
extern uint sql_command_flags[];
729
754
extern TYPELIB log_output_typelib;
730
755
 
731
756
/* optional things, have_* variables */
740
765
 
741
766
extern pthread_t signal_thread;
742
767
 
743
 
DRIZZLE_LOCK *mysql_lock_tables(Session *session, Table **table, uint32_t count,
744
 
                              uint32_t flags, bool *need_reopen);
 
768
DRIZZLE_LOCK *mysql_lock_tables(THD *thd, Table **table, uint count,
 
769
                              uint flags, bool *need_reopen);
745
770
/* mysql_lock_tables() and open_table() flags bits */
746
771
#define DRIZZLE_LOCK_IGNORE_GLOBAL_READ_LOCK      0x0001
747
772
#define DRIZZLE_LOCK_IGNORE_FLUSH                 0x0002
750
775
#define DRIZZLE_LOCK_IGNORE_GLOBAL_READ_ONLY      0x0010
751
776
#define DRIZZLE_LOCK_PERF_SCHEMA                  0x0020
752
777
 
753
 
void mysql_unlock_tables(Session *session, DRIZZLE_LOCK *sql_lock);
754
 
void mysql_unlock_read_tables(Session *session, DRIZZLE_LOCK *sql_lock);
755
 
void mysql_unlock_some_tables(Session *session, Table **table,uint32_t count);
756
 
void mysql_lock_remove(Session *session, DRIZZLE_LOCK *locked,Table *table,
 
778
void mysql_unlock_tables(THD *thd, DRIZZLE_LOCK *sql_lock);
 
779
void mysql_unlock_read_tables(THD *thd, DRIZZLE_LOCK *sql_lock);
 
780
void mysql_unlock_some_tables(THD *thd, Table **table,uint count);
 
781
void mysql_lock_remove(THD *thd, DRIZZLE_LOCK *locked,Table *table,
757
782
                       bool always_unlock);
758
 
void mysql_lock_abort(Session *session, Table *table, bool upgrade_lock);
759
 
void mysql_lock_downgrade_write(Session *session, Table *table,
 
783
void mysql_lock_abort(THD *thd, Table *table, bool upgrade_lock);
 
784
void mysql_lock_downgrade_write(THD *thd, Table *table,
760
785
                                thr_lock_type new_lock_type);
761
 
bool mysql_lock_abort_for_thread(Session *session, Table *table);
 
786
bool mysql_lock_abort_for_thread(THD *thd, Table *table);
762
787
DRIZZLE_LOCK *mysql_lock_merge(DRIZZLE_LOCK *a,DRIZZLE_LOCK *b);
763
 
TableList *mysql_lock_have_duplicate(Session *session, TableList *needle,
 
788
TableList *mysql_lock_have_duplicate(THD *thd, TableList *needle,
764
789
                                      TableList *haystack);
765
 
bool lock_global_read_lock(Session *session);
766
 
void unlock_global_read_lock(Session *session);
767
 
bool wait_if_global_read_lock(Session *session, bool abort_on_refresh,
 
790
bool lock_global_read_lock(THD *thd);
 
791
void unlock_global_read_lock(THD *thd);
 
792
bool wait_if_global_read_lock(THD *thd, bool abort_on_refresh,
768
793
                              bool is_not_commit);
769
 
void start_waiting_global_read_lock(Session *session);
770
 
bool make_global_read_lock_block_commit(Session *session);
 
794
void start_waiting_global_read_lock(THD *thd);
 
795
bool make_global_read_lock_block_commit(THD *thd);
771
796
bool set_protect_against_global_read_lock(void);
772
797
void unset_protect_against_global_read_lock(void);
773
798
void broadcast_refresh(void);
774
 
int try_transactional_lock(Session *session, TableList *table_list);
775
 
int check_transactional_lock(Session *session, TableList *table_list);
776
 
int set_handler_table_locks(Session *session, TableList *table_list,
 
799
int try_transactional_lock(THD *thd, TableList *table_list);
 
800
int check_transactional_lock(THD *thd, TableList *table_list);
 
801
int set_handler_table_locks(THD *thd, TableList *table_list,
777
802
                            bool transactional);
778
803
 
779
804
/* Lock based on name */
780
 
int lock_and_wait_for_table_name(Session *session, TableList *table_list);
781
 
int lock_table_name(Session *session, TableList *table_list, bool check_in_use);
782
 
void unlock_table_name(Session *session, TableList *table_list);
783
 
bool wait_for_locked_table_names(Session *session, TableList *table_list);
784
 
bool lock_table_names(Session *session, TableList *table_list);
785
 
void unlock_table_names(Session *session, TableList *table_list,
 
805
int lock_and_wait_for_table_name(THD *thd, TableList *table_list);
 
806
int lock_table_name(THD *thd, TableList *table_list, bool check_in_use);
 
807
void unlock_table_name(THD *thd, TableList *table_list);
 
808
bool wait_for_locked_table_names(THD *thd, TableList *table_list);
 
809
bool lock_table_names(THD *thd, TableList *table_list);
 
810
void unlock_table_names(THD *thd, TableList *table_list,
786
811
                        TableList *last_table);
787
 
bool lock_table_names_exclusively(Session *session, TableList *table_list);
788
 
bool is_table_name_exclusively_locked_by_this_thread(Session *session, 
 
812
bool lock_table_names_exclusively(THD *thd, TableList *table_list);
 
813
bool is_table_name_exclusively_locked_by_this_thread(THD *thd, 
789
814
                                                     TableList *table_list);
790
 
bool is_table_name_exclusively_locked_by_this_thread(Session *session, unsigned char *key,
 
815
bool is_table_name_exclusively_locked_by_this_thread(THD *thd, uchar *key,
791
816
                                                     int key_length);
792
817
 
793
818
 
795
820
 
796
821
void unireg_init(ulong options);
797
822
void unireg_end(void) __attribute__((noreturn));
798
 
bool mysql_create_frm(Session *session, const char *file_name,
 
823
bool mysql_create_frm(THD *thd, const char *file_name,
799
824
                      const char *db, const char *table,
800
825
                      HA_CREATE_INFO *create_info,
801
826
                      List<Create_field> &create_field,
802
 
                      uint32_t key_count,KEY *key_info,handler *db_type);
803
 
int rea_create_table(Session *session, const char *path,
 
827
                      uint key_count,KEY *key_info,handler *db_type);
 
828
int rea_create_table(THD *thd, const char *path,
804
829
                     const char *db, const char *table_name,
805
830
                     HA_CREATE_INFO *create_info,
806
831
                     List<Create_field> &create_field,
807
 
                     uint32_t key_count,KEY *key_info,
 
832
                     uint key_count,KEY *key_info,
808
833
                     handler *file);
809
 
int format_number(uint32_t inputflag,uint32_t max_length,char * pos,uint32_t length,
 
834
int format_number(uint inputflag,uint max_length,char * pos,uint length,
810
835
                  char * *errpos);
811
836
 
812
837
/* table.cc */
813
838
TABLE_SHARE *alloc_table_share(TableList *table_list, char *key,
814
 
                               uint32_t key_length);
815
 
void init_tmp_table_share(Session *session, TABLE_SHARE *share, const char *key,
816
 
                          uint32_t key_length,
 
839
                               uint key_length);
 
840
void init_tmp_table_share(THD *thd, TABLE_SHARE *share, const char *key,
 
841
                          uint key_length,
817
842
                          const char *table_name, const char *path);
818
843
void free_table_share(TABLE_SHARE *share);
819
 
int open_table_def(Session *session, TABLE_SHARE *share, uint32_t db_flags);
 
844
int open_table_def(THD *thd, TABLE_SHARE *share, uint db_flags);
820
845
void open_table_error(TABLE_SHARE *share, int error, int db_errno, int errarg);
821
 
int open_table_from_share(Session *session, TABLE_SHARE *share, const char *alias,
822
 
                          uint32_t db_stat, uint32_t prgflag, uint32_t ha_open_flags,
 
846
int open_table_from_share(THD *thd, TABLE_SHARE *share, const char *alias,
 
847
                          uint db_stat, uint prgflag, uint ha_open_flags,
823
848
                          Table *outparam, open_table_mode open_mode);
824
 
int readfrm(const char *name, unsigned char **data, size_t *length);
825
 
int writefrm(const char* name, const unsigned char* data, size_t len);
 
849
int readfrm(const char *name, uchar **data, size_t *length);
 
850
int writefrm(const char* name, const uchar* data, size_t len);
826
851
int closefrm(Table *table, bool free_share);
827
 
int read_string(File file, unsigned char* *to, size_t length);
 
852
int read_string(File file, uchar* *to, size_t length);
828
853
void free_blobs(Table *table);
829
854
int set_zone(int nr,int min_zone,int max_zone);
830
 
uint32_t convert_period_to_month(uint32_t period);
831
 
uint32_t convert_month_to_period(uint32_t month);
832
 
void get_date_from_daynr(long daynr,uint32_t *year, uint32_t *month,
833
 
                         uint32_t *day);
834
 
my_time_t TIME_to_timestamp(Session *session, const DRIZZLE_TIME *t, bool *not_exist);
835
 
bool str_to_time_with_warn(const char *str,uint32_t length,DRIZZLE_TIME *l_time);
836
 
enum enum_drizzle_timestamp_type str_to_datetime_with_warn(const char *str, uint32_t length,
837
 
                                         DRIZZLE_TIME *l_time, uint32_t flags);
 
855
ulong convert_period_to_month(ulong period);
 
856
ulong convert_month_to_period(ulong month);
 
857
void get_date_from_daynr(long daynr,uint *year, uint *month,
 
858
                         uint *day);
 
859
my_time_t TIME_to_timestamp(THD *thd, const DRIZZLE_TIME *t, bool *not_exist);
 
860
bool str_to_time_with_warn(const char *str,uint length,DRIZZLE_TIME *l_time);
 
861
timestamp_type str_to_datetime_with_warn(const char *str, uint length,
 
862
                                         DRIZZLE_TIME *l_time, uint flags);
838
863
void localtime_to_TIME(DRIZZLE_TIME *to, struct tm *from);
839
864
void calc_time_from_sec(DRIZZLE_TIME *to, long seconds, long microseconds);
840
865
 
841
 
void make_truncated_value_warning(Session *session, DRIZZLE_ERROR::enum_warning_level level,
 
866
void make_truncated_value_warning(THD *thd, DRIZZLE_ERROR::enum_warning_level level,
842
867
                                  const char *str_val,
843
 
                                  uint32_t str_length, enum enum_drizzle_timestamp_type time_type,
 
868
                                  uint str_length, timestamp_type time_type,
844
869
                                  const char *field_name);
845
870
 
846
871
bool date_add_interval(DRIZZLE_TIME *ltime, interval_type int_type, INTERVAL interval);
849
874
 
850
875
extern LEX_STRING interval_type_to_name[];
851
876
 
852
 
extern DATE_TIME_FORMAT *date_time_format_make(enum enum_drizzle_timestamp_type format_type,
 
877
extern DATE_TIME_FORMAT *date_time_format_make(timestamp_type format_type,
853
878
                                               const char *format_str,
854
 
                                               uint32_t format_length);
855
 
extern DATE_TIME_FORMAT *date_time_format_copy(Session *session,
 
879
                                               uint format_length);
 
880
extern DATE_TIME_FORMAT *date_time_format_copy(THD *thd,
856
881
                                               DATE_TIME_FORMAT *format);
857
882
const char *get_date_time_format_str(KNOWN_DATE_TIME_FORMAT *format,
858
 
                                                             enum enum_drizzle_timestamp_type type);
 
883
                                     timestamp_type type);
859
884
extern bool make_date_time(DATE_TIME_FORMAT *format, DRIZZLE_TIME *l_time,
860
 
                                             enum enum_drizzle_timestamp_type type, String *str);
 
885
                           timestamp_type type, String *str);
861
886
void make_datetime(const DATE_TIME_FORMAT *format, const DRIZZLE_TIME *l_time,
862
887
                   String *str);
863
888
void make_date(const DATE_TIME_FORMAT *format, const DRIZZLE_TIME *l_time,
865
890
void make_time(const DATE_TIME_FORMAT *format, const DRIZZLE_TIME *l_time,
866
891
               String *str);
867
892
int my_time_compare(DRIZZLE_TIME *a, DRIZZLE_TIME *b);
868
 
uint64_t get_datetime_value(Session *session, Item ***item_arg, Item **cache_arg,
 
893
uint64_t get_datetime_value(THD *thd, Item ***item_arg, Item **cache_arg,
869
894
                             Item *warn_item, bool *is_null);
870
895
 
871
896
int test_if_number(char *str,int *res,bool allow_wildcards);
872
 
void change_byte(unsigned char *,uint,char,char);
873
 
void init_read_record(READ_RECORD *info, Session *session, Table *reg_form,
 
897
void change_byte(uchar *,uint,char,char);
 
898
void init_read_record(READ_RECORD *info, THD *thd, Table *reg_form,
874
899
                      SQL_SELECT *select,
875
900
                      int use_record_cache, bool print_errors);
876
 
void init_read_record_idx(READ_RECORD *info, Session *session, Table *table, 
877
 
                          bool print_error, uint32_t idx);
 
901
void init_read_record_idx(READ_RECORD *info, THD *thd, Table *table, 
 
902
                          bool print_error, uint idx);
878
903
void end_read_record(READ_RECORD *info);
879
 
ha_rows filesort(Session *session, Table *form,struct st_sort_field *sortorder,
880
 
                 uint32_t s_length, SQL_SELECT *select,
 
904
ha_rows filesort(THD *thd, Table *form,struct st_sort_field *sortorder,
 
905
                 uint s_length, SQL_SELECT *select,
881
906
                 ha_rows max_rows, bool sort_positions,
882
907
                 ha_rows *examined_rows);
883
908
void filesort_free_buffers(Table *table, bool full);
884
 
void change_double_for_sort(double nr,unsigned char *to);
 
909
void change_double_for_sort(double nr,uchar *to);
885
910
double my_double_round(double value, int64_t dec, bool dec_unsigned,
886
911
                       bool truncate);
887
912
int get_quick_record(SQL_SELECT *select);
888
913
 
889
914
int calc_weekday(long daynr,bool sunday_first_day_of_week);
890
 
uint32_t calc_week(DRIZZLE_TIME *l_time, uint32_t week_behaviour, uint32_t *year);
891
 
void find_date(char *pos,uint32_t *vek,uint32_t flag);
 
915
uint calc_week(DRIZZLE_TIME *l_time, uint week_behaviour, uint *year);
 
916
void find_date(char *pos,uint *vek,uint flag);
892
917
TYPELIB *convert_strings_to_array_type(char * *typelibs, char * *end);
893
918
TYPELIB *typelib(MEM_ROOT *mem_root, List<String> &strings);
894
 
ulong get_form_pos(File file, unsigned char *head, TYPELIB *save_names);
895
 
ulong make_new_entry(File file,unsigned char *fileinfo,TYPELIB *formnames,
 
919
ulong get_form_pos(File file, uchar *head, TYPELIB *save_names);
 
920
ulong make_new_entry(File file,uchar *fileinfo,TYPELIB *formnames,
896
921
                     const char *newname);
897
922
ulong next_io_size(ulong pos);
898
 
void append_unescaped(String *res, const char *pos, uint32_t length);
899
 
int create_frm(Session *session, const char *name, const char *db, const char *table,
900
 
               uint32_t reclength, unsigned char *fileinfo,
901
 
               HA_CREATE_INFO *create_info, uint32_t keys, KEY *key_info);
 
923
void append_unescaped(String *res, const char *pos, uint length);
 
924
int create_frm(THD *thd, const char *name, const char *db, const char *table,
 
925
               uint reclength, uchar *fileinfo,
 
926
               HA_CREATE_INFO *create_info, uint keys, KEY *key_info);
902
927
int rename_file_ext(const char * from,const char * to,const char * ext);
903
928
bool check_db_name(LEX_STRING *db);
904
929
bool check_column_name(const char *name);
905
 
bool check_table_name(const char *name, uint32_t length);
 
930
bool check_table_name(const char *name, uint length);
906
931
char *get_field(MEM_ROOT *mem, Field *field);
907
932
bool get_field(MEM_ROOT *mem, Field *field, class String *res);
908
933
char *fn_rext(char *name);
909
934
 
910
935
/* Conversion functions */
911
 
uint32_t build_table_filename(char *buff, size_t bufflen, const char *db,
912
 
                          const char *table, const char *ext, uint32_t flags);
 
936
uint build_table_filename(char *buff, size_t bufflen, const char *db,
 
937
                          const char *table, const char *ext, uint flags);
913
938
 
914
939
#define MYSQL50_TABLE_NAME_PREFIX         "#mysql50#"
915
 
#define MYSQL50_TABLE_NAME_PREFIX_LENGTH  sizeof(MYSQL50_TABLE_NAME_PREFIX)
 
940
#define MYSQL50_TABLE_NAME_PREFIX_LENGTH  9
916
941
 
917
942
/* Flags for conversion functions. */
918
943
#define FN_FROM_IS_TMP  (1 << 0)
921
946
#define NO_FRM_RENAME   (1 << 2)
922
947
 
923
948
/* item_func.cc */
924
 
Item *get_system_var(Session *session, enum_var_type var_type, LEX_STRING name,
 
949
Item *get_system_var(THD *thd, enum_var_type var_type, LEX_STRING name,
925
950
                     LEX_STRING component);
926
 
int get_var_with_binlog(Session *session, enum_sql_command sql_command,
 
951
int get_var_with_binlog(THD *thd, enum_sql_command sql_command,
927
952
                        LEX_STRING &name, user_var_entry **out_entry);
928
953
/* log.cc */
929
954
bool flush_error_log(void);
934
959
 
935
960
/* Some inline functions for more speed */
936
961
 
937
 
inline bool add_item_to_list(Session *session, Item *item)
938
 
{
939
 
  return session->lex->current_select->add_item_to_list(session, item);
940
 
}
941
 
 
942
 
inline bool add_value_to_list(Session *session, Item *value)
943
 
{
944
 
  return session->lex->value_list.push_back(value);
945
 
}
946
 
 
947
 
inline bool add_order_to_list(Session *session, Item *item, bool asc)
948
 
{
949
 
  return session->lex->current_select->add_order_to_list(session, item, asc);
950
 
}
951
 
 
952
 
inline bool add_group_to_list(Session *session, Item *item, bool asc)
953
 
{
954
 
  return session->lex->current_select->add_group_to_list(session, item, asc);
 
962
inline bool add_item_to_list(THD *thd, Item *item)
 
963
{
 
964
  return thd->lex->current_select->add_item_to_list(thd, item);
 
965
}
 
966
 
 
967
inline bool add_value_to_list(THD *thd, Item *value)
 
968
{
 
969
  return thd->lex->value_list.push_back(value);
 
970
}
 
971
 
 
972
inline bool add_order_to_list(THD *thd, Item *item, bool asc)
 
973
{
 
974
  return thd->lex->current_select->add_order_to_list(thd, item, asc);
 
975
}
 
976
 
 
977
inline bool add_group_to_list(THD *thd, Item *item, bool asc)
 
978
{
 
979
  return thd->lex->current_select->add_group_to_list(thd, item, asc);
955
980
}
956
981
 
957
982
inline void mark_as_null_row(Table *table)
961
986
  memset(table->null_flags, 255, table->s->null_bytes);
962
987
}
963
988
 
 
989
inline void table_case_convert(char * name, uint length)
 
990
{
 
991
  if (lower_case_table_names)
 
992
    files_charset_info->cset->casedn(files_charset_info,
 
993
                                     name, length, name, length);
 
994
}
 
995
 
 
996
inline const char *table_case_name(HA_CREATE_INFO *info, const char *name)
 
997
{
 
998
  return ((lower_case_table_names == 2 && info->alias) ? info->alias : name);
 
999
}
 
1000
 
964
1001
inline ulong sql_rnd()
965
1002
{
966
1003
  ulong tmp= (ulong) (rand() * 0xffffffff); /* make all bits random */
987
1024
  @param table_list   TableList structure pointer (owner of Table)
988
1025
  @param tablenr     table number
989
1026
*/
990
 
inline void setup_table_map(Table *table, TableList *table_list, uint32_t tablenr)
 
1027
inline void setup_table_map(Table *table, TableList *table_list, uint tablenr)
991
1028
{
992
1029
  table->used_fields= 0;
993
1030
  table->const_table= 0;
1023
1060
  return -1;
1024
1061
}
1025
1062
 
 
1063
/**
 
1064
  return true if the table was created explicitly.
 
1065
*/
 
1066
inline bool is_user_table(Table * table)
 
1067
{
 
1068
  const char *name= table->s->table_name.str;
 
1069
  return strncmp(name, tmp_file_prefix, tmp_file_prefix_length);
 
1070
}
 
1071
 
 
1072
 
 
1073
#ifndef HAVE_LOG2
 
1074
/*
 
1075
  This will be slightly slower and perhaps a tiny bit less accurate than
 
1076
  doing it the IEEE754 way but log2() should be available on C99 systems.
 
1077
*/
 
1078
static inline double log2(double x)
 
1079
{
 
1080
  return (log(x) / M_LN2);
 
1081
}
 
1082
#endif
 
1083
 
 
1084
 
1026
1085
/*
1027
1086
  Some functions that are different in the embedded library and the normal
1028
1087
  server
1029
1088
*/
1030
1089
 
1031
1090
extern "C" void unireg_abort(int exit_code) __attribute__((noreturn));
1032
 
bool check_stack_overrun(Session *session, long margin, unsigned char *dummy);
 
1091
void kill_delayed_threads(void);
 
1092
bool check_stack_overrun(THD *thd, long margin, uchar *dummy);
 
1093
 
 
1094
/** 
 
1095
 * Used by handlers to store things in schema tables 
 
1096
 *
 
1097
 * @TODO These should be placed in an information_schema.h header
 
1098
 * file once the new information schema design is finalized.
 
1099
 */
 
1100
#define IS_FILES_FILE_ID              0
 
1101
#define IS_FILES_FILE_NAME            1
 
1102
#define IS_FILES_FILE_TYPE            2
 
1103
#define IS_FILES_TABLESPACE_NAME      3
 
1104
#define IS_FILES_TABLE_CATALOG        4
 
1105
#define IS_FILES_TABLE_SCHEMA         5
 
1106
#define IS_FILES_TABLE_NAME           6
 
1107
#define IS_FILES_LOGFILE_GROUP_NAME   7
 
1108
#define IS_FILES_LOGFILE_GROUP_NUMBER 8
 
1109
#define IS_FILES_ENGINE               9
 
1110
#define IS_FILES_FULLTEXT_KEYS       10
 
1111
#define IS_FILES_DELETED_ROWS        11
 
1112
#define IS_FILES_UPDATE_COUNT        12
 
1113
#define IS_FILES_FREE_EXTENTS        13
 
1114
#define IS_FILES_TOTAL_EXTENTS       14
 
1115
#define IS_FILES_EXTENT_SIZE         15
 
1116
#define IS_FILES_INITIAL_SIZE        16
 
1117
#define IS_FILES_MAXIMUM_SIZE        17
 
1118
#define IS_FILES_AUTOEXTEND_SIZE     18
 
1119
#define IS_FILES_CREATION_TIME       19
 
1120
#define IS_FILES_LAST_UPDATE_TIME    20
 
1121
#define IS_FILES_LAST_ACCESS_TIME    21
 
1122
#define IS_FILES_RECOVER_TIME        22
 
1123
#define IS_FILES_TRANSACTION_COUNTER 23
 
1124
#define IS_FILES_VERSION             24
 
1125
#define IS_FILES_ROW_FORMAT          25
 
1126
#define IS_FILES_TABLE_ROWS          26
 
1127
#define IS_FILES_AVG_ROW_LENGTH      27
 
1128
#define IS_FILES_DATA_LENGTH         28
 
1129
#define IS_FILES_MAX_DATA_LENGTH     29
 
1130
#define IS_FILES_INDEX_LENGTH        30
 
1131
#define IS_FILES_DATA_FREE           31
 
1132
#define IS_FILES_CREATE_TIME         32
 
1133
#define IS_FILES_UPDATE_TIME         33
 
1134
#define IS_FILES_CHECK_TIME          34
 
1135
#define IS_FILES_CHECKSUM            35
 
1136
#define IS_FILES_STATUS              36
 
1137
#define IS_FILES_EXTRA               37
1033
1138
 
1034
1139
#endif /* DRIZZLE_SERVER_SERVER_INCLUDES_H */