~drizzle-trunk/drizzle/development

/* Copyright (C) 2000-2003 MySQL 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; version 2 of the License.

   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 */

/**

  @file

  @details

  Mostly this file is used in the server. But a little part of it is used in

  mysqlbinlog too (definition of SELECT_DISTINCT and others).

  The consequence is that 90% of the file is wrapped in \#ifndef DRIZZLE_CLIENT,

  except the part which must be in the server and in the client.

  @TODO Name this file better. "priv" could mean private, privileged, privileges.

  @TODO Get rid of the DRIZZLE_CLIENT and DRIZZLE_SERVER conditionals

*/

#ifndef DRIZZLE_SERVER_SERVER_INCLUDES_H

#define DRIZZLE_SERVER_SERVER_INCLUDES_H

/* Some forward declarations just for the server */

class Comp_creator;

typedef Comp_creator* (*chooser_compare_func_creator)(bool invert);

/**

 * Contains all headers, definitions, and declarations common to 

 * the server and the plugin infrastructure, and not the client 

 */

#include <drizzled/common_includes.h>       

/* Range optimization API/library */

#include <drizzled/opt_range.h>

/* Simple error injection (crash) module */

#include <drizzled/error_injection.h>

/* API for connecting, logging in to a drizzled server */

#include <drizzled/connect.h>

/* Routines for dropping, repairing, checking schema tables */

#include <drizzled/sql_table.h>

/* sql_db.cc */

int mysql_create_db(THD *thd, char *db, HA_CREATE_INFO *create, bool silent);

bool mysql_alter_db(THD *thd, const char *db, HA_CREATE_INFO *create);

bool mysql_rm_db(THD *thd,char *db,bool if_exists, bool silent);

bool mysql_change_db(THD *thd, const LEX_STRING *new_db_name,

                     bool force_switch);

bool mysql_opt_change_db(THD *thd,

                         const LEX_STRING *new_db_name,

                         LEX_STRING *saved_db_name,

                         bool force_switch,

                         bool *cur_db_changed);

/* sql_repl.cc */

void write_bin_log(THD *thd, bool clear_error,

                   char const *query, ulong query_length);

void mysql_binlog_send(THD* thd, char* log_ident, my_off_t pos, ushort flags);

void mysql_client_binlog_statement(THD *thd);

/* sql_rename.cc */

bool mysql_rename_tables(THD *thd, TableList *table_list, bool silent);

bool do_rename(THD *thd, TableList *ren_table, char *new_db,

                      char *new_table_name, char *new_table_alias,

                      bool skip_error);

/* sql_parse.cc */

void mysql_parse(THD *thd, const char *inBuf, uint length,

                 const char ** semicolon);

bool mysql_test_parse_for_slave(THD *thd,char *inBuf,uint length);

bool is_update_query(enum enum_sql_command command);

bool alloc_query(THD *thd, const char *packet, uint packet_length);

void mysql_reset_thd_for_next_command(THD *thd);

void create_select_for_variable(const char *var_name);

void mysql_init_multi_delete(LEX *lex);

bool multi_delete_set_locks_and_link_aux_tables(LEX *lex);

void init_update_queries(void);

bool do_command(THD *thd);

bool dispatch_command(enum enum_server_command command, THD *thd,

		      char* packet, uint packet_length);

void log_slow_statement(THD *thd);

bool append_file_to_dir(THD *thd, const char **filename_ptr, 

                        const char *table_name);

bool reload_cache(THD *thd, ulong options, TableList *tables, bool *write_to_binlog);

bool check_simple_select();

/* @TODO <UNUSED> */

void mysql_init_select(LEX *lex);

bool mysql_new_select(LEX *lex, bool move_down);

void init_max_user_conn(void);

void free_max_user_conn(void);

pthread_handler_t handle_bootstrap(void *arg);

int mysql_execute_command(THD *thd);

bool check_dup(const char *db, const char *name, TableList *tables);

bool check_table_access(THD *thd, ulong want_access, TableList *tables,

                        bool no_errors,

                        bool any_combination_of_privileges_will_do,

                        uint number);

/*

  General routine to change field->ptr of a NULL-terminated array of Field

  objects. Useful when needed to call val_int, val_str or similar and the

  field data is not in table->record[0] but in some other structure.

  set_key_field_ptr changes all fields of an index using a key_info object.

  All methods presume that there is at least one field to change.

*/

void set_field_ptr(Field **ptr, const uchar *new_buf, const uchar *old_buf);

void set_key_field_ptr(KEY *key_info, const uchar *new_buf,

                       const uchar *old_buf);

/* </UNUSED> */

/* sql_base.cc */

void table_cache_free(void);

bool table_cache_init(void);

bool table_def_init(void);

void table_def_free(void);

void assign_new_table_id(TABLE_SHARE *share);

uint cached_open_tables(void);

uint cached_table_definitions(void);

/* drizzled.cc */

void kill_mysql(void);

void close_connection(THD *thd, uint errcode, bool lock);

/* sql_select.cc */

Table *create_virtual_tmp_table(THD *thd, List<Create_field> &field_list);

/* handler.cc */

bool mysql_xa_recover(THD *thd);

SORT_FIELD * make_unireg_sortorder(order_st *order, uint *length,

                                  SORT_FIELD *sortorder);

int setup_order(THD *thd, Item **ref_pointer_array, TableList *tables,

		List<Item> &fields, List <Item> &all_fields, order_st *order);

int setup_group(THD *thd, Item **ref_pointer_array, TableList *tables,

		List<Item> &fields, List<Item> &all_fields, order_st *order,

		bool *hidden_group_fields);

bool fix_inner_refs(THD *thd, List<Item> &all_fields, SELECT_LEX *select,

                   Item **ref_pointer_array);

bool handle_select(THD *thd, LEX *lex, select_result *result,

                   ulong setup_tables_done_option);

bool mysql_select(THD *thd, Item ***rref_pointer_array,

                  TableList *tables, uint wild_num,  List<Item> &list,

                  COND *conds, uint og_num, order_st *order, order_st *group,

                  Item *having, order_st *proc_param, uint64_t select_type, 

                  select_result *result, SELECT_LEX_UNIT *unit, 

                  SELECT_LEX *select_lex);

void free_underlaid_joins(THD *thd, SELECT_LEX *select);

bool mysql_explain_union(THD *thd, SELECT_LEX_UNIT *unit,

                         select_result *result);

int mysql_explain_select(THD *thd, SELECT_LEX *sl, char const *type,

			 select_result *result);

bool mysql_union(THD *thd, LEX *lex, select_result *result,

                 SELECT_LEX_UNIT *unit, ulong setup_tables_done_option);

bool mysql_handle_derived(LEX *lex, bool (*processor)(THD *thd,

                                                      LEX *lex,

                                                      TableList *table));

bool mysql_derived_prepare(THD *thd, LEX *lex, TableList *t);

bool mysql_derived_filling(THD *thd, LEX *lex, TableList *t);

Field *create_tmp_field(THD *thd, Table *table,Item *item, Item::Type type,

			Item ***copy_func, Field **from_field,

                        Field **def_field,

			bool group, bool modify_item,

			bool table_cant_handle_bit_fields,

                        bool make_copy_field,

                        uint convert_blob_length);

void sp_prepare_create_field(THD *thd, Create_field *sql_field);

int prepare_create_field(Create_field *sql_field, 

			 uint *blob_columns, 

			 int *timestamps, int *timestamps_with_niladic,

			 int64_t table_flags);

bool mysql_create_table(THD *thd,const char *db, const char *table_name,

                        HA_CREATE_INFO *create_info,

                        Alter_info *alter_info,

                        bool tmp_table, uint select_field_count);

bool mysql_create_table_no_lock(THD *thd, const char *db,

                                const char *table_name,

                                HA_CREATE_INFO *create_info,

                                Alter_info *alter_info,

                                bool tmp_table, uint select_field_count);

bool mysql_alter_table(THD *thd, char *new_db, char *new_name,

                       HA_CREATE_INFO *create_info,

                       TableList *table_list,

                       Alter_info *alter_info,

                       uint order_num, order_st *order, bool ignore);

bool mysql_recreate_table(THD *thd, TableList *table_list);

bool mysql_create_like_table(THD *thd, TableList *table,

                             TableList *src_table,

                             HA_CREATE_INFO *create_info);

bool mysql_rename_table(handlerton *base, const char *old_db,

                        const char * old_name, const char *new_db,

                        const char * new_name, uint flags);

bool mysql_prepare_update(THD *thd, TableList *table_list,

                          Item **conds, uint order_num, order_st *order);

int mysql_update(THD *thd,TableList *tables,List<Item> &fields,

		 List<Item> &values,COND *conds,

		 uint order_num, order_st *order, ha_rows limit,

		 enum enum_duplicates handle_duplicates, bool ignore);

bool mysql_multi_update(THD *thd, TableList *table_list,

                        List<Item> *fields, List<Item> *values,

                        COND *conds, uint64_t options,

                        enum enum_duplicates handle_duplicates, bool ignore,

                        SELECT_LEX_UNIT *unit, SELECT_LEX *select_lex);

bool mysql_prepare_insert(THD *thd, TableList *table_list, Table *table,

                          List<Item> &fields, List_item *values,

                          List<Item> &update_fields,

                          List<Item> &update_values, enum_duplicates duplic,

                          COND **where, bool select_insert,

                          bool check_fields, bool abort_on_warning);

bool mysql_insert(THD *thd,TableList *table,List<Item> &fields,

                  List<List_item> &values, List<Item> &update_fields,

                  List<Item> &update_values, enum_duplicates flag,

                  bool ignore);

int check_that_all_fields_are_given_values(THD *thd, Table *entry,

                                           TableList *table_list);

void prepare_triggers_for_insert_stmt(Table *table);

int mysql_prepare_delete(THD *thd, TableList *table_list, Item **conds);

bool mysql_delete(THD *thd, TableList *table_list, COND *conds,

                  SQL_LIST *order, ha_rows rows, uint64_t options,

                  bool reset_auto_increment);

bool mysql_truncate(THD *thd, TableList *table_list, bool dont_send_ok);

uint create_table_def_key(THD *thd, char *key, TableList *table_list,

                          bool tmp_table);

TABLE_SHARE *get_table_share(THD *thd, TableList *table_list, char *key,

                             uint key_length, uint db_flags, int *error);

void release_table_share(TABLE_SHARE *share, enum release_type type);

TABLE_SHARE *get_cached_table_share(const char *db, const char *table_name);

Table *open_ltable(THD *thd, TableList *table_list, thr_lock_type update,

                   uint lock_flags);

Table *open_table(THD *thd, TableList *table_list, bool *refresh, uint flags);

bool name_lock_locked_table(THD *thd, TableList *tables);

bool reopen_name_locked_table(THD* thd, TableList* table_list, bool link_in);

Table *table_cache_insert_placeholder(THD *thd, const char *key,

                                      uint key_length);

bool lock_table_name_if_not_cached(THD *thd, const char *db,

                                   const char *table_name, Table **table);

Table *find_locked_table(THD *thd, const char *db,const char *table_name);

void detach_merge_children(Table *table, bool clear_refs);

bool fix_merge_after_open(TableList *old_child_list, TableList **old_last,

                          TableList *new_child_list, TableList **new_last);

bool reopen_table(Table *table);

bool reopen_tables(THD *thd,bool get_locks,bool in_refresh);

void close_data_files_and_morph_locks(THD *thd, const char *db,

                                      const char *table_name);

void close_handle_and_leave_table_as_lock(Table *table);

bool open_new_frm(THD *thd, TABLE_SHARE *share, const char *alias,

                  uint db_stat, uint prgflag,

                  uint ha_open_flags, Table *outparam,

                  TableList *table_desc, MEM_ROOT *mem_root);

bool wait_for_tables(THD *thd);

bool table_is_used(Table *table, bool wait_for_name_lock);

Table *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);

void execute_init_command(THD *thd, sys_var_str *init_command_var,

			  rw_lock_t *var_mutex);

extern Field *not_found_field;

extern Field *view_ref_found;

enum find_item_error_report_type {REPORT_ALL_ERRORS, REPORT_EXCEPT_NOT_FOUND,

				  IGNORE_ERRORS, REPORT_EXCEPT_NON_UNIQUE,

                                  IGNORE_EXCEPT_NON_UNIQUE};

Field *

find_field_in_tables(THD *thd, Item_ident *item,

                     TableList *first_table, TableList *last_table,

                     Item **ref, find_item_error_report_type report_error,

                     bool check_privileges, bool register_tree_change);

Field *

find_field_in_table_ref(THD *thd, TableList *table_list,

                        const char *name, uint length,

                        const char *item_name, const char *db_name,

                        const char *table_name, Item **ref,

                        bool check_privileges, bool allow_rowid,

                        uint *cached_field_index_ptr,

                        bool register_tree_change, TableList **actual_table);

Field *

find_field_in_table(THD *thd, Table *table, const char *name, uint length,

                    bool allow_rowid, uint *cached_field_index_ptr);

Field *

find_field_in_table_sef(Table *table, const char *name);

/* sql_do.cc */

bool mysql_do(THD *thd, List<Item> &values);

/* sql_analyse.h */

bool append_escaped(String *to_str, String *from_str);

#include <drizzled/show.h>

/* information schema */

extern LEX_STRING INFORMATION_SCHEMA_NAME;

/* log tables */

extern LEX_STRING DRIZZLE_SCHEMA_NAME;

extern LEX_STRING GENERAL_LOG_NAME;

extern LEX_STRING SLOW_LOG_NAME;

extern const LEX_STRING partition_keywords[];

ST_SCHEMA_TABLE *find_schema_table(THD *thd, const char* table_name);

ST_SCHEMA_TABLE *get_schema_table(enum enum_schema_tables schema_table_idx);

int prepare_schema_table(THD *thd, LEX *lex, Table_ident *table_ident,

                         enum enum_schema_tables schema_table_idx);

int make_schema_select(THD *thd,  SELECT_LEX *sel,

                       enum enum_schema_tables schema_table_idx);

int mysql_schema_table(THD *thd, LEX *lex, TableList *table_list);

bool get_schema_tables_result(JOIN *join,

                              enum enum_schema_table_state executed_place);

enum enum_schema_tables get_schema_table_idx(ST_SCHEMA_TABLE *schema_table);

#define is_schema_db(X) \

  !my_strcasecmp(system_charset_info, INFORMATION_SCHEMA_NAME.str, (X))

/* sql_handler.cc */

bool mysql_ha_open(THD *thd, TableList *tables, bool reopen);

bool mysql_ha_close(THD *thd, TableList *tables);

bool mysql_ha_read(THD *, TableList *,enum enum_ha_read_modes,char *,

                   List<Item> *,enum ha_rkey_function,Item *,ha_rows,ha_rows);

void mysql_ha_flush(THD *thd);

void mysql_ha_rm_tables(THD *thd, TableList *tables, bool is_locked);

void mysql_ha_cleanup(THD *thd);

/* sql_base.cc */

#define TMP_TABLE_KEY_EXTRA 8

void set_item_name(Item *item,char *pos,uint length);

bool add_field_to_list(THD *thd, LEX_STRING *field_name, enum enum_field_types type,

		       char *length, char *decimal,

		       uint type_modifier,

                       enum column_format_type column_format,

		       Item *default_value, Item *on_update_value,

		       LEX_STRING *comment,

		       char *change, List<String> *interval_list,

		       const CHARSET_INFO * const cs);

Create_field * new_create_field(THD *thd, char *field_name, enum_field_types type,

				char *length, char *decimals,

				uint type_modifier, 

				Item *default_value, Item *on_update_value,

				LEX_STRING *comment, char *change, 

				List<String> *interval_list, CHARSET_INFO *cs);

void store_position_for_column(const char *name);

bool add_to_list(THD *thd, SQL_LIST &list,Item *group,bool asc);

bool push_new_name_resolution_context(THD *thd,

                                      TableList *left_op,

                                      TableList *right_op);

void add_join_on(TableList *b,Item *expr);

void add_join_natural(TableList *a,TableList *b,List<String> *using_fields,

                      SELECT_LEX *lex);

bool add_proc_to_list(THD *thd, Item *item);

void unlink_open_table(THD *thd, Table *find, bool unlock);

void drop_open_table(THD *thd, Table *table, const char *db_name,

                     const char *table_name);

void update_non_unique_table_error(TableList *update,

                                   const char *operation,

                                   TableList *duplicate);

SQL_SELECT *make_select(Table *head, table_map const_tables,

			table_map read_tables, COND *conds,

                        bool allow_null_cond,  int *error);

extern Item **not_found_item;

/*

  A set of constants used for checking non aggregated fields and sum

  functions mixture in the ONLY_FULL_GROUP_BY_MODE.

*/

#define NON_AGG_FIELD_USED  1

#define SUM_FUNC_USED       2

/*

  This enumeration type is used only by the function find_item_in_list

  to return the info on how an item has been resolved against a list

  of possibly aliased items.

  The item can be resolved: 

   - against an alias name of the list's element (RESOLVED_AGAINST_ALIAS)

   - against non-aliased field name of the list  (RESOLVED_WITH_NO_ALIAS)

   - against an aliased field name of the list   (RESOLVED_BEHIND_ALIAS)

   - ignoring the alias name in cases when SQL requires to ignore aliases

     (e.g. when the resolved field reference contains a table name or

     when the resolved item is an expression)   (RESOLVED_IGNORING_ALIAS)    

*/

enum enum_resolution_type {

  NOT_RESOLVED=0,

  RESOLVED_IGNORING_ALIAS,

  RESOLVED_BEHIND_ALIAS,

  RESOLVED_WITH_NO_ALIAS,

  RESOLVED_AGAINST_ALIAS

};

Item ** find_item_in_list(Item *item, List<Item> &items, uint *counter,

                          find_item_error_report_type report_error,

                          enum_resolution_type *resolution);

bool get_key_map_from_key_list(key_map *map, Table *table,

                               List<String> *index_list);

bool insert_fields(THD *thd, Name_resolution_context *context,

		   const char *db_name, const char *table_name,

                   List_iterator<Item> *it, bool any_privileges);

bool setup_tables(THD *thd, Name_resolution_context *context,

                  List<TableList> *from_clause, TableList *tables,

                  TableList **leaves, bool select_insert);

bool setup_tables_and_check_access(THD *thd, 

                                   Name_resolution_context *context,

                                   List<TableList> *from_clause, 

                                   TableList *tables, 

                                   TableList **leaves, 

                                   bool select_insert);

int setup_wild(THD *thd, TableList *tables, List<Item> &fields,

	       List<Item> *sum_func_list, uint wild_num);

bool setup_fields(THD *thd, Item** ref_pointer_array,

                  List<Item> &item, enum_mark_columns mark_used_columns,

                  List<Item> *sum_func_list, bool allow_sum_func);

inline bool setup_fields_with_no_wrap(THD *thd, Item **ref_pointer_array,

                                      List<Item> &item,

                                      enum_mark_columns mark_used_columns,

                                      List<Item> *sum_func_list,

                                      bool allow_sum_func)

{

  bool res;

  res= setup_fields(thd, ref_pointer_array, item, mark_used_columns, sum_func_list,

                    allow_sum_func);

  return res;

}

int setup_conds(THD *thd, TableList *tables, TableList *leaves,

		COND **conds);

int setup_ftfuncs(SELECT_LEX* select);

int init_ftfuncs(THD *thd, SELECT_LEX* select, bool no_order);

void wait_for_condition(THD *thd, pthread_mutex_t *mutex,

                        pthread_cond_t *cond);

int open_tables(THD *thd, TableList **tables, uint *counter, uint flags);

/* open_and_lock_tables with optional derived handling */

int open_and_lock_tables_derived(THD *thd, TableList *tables, bool derived);

/* simple open_and_lock_tables without derived handling */

inline int simple_open_n_lock_tables(THD *thd, TableList *tables)

{

  return open_and_lock_tables_derived(thd, tables, false);

}

/* open_and_lock_tables with derived handling */

inline int open_and_lock_tables(THD *thd, TableList *tables)

{

  return open_and_lock_tables_derived(thd, tables, true);

}

/* simple open_and_lock_tables without derived handling for single table */

Table *open_n_lock_single_table(THD *thd, TableList *table_l,

                                thr_lock_type lock_type);

bool open_normal_and_derived_tables(THD *thd, TableList *tables, uint flags);

int lock_tables(THD *thd, TableList *tables, uint counter, bool *need_reopen);

int decide_logging_format(THD *thd, TableList *tables);

Table *open_temporary_table(THD *thd, const char *path, const char *db,

                            const char *table_name, bool link_in_list,

                            open_table_mode open_mode);

bool rm_temporary_table(handlerton *base, char *path, bool frm_only);

void free_io_cache(Table *entry);

void intern_close_table(Table *entry);

bool close_thread_table(THD *thd, Table **table_ptr);

void close_temporary_tables(THD *thd);

void close_tables_for_reopen(THD *thd, TableList **tables);

TableList *find_table_in_list(TableList *table,

                               TableList *TableList::*link,

                               const char *db_name,

                               const char *table_name);

TableList *unique_table(THD *thd, TableList *table, TableList *table_list,

                         bool check_alias);

Table *find_temporary_table(THD *thd, const char *db, const char *table_name);

Table *find_temporary_table(THD *thd, TableList *table_list);

int drop_temporary_table(THD *thd, TableList *table_list);

void close_temporary_table(THD *thd, Table *table, bool free_share,

                           bool delete_table);

void close_temporary(Table *table, bool free_share, bool delete_table);

bool rename_temporary_table(THD* thd, Table *table, const char *new_db,

			    const char *table_name);

void remove_db_from_cache(const char *db);

void flush_tables();

bool is_equal(const LEX_STRING *a, const LEX_STRING *b);

char *make_default_log_name(char *buff,const char* log_ext);

/* bits for last argument to remove_table_from_cache() */

#define RTFC_NO_FLAG                0x0000

#define RTFC_OWNED_BY_THD_FLAG      0x0001

#define RTFC_WAIT_OTHER_THREAD_FLAG 0x0002

#define RTFC_CHECK_KILLED_FLAG      0x0004

bool remove_table_from_cache(THD *thd, const char *db, const char *table,

                             uint flags);

#define NORMAL_PART_NAME 0

#define TEMP_PART_NAME 1

#define RENAMED_PART_NAME 2

void mem_alloc_error(size_t size);

#define WFRM_WRITE_SHADOW 1

#define WFRM_INSTALL_SHADOW 2

#define WFRM_PACK_FRM 4

#define WFRM_KEEP_SHARE 8

bool close_cached_tables(THD *thd, TableList *tables, bool have_lock,

                         bool wait_for_refresh, bool wait_for_placeholders);

bool close_cached_connection_tables(THD *thd, bool wait_for_refresh,

                                    LEX_STRING *connect_string,

                                    bool have_lock= false);

void copy_field_from_tmp_record(Field *field,int offset);

bool fill_record(THD * thd, List<Item> &fields, List<Item> &values, bool ignore_errors);

bool fill_record(THD *thd, Field **field, List<Item> &values, bool ignore_errors);

OPEN_TableList *list_open_tables(THD *thd, const char *db, const char *wild);

inline TableList *find_table_in_global_list(TableList *table,

                                             const char *db_name,

                                             const char *table_name)

{

  return find_table_in_list(table, &TableList::next_global,

                            db_name, table_name);

}

inline TableList *find_table_in_local_list(TableList *table,

                                            const char *db_name,

                                            const char *table_name)

{

  return find_table_in_list(table, &TableList::next_local,

                            db_name, table_name);

}

/* sql_calc.cc */

bool eval_const_cond(COND *cond);

/* sql_load.cc */

int mysql_load(THD *thd, sql_exchange *ex, TableList *table_list,

	        List<Item> &fields_vars, List<Item> &set_fields,

                List<Item> &set_values_list,

                enum enum_duplicates handle_duplicates, bool ignore,

                bool local_file);

int write_record(THD *thd, Table *table, COPY_INFO *info);

/* sql_test.cc */

void print_where(COND *cond,const char *info, enum_query_type query_type);

void print_cached_tables(void);

void TEST_filesort(SORT_FIELD *sortorder,uint s_length);

void print_plan(JOIN* join,uint idx, double record_count, double read_time,

                double current_read_time, const char *info);

void print_keyuse_array(DYNAMIC_ARRAY *keyuse_array);

void dump_TableList_graph(SELECT_LEX *select_lex, TableList* tl);

void mysql_print_status();