← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/server_includes.h

  • Committer: Eric Herman
  • Date: 2008-12-07 15:29:44 UTC
  • mto: (656.1.14 devel)
  • mto: This revision was merged to the branch mainline in revision 670.
  • Revision ID: eric@mysql.com-20081207152944-cq1nx1cyi0huqj0f
Added pointer to online version of the FAQ

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/server_includes.h
 
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
 
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
 
3
 *
 
4
 *  Copyright (C) 2008 Sun Microsystems
 
5
 *
 
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; version 2 of the License.
 
9
 *
 
10
 *  This program is distributed in the hope that it will be useful,
 
11
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
 *  GNU General Public License for more details.
 
14
 *
 
15
 *  You should have received a copy of the GNU General Public License
 
16
 *  along with this program; if not, write to the Free Software
 
17
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
18
 */
 
19
 
 
20
/**
 
21
  @file
 
22
 
 
23
  @details
 
24
  Mostly this file is used in the server. But a little part of it is used in
 
25
  mysqlbinlog too (definition of SELECT_DISTINCT and others).
 
26
 
 
27
  @TODO Name this file better. "priv" could mean private, privileged, privileges.
 
28
*/
 
29
 
 
30
#ifndef DRIZZLED_SERVER_INCLUDES_H
 
31
#define DRIZZLED_SERVER_INCLUDES_H
 
32
 
 
33
/**
 
34
 * Contains all headers, definitions, and declarations common to
 
35
 * the server and the plugin infrastructure, and not the client
 
36
 */
 
37
#include <drizzled/common_includes.h>
 
38
/* Range optimization API/library */
 
39
#include <drizzled/opt_range.h>
 
40
/* Simple error injection (crash) module */
 
41
#include <drizzled/error_injection.h>
 
42
/* API for connecting, logging in to a drizzled server */
 
43
#include <drizzled/connect.h>
 
44
/* Routines for dropping, repairing, checking schema tables */
 
45
#include <drizzled/sql_table.h>
 
46
#include <drizzled/log.h>
 
47
 
 
48
#include <string>
 
49
#include <bitset>
 
50
 
 
51
typedef class st_select_lex SELECT_LEX;
 
52
typedef struct st_mysql_lock DRIZZLE_LOCK;
 
53
typedef struct st_ha_create_information HA_CREATE_INFO;
 
54
 
 
55
/* information schema */
 
56
static const std::string INFORMATION_SCHEMA_NAME("information_schema");
 
57
 
 
58
 
 
59
#define is_schema_db(X) \
 
60
  !my_strcasecmp(system_charset_info, INFORMATION_SCHEMA_NAME.str, (X))
 
61
 
 
62
/* sql_test.cc */
 
63
void print_where(COND *cond,const char *info, enum_query_type query_type);
 
64
void print_cached_tables(void);
 
65
void print_plan(JOIN* join,uint32_t idx, double record_count, double read_time,
 
66
                double current_read_time, const char *info);
 
67
void print_keyuse_array(DYNAMIC_ARRAY *keyuse_array);
 
68
void dump_TableList_graph(SELECT_LEX *select_lex, TableList* tl);
 
69
void mysql_print_status();
 
70
 
 
71
 
 
72
bool init_errmessage(void);
 
73
File open_binlog(IO_CACHE *log, const char *log_file_name,
 
74
                 const char **errmsg);
 
75
 
 
76
/* mysqld.cc */
 
77
void refresh_status(Session *session);
 
78
bool drizzle_rm_tmp_tables(void);
 
79
void handle_connection_in_main_thread(Session *session);
 
80
void create_thread_to_handle_connection(Session *session);
 
81
void unlink_session(Session *session);
 
82
bool one_thread_per_connection_end(Session *session, bool put_in_cache);
 
83
void flush_thread_cache();
 
84
 
 
85
/* item_func.cc */
 
86
extern bool check_reserved_words(LEX_STRING *name);
 
87
extern enum_field_types agg_field_type(Item **items, uint32_t nitems);
 
88
 
 
89
/* strfunc.cc */
 
90
uint64_t find_set(TYPELIB *lib, const char *x, uint32_t length, const CHARSET_INFO * const cs,
 
91
                   char **err_pos, uint32_t *err_len, bool *set_warning);
 
92
uint32_t find_type(const TYPELIB *lib, const char *find, uint32_t length,
 
93
               bool part_match);
 
94
uint32_t find_type2(const TYPELIB *lib, const char *find, uint32_t length,
 
95
                const CHARSET_INFO *cs);
 
96
void unhex_type2(TYPELIB *lib);
 
97
uint32_t check_word(TYPELIB *lib, const char *val, const char *end,
 
98
                const char **end_of_word);
 
99
int find_string_in_array(LEX_STRING * const haystack, LEX_STRING * const needle,
 
100
                         const CHARSET_INFO * const cs);
 
101
 
 
102
 
 
103
bool is_keyword(const char *name, uint32_t len);
 
104
 
 
105
/*
 
106
  External variables
 
107
*/
 
108
 
 
109
extern time_t server_start_time, flush_status_time;
 
110
extern char *opt_drizzle_tmpdir;
 
111
 
 
112
#define drizzle_tmpdir (my_tmpdir(&drizzle_tmpdir_list))
 
113
extern MY_TMPDIR drizzle_tmpdir_list;
 
114
extern const LEX_STRING command_name[];
 
115
extern const char *first_keyword, *my_localhost, *delayed_user, *binary_keyword;
 
116
extern const char *myisam_recover_options_str;
 
117
extern const char *in_left_expr_name, *in_additional_cond, *in_having_cond;
 
118
extern const char * const TRG_EXT;
 
119
extern const char * const TRN_EXT;
 
120
extern char language[FN_REFLEN];
 
121
extern char glob_hostname[FN_REFLEN], drizzle_home[FN_REFLEN];
 
122
extern char pidfile_name[FN_REFLEN], system_time_zone[30], *opt_init_file;
 
123
extern char log_error_file[FN_REFLEN], *opt_tc_log_file;
 
124
extern const double log_10[309];
 
125
extern uint64_t log_10_int[20];
 
126
extern uint64_t keybuff_size;
 
127
extern uint64_t session_startup_options;
 
128
extern ulong thread_id;
 
129
extern uint64_t binlog_cache_use;
 
130
extern uint64_t binlog_cache_disk_use;
 
131
extern uint64_t aborted_threads;
 
132
extern uint64_t aborted_connects;
 
133
extern uint64_t slave_open_temp_tables;
 
134
extern uint64_t slow_launch_threads;
 
135
extern uint64_t slow_launch_time;
 
136
extern uint64_t table_cache_size;
 
137
extern uint64_t table_def_size;
 
138
extern uint64_t max_connections;
 
139
extern uint64_t max_connect_errors;
 
140
extern uint64_t connect_timeout;
 
141
extern bool slave_allow_batching;
 
142
extern uint64_t slave_net_timeout;
 
143
extern uint64_t slave_trans_retries;
 
144
extern uint32_t max_user_connections;
 
145
extern ulong what_to_log;
 
146
extern uint64_t binlog_cache_size;
 
147
extern uint64_t max_binlog_cache_size;
 
148
extern uint64_t open_files_limit;
 
149
extern uint64_t max_binlog_size;
 
150
extern uint64_t max_relay_log_size;
 
151
extern uint64_t opt_binlog_rows_event_max_size;
 
152
extern uint64_t thread_pool_size;
 
153
extern uint32_t back_log;
 
154
extern pid_t current_pid;
 
155
extern uint64_t expire_logs_days;
 
156
extern uint64_t sync_binlog_period;
 
157
extern uint64_t tc_log_max_pages_used;
 
158
extern uint64_t tc_log_page_size;
 
159
extern uint64_t opt_tc_log_size;
 
160
extern uint64_t tc_log_page_waits;
 
161
extern bool relay_log_purge;
 
162
extern bool opt_innodb_safe_binlog, opt_innodb;
 
163
extern uint32_t test_flags,select_errors,ha_open_options;
 
164
extern uint32_t protocol_version, drizzled_port, dropping_tables;
 
165
extern uint32_t delay_key_write_options;
 
166
extern bool opt_endinfo, using_udf_functions;
 
167
extern bool locked_in_memory;
 
168
extern bool opt_using_transactions;
 
169
extern bool using_update_log, server_id_supplied;
 
170
extern bool opt_update_log, opt_bin_log, opt_error_log;
 
171
extern bool opt_log;
 
172
extern bool opt_slow_log;
 
173
extern ulong log_output_options;
 
174
extern bool opt_log_queries_not_using_indexes;
 
175
extern bool opt_character_set_client_handshake;
 
176
extern bool volatile abort_loop, shutdown_in_progress;
 
177
extern uint32_t volatile thread_count, thread_running, global_read_lock;
 
178
extern uint32_t connection_count;
 
179
extern bool opt_sql_bin_update;
 
180
extern bool opt_safe_user_create;
 
181
extern bool opt_no_mix_types;
 
182
extern bool opt_safe_show_db, opt_myisam_use_mmap;
 
183
extern bool opt_local_infile;
 
184
extern bool opt_slave_compressed_protocol;
 
185
extern bool use_temp_pool;
 
186
extern ulong slave_exec_mode_options;
 
187
extern bool opt_readonly;
 
188
extern char* opt_secure_file_priv;
 
189
extern bool opt_noacl;
 
190
extern bool opt_old_style_user_limits;
 
191
extern uint32_t opt_crash_binlog_innodb;
 
192
extern char *default_tz_name;
 
193
extern char *opt_logname, *opt_slow_logname;
 
194
extern const char *log_output_str;
 
195
 
 
196
extern DRIZZLE_BIN_LOG drizzle_bin_log;
 
197
extern TableList general_log, slow_log;
 
198
extern FILE *stderror_file;
 
199
extern pthread_key_t THR_MALLOC;
 
200
extern pthread_mutex_t LOCK_drizzle_create_db,LOCK_open, LOCK_lock_db,
 
201
       LOCK_thread_count,LOCK_user_locks, LOCK_status,
 
202
       LOCK_error_log, LOCK_uuid_generator,
 
203
       LOCK_crypt, LOCK_timezone,
 
204
       LOCK_slave_list, LOCK_active_mi, LOCK_global_read_lock,
 
205
       LOCK_global_system_variables, LOCK_user_conn,
 
206
       LOCK_bytes_sent, LOCK_bytes_received, LOCK_connection_count;
 
207
extern pthread_mutex_t LOCK_server_started;
 
208
extern pthread_rwlock_t LOCK_sys_init_connect;
 
209
extern pthread_rwlock_t LOCK_sys_init_slave;
 
210
extern pthread_rwlock_t LOCK_system_variables_hash;
 
211
extern pthread_cond_t COND_refresh, COND_thread_count, COND_manager;
 
212
extern pthread_cond_t COND_global_read_lock;
 
213
extern pthread_attr_t connection_attrib;
 
214
extern I_List<Session> threads;
 
215
extern MY_BITMAP temp_pool;
 
216
extern String my_empty_string;
 
217
extern const String my_null_string;
 
218
extern SHOW_VAR status_vars[];
 
219
extern struct system_variables max_system_variables;
 
220
extern struct system_status_var global_status_var;
 
221
extern struct rand_struct sql_rand;
 
222
 
 
223
extern const char *opt_date_time_formats[];
 
224
extern KNOWN_DATE_TIME_FORMAT known_date_time_formats[];
 
225
 
 
226
extern Table *unused_tables;
 
227
extern const char* any_db;
 
228
extern struct my_option my_long_options[];
 
229
extern const LEX_STRING view_type;
 
230
extern TYPELIB thread_handling_typelib;
 
231
extern uint8_t uc_update_queries[SQLCOM_END+1];
 
232
extern std::bitset<5> sql_command_flags[];
 
233
extern TYPELIB log_output_typelib;
 
234
 
 
235
/* optional things, have_* variables */
 
236
extern SHOW_COMP_OPTION have_community_features;
 
237
 
 
238
extern handlerton *myisam_hton;
 
239
extern handlerton *heap_hton;
 
240
 
 
241
extern SHOW_COMP_OPTION have_symlink;
 
242
extern SHOW_COMP_OPTION have_compress;
 
243
 
 
244
 
 
245
extern pthread_t signal_thread;
 
246
 
 
247
DRIZZLE_LOCK *mysql_lock_tables(Session *session, Table **table, uint32_t count,
 
248
                              uint32_t flags, bool *need_reopen);
 
249
/* mysql_lock_tables() and open_table() flags bits */
 
250
#define DRIZZLE_LOCK_IGNORE_GLOBAL_READ_LOCK      0x0001
 
251
#define DRIZZLE_LOCK_IGNORE_FLUSH                 0x0002
 
252
#define DRIZZLE_LOCK_NOTIFY_IF_NEED_REOPEN        0x0004
 
253
#define DRIZZLE_OPEN_TEMPORARY_ONLY               0x0008
 
254
#define DRIZZLE_LOCK_IGNORE_GLOBAL_READ_ONLY      0x0010
 
255
#define DRIZZLE_LOCK_PERF_SCHEMA                  0x0020
 
256
 
 
257
void mysql_unlock_tables(Session *session, DRIZZLE_LOCK *sql_lock);
 
258
void mysql_unlock_read_tables(Session *session, DRIZZLE_LOCK *sql_lock);
 
259
void mysql_unlock_some_tables(Session *session, Table **table,uint32_t count);
 
260
void mysql_lock_remove(Session *session, DRIZZLE_LOCK *locked,Table *table,
 
261
                       bool always_unlock);
 
262
void mysql_lock_abort(Session *session, Table *table, bool upgrade_lock);
 
263
void mysql_lock_downgrade_write(Session *session, Table *table,
 
264
                                thr_lock_type new_lock_type);
 
265
bool mysql_lock_abort_for_thread(Session *session, Table *table);
 
266
DRIZZLE_LOCK *mysql_lock_merge(DRIZZLE_LOCK *a,DRIZZLE_LOCK *b);
 
267
TableList *mysql_lock_have_duplicate(Session *session, TableList *needle,
 
268
                                      TableList *haystack);
 
269
bool lock_global_read_lock(Session *session);
 
270
void unlock_global_read_lock(Session *session);
 
271
bool wait_if_global_read_lock(Session *session, bool abort_on_refresh,
 
272
                              bool is_not_commit);
 
273
void start_waiting_global_read_lock(Session *session);
 
274
bool make_global_read_lock_block_commit(Session *session);
 
275
bool set_protect_against_global_read_lock(void);
 
276
void unset_protect_against_global_read_lock(void);
 
277
void broadcast_refresh(void);
 
278
int try_transactional_lock(Session *session, TableList *table_list);
 
279
int check_transactional_lock(Session *session, TableList *table_list);
 
280
int set_handler_table_locks(Session *session, TableList *table_list,
 
281
                            bool transactional);
 
282
 
 
283
/* Lock based on name */
 
284
int lock_and_wait_for_table_name(Session *session, TableList *table_list);
 
285
int lock_table_name(Session *session, TableList *table_list, bool check_in_use);
 
286
void unlock_table_name(Session *session, TableList *table_list);
 
287
bool wait_for_locked_table_names(Session *session, TableList *table_list);
 
288
bool lock_table_names(Session *session, TableList *table_list);
 
289
void unlock_table_names(Session *session, TableList *table_list,
 
290
                        TableList *last_table);
 
291
bool lock_table_names_exclusively(Session *session, TableList *table_list);
 
292
bool is_table_name_exclusively_locked_by_this_thread(Session *session,
 
293
                                                     TableList *table_list);
 
294
bool is_table_name_exclusively_locked_by_this_thread(Session *session, unsigned char *key,
 
295
                                                     int key_length);
 
296
 
 
297
 
 
298
/* old unireg functions */
 
299
 
 
300
void unireg_init(ulong options);
 
301
void unireg_end(void) __attribute__((noreturn));
 
302
bool mysql_create_frm(Session *session, const char *file_name,
 
303
                      const char *db, const char *table,
 
304
                      HA_CREATE_INFO *create_info,
 
305
                      List<Create_field> &create_field,
 
306
                      uint32_t key_count,KEY *key_info,handler *db_type);
 
307
int rea_create_table(Session *session, const char *path,
 
308
                     const char *db, const char *table_name,
 
309
                     HA_CREATE_INFO *create_info,
 
310
                     List<Create_field> &create_field,
 
311
                     uint32_t key_count,KEY *key_info,
 
312
                     handler *file);
 
313
int format_number(uint32_t inputflag,uint32_t max_length,char * pos,uint32_t length,
 
314
                  char * *errpos);
 
315
 
 
316
/* table.cc */
 
317
TABLE_SHARE *alloc_table_share(TableList *table_list, char *key,
 
318
                               uint32_t key_length);
 
319
void init_tmp_table_share(Session *session, TABLE_SHARE *share, const char *key,
 
320
                          uint32_t key_length,
 
321
                          const char *table_name, const char *path);
 
322
void free_table_share(TABLE_SHARE *share);
 
323
int open_table_def(Session *session, TABLE_SHARE *share, uint32_t db_flags);
 
324
void open_table_error(TABLE_SHARE *share, int error, int db_errno, int errarg);
 
325
int open_table_from_share(Session *session, TABLE_SHARE *share, const char *alias,
 
326
                          uint32_t db_stat, uint32_t prgflag, uint32_t ha_open_flags,
 
327
                          Table *outparam, open_table_mode open_mode);
 
328
int readfrm(const char *name, unsigned char **data, size_t *length);
 
329
int writefrm(const char* name, const unsigned char* data, size_t len);
 
330
int closefrm(Table *table, bool free_share);
 
331
int read_string(File file, unsigned char* *to, size_t length);
 
332
void free_blobs(Table *table);
 
333
int set_zone(int nr,int min_zone,int max_zone);
 
334
uint32_t convert_period_to_month(uint32_t period);
 
335
uint32_t convert_month_to_period(uint32_t month);
 
336
void get_date_from_daynr(long daynr,uint32_t *year, uint32_t *month,
 
337
                         uint32_t *day);
 
338
my_time_t TIME_to_timestamp(Session *session, const DRIZZLE_TIME *t, bool *not_exist);
 
339
bool str_to_time_with_warn(const char *str,uint32_t length,DRIZZLE_TIME *l_time);
 
340
enum enum_drizzle_timestamp_type str_to_datetime_with_warn(const char *str, uint32_t length,
 
341
                                         DRIZZLE_TIME *l_time, uint32_t flags);
 
342
void localtime_to_TIME(DRIZZLE_TIME *to, struct tm *from);
 
343
void calc_time_from_sec(DRIZZLE_TIME *to, long seconds, long microseconds);
 
344
 
 
345
void make_truncated_value_warning(Session *session, DRIZZLE_ERROR::enum_warning_level level,
 
346
                                  const char *str_val,
 
347
                                  uint32_t str_length, enum enum_drizzle_timestamp_type time_type,
 
348
                                  const char *field_name);
 
349
 
 
350
bool date_add_interval(DRIZZLE_TIME *ltime, interval_type int_type, INTERVAL interval);
 
351
bool calc_time_diff(DRIZZLE_TIME *l_time1, DRIZZLE_TIME *l_time2, int l_sign,
 
352
                    int64_t *seconds_out, long *microseconds_out);
 
353
 
 
354
extern LEX_STRING interval_type_to_name[];
 
355
 
 
356
extern DATE_TIME_FORMAT *date_time_format_make(enum enum_drizzle_timestamp_type format_type,
 
357
                                               const char *format_str,
 
358
                                               uint32_t format_length);
 
359
extern DATE_TIME_FORMAT *date_time_format_copy(Session *session,
 
360
                                               DATE_TIME_FORMAT *format);
 
361
const char *get_date_time_format_str(KNOWN_DATE_TIME_FORMAT *format,
 
362
                                                             enum enum_drizzle_timestamp_type type);
 
363
void make_datetime(const DATE_TIME_FORMAT *format, const DRIZZLE_TIME *l_time,
 
364
                   String *str);
 
365
void make_date(const DATE_TIME_FORMAT *format, const DRIZZLE_TIME *l_time,
 
366
               String *str);
 
367
void make_time(const DATE_TIME_FORMAT *format, const DRIZZLE_TIME *l_time,
 
368
               String *str);
 
369
int my_time_compare(DRIZZLE_TIME *a, DRIZZLE_TIME *b);
 
370
uint64_t get_datetime_value(Session *session, Item ***item_arg, Item **cache_arg,
 
371
                             Item *warn_item, bool *is_null);
 
372
 
 
373
int test_if_number(char *str,int *res,bool allow_wildcards);
 
374
void change_byte(unsigned char *,uint,char,char);
 
375
void init_read_record(READ_RECORD *info, Session *session, Table *reg_form,
 
376
                      SQL_SELECT *select,
 
377
                      int use_record_cache, bool print_errors);
 
378
void init_read_record_idx(READ_RECORD *info, Session *session, Table *table,
 
379
                          bool print_error, uint32_t idx);
 
380
void end_read_record(READ_RECORD *info);
 
381
ha_rows filesort(Session *session, Table *form,struct st_sort_field *sortorder,
 
382
                 uint32_t s_length, SQL_SELECT *select,
 
383
                 ha_rows max_rows, bool sort_positions,
 
384
                 ha_rows *examined_rows);
 
385
void filesort_free_buffers(Table *table, bool full);
 
386
void change_double_for_sort(double nr,unsigned char *to);
 
387
double my_double_round(double value, int64_t dec, bool dec_unsigned,
 
388
                       bool truncate);
 
389
int get_quick_record(SQL_SELECT *select);
 
390
 
 
391
int calc_weekday(long daynr,bool sunday_first_day_of_week);
 
392
uint32_t calc_week(DRIZZLE_TIME *l_time, uint32_t week_behaviour, uint32_t *year);
 
393
void find_date(char *pos,uint32_t *vek,uint32_t flag);
 
394
TYPELIB *convert_strings_to_array_type(char * *typelibs, char * *end);
 
395
TYPELIB *typelib(MEM_ROOT *mem_root, List<String> &strings);
 
396
ulong get_form_pos(File file, unsigned char *head, TYPELIB *save_names);
 
397
ulong make_new_entry(File file,unsigned char *fileinfo,TYPELIB *formnames,
 
398
                     const char *newname);
 
399
ulong next_io_size(ulong pos);
 
400
void append_unescaped(String *res, const char *pos, uint32_t length);
 
401
int create_frm(Session *session, const char *name, const char *db, const char *table,
 
402
               uint32_t reclength, unsigned char *fileinfo,
 
403
               HA_CREATE_INFO *create_info, uint32_t keys, KEY *key_info);
 
404
int rename_table_proto_file(const char *from, const char* to);
 
405
int delete_table_proto_file(char *file_name);
 
406
int rename_file_ext(const char * from,const char * to,const char * ext);
 
407
bool check_db_name(LEX_STRING *db);
 
408
bool check_column_name(const char *name);
 
409
bool check_table_name(const char *name, uint32_t length);
 
410
char *get_field(MEM_ROOT *mem, Field *field);
 
411
bool get_field(MEM_ROOT *mem, Field *field, class String *res);
 
412
char *fn_rext(char *name);
 
413
 
 
414
/* Conversion functions */
 
415
uint32_t build_table_filename(char *buff, size_t bufflen, const char *db,
 
416
                          const char *table, const char *ext, uint32_t flags);
 
417
 
 
418
#define MYSQL50_TABLE_NAME_PREFIX         "#mysql50#"
 
419
#define MYSQL50_TABLE_NAME_PREFIX_LENGTH  sizeof(MYSQL50_TABLE_NAME_PREFIX)
 
420
 
 
421
/* Flags for conversion functions. */
 
422
#define FN_FROM_IS_TMP  (1 << 0)
 
423
#define FN_TO_IS_TMP    (1 << 1)
 
424
#define FN_IS_TMP       (FN_FROM_IS_TMP | FN_TO_IS_TMP)
 
425
#define NO_FRM_RENAME   (1 << 2)
 
426
 
 
427
/* item_func.cc */
 
428
Item *get_system_var(Session *session, enum_var_type var_type, LEX_STRING name,
 
429
                     LEX_STRING component);
 
430
int get_var_with_binlog(Session *session, enum_sql_command sql_command,
 
431
                        LEX_STRING &name, user_var_entry **out_entry);
 
432
/* log.cc */
 
433
bool flush_error_log(void);
 
434
 
 
435
 
 
436
inline ulong sql_rnd()
 
437
{
 
438
  ulong tmp= (ulong) (rand() * 0xffffffff); /* make all bits random */
 
439
 
 
440
  return tmp;
 
441
}
 
442
 
 
443
 
 
444
 
 
445
/**
 
446
  convert a hex digit into number.
 
447
*/
 
448
 
 
449
inline int hexchar_to_int(char c)
 
450
{
 
451
  if (c <= '9' && c >= '0')
 
452
    return c-'0';
 
453
  c|=32;
 
454
  if (c <= 'f' && c >= 'a')
 
455
    return c-'a'+10;
 
456
  return -1;
 
457
}
 
458
 
 
459
/*
 
460
  Some functions that are different in the embedded library and the normal
 
461
  server
 
462
*/
 
463
 
 
464
extern "C" void unireg_abort(int exit_code) __attribute__((noreturn));
 
465
bool check_stack_overrun(Session *session, long margin, unsigned char *dummy);
 
466
 
 
467
#endif /* DRIZZLE_SERVER_SERVER_INCLUDES_H */