home *** CD-ROM | disk | FTP | other *** search
/ Chip 2001 January / Chip_2001-01_cd1.bin / tema / mysql / mysql-3.23.28g-win-source.exe / sql / mysql_priv.h < prev    next >
C/C++ Source or Header  |  2000-11-21  |  25KB  |  633 lines
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  2.  
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  7.  
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  12.  
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  16.  
  17. #ifndef _MYSQL_PRIV_H
  18. #define _MYSQL_PRIV_H
  19.  
  20. #include <global.h>
  21. #include <my_sys.h>
  22. #include <m_string.h>
  23. #include "mysql_version.h"
  24. #include <hash.h>
  25. #include <signal.h>
  26. #include <thr_lock.h>
  27. #include <my_base.h>            /* Needed by field.h */
  28. #include <violite.h>
  29.  
  30. typedef ulong table_map;        /* Used for table bits in join */
  31. typedef ulong key_map;            /* Used for finding keys */
  32. typedef ulong key_part_map;        /* Used for finding key parts */
  33.  
  34. #include "mysql_com.h"
  35. #include "unireg.h"
  36.  
  37. void init_sql_alloc(MEM_ROOT *root, uint block_size, uint pre_alloc_size);
  38. gptr sql_alloc(unsigned size);
  39. gptr sql_calloc(unsigned size);
  40. char *sql_strdup(const char *str);
  41. char *sql_strmake(const char *str,uint len);
  42. gptr sql_memdup(const void * ptr,unsigned size);
  43. void sql_element_free(void *ptr);
  44. void kill_one_thread(THD *thd, ulong id);
  45.  
  46. #define x_free(A)    { my_free((gptr) (A),MYF(MY_WME | MY_FAE | MY_ALLOW_ZERO_PTR)); }
  47. #define safeFree(x)    { if(x) { my_free((gptr) x,MYF(0)); x = NULL; } }
  48. #define PREV_BITS(type,A)    ((type) (((type) 1 << (A)) -1))
  49. #define all_bits_set(A,B) ((A) & (B) != (B))
  50.  
  51. #ifndef LL
  52. #ifdef HAVE_LONG_LONG
  53. #define LL(A) A ## LL
  54. #else
  55. #define LL(A) A ## L
  56. #endif
  57. #endif
  58.  
  59. /***************************************************************************
  60.   Configuration parameters
  61. ****************************************************************************/
  62.  
  63. #define ACL_CACHE_SIZE        256
  64. #define HASH_PASSWORD_LENGTH    16
  65. #define HOST_CACHE_SIZE        128
  66. #define MAX_ACCEPT_RETRY    10    // Test accept this many times
  67. #define MAX_BLOB_WIDTH        8192    // Default width for blob
  68. #define MAX_FIELDS_BEFORE_HASH    32
  69. #define USER_VARS_HASH_SIZE     16
  70. #define STACK_MIN_SIZE        8192    // Abort if less stack during eval.
  71. #ifndef MYSQLD_NET_RETRY_COUNT
  72. #define MYSQLD_NET_RETRY_COUNT  10    // Abort read after this many int.
  73. #endif
  74. /* The following parameters is to decide when to use an extra cache to
  75.    optimise seeks when reading a big table in sorted order */
  76. #define MIN_FILE_LENGTH_TO_USE_ROW_CACHE (16L*1024*1024)
  77. #define MIN_ROWS_TO_USE_TABLE_CACHE     100
  78.  
  79. // The following is used to decide if MySQL should use table scanning
  80. // instead of reading with keys.  The number says how many evaluation of the
  81. // WHERE clause is comparable to reading one extra row from a table.
  82. #define TIME_FOR_COMPARE   5    // 5 compares == one read
  83. // Number of rows in a reference table when refereed through a not unique key.
  84. // This value is only used when we don't know anything about the key
  85. // distribution.
  86. #define MATCHING_ROWS_IN_OTHER_TABLE 10
  87.  
  88. /* Don't pack string keys shorter than this (if PACK_KEYS=1 isn't used) */
  89. #define KEY_DEFAULT_PACK_LENGTH 8
  90.  
  91. /* Characters shown for the command in 'show processlist' */
  92. #define PROCESS_LIST_WIDTH 100
  93.  
  94. /* Time handling defaults */
  95. #define TIMESTAMP_MAX_YEAR 2038
  96. #define YY_PART_YEAR       70
  97. #define PRECISION_FOR_DOUBLE 53
  98. #define PRECISION_FOR_FLOAT  24
  99.  
  100. /* The following can also be changed from the command line */
  101. #define CONNECT_TIMEOUT        5        // Do not wait long for connect
  102. #define DEFAULT_CONCURRENCY    10
  103. #define DELAYED_LIMIT        100        /* pause after xxx inserts */
  104. #define DELAYED_QUEUE_SIZE    1000
  105. #define DELAYED_WAIT_TIMEOUT    5*60        /* Wait for delayed insert */
  106. #define FLUSH_TIME        0        /* Don't flush tables */
  107. #define MAX_CONNECT_ERRORS    10        // errors before disabling host
  108.  
  109. #ifdef    __WIN__
  110. #define IF_WIN(A,B) (A)
  111. #undef    FLUSH_TIME
  112. #define FLUSH_TIME    1800            /* Flush every half hour */
  113.  
  114. #define INTERRUPT_PRIOR -2
  115. #define CONNECT_PRIOR    -1
  116. #define WAIT_PRIOR    0
  117. #define QUERY_PRIOR    2
  118. #else
  119. #define IF_WIN(A,B) (B)
  120. #define INTERRUPT_PRIOR 10
  121. #define CONNECT_PRIOR    9
  122. #define WAIT_PRIOR    8
  123. #define QUERY_PRIOR    6
  124. #endif /* __WIN92__ */
  125.  
  126.     /* Bits fro testflag */
  127. #define TEST_PRINT_CACHED_TABLES 1
  128. #define TEST_NO_KEY_GROUP     2
  129. #define TEST_MIT_THREAD        4
  130. #define TEST_BLOCKING        8
  131. #define TEST_KEEP_TMP_TABLES    16
  132. #define TEST_NO_THREADS        32    /* For debugging under Linux */
  133. #define TEST_READCHECK        64    /* Force use of readcheck */
  134. #define TEST_NO_EXTRA        128
  135. #define TEST_CORE_ON_SIGNAL    256    /* Give core if signal */
  136.  
  137. /* options for select set by the yacc parser */
  138. #define SELECT_DISTINCT        1
  139. #define SELECT_STRAIGHT_JOIN    2
  140. #define SELECT_DESCRIBE        4
  141. #define SELECT_SMALL_RESULT    8
  142. #define SELECT_BIG_RESULT    16
  143. #define SELECT_HIGH_PRIORITY    64        /* Intern */
  144. #define SELECT_USE_CACHE    256        /* Intern */
  145. #define SELECT_COUNT_DISTINCT    512        /* Intern */
  146.  
  147. #define OPTION_BIG_TABLES    512        /* for SQL OPTION */
  148. #define OPTION_BIG_SELECTS    1024        /* for SQL OPTION */
  149. #define OPTION_LOG_OFF        2048
  150. #define OPTION_UPDATE_LOG    4096        /* update log flag */
  151. #define OPTION_LOW_PRIORITY_UPDATES    8192
  152. #define OPTION_WARNINGS        16384
  153. #define OPTION_AUTO_IS_NULL    32768
  154. #define OPTION_ANSI_MODE    65536L
  155. #define OPTION_SAFE_UPDATES    OPTION_ANSI_MODE*2
  156. #define OPTION_BUFFER_RESULT    OPTION_SAFE_UPDATES*2
  157. #define OPTION_BIN_LOG          OPTION_BUFFER_RESULT*2
  158. #define OPTION_AUTO_COMMIT    OPTION_BIN_LOG*2
  159. #define OPTION_BEGIN        OPTION_AUTO_COMMIT*2
  160. #define OPTION_QUICK        OPTION_BEGIN*2
  161. #define OPTION_QUOTE_SHOW_CREATE OPTION_QUICK*2
  162.  
  163. /* The following is set when parsing the query */
  164. #define OPTION_NO_INDEX_USED        OPTION_QUOTE_SHOW_CREATE*2
  165. #define OPTION_NO_GOOD_INDEX_USED    OPTION_NO_INDEX_USED*2
  166.  
  167. #define RAID_BLOCK_SIZE 1024
  168.  
  169. /* BINLOG_DUMP options */
  170.  
  171. #define BINLOG_DUMP_NON_BLOCK   1
  172.  
  173. /* Some portable defines */
  174.  
  175. #define portable_sizeof_char_ptr 8
  176.  
  177. #define tmp_file_prefix "#sql"            /* Prefix for tmp tables */
  178. #define tmp_file_prefix_length 4
  179.  
  180. struct st_table;
  181. class THD;
  182.  
  183. /* Struct to handle simple linked lists */
  184.  
  185. typedef struct st_sql_list {
  186.   uint elements;
  187.   byte *first;
  188.   byte **next;
  189. } SQL_LIST;
  190.  
  191.  
  192. uint nr_of_decimals(const char *str);        /* Neaded by sql_string.h */
  193.  
  194. extern pthread_key(THD*, THR_THD);
  195. inline THD *_current_thd(void)
  196. {
  197.   return my_pthread_getspecific_ptr(THD*,THR_THD);
  198. }
  199. #define current_thd _current_thd()
  200.  
  201. #include "sql_string.h"
  202. #include "sql_list.h"
  203. #include "sql_map.h"
  204. #include "handler.h"
  205. #include "table.h"
  206. #include "field.h"                /* Field definitions */
  207. #include "sql_udf.h"
  208. #include "item.h"
  209. #include "sql_class.h"
  210. #include "opt_range.h"
  211.  
  212.  
  213. void mysql_create_db(THD *thd, char *db, uint create_info);
  214. void mysql_binlog_send(THD* thd, char* log_ident, ulong pos, ushort flags);
  215. int mysql_rm_table(THD *thd,TABLE_LIST *tables, my_bool if_exists);
  216. int quick_rm_table(enum db_type base,const char *db,
  217.            const char *table_name);
  218. bool mysql_rename_tables(THD *thd, TABLE_LIST *table_list);
  219. bool mysql_change_db(THD *thd,const char *name);
  220. void mysql_parse(THD *thd,char *inBuf,uint length);
  221. void mysql_init_select(LEX *lex);
  222. pthread_handler_decl(handle_one_connection,arg);
  223. int handle_bootstrap(THD *thd,FILE *file);
  224. sig_handler end_thread_signal(int sig);
  225. void end_thread(THD *thd,bool put_in_cache);
  226. void flush_thread_cache();
  227. void mysql_execute_command(void);
  228. bool do_command(THD *thd);
  229. bool check_stack_overrun(THD *thd,char *dummy);
  230. bool reload_acl_and_cache(THD *thd, uint options, TABLE_LIST *tables);
  231. void mysql_rm_db(THD *thd,char *db,bool if_exists);
  232. void table_cache_init(void);
  233. void table_cache_free(void);
  234. uint cached_tables(void);
  235. void kill_mysql(void);
  236. void close_connection(NET *net,uint errcode=0,bool lock=1);
  237. bool check_access(THD *thd,uint access,const char *db=0,uint *save_priv=0,
  238.           bool no_grant=0);
  239.  
  240. int generate_table(THD *thd, TABLE_LIST *table_list,
  241.            TABLE *locked_table);
  242.  
  243.  
  244. int mysql_backup_table(THD* thd, TABLE_LIST* table_list);
  245. int mysql_restore_table(THD* thd, TABLE_LIST* table_list);
  246.  
  247. int mysql_check_table(THD* thd, TABLE_LIST* table_list,
  248.               HA_CHECK_OPT* check_opt);
  249. int mysql_repair_table(THD* thd, TABLE_LIST* table_list,
  250.                HA_CHECK_OPT* check_opt);
  251. int mysql_analyze_table(THD* thd, TABLE_LIST* table_list,
  252.             HA_CHECK_OPT* check_opt);
  253. int mysql_optimize_table(THD* thd, TABLE_LIST* table_list,
  254.              HA_CHECK_OPT* check_opt);
  255.  
  256. /* net_pkg.c */
  257. void send_error(NET *net,uint sql_errno=0, const char *err=0);
  258. void net_printf(NET *net,uint sql_errno, ...);
  259. void send_ok(NET *net,ha_rows affected_rows=0L,ulonglong id=0L,
  260.          const char *info=0);
  261. void send_eof(NET *net,bool no_flush=0);
  262. char *net_store_length(char *packet,ulonglong length);
  263. char *net_store_length(char *packet,uint length);
  264. char *net_store_data(char *to,const char *from);
  265. char *net_store_data(char *to,int32 from);
  266. char *net_store_data(char *to,longlong from);
  267. bool net_store_null(String *packet);
  268. bool net_store_data(String *packet,uint32 from);
  269. bool net_store_data(String *packet,longlong from);
  270. bool net_store_data(String *packet,const char *from);
  271. bool net_store_data(String *packet,const char *from,uint length);
  272. bool net_store_data(String *packet,struct tm *tmp);
  273. bool net_store_data(String* packet, I_List<i_string>* str_list);
  274.  
  275. SORT_FIELD * make_unireg_sortorder(ORDER *order, uint *length);
  276. int setup_order(THD *thd,TABLE_LIST *tables, List<Item> &fields,
  277.                 List <Item> &all_fields, ORDER *order);
  278.  
  279. int mysql_select(THD *thd,TABLE_LIST *tables,List<Item> &list,COND *conds,
  280.                  List<Item_func_match> &ftfuncs,
  281.          ORDER *order, ORDER *group,Item *having,ORDER *proc_param,
  282.          uint select_type,select_result *result);
  283. Field *create_tmp_field(TABLE *table,Item *item, Item::Type type,
  284.             Item_result_field ***copy_func, Field **from_field,
  285.             bool group,bool modify_item);
  286. int mysql_create_table(THD *thd,const char *db, const char *table_name,
  287.                HA_CREATE_INFO *create_info,
  288.                List<create_field> &fields, List<Key> &keys,
  289.                bool tmp_table, bool no_log);
  290. // no_log is needed for the case of CREATE TABLE ... SELECT , as the logging
  291. // will be done later in sql_insert.cc
  292.  
  293. TABLE *create_table_from_items(THD *thd, HA_CREATE_INFO *create_info,
  294.                    const char *db, const char *name,
  295.                    List<create_field> *extra_fields,
  296.                    List<Key> *keys,
  297.                    List<Item> *items,
  298.                    MYSQL_LOCK **lock);
  299. int mysql_alter_table(THD *thd, char *new_db, char *new_name,
  300.               HA_CREATE_INFO *create_info,
  301.               TABLE_LIST *table_list,
  302.               List<create_field> &fields,
  303.               List<Key> &keys,List<Alter_drop> &drop_list,
  304.               List<Alter_column> &alter_list,
  305.                       ORDER *order,
  306.               bool drop_primary,
  307.               enum enum_duplicates handle_duplicates);
  308. bool mysql_rename_table(enum db_type base,
  309.             const char *old_db,
  310.             const char * old_name,
  311.             const char *new_db,
  312.             const char * new_name);
  313. bool close_cached_table(THD *thd,TABLE *table);
  314. int mysql_create_index(THD *thd, TABLE_LIST *table_list, List<Key> &keys);
  315. int mysql_drop_index(THD *thd, TABLE_LIST *table_list,
  316.              List<Alter_drop> &drop_list);
  317. int mysql_update(THD *thd,TABLE_LIST *tables,List<Item> &fields,
  318.          List<Item> &values,COND *conds, ha_rows limit,
  319.          enum enum_duplicates handle_duplicates,
  320.          thr_lock_type lock_type);
  321. int mysql_insert(THD *thd,TABLE_LIST *table,List<Item> &fields,
  322.          List<List_item> &values, enum_duplicates flag,
  323.          thr_lock_type lock_type);
  324. void kill_delayed_threads(void);
  325. int mysql_delete(THD *thd,TABLE_LIST *table,COND *conds,ha_rows rows,
  326.          thr_lock_type lock_type, ulong options);
  327. TABLE *open_ltable(THD *thd, TABLE_LIST *table_list, thr_lock_type update);
  328. TABLE *open_table(THD *thd,const char *db,const char *table,const char *alias,
  329.           bool *refresh);
  330. TABLE *reopen_name_locked_table(THD* thd, TABLE_LIST* table);
  331. TABLE *find_locked_table(THD *thd, const char *db,const char *table_name);
  332. bool reopen_table(TABLE *table,bool locked=0);
  333. bool reopen_tables(THD *thd,bool get_locks,bool in_refresh);
  334. void close_old_data_files(THD *thd, TABLE *table, bool abort_locks,
  335.               bool send_refresh);
  336. bool close_data_tables(THD *thd,const char *db, const char *table_name);
  337. bool wait_for_tables(THD *thd);
  338. bool table_is_used(TABLE *table, bool wait_for_name_lock);
  339. bool drop_locked_tables(THD *thd,const char *db, const char *table_name);
  340. void abort_locked_tables(THD *thd,const char *db, const char *table_name);
  341. Field *find_field_in_tables(THD *thd,Item_field *item,TABLE_LIST *tables);
  342. Field *find_field_in_table(THD *thd,TABLE *table,const char *name,uint length,
  343.                bool check_grant,bool allow_rowid);
  344.  
  345. /* sql_list.c */
  346. int mysqld_show_dbs(THD *thd,const char *wild);
  347. int mysqld_show_tables(THD *thd,const char *db,const char *wild);
  348. int mysqld_extend_show_tables(THD *thd,const char *db,const char *wild);
  349. int mysqld_show_fields(THD *thd,TABLE_LIST *table, const char *wild);
  350. int mysqld_show_keys(THD *thd, TABLE_LIST *table);
  351. void mysqld_list_fields(THD *thd,TABLE_LIST *table, const char *wild);
  352. int mysqld_dump_create_info(THD *thd, TABLE *table, int fd = -1);
  353. int mysqld_show_create(THD *thd, TABLE_LIST *table_list);
  354.  
  355. void mysqld_list_processes(THD *thd,const char *user,bool verbose);
  356. int mysqld_show_status(THD *thd);
  357. int mysqld_show_variables(THD *thd,const char *wild);
  358. int mysqld_show(THD *thd, const char *wild, show_var_st *variables);
  359.  
  360. /* sql_base.cc */
  361. void set_item_name(Item *item,char *pos,uint length);
  362. bool add_field_to_list(char *field_name, enum enum_field_types type,
  363.                char *length, char *decimal,
  364.                uint type_modifier, Item *default_value,char *change,
  365.                TYPELIB *interval);
  366. void store_position_for_column(const char *name);
  367. bool add_to_list(SQL_LIST &list,Item *group,bool asc=0);
  368. TABLE_LIST *add_table_to_list(Table_ident *table,LEX_STRING *alias,
  369.                   bool updating,
  370.                   thr_lock_type flags=TL_UNLOCK,
  371.                   List<String> *use_index=0,
  372.                   List<String> *ignore_index=0);
  373. void add_join_on(TABLE_LIST *b,Item *expr);
  374. void add_join_natural(TABLE_LIST *a,TABLE_LIST *b);
  375. bool add_proc_to_list(Item *item);
  376. TABLE *unlink_open_table(THD *thd,TABLE *list,TABLE *find);
  377.  
  378. SQL_SELECT *make_select(TABLE *head, table_map const_tables,
  379.             table_map read_tables, COND *conds, int *error);
  380. Item ** find_item_in_list(Item *item,List<Item> &items);
  381. int setup_fields(THD *thd,TABLE_LIST *tables,List<Item> &item,
  382.          bool set_query_id,List<Item> *sum_func_list);
  383. int setup_conds(THD *thd,TABLE_LIST *tables,COND **conds);
  384. int setup_ftfuncs(THD *thd,TABLE_LIST *tables, List<Item_func_match> &ftfuncs);
  385. void wait_for_refresh(THD *thd);
  386. int open_tables(THD *thd,TABLE_LIST *tables);
  387. int open_and_lock_tables(THD *thd,TABLE_LIST *tables);
  388. int lock_tables(THD *thd,TABLE_LIST *tables);
  389. TABLE *open_temporary_table(THD *thd, const char *path, const char *db,
  390.                 const char *table_name, bool link_in_list);
  391. bool rm_temporary_table(enum db_type base, char *path);
  392. bool send_fields(THD *thd,List<Item> &item,uint send_field_count);
  393. void free_io_cache(TABLE *entry);
  394. void intern_close_table(TABLE *entry);
  395. void close_thread_tables(THD *thd,bool locked=0);
  396. void close_temporary_tables(THD *thd);
  397. TABLE **find_temporary_table(THD *thd, const char *db, const char *table_name);
  398. bool close_temporary_table(THD *thd, const char *db, const char *table_name);
  399. void close_temporary(TABLE *table, bool delete_table=1);
  400. bool rename_temporary_table(TABLE *table, const char *new_db,
  401.                 const char *table_name);
  402. void remove_db_from_cache(const my_string db);
  403. void flush_tables();
  404. bool remove_table_from_cache(THD *thd, const char *db, const char *table);
  405. bool close_cached_tables(THD *thd, bool wait_for_refresh, TABLE_LIST *tables);
  406. void copy_field_from_tmp_record(Field *field,int offset);
  407. int fill_record(List<Item> &fields,List<Item> &values);
  408. int fill_record(Field **field,List<Item> &values);
  409.  
  410. /* sql_calc.cc */
  411. bool eval_const_cond(COND *cond);
  412.  
  413. /* sql_load.cc */
  414. int mysql_load(THD *thd,sql_exchange *ex, TABLE_LIST *table_list,
  415.            List<Item> &fields, enum enum_duplicates handle_duplicates,
  416.            bool local_file,thr_lock_type lock_type);
  417. int write_record(TABLE *table,COPY_INFO *info);
  418. /* sql_test.cc */
  419. #ifndef DBUG_OFF
  420. void print_where(COND *cond,const char *info);
  421. void print_cached_tables(void);
  422. void TEST_filesort(TABLE **form,SORT_FIELD *sortorder,uint s_length,
  423.            ha_rows special);
  424. #endif
  425. void mysql_print_status(THD *thd);
  426. /* key.cc */
  427. int find_ref_key(TABLE *form,Field *field, uint *offset);
  428. void key_copy(byte *key,TABLE *form,uint index,uint key_length);
  429. void key_restore(TABLE *form,byte *key,uint index,uint key_length);
  430. int key_cmp(TABLE *form,const byte *key,uint index,uint key_length);
  431. void key_unpack(String *to,TABLE *form,uint index);
  432. bool check_if_key_used(TABLE *table, uint idx, List<Item> &fields);
  433. void init_errmessage(void);
  434.  
  435. void sql_perror(const char *message);
  436. void sql_print_error(const char *format,...)
  437.             __attribute__ ((format (printf, 1, 2)));
  438.  
  439. extern uint32 server_id;
  440. extern char mysql_data_home[2],server_version[50],max_sort_char,
  441.             mysql_real_data_home[];
  442. extern my_string mysql_unix_port,mysql_tmpdir;
  443. extern const char *first_keyword, *localhost;
  444. extern ulong refresh_version,flush_version, thread_id,query_id,opened_tables,
  445.          created_tmp_tables, created_tmp_disk_tables,
  446.          aborted_threads,aborted_connects,
  447.          delayed_insert_timeout,
  448.          delayed_insert_limit, delayed_queue_size,
  449.          delayed_insert_threads, delayed_insert_writes,
  450.          delayed_rows_in_use,delayed_insert_errors;
  451. extern ulong filesort_rows, filesort_range_count, filesort_scan_count;
  452. extern ulong filesort_merge_passes;
  453. extern ulong select_range_check_count, select_range_count, select_scan_count;
  454. extern ulong select_full_range_join_count,select_full_join_count;
  455. extern uint test_flags,select_errors,mysql_port,ha_open_options;
  456. extern ulong thd_startup_options, slow_launch_threads, slow_launch_time;
  457. extern time_t start_time;
  458. extern const char *command_name[];
  459. extern I_List<THD> threads;
  460. extern MYSQL_LOG mysql_log,mysql_update_log,mysql_slow_log,mysql_bin_log;
  461. extern pthread_key(MEM_ROOT*,THR_MALLOC);
  462. extern pthread_key(NET*, THR_NET);
  463. extern pthread_mutex_t LOCK_mysql_create_db,LOCK_Acl,LOCK_open,
  464.        LOCK_thread_count,LOCK_mapped_file,LOCK_user_locks, LOCK_status,
  465.        LOCK_grant, LOCK_error_log, LOCK_delayed_insert,
  466.        LOCK_delayed_status, LOCK_delayed_create, LOCK_crypt, LOCK_timezone,
  467.        LOCK_binlog_update, LOCK_slave, LOCK_server_id;
  468. extern pthread_cond_t COND_refresh,COND_thread_count, COND_binlog_update,
  469.   COND_slave_stopped;
  470. extern pthread_attr_t connection_attrib;
  471. extern bool opt_endinfo,using_udf_functions, locked_in_memory;
  472. extern ulong ha_read_count, ha_write_count, ha_delete_count, ha_update_count,
  473.          ha_read_key_count, ha_read_next_count, ha_read_prev_count,
  474.          ha_read_first_count, ha_read_last_count,
  475.            ha_read_rnd_count, ha_read_rnd_next_count;
  476.  
  477. extern char f_fyllchar;
  478. extern uchar *days_in_month;
  479. extern DATE_FORMAT dayord;
  480. extern double log_10[32];
  481. extern uint protocol_version,dropping_tables;
  482. extern ulong keybuff_size,sortbuff_size,max_item_sort_length,table_cache_size,
  483.          max_join_size,join_buff_size,tmp_table_size,
  484.          max_connections,max_connect_errors,long_query_time,
  485.          max_insert_delayed_threads,
  486.          long_query_count,net_wait_timeout,net_interactive_timeout,
  487.          net_read_timeout,net_write_timeout,
  488.          what_to_log,flush_time,
  489.          max_tmp_tables,max_heap_table_size,query_buff_size,
  490.          lower_case_table_names,thread_stack,thread_stack_min;
  491. extern ulong specialflag;
  492. extern ulong current_pid;
  493. extern bool low_priority_updates;
  494. extern bool opt_sql_bin_update;
  495. extern char language[LIBLEN],reg_ext[FN_EXTLEN],blob_newline;
  496. extern const char **errmesg;            /* Error messages */
  497. extern byte last_ref[MAX_REFLENGTH];        /* Index ref of keys */
  498. extern String empty_string;
  499. extern struct show_var_st init_vars[];
  500. extern struct show_var_st status_vars[];
  501. extern enum db_type default_table_type;
  502.  
  503. #ifndef __WIN__
  504. extern pthread_t signal_thread;
  505. #endif
  506.  
  507. extern bool volatile abort_loop, shutdown_in_progress, grant_option;
  508. extern uint volatile thread_count, thread_running, global_read_lock;
  509.  
  510. MYSQL_LOCK *mysql_lock_tables(THD *thd,TABLE **table,uint count);
  511. void mysql_unlock_tables(THD *thd, MYSQL_LOCK *sql_lock);
  512. void mysql_unlock_read_tables(THD *thd, MYSQL_LOCK *sql_lock);
  513. void mysql_unlock_some_tables(THD *thd, TABLE **table,uint count);
  514. void mysql_lock_remove(THD *thd, MYSQL_LOCK *locked,TABLE *table);
  515. void mysql_lock_abort(THD *thd, TABLE *table);
  516. MYSQL_LOCK *mysql_lock_merge(MYSQL_LOCK *a,MYSQL_LOCK *b);
  517.  
  518. /* Lock based on name */
  519. int lock_table_name(THD *thd, TABLE_LIST *table_list);
  520. void unlock_table_name(THD *thd, TABLE_LIST *table_list);
  521. bool wait_for_locked_table_names(THD *thd, TABLE_LIST *table_list);
  522.  
  523.  
  524. /* old unireg functions */
  525.  
  526. void unireg_init(ulong options);
  527. void unireg_end(int signal);
  528. int rea_create_table(my_string file_name,HA_CREATE_INFO *create_info,
  529.              List<create_field> &create_field,
  530.              uint key_count,KEY *key_info);
  531. int format_number(uint inputflag,uint max_length,my_string pos,uint length,
  532.           my_string *errpos);
  533. int openfrm(const char *name,const char *alias,uint filestat,uint prgflag,
  534.         uint ha_open_flags, TABLE *outparam);
  535. int closefrm(TABLE *table);
  536. db_type get_table_type(const char *name);
  537. int read_string(File file, gptr *to, uint length);
  538. void free_blobs(TABLE *table);
  539. int set_zone(int nr,int min_zone,int max_zone);
  540. ulong convert_period_to_month(ulong period);
  541. ulong convert_month_to_period(ulong month);
  542. long calc_daynr(uint year,uint month,uint day);
  543. uint calc_days_in_year(uint year);
  544. void get_date_from_daynr(long daynr,uint *year, uint *month,
  545.              uint *day);
  546. void init_time(void);
  547. long my_gmt_sec(TIME *);
  548. time_t str_to_timestamp(const char *str,uint length);
  549. bool str_to_time(const char *str,uint length,TIME *l_time);
  550. longlong str_to_datetime(const char *str,uint length,bool fuzzy_date);
  551. timestamp_type str_to_TIME(const char *str, uint length, TIME *l_time,
  552.                bool fuzzy_date);
  553.  
  554. int test_if_number(char *str,int *res,bool allow_wildcards);
  555. void change_byte(byte *,uint,char,char);
  556. void unireg_abort(int exit_code);
  557. void init_read_record(READ_RECORD *info, THD *thd, TABLE *reg_form,
  558.               SQL_SELECT *select,
  559.               bool use_record_cache, bool print_errors);
  560. void end_read_record(READ_RECORD *info);
  561. ha_rows filesort(TABLE **form,struct st_sort_field *sortorder, uint s_length,
  562.          SQL_SELECT *select, ha_rows special,ha_rows max_rows);
  563. void change_double_for_sort(double nr,byte *to);
  564. int get_quick_record(SQL_SELECT *select);
  565. int calc_weekday(long daynr,bool sunday_first_day_of_week);
  566. uint calc_week(TIME *ltime, bool with_year, bool sunday_first_day_of_week,
  567.            uint *year);
  568. void find_date(char *pos,uint *vek,uint flag);
  569. TYPELIB *convert_strings_to_array_type(my_string *typelibs, my_string *end);
  570. TYPELIB *typelib(List<String> &strings);
  571. void clean_up(void);
  572. ulong get_form_pos(File file, uchar *head, TYPELIB *save_names);
  573. ulong make_new_entry(File file,uchar *fileinfo,TYPELIB *formnames,
  574.              const char *newname);
  575. ulong next_io_size(ulong pos);
  576. void append_unescaped(String *res,const char *pos);
  577. int create_frm(char *name,uint reclength,uchar *fileinfo,
  578.            HA_CREATE_INFO *create_info, uint keys);
  579. void update_create_info_from_table(HA_CREATE_INFO *info, TABLE *form);
  580. int rename_file_ext(const char * from,const char * to,const char * ext);
  581. bool check_db_name(const char *db);
  582. bool check_column_name(const char *name);
  583. bool check_table_name(const char *name, uint length);
  584. char *get_field(MEM_ROOT *mem,TABLE *table,uint fieldnr);
  585. int wild_case_compare(const char *str,const char *wildstr);
  586. int wild_compare(const char *str,const char *str_end,
  587.          const char *wildstr,const char *wildend,char escape);
  588. int wild_case_compare(const char *str,const char *str_end,
  589.          const char *wildstr,const char *wildend,char escape);
  590.  
  591. /* from hostname.cc */
  592. struct in_addr;
  593. my_string ip_to_hostname(struct in_addr *in,uint *errors);
  594. void inc_host_errors(struct in_addr *in);
  595. void reset_host_errors(struct in_addr *in);
  596. bool hostname_cache_init();
  597. void hostname_cache_free();
  598. void hostname_cache_refresh(void);
  599. bool get_interval_info(const char *str,uint length,uint count,
  600.                long *values);
  601. /* sql_cache */
  602.  
  603. extern bool sql_cache_init();
  604. extern void sql_cache_free();
  605. extern int sql_cache_hit(THD *thd, char *inBuf, uint length);
  606.  
  607. /* Some inline functions for more speed */
  608.  
  609. inline bool add_item_to_list(Item *item)
  610. {
  611.   return current_lex->item_list.push_back(item);
  612. }
  613. inline bool add_value_to_list(Item *value)
  614. {
  615.   return current_lex->value_list.push_back(value);
  616. }
  617. inline bool add_order_to_list(Item *item,bool asc)
  618. {
  619.   return add_to_list(current_lex->order_list,item,asc);
  620. }
  621. inline bool add_group_to_list(Item *item,bool asc)
  622. {
  623.   return add_to_list(current_lex->group_list,item,asc);
  624. }
  625. inline void mark_as_null_row(TABLE *table)
  626. {
  627.   table->null_row=1;
  628.   table->status|=STATUS_NULL_ROW;
  629.   bfill(table->null_flags,table->null_bytes,255);
  630. }
  631.  
  632. #endif
  633.