diff options
Diffstat (limited to 'sql/mysql_priv.h')
| -rw-r--r-- | sql/mysql_priv.h | 594 |
1 files changed, 594 insertions, 0 deletions
diff --git a/sql/mysql_priv.h b/sql/mysql_priv.h new file mode 100644 index 00000000000..0963b4dd03a --- /dev/null +++ b/sql/mysql_priv.h @@ -0,0 +1,594 @@ +/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef _MYSQL_PRIV_H +#define _MYSQL_PRIV_H + +#include <global.h> +#include <my_sys.h> +#include <m_string.h> +#include "mysql_version.h" +#include <hash.h> +#include <signal.h> +#include <thr_lock.h> +#include <my_base.h> /* Needed by field.h */ +#include <violite.h> + +typedef ulong table_map; /* Used for table bits in join */ +typedef ulong key_map; /* Used for finding keys */ +typedef ulong key_part_map; /* Used for finding key parts */ + +#include "mysql_com.h" +#include "unireg.h" + +void init_sql_alloc(MEM_ROOT *root,uint block_size); +gptr sql_alloc(unsigned size); +gptr sql_calloc(unsigned size); +char *sql_strdup(const char *str); +char *sql_strmake(const char *str,uint len); +gptr sql_memdup(const void * ptr,unsigned size); +void sql_element_free(void *ptr); + +#define x_free(A) { my_free((gptr) (A),MYF(MY_WME | MY_FAE | MY_ALLOW_ZERO_PTR)); } +#define safeFree(x) { if(x) { my_free((gptr) x,MYF(0)); x = NULL; } } +#define PREV_BITS(type,A) ((type) (((type) 1 << (A)) -1)) +#define all_bits_set(A,B) ((A) & (B) != (B)) + +#ifndef LL +#ifdef HAVE_LONG_LONG +#define LL(A) A ## LL +#else +#define LL(A) A ## L +#endif +#endif + +/*************************************************************************** + Configuration parameters +****************************************************************************/ + +#define ACL_CACHE_SIZE 256 +#define HASH_PASSWORD_LENGTH 16 +#define HOST_CACHE_SIZE 128 +#define MAX_ACCEPT_RETRY 10 // Test accept this many times +#define MAX_BLOB_WIDTH 8192 // Default width for blob +#define MAX_FIELDS_BEFORE_HASH 32 +#define USER_VARS_HASH_SIZE 16 +#define STACK_MIN_SIZE 8192 // Abort if less stack during eval. +#ifndef MYSQLD_NET_RETRY_COUNT +#define MYSQLD_NET_RETRY_COUNT 10 // Abort read after this many int. +#endif +/* The following parameters is to decide when to use an extra cache to + optimise seeks when reading a big table in sorted order */ +#define MIN_FILE_LENGTH_TO_USE_ROW_CACHE (16L*1024*1024) +#define MIN_ROWS_TO_USE_TABLE_CACHE 100 + +// The following is used to decide if MySQL should use table scanning +// instead of reading with keys. The number says how many evaluation of the +// WHERE clause is comparable to reading one extra row from a table. +#define TIME_FOR_COMPARE 5 // 5 compares == one read + +/* Don't pack string keys shorter than this (if PACK_KEYS=1 isn't used) */ +#define KEY_DEFAULT_PACK_LENGTH 8 + +/* Characters shown for the command in 'show processlist' */ +#define PROCESS_LIST_WIDTH 100 + +/* Time handling defaults */ +#define TIMESTAMP_MAX_YEAR 2038 +#define YY_PART_YEAR 70 +#define PRECISION_FOR_DOUBLE 53 +#define PRECISION_FOR_FLOAT 24 + +/* The following can also be changed from the command line */ +#define CONNECT_TIMEOUT 5 // Do not wait long for connect +#define DEFAULT_CONCURRENCY 10 +#define DELAYED_LIMIT 100 /* pause after xxx inserts */ +#define DELAYED_QUEUE_SIZE 1000 +#define DELAYED_WAIT_TIMEOUT 5*60 /* Wait for delayed insert */ +#define FLUSH_TIME 0 /* Don't flush tables */ +#define MAX_CONNECT_ERRORS 10 // errors before disabling host + +#ifdef __WIN__ +#define IF_WIN(A,B) (A) +#undef FLUSH_TIME +#define FLUSH_TIME 1800 /* Flush every half hour */ + +#define INTERRUPT_PRIOR -2 +#define CONNECT_PRIOR -1 +#define WAIT_PRIOR 0 +#define QUERY_PRIOR 2 +#else +#define IF_WIN(A,B) (B) +#define INTERRUPT_PRIOR 10 +#define CONNECT_PRIOR 9 +#define WAIT_PRIOR 8 +#define QUERY_PRIOR 6 +#endif /* __WIN92__ */ + + /* Bits fro testflag */ +#define TEST_PRINT_CACHED_TABLES 1 +#define TEST_NO_KEY_GROUP 2 +#define TEST_MIT_THREAD 4 +#define TEST_BLOCKING 8 +#define TEST_KEEP_TMP_TABLES 16 +#define TEST_NO_THREADS 32 /* For debugging under Linux */ +#define TEST_READCHECK 64 /* Force use of readcheck */ +#define TEST_NO_EXTRA 128 +#define TEST_KILL_ON_DEBUG 256 /* Kill server */ + +/* options for select set by the yacc parser */ +#define SELECT_DISTINCT 1 +#define SELECT_STRAIGHT_JOIN 2 +#define SELECT_DESCRIBE 4 +#define SELECT_SMALL_RESULT 8 +#define SELECT_BIG_RESULT 16 +#define SELECT_HIGH_PRIORITY 64 /* Intern */ +#define SELECT_USE_CACHE 256 /* Intern */ +#define SELECT_COUNT_DISTINCT 512 /* Intern */ + +#define OPTION_BIG_TABLES 512 /* for SQL OPTION */ +#define OPTION_BIG_SELECTS 1024 /* for SQL OPTION */ +#define OPTION_LOG_OFF 2048 +#define OPTION_UPDATE_LOG 4096 /* update log flag */ +#define OPTION_LOW_PRIORITY_UPDATES 8192 +#define OPTION_WARNINGS 16384 +#define OPTION_AUTO_IS_NULL 32768 +#define OPTION_ANSI_MODE 65536L +#define OPTION_SAFE_UPDATES OPTION_ANSI_MODE*2 +#define OPTION_BUFFER_RESULT OPTION_SAFE_UPDATES*2 +#define OPTION_BIN_LOG OPTION_BUFFER_RESULT*2 +#define OPTION_AUTO_COMMIT OPTION_BIN_LOG*2 +#define OPTION_BEGIN OPTION_AUTO_COMMIT*2 + +#define RAID_BLOCK_SIZE 1024 + +/* BINLOG_DUMP options */ + +#define BINLOG_DUMP_NON_BLOCK 1 + +/* Some portable defines */ + +#define portable_sizeof_char_ptr 8 + +#define tmp_file_prefix "#sql" /* Prefix for tmp tables */ +#define tmp_file_prefix_length 4 + +struct st_table; +class THD; + +/* Struct to handle simple linked lists */ + +typedef struct st_sql_list { + uint elements; + byte *first; + byte **next; +} SQL_LIST; + + +uint nr_of_decimals(const char *str); /* Neaded by sql_string.h */ + +extern pthread_key(THD*, THR_THD); +inline THD *_current_thd(void) +{ + return my_pthread_getspecific_ptr(THD*,THR_THD); +} +#define current_thd _current_thd() + +#include "sql_string.h" +#include "sql_list.h" +#include "sql_map.h" +#include "handler.h" +#include "table.h" +#include "field.h" /* Field definitions */ +#include "sql_udf.h" +#include "item.h" +#include "sql_class.h" +#include "opt_range.h" + +int mysql_table_dump(THD* thd, char* db, char* tbl_name, int fd = -1); +// if fd is -1, dump to NET +int fetch_nx_table(THD* thd, MASTER_INFO* mi); +// retrieve non-exitent table from master +// the caller must set thd->last_nx_table and thd->last_nx_db first +int show_master_info(THD* thd); +int show_binlog_info(THD* thd); + +int db_ok(const char* db, I_List<i_string> &do_list, + I_List<i_string> &ignore_list ); +// check to see if the database is ok to operate on with respect to the +// do and ignore lists - used in replication + + +void mysql_create_db(THD *thd, char *db, uint create_info); +void mysql_binlog_send(THD* thd, char* log_ident, ulong pos, ushort flags); +int mysql_rm_table(THD *thd,TABLE_LIST *tables, my_bool if_exists); +int quick_rm_table(enum db_type base,const char *db, + const char *table_name); +bool mysql_change_db(THD *thd,const char *name); +void mysql_parse(THD *thd,char *inBuf,uint length); +pthread_handler_decl(handle_one_connection,arg); +int handle_bootstrap(THD *thd,FILE *file); +sig_handler end_thread_signal(int sig); +void end_thread(THD *thd,bool put_in_cache); +void flush_thread_cache(); +void mysql_execute_command(void); +bool do_command(THD *thd); +bool check_stack_overrun(THD *thd,char *dummy); +bool reload_acl_and_cache(uint options); +void mysql_rm_db(THD *thd,char *db,bool if_exists); +void table_cache_init(void); +void table_cache_free(void); +uint cached_tables(void); +void kill_mysql(void); +void close_connection(NET *net,uint errcode=0,bool lock=1); +bool check_access(THD *thd,uint access,const char *db=0,uint *save_priv=0, + bool no_grant=0); + +int mysql_check_table(THD* thd, TABLE_LIST* table_list, + HA_CHECK_OPT* check_opt); +int mysql_repair_table(THD* thd, TABLE_LIST* table_list, + HA_CHECK_OPT* check_opt); +int mysql_analyze_table(THD* thd, TABLE_LIST* table_list); +int mysql_optimize_table(THD* thd, TABLE_LIST* table_list); + + +/* net_pkg.c */ +void send_error(NET *net,uint sql_errno=0, const char *err=0); +void net_printf(NET *net,uint sql_errno, ...); +void send_ok(NET *net,ha_rows affected_rows=0L,ulonglong id=0L, + const char *info=0); +void send_eof(NET *net,bool no_flush=0); +char *net_store_length(char *packet,ulonglong length); +char *net_store_length(char *packet,uint length); +char *net_store_data(char *to,const char *from); +char *net_store_data(char *to,int32 from); +char *net_store_data(char *to,longlong from); +bool net_store_null(String *packet); +bool net_store_data(String *packet,uint32 from); +bool net_store_data(String *packet,longlong from); +bool net_store_data(String *packet,const char *from); +bool net_store_data(String *packet,const char *from,uint length); +bool net_store_data(String *packet,struct tm *tmp); +bool net_store_data(String* packet, I_List<i_string>* str_list); + +int mysql_select(THD *thd,TABLE_LIST *tables,List<Item> &list,COND *conds, + List<Item_func_match> &ftfuncs, + ORDER *order, ORDER *group,Item *having,ORDER *proc_param, + uint select_type,select_result *result); +Field *create_tmp_field(TABLE *table,Item *item, Item::Type type, + Item_result_field ***copy_func, Field **from_field, + bool group,bool modify_item); +int mysql_create_table(THD *thd,const char *db, const char *table_name, + HA_CREATE_INFO *create_info, + List<create_field> &fields, List<Key> &keys, + bool tmp_table, bool no_log); +// no_log is needed for the case of CREATE TABLE ... SELECT , as the logging +// will be done later in sql_insert.cc + +TABLE *create_table_from_items(THD *thd, HA_CREATE_INFO *create_info, + const char *db, const char *name, + List<create_field> *extra_fields, + List<Key> *keys, + List<Item> *items, + MYSQL_LOCK **lock); +int mysql_alter_table(THD *thd, char *new_db, char *new_name, + HA_CREATE_INFO *create_info, + TABLE_LIST *table_list, + List<create_field> &fields, + List<Key> &keys,List<Alter_drop> &drop_list, + List<Alter_column> &alter_list, + bool drop_primary, + enum enum_duplicates handle_duplicates); +bool close_cached_table(THD *thd,TABLE *table); +int mysql_create_index(THD *thd, TABLE_LIST *table_list, List<Key> &keys); +int mysql_drop_index(THD *thd, TABLE_LIST *table_list, + List<Alter_drop> &drop_list); +int mysql_update(THD *thd,TABLE_LIST *tables,List<Item> &fields, + List<Item> &values,COND *conds, ha_rows limit, + enum enum_duplicates handle_duplicates, + thr_lock_type lock_type); +int mysql_insert(THD *thd,TABLE_LIST *table,List<Item> &fields, + List<List_item> &values, enum_duplicates flag, + thr_lock_type lock_type); +void kill_delayed_threads(void); +int mysql_delete(THD *thd,TABLE_LIST *table,COND *conds,ha_rows rows, + thr_lock_type lock_type); +TABLE *open_ltable(THD *thd, TABLE_LIST *table_list, thr_lock_type update); +TABLE *open_table(THD *thd,const char *db,const char *table,const char *alias, + bool *refresh); +TABLE *find_locked_table(THD *thd, const char *db,const char *table_name); +bool reopen_table(TABLE *table,bool locked=0); +bool reopen_tables(THD *thd,bool get_locks,bool in_refresh); +void close_old_data_files(THD *thd, TABLE *table, bool abort_locks); +bool close_data_tables(THD *thd,const char *db, const char *table_name); +bool wait_for_tables(THD *thd); +bool drop_locked_tables(THD *thd,const char *db, const char *table_name); +void abort_locked_tables(THD *thd,const char *db, const char *table_name); +Field *find_field_in_tables(THD *thd,Item_field *item,TABLE_LIST *tables); +Field *find_field_in_table(THD *thd,TABLE *table,const char *name,uint length, + bool check_grant,bool allow_rowid); + +/* sql_list.c */ +int mysqld_show_dbs(THD *thd,const char *wild); +int mysqld_show_tables(THD *thd,const char *db,const char *wild); +int mysqld_extend_show_tables(THD *thd,const char *db,const char *wild); +int mysqld_show_fields(THD *thd,TABLE_LIST *table, const char *wild); +int mysqld_show_keys(THD *thd, TABLE_LIST *table); +void mysqld_list_fields(THD *thd,TABLE_LIST *table, const char *wild); +int mysqld_dump_create_info(THD *thd, TABLE *table, int fd = -1); +int mysqld_show_create(THD *thd, TABLE_LIST *table_list); + +void mysqld_list_processes(THD *thd,const char *user,bool verbose); +int mysqld_show_status(THD *thd); +int mysqld_show_variables(THD *thd,const char *wild); +int mysqld_show(THD *thd, const char *wild, show_var_st *variables); + +/* sql_base.cc */ +void set_item_name(Item *item,char *pos,uint length); +bool add_field_to_list(char *field_name, enum enum_field_types type, + char *length, char *decimal, + uint type_modifier, Item *default_value,char *change, + TYPELIB *interval); +void store_position_for_column(const char *name); +bool add_to_list(SQL_LIST &list,Item *group,bool asc=0); +TABLE_LIST *add_table_to_list(Table_ident *table,LEX_STRING *alias, + thr_lock_type flags=TL_UNLOCK, + List<String> *use_index=0, + List<String> *ignore_index=0); +void add_join_on(TABLE_LIST *b,Item *expr); +void add_join_natural(TABLE_LIST *a,TABLE_LIST *b); +bool add_proc_to_list(Item *item); +TABLE *unlink_open_table(THD *thd,TABLE *list,TABLE *find); + +SQL_SELECT *make_select(TABLE *head, table_map const_tables, + table_map read_tables, COND *conds, int *error); +Item ** find_item_in_list(Item *item,List<Item> &items); +int setup_fields(THD *thd,TABLE_LIST *tables,List<Item> &item, + bool set_query_id,List<Item> *sum_func_list); +int setup_conds(THD *thd,TABLE_LIST *tables,COND **conds); +int setup_ftfuncs(THD *thd,TABLE_LIST *tables, List<Item_func_match> &ftfuncs); +void wait_for_refresh(THD *thd); +int open_tables(THD *thd,TABLE_LIST *tables); +int open_and_lock_tables(THD *thd,TABLE_LIST *tables); +int lock_tables(THD *thd,TABLE_LIST *tables); +TABLE *open_temporary_table(THD *thd, const char *path, const char *db, + const char *table_name, bool link_in_list); +bool rm_temporary_table(enum db_type base, char *path); +bool send_fields(THD *thd,List<Item> &item,uint send_field_count); +void free_io_cache(TABLE *entry); +void intern_close_table(TABLE *entry); +void close_thread_tables(THD *thd,bool locked=0); +void close_temporary_tables(THD *thd); +TABLE **find_temporary_table(THD *thd, const char *db, const char *table_name); +bool close_temporary_table(THD *thd, const char *db, const char *table_name); +void close_temporary(TABLE *table, bool delete_table=1); +bool rename_temporary_table(TABLE *table, const char *new_db, + const char *table_name); +void remove_db_from_cache(const my_string db); +void flush_tables(); +bool remove_table_from_cache(THD *thd, const char *db, const char *table); +bool close_cached_tables(bool wait_for_refresh); +void copy_field_from_tmp_record(Field *field,int offset); +int fill_record(List<Item> &fields,List<Item> &values); +int fill_record(Field **field,List<Item> &values); + +/* sql_calc.cc */ +bool eval_const_cond(COND *cond); + +/* sql_load.cc */ +int mysql_load(THD *thd,sql_exchange *ex, TABLE_LIST *table_list, + List<Item> &fields, enum enum_duplicates handle_duplicates, + bool local_file,thr_lock_type lock_type); +int write_record(TABLE *table,COPY_INFO *info); +/* sql_test.cc */ +#ifndef DBUG_OFF +void print_where(COND *cond,const char *info); +void print_cached_tables(void); +void TEST_filesort(TABLE **form,SORT_FIELD *sortorder,uint s_length, + ha_rows special); +#endif +void mysql_print_status(THD *thd); +/* key.cc */ +int find_ref_key(TABLE *form,Field *field, uint *offset); +void key_copy(byte *key,TABLE *form,uint index,uint key_length); +void key_restore(TABLE *form,byte *key,uint index,uint key_length); +int key_cmp(TABLE *form,const byte *key,uint index,uint key_length); +void key_unpack(String *to,TABLE *form,uint index); +bool check_if_key_used(TABLE *table, uint idx, List<Item> &fields); +void init_errmessage(void); + +void sql_perror(const char *message); +void sql_print_error(const char *format,...) + __attribute__ ((format (printf, 1, 2))); + +extern char mysql_data_home[2],server_version[50],max_sort_char, + mysql_real_data_home[]; +extern my_string mysql_unix_port,mysql_tmpdir; +extern const char *first_keyword; +extern ulong refresh_version,flush_version, thread_id,query_id,opened_tables, + created_tmp_tables, aborted_threads,aborted_connects, + delayed_insert_timeout, + delayed_insert_limit, delayed_queue_size, + delayed_insert_threads, delayed_insert_writes, + delayed_rows_in_use,delayed_insert_errors; +extern uint test_flags,select_errors,mysql_port,ha_open_options; +extern ulong thd_startup_options, slow_launch_threads, slow_launch_time; +extern time_t start_time; +extern const char *command_name[]; +extern I_List<THD> threads; +extern MYSQL_LOG mysql_log,mysql_update_log,mysql_slow_log,mysql_bin_log; +extern pthread_key(MEM_ROOT*,THR_MALLOC); +extern pthread_key(NET*, THR_NET); +extern pthread_mutex_t LOCK_mysql_create_db,LOCK_Acl,LOCK_open, + LOCK_thread_count,LOCK_mapped_file,LOCK_user_locks, LOCK_status, + LOCK_grant, LOCK_error_log, LOCK_delayed_insert, + LOCK_delayed_status, LOCK_delayed_create, LOCK_crypt, LOCK_timezone, + LOCK_binlog_update, LOCK_slave; +extern pthread_cond_t COND_refresh,COND_thread_count, COND_binlog_update, + COND_slave_stopped; +extern pthread_attr_t connection_attrib; +extern bool opt_endinfo,using_udf_functions; +extern ulong ha_read_count, ha_write_count, ha_delete_count, ha_update_count, + ha_read_key_count, ha_read_next_count, ha_read_prev_count, + ha_read_first_count, ha_read_last_count, + ha_read_rnd_count, ha_read_rnd_next_count; + +extern char f_fyllchar; +extern uchar *days_in_month; +extern DATE_FORMAT dayord; +extern double log_10[32]; +extern uint protocol_version,dropping_tables; +extern ulong keybuff_size,sortbuff_size,max_item_sort_length,table_cache_size, + max_join_size,join_buff_size,tmp_table_size, + max_connections,max_connect_errors,long_query_time, + max_insert_delayed_threads, + long_query_count,net_wait_timeout,net_interactive_timeout, + net_read_timeout,net_write_timeout, + what_to_log,flush_time, + max_tmp_tables,max_heap_table_size,query_buff_size, + lower_case_table_names,thread_stack,thread_stack_min; +extern ulong specialflag; +extern ulong current_pid; +extern bool low_priority_updates; +extern bool opt_sql_bin_update; +extern char language[LIBLEN],reg_ext[FN_EXTLEN],blob_newline; +extern const char **errmesg; /* Error messages */ +extern byte last_ref[MAX_REFLENGTH]; /* Index ref of keys */ +extern String empty_string; +extern struct show_var_st init_vars[]; +extern struct show_var_st status_vars[]; +extern enum db_type default_table_type; + +#ifndef __WIN__ +extern pthread_t signal_thread; +#endif + +extern bool volatile abort_loop, shutdown_in_progress, grant_option; +extern uint volatile thread_count, thread_running, global_read_lock; + +MYSQL_LOCK *mysql_lock_tables(THD *thd,TABLE **table,uint count); +void mysql_unlock_tables(THD *thd, MYSQL_LOCK *sql_lock); +void mysql_unlock_read_tables(THD *thd, MYSQL_LOCK *sql_lock); +void mysql_unlock_some_tables(THD *thd, TABLE **table,uint count); +void mysql_lock_remove(THD *thd, MYSQL_LOCK *locked,TABLE *table); +void mysql_lock_abort(THD *thd, TABLE *table); +MYSQL_LOCK *mysql_lock_merge(MYSQL_LOCK *a,MYSQL_LOCK *b); + +extern int flush_master_info(MASTER_INFO* mi); + +/* old unireg functions */ + +void unireg_init(ulong options); +void unireg_end(int signal); +int rea_create_table(my_string file_name,HA_CREATE_INFO *create_info, + List<create_field> &create_field, + uint key_count,KEY *key_info); +int format_number(uint inputflag,uint max_length,my_string pos,uint length, + my_string *errpos); +int openfrm(const char *name,const char *alias,uint filestat,uint prgflag, + TABLE *outparam); +int closefrm(TABLE *table); +db_type get_table_type(const char *name); +int read_string(File file, gptr *to, uint length); +void free_blobs(TABLE *table); +int set_zone(int nr,int min_zone,int max_zone); +ulong convert_period_to_month(ulong period); +ulong convert_month_to_period(ulong month); +long calc_daynr(uint year,uint month,uint day); +uint calc_days_in_year(uint year); +void get_date_from_daynr(long daynr,uint *year, uint *month, + uint *day); +void init_time(void); +long my_gmt_sec(TIME *); +time_t str_to_timestamp(const char *str,uint length); +bool str_to_time(const char *str,uint length,TIME *l_time); +longlong str_to_datetime(const char *str,uint length,bool fuzzy_date); +timestamp_type str_to_TIME(const char *str, uint length, TIME *l_time, + bool fuzzy_date); + +int test_if_number(char *str,int *res,bool allow_wildcards); +void change_byte(byte *,uint,char,char); +void unireg_abort(int exit_code); +void init_read_record(READ_RECORD *info, THD *thd, TABLE *reg_form, + SQL_SELECT *select, + bool use_record_cache, bool print_errors); +void end_read_record(READ_RECORD *info); +ha_rows filesort(TABLE **form,struct st_sort_field *sortorder, uint s_length, + SQL_SELECT *select, ha_rows special,ha_rows max_rows); +void change_double_for_sort(double nr,byte *to); +int get_quick_record(SQL_SELECT *select); +int calc_weekday(long daynr,bool sunday_first_day_of_week); +uint calc_week(TIME *ltime, bool with_year, bool sunday_first_day_of_week, + uint *year); +void find_date(char *pos,uint *vek,uint flag); +TYPELIB *convert_strings_to_array_type(my_string *typelibs, my_string *end); +TYPELIB *typelib(List<String> &strings); +void clean_up(void); +ulong get_form_pos(File file, uchar *head, TYPELIB *save_names); +ulong make_new_entry(File file,uchar *fileinfo,TYPELIB *formnames, + const char *newname); +ulong next_io_size(ulong pos); +void append_unescaped(String *res,const char *pos); +int create_frm(char *name,uint reclength,uchar *fileinfo, + HA_CREATE_INFO *create_info, uint keys); +void update_create_info_from_table(HA_CREATE_INFO *info, TABLE *form); +int rename_file_ext(const char * from,const char * to,const char * ext); +bool check_db_name(const char *db); +bool check_column_name(const char *name); +bool check_table_name(const char *name, uint length); +char *get_field(MEM_ROOT *mem,TABLE *table,uint fieldnr); +int wild_case_compare(const char *str,const char *wildstr); +/* from hostname.cc */ +struct in_addr; +my_string ip_to_hostname(struct in_addr *in,uint *errors); +void inc_host_errors(struct in_addr *in); +void reset_host_errors(struct in_addr *in); +bool hostname_cache_init(); +void hostname_cache_free(); +void hostname_cache_refresh(void); +bool get_interval_info(const char *str,uint length,uint count, + long *values); +/* sql_cache */ + +extern bool sql_cache_init(); +extern void sql_cache_free(); +extern int sql_cache_hit(THD *thd, char *inBuf, uint length); + +/* Some inline functions for more speed */ + +inline bool add_item_to_list(Item *item) +{ + return current_lex->item_list.push_back(item); +} +inline bool add_value_to_list(Item *value) +{ + return current_lex->value_list.push_back(value); +} +inline bool add_order_to_list(Item *item,bool asc) +{ + return add_to_list(current_lex->order_list,item,asc); +} +inline bool add_group_to_list(Item *item,bool asc) +{ + return add_to_list(current_lex->group_list,item,asc); +} +inline void mark_as_null_row(TABLE *table) +{ + table->null_row=1; + bfill(table->null_flags,table->null_bytes,255); +} + +#endif |