Skip to content

M
MariaDB
Commit b5ebf1e2 authored by Kentoku SHIBA's avatar Kentoku SHIBA
Browse files
Options

fix line endings

parent 356a665b
Hide whitespace changes
Inline Side-by-side
Showing with 35036 additions and 35036 deletions
storage/spider/spd_db_handlersocket.cc
View file @ b5ebf1e2
This source diff could not be displayed because it is too large. You can view the blob instead.
storage/spider/spd_db_handlersocket.h
View file @ b5ebf1e2
/* Copyright (C) 2012-2013 Kentoku Shiba
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 */
#define SPIDER_HS_CONN dena::hstcpcli_ptr
#define SPIDER_HS_CONN_CREATE dena::hstcpcli_i::create
#define SPIDER_HS_RESULT dena::hstresult
#define SPIDER_HS_SOCKARGS dena::socket_args
class spider_db_handlersocket_util: public spider_db_util
{
public:
spider_db_handlersocket_util();
~spider_db_handlersocket_util();
int append_name(
spider_string *str,
const char *name,
uint name_length
);
int append_name_with_charset(
spider_string *str,
const char *name,
uint name_length,
CHARSET_INFO *name_charset
);
bool is_name_quote(
const char head_code
);
int append_escaped_name_quote(
spider_string *str
);
int append_column_value(
ha_spider *spider,
spider_string *str,
Field *field,
const uchar *new_ptr,
CHARSET_INFO *access_charset
);
int append_trx_isolation(
spider_string *str,
int trx_isolation
);
int append_autocommit(
spider_string *str,
bool autocommit
);
int append_sql_log_off(
spider_string *str,
bool sql_log_off
);
int append_time_zone(
spider_string *str,
Time_zone *time_zone
);
int append_start_transaction(
spider_string *str
);
int append_xa_start(
spider_string *str,
XID *xid
);
int append_lock_table_head(
spider_string *str
);
int append_lock_table_body(
spider_string *str,
const char *db_name,
uint db_name_length,
CHARSET_INFO *db_name_charset,
const char *table_name,
uint table_name_length,
CHARSET_INFO *table_name_charset,
int lock_type
);
int append_lock_table_tail(
spider_string *str
);
int append_unlock_table(
spider_string *str
);
int open_item_func(
Item_func *item_func,
ha_spider *spider,
spider_string *str,
const char *alias,
uint alias_length
);
#ifdef HANDLER_HAS_DIRECT_AGGREGATE
int open_item_sum_func(
Item_sum *item_sum,
ha_spider *spider,
spider_string *str,
const char *alias,
uint alias_length
);
#endif
int append_escaped_util(
spider_string *to,
String *from
);
};
class spider_db_handlersocket_row: public spider_db_row
{
public:
SPIDER_HS_STRING_REF *hs_row;
SPIDER_HS_STRING_REF *hs_row_first;
uint field_count;
bool cloned;
spider_db_handlersocket_row();
~spider_db_handlersocket_row();
int store_to_field(
Field *field,
CHARSET_INFO *access_charset
);
int append_to_str(
spider_string *str
);
int append_escaped_to_str(
spider_string *str,
uint dbton_id
);
void first();
void next();
bool is_null();
int val_int();
double val_real();
my_decimal *val_decimal(
my_decimal *decimal_value,
CHARSET_INFO *access_charset
);
SPIDER_DB_ROW *clone();
int store_to_tmp_table(
TABLE *tmp_table,
spider_string *str
);
};
class spider_db_handlersocket_result_buffer: public spider_db_result_buffer
{
public:
SPIDER_HS_RESULT hs_result;
spider_db_handlersocket_result_buffer();
~spider_db_handlersocket_result_buffer();
void clear();
bool check_size(
longlong size
);
};
class spider_db_handlersocket_result: public spider_db_result
{
public:
SPIDER_HS_CONN *hs_conn_p;
spider_db_handlersocket_row row;
SPIDER_HS_STRING_REF hs_row;
uint field_count;
int store_error_num;
spider_db_handlersocket_result();
~spider_db_handlersocket_result();
bool has_result();
void free_result();
SPIDER_DB_ROW *current_row();
SPIDER_DB_ROW *fetch_row();
SPIDER_DB_ROW *fetch_row_from_result_buffer(
spider_db_result_buffer *spider_res_buf
);
SPIDER_DB_ROW *fetch_row_from_tmp_table(
TABLE *tmp_table
);
int fetch_table_status(
int mode,
ha_rows &records,
ulong &mean_rec_length,
ulonglong &data_file_length,
ulonglong &max_data_file_length,
ulonglong &index_file_length,
ulonglong &auto_increment_value,
time_t &create_time,
time_t &update_time,
time_t &check_time
);
int fetch_table_records(
int mode,
ha_rows &records
);
int fetch_table_cardinality(
int mode,
TABLE *table,
longlong *cardinality,
uchar *cardinality_upd,
int bitmap_size
);
int fetch_table_mon_status(
int &status
);
longlong num_rows();
uint num_fields();
void move_to_pos(
longlong pos
);
int get_errno();
#ifdef SPIDER_HAS_DISCOVER_TABLE_STRUCTURE
int fetch_columns_for_discover_table_structure(
spider_string *str,
CHARSET_INFO *access_charset
);
int fetch_index_for_discover_table_structure(
spider_string *str,
CHARSET_INFO *access_charset
);
#endif
};
class spider_db_handlersocket: public spider_db_conn
{
SPIDER_HS_CONN hs_conn;
int stored_error;
uint field_count;
public:
DYNAMIC_ARRAY handler_open_array;
bool handler_open_array_inited;
uint handler_open_array_id;
const char *handler_open_array_func_name;
const char *handler_open_array_file_name;
ulong handler_open_array_line_no;
st_spider_db_request_key *request_key_req_first;
st_spider_db_request_key *request_key_req_last;
st_spider_db_request_key *request_key_snd_first;
st_spider_db_request_key *request_key_snd_last;
st_spider_db_request_key *request_key_reuse_first;
st_spider_db_request_key *request_key_reuse_last;
spider_db_handlersocket(
SPIDER_CONN *conn
);
~spider_db_handlersocket();
int init();
bool is_connected();
void bg_connect();
int connect(
char *tgt_host,
char *tgt_username,
char *tgt_password,
long tgt_port,
char *tgt_socket,
char *server_name,
int connect_retry_count,
longlong connect_retry_interval
);
int ping();
void bg_disconnect();
void disconnect();
int set_net_timeout();
int exec_query(
const char *query,
uint length,
int quick_mode
);
int get_errno();
const char *get_error();
bool is_server_gone_error(
int error_num
);
bool is_dup_entry_error(
int error_num
);
bool is_xa_nota_error(
int error_num
);
spider_db_result *store_result(
spider_db_result_buffer **spider_res_buf,
st_spider_db_request_key *request_key,
int *error_num
);
spider_db_result *use_result(
st_spider_db_request_key *request_key,
int *error_num
);
int next_result();
uint affected_rows();
ulonglong last_insert_id();
int set_character_set(
const char *csname
);
int select_db(
const char *dbname
);
int consistent_snapshot(
int *need_mon
);
bool trx_start_in_bulk_sql();
int start_transaction(
int *need_mon
);
int commit(
int *need_mon
);
int rollback(
int *need_mon
);
bool xa_start_in_bulk_sql();
int xa_start(
XID *xid,
int *need_mon
);
int xa_end(
XID *xid,
int *need_mon
);
int xa_prepare(
XID *xid,
int *need_mon
);
int xa_commit(
XID *xid,
int *need_mon
);
int xa_rollback(
XID *xid,
int *need_mon
);
bool set_trx_isolation_in_bulk_sql();
int set_trx_isolation(
int trx_isolation,
int *need_mon
);
bool set_autocommit_in_bulk_sql();
int set_autocommit(
bool autocommit,
int *need_mon
);
bool set_sql_log_off_in_bulk_sql();
int set_sql_log_off(
bool sql_log_off,
int *need_mon
);
bool set_time_zone_in_bulk_sql();
int set_time_zone(
Time_zone *time_zone,
int *need_mon
);
int append_sql(
char *sql,
ulong sql_length,
st_spider_db_request_key *request_key
);
int append_open_handler(
uint handler_id,
const char *db_name,
const char *table_name,
const char *index_name,
const char *sql,
st_spider_db_request_key *request_key
);
int append_select(
uint handler_id,
spider_string *sql,
SPIDER_DB_HS_STRING_REF_BUFFER *keys,
int limit,
int skip,
st_spider_db_request_key *request_key
);
int append_insert(
uint handler_id,
SPIDER_DB_HS_STRING_REF_BUFFER *upds,
st_spider_db_request_key *request_key
);
int append_update(
uint handler_id,
spider_string *sql,
SPIDER_DB_HS_STRING_REF_BUFFER *keys,
SPIDER_DB_HS_STRING_REF_BUFFER *upds,
int limit,
int skip,
bool increment,
bool decrement,
st_spider_db_request_key *request_key
);
int append_delete(
uint handler_id,
spider_string *sql,
SPIDER_DB_HS_STRING_REF_BUFFER *keys,
int limit,
int skip,
st_spider_db_request_key *request_key
);
void reset_request_queue();
size_t escape_string(
char *to,
const char *from,
size_t from_length
);
bool have_lock_table_list();
int append_lock_tables(
spider_string *str
);
int append_unlock_tables(
spider_string *str
);
uint get_lock_table_hash_count();
void reset_lock_table_hash();
uint get_opened_handler_count();
void reset_opened_handler();
void set_dup_key_idx(
ha_spider *spider,
int link_idx
);
int append_request_key(
st_spider_db_request_key *request_key
);
void reset_request_key_req();
void reset_request_key_snd();
void move_request_key_to_snd();
int check_request_key(
st_spider_db_request_key *request_key
);
bool cmp_request_key_to_snd(
st_spider_db_request_key *request_key
);
};
class spider_handlersocket_share: public spider_db_share
{
public:
spider_string *table_names_str;
spider_string *db_names_str;
spider_string *db_table_str;
#ifdef SPIDER_HAS_HASH_VALUE_TYPE
my_hash_value_type *db_table_str_hash_value;
#endif
uint table_nm_max_length;
uint db_nm_max_length;
spider_string *column_name_str;
bool same_db_table_name;
int first_all_link_idx;
spider_handlersocket_share(
st_spider_share *share
);
~spider_handlersocket_share();
int init();
int append_table_name(
spider_string *str,
int all_link_idx
);
int create_table_names_str();
void free_table_names_str();
int create_column_name_str();
void free_column_name_str();
uint get_column_name_length(
uint field_index
);
int append_column_name(
spider_string *str,
uint field_index
);
int append_column_name_with_alias(
spider_string *str,
uint field_index,
const char *alias,
uint alias_length
);
bool need_change_db_table_name();
#ifdef SPIDER_HAS_DISCOVER_TABLE_STRUCTURE
int discover_table_structure(
SPIDER_TRX *trx,
SPIDER_SHARE *spider_share,
spider_string *str
);
#endif
};
class spider_handlersocket_handler: public spider_db_handler
{
spider_string hs_sql;
public:
bool hs_adding_keys;
SPIDER_DB_HS_STRING_REF_BUFFER hs_keys;
SPIDER_DB_HS_STRING_REF_BUFFER hs_upds;
SPIDER_DB_HS_STR_BUFFER hs_strs;
uint hs_strs_pos;
int hs_limit;
int hs_skip;
spider_handlersocket_share *handlersocket_share;
SPIDER_LINK_FOR_HASH *link_for_hash;
spider_handlersocket_handler(
ha_spider *spider,
spider_handlersocket_share *db_share
);
~spider_handlersocket_handler();
int init();
int append_table_name_with_adjusting(
spider_string *str,
int link_idx,
ulong sql_type
);
int append_tmp_table_and_sql_for_bka(
const key_range *start_key
);
int reuse_tmp_table_and_sql_for_bka();
int append_union_table_and_sql_for_bka(
const key_range *start_key
);
int reuse_union_table_and_sql_for_bka();
int append_insert_for_recovery(
ulong sql_type,
int link_idx
);
int append_update(
const TABLE *table,
my_ptrdiff_t ptr_diff
);
int append_update(
const TABLE *table,
my_ptrdiff_t ptr_diff,
int link_idx
);
int append_delete(
const TABLE *table,
my_ptrdiff_t ptr_diff
);
int append_delete(
const TABLE *table,
my_ptrdiff_t ptr_diff,
int link_idx
);
int append_insert_part();
int append_update_part();
int append_delete_part();
#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
int append_increment_update_set_part();
#endif
int append_update_set_part();
#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
int append_direct_update_set_part();
#endif
int append_minimum_select_without_quote(
spider_string *str
);
#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
int append_minimum_select_by_field_idx_list(
spider_string *str,
uint32 *field_idxs,
size_t field_idxs_num
);
int append_dup_update_pushdown_part(
const char *alias,
uint alias_length
);
int append_update_columns_part(
const char *alias,
uint alias_length
);
int check_update_columns_part();
int append_select_part(
ulong sql_type
);
#endif
int append_table_select_part(
ulong sql_type
);
int append_key_select_part(
ulong sql_type,
uint idx
);
int append_minimum_select_part(
ulong sql_type
);
int append_hint_after_table_part(
ulong sql_type
);
void set_where_pos(
ulong sql_type
);
void set_where_to_pos(
ulong sql_type
);
int check_item_type(
Item *item
);
int append_values_connector_part(
ulong sql_type
);
int append_values_terminator_part(
ulong sql_type
);
int append_union_table_connector_part(
ulong sql_type
);
int append_union_table_terminator_part(
ulong sql_type
);
int append_key_column_values_part(
const key_range *start_key,
ulong sql_type
);
int append_key_column_values_with_name_part(
const key_range *start_key,
ulong sql_type
);
int append_key_where_part(
const key_range *start_key,
const key_range *end_key,
ulong sql_type
);
int append_key_where(
spider_string *str,
spider_string *str_part,
spider_string *str_part2,
const key_range *start_key,
const key_range *end_key,
ulong sql_type,
bool set_order
);
int append_is_null_part(
ulong sql_type,
KEY_PART_INFO *key_part,
const key_range *key,
const uchar **ptr,
bool key_eq
);
int append_is_null(
ulong sql_type,
spider_string *str,
spider_string *str_part,
spider_string *str_part2,
KEY_PART_INFO *key_part,
const key_range *key,
const uchar **ptr,
bool key_eq
);
int append_where_terminator_part(
ulong sql_type,
bool set_order,
int key_count
);
int append_match_where_part(
ulong sql_type
);
int append_condition_part(
const char *alias,
uint alias_length,
ulong sql_type,
bool test_flg
);
int append_match_select_part(
ulong sql_type,
const char *alias,
uint alias_length
);
#ifdef HANDLER_HAS_DIRECT_AGGREGATE
int append_sum_select_part(
ulong sql_type,
const char *alias,
uint alias_length
);
#endif
void set_order_pos(
ulong sql_type
);
void set_order_to_pos(
ulong sql_type
);
int append_key_order_for_merge_with_alias_part(
const char *alias,
uint alias_length,
ulong sql_type
);
int append_key_order_for_direct_order_limit_with_alias_part(
const char *alias,
uint alias_length,
ulong sql_type
);
int append_key_order_with_alias_part(
const char *alias,
uint alias_length,
ulong sql_type
);
int append_limit_part(
longlong offset,
longlong limit,
ulong sql_type
);
int reappend_limit_part(
longlong offset,
longlong limit,
ulong sql_type
);
int append_select_lock_part(
ulong sql_type
);
int append_union_all_start_part(
ulong sql_type
);
int append_union_all_part(
ulong sql_type
);
int append_union_all_end_part(
ulong sql_type
);
int append_multi_range_cnt_part(
ulong sql_type,
uint multi_range_cnt,
bool with_comma
);
int append_multi_range_cnt_with_name_part(
ulong sql_type,
uint multi_range_cnt
);
int append_open_handler_part(
ulong sql_type,
uint handler_id,
SPIDER_CONN *conn,
int link_idx
);
int append_open_handler(
spider_string *str,
uint handler_id,
SPIDER_CONN *conn,
int link_idx
);
int append_close_handler_part(
ulong sql_type,
int link_idx
);
int append_insert_terminator_part(
ulong sql_type
);
int append_insert_values_part(
ulong sql_type
);
int append_insert_values(
spider_string *str
);
int append_into_part(
ulong sql_type
);
void set_insert_to_pos(
ulong sql_type
);
int append_from_part(
ulong sql_type,
int link_idx
);
int append_delete_all_rows_part(
ulong sql_type
);
int append_explain_select_part(
key_range *start_key,
key_range *end_key,
ulong sql_type,
int link_idx
);
bool is_bulk_insert_exec_period(
bool bulk_end
);
bool sql_is_filled_up(
ulong sql_type
);
bool sql_is_empty(
ulong sql_type
);
bool support_multi_split_read();
bool support_bulk_update();
int bulk_tmp_table_insert();
int bulk_tmp_table_insert(
int link_idx
);
int bulk_tmp_table_end_bulk_insert();
int bulk_tmp_table_rnd_init();
int bulk_tmp_table_rnd_next();
int bulk_tmp_table_rnd_end();
bool need_copy_for_update(
int link_idx
);
bool bulk_tmp_table_created();
int mk_bulk_tmp_table_and_bulk_start();
void rm_bulk_tmp_table();
int insert_lock_tables_list(
SPIDER_CONN *conn,
int link_idx
);
int append_lock_tables_list(
SPIDER_CONN *conn,
int link_idx,
int *appended
);
int realloc_sql(
ulong *realloced
);
int reset_sql(
ulong sql_type
);
int reset_keys(
ulong sql_type
);
int reset_upds(
ulong sql_type
);
int reset_strs(
ulong sql_type
);
int reset_strs_pos(
ulong sql_type
);
int push_back_upds(
SPIDER_HS_STRING_REF &info
);
int request_buf_find(
int link_idx
);
int request_buf_insert(
int link_idx
);
int request_buf_update(
int link_idx
);
int request_buf_delete(
int link_idx
);
bool need_lock_before_set_sql_for_exec(
ulong sql_type
);
int set_sql_for_exec(
ulong sql_type,
int link_idx
);
int set_sql_for_exec(
spider_db_copy_table *tgt_ct,
ulong sql_type
);
int execute_sql(
ulong sql_type,
SPIDER_CONN *conn,
int quick_mode,
int *need_mon
);
int reset();
int sts_mode_exchange(
int sts_mode
);
int show_table_status(
int link_idx,
int sts_mode,
uint flag
);
int crd_mode_exchange(
int crd_mode
);
int show_index(
int link_idx,
int crd_mode
);
int show_records(
int link_idx
);
int show_last_insert_id(
int link_idx,
ulonglong &last_insert_id
);
ha_rows explain_select(
key_range *start_key,
key_range *end_key,
int link_idx
);
int lock_tables(
int link_idx
);
int unlock_tables(
int link_idx
);
int disable_keys(
SPIDER_CONN *conn,
int link_idx
);
int enable_keys(
SPIDER_CONN *conn,
int link_idx
);
int check_table(
SPIDER_CONN *conn,
int link_idx,
HA_CHECK_OPT* check_opt
);
int repair_table(
SPIDER_CONN *conn,
int link_idx,
HA_CHECK_OPT* check_opt
);
int analyze_table(
SPIDER_CONN *conn,
int link_idx
);
int optimize_table(
SPIDER_CONN *conn,
int link_idx
);
int flush_tables(
SPIDER_CONN *conn,
int link_idx,
bool lock
);
int flush_logs(
SPIDER_CONN *conn,
int link_idx
);
int insert_opened_handler(
SPIDER_CONN *conn,
int link_idx
);
int delete_opened_handler(
SPIDER_CONN *conn,
int link_idx
);
int sync_from_clone_source(
spider_db_handler *dbton_hdl
);
bool support_use_handler(
int use_handler
);
bool minimum_select_bit_is_set(
uint field_index
);
void copy_minimum_select_bitmap(
uchar *bitmap
);
int init_union_table_name_pos();
int set_union_table_name_pos();
int reset_union_table_name(
spider_string *str,
int link_idx,
ulong sql_type
);
};
/* Copyright (C) 2012-2013 Kentoku Shiba
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 */
#define SPIDER_HS_CONN dena::hstcpcli_ptr
#define SPIDER_HS_CONN_CREATE dena::hstcpcli_i::create
#define SPIDER_HS_RESULT dena::hstresult
#define SPIDER_HS_SOCKARGS dena::socket_args
class spider_db_handlersocket_util: public spider_db_util
{
public:
spider_db_handlersocket_util();
~spider_db_handlersocket_util();
int append_name(
spider_string *str,
const char *name,
uint name_length
);
int append_name_with_charset(
spider_string *str,
const char *name,
uint name_length,
CHARSET_INFO *name_charset
);
bool is_name_quote(
const char head_code
);
int append_escaped_name_quote(
spider_string *str
);
int append_column_value(
ha_spider *spider,
spider_string *str,
Field *field,
const uchar *new_ptr,
CHARSET_INFO *access_charset
);
int append_trx_isolation(
spider_string *str,
int trx_isolation
);
int append_autocommit(
spider_string *str,
bool autocommit
);
int append_sql_log_off(
spider_string *str,
bool sql_log_off
);
int append_time_zone(
spider_string *str,
Time_zone *time_zone
);
int append_start_transaction(
spider_string *str
);
int append_xa_start(
spider_string *str,
XID *xid
);
int append_lock_table_head(
spider_string *str
);
int append_lock_table_body(
spider_string *str,
const char *db_name,
uint db_name_length,
CHARSET_INFO *db_name_charset,
const char *table_name,
uint table_name_length,
CHARSET_INFO *table_name_charset,
int lock_type
);
int append_lock_table_tail(
spider_string *str
);
int append_unlock_table(
spider_string *str
);
int open_item_func(
Item_func *item_func,
ha_spider *spider,
spider_string *str,
const char *alias,
uint alias_length
);
#ifdef HANDLER_HAS_DIRECT_AGGREGATE
int open_item_sum_func(
Item_sum *item_sum,
ha_spider *spider,
spider_string *str,
const char *alias,
uint alias_length
);
#endif
int append_escaped_util(
spider_string *to,
String *from
);
};
class spider_db_handlersocket_row: public spider_db_row
{
public:
SPIDER_HS_STRING_REF *hs_row;
SPIDER_HS_STRING_REF *hs_row_first;
uint field_count;
bool cloned;
spider_db_handlersocket_row();
~spider_db_handlersocket_row();
int store_to_field(
Field *field,
CHARSET_INFO *access_charset
);
int append_to_str(
spider_string *str
);
int append_escaped_to_str(
spider_string *str,
uint dbton_id
);
void first();
void next();
bool is_null();
int val_int();
double val_real();
my_decimal *val_decimal(
my_decimal *decimal_value,
CHARSET_INFO *access_charset
);
SPIDER_DB_ROW *clone();
int store_to_tmp_table(
TABLE *tmp_table,
spider_string *str
);
};
class spider_db_handlersocket_result_buffer: public spider_db_result_buffer
{
public:
SPIDER_HS_RESULT hs_result;
spider_db_handlersocket_result_buffer();
~spider_db_handlersocket_result_buffer();
void clear();
bool check_size(
longlong size
);
};
class spider_db_handlersocket_result: public spider_db_result
{
public:
SPIDER_HS_CONN *hs_conn_p;
spider_db_handlersocket_row row;
SPIDER_HS_STRING_REF hs_row;
uint field_count;
int store_error_num;
spider_db_handlersocket_result();
~spider_db_handlersocket_result();
bool has_result();
void free_result();
SPIDER_DB_ROW *current_row();
SPIDER_DB_ROW *fetch_row();
SPIDER_DB_ROW *fetch_row_from_result_buffer(
spider_db_result_buffer *spider_res_buf
);
SPIDER_DB_ROW *fetch_row_from_tmp_table(
TABLE *tmp_table
);
int fetch_table_status(
int mode,
ha_rows &records,
ulong &mean_rec_length,
ulonglong &data_file_length,
ulonglong &max_data_file_length,
ulonglong &index_file_length,
ulonglong &auto_increment_value,
time_t &create_time,
time_t &update_time,
time_t &check_time
);
int fetch_table_records(
int mode,
ha_rows &records
);
int fetch_table_cardinality(
int mode,
TABLE *table,
longlong *cardinality,
uchar *cardinality_upd,
int bitmap_size
);
int fetch_table_mon_status(
int &status
);
longlong num_rows();
uint num_fields();
void move_to_pos(
longlong pos
);
int get_errno();
#ifdef SPIDER_HAS_DISCOVER_TABLE_STRUCTURE
int fetch_columns_for_discover_table_structure(
spider_string *str,
CHARSET_INFO *access_charset
);
int fetch_index_for_discover_table_structure(
spider_string *str,
CHARSET_INFO *access_charset
);
#endif
};
class spider_db_handlersocket: public spider_db_conn
{
SPIDER_HS_CONN hs_conn;
int stored_error;
uint field_count;
public:
DYNAMIC_ARRAY handler_open_array;
bool handler_open_array_inited;
uint handler_open_array_id;
const char *handler_open_array_func_name;
const char *handler_open_array_file_name;
ulong handler_open_array_line_no;
st_spider_db_request_key *request_key_req_first;
st_spider_db_request_key *request_key_req_last;
st_spider_db_request_key *request_key_snd_first;
st_spider_db_request_key *request_key_snd_last;
st_spider_db_request_key *request_key_reuse_first;
st_spider_db_request_key *request_key_reuse_last;
spider_db_handlersocket(
SPIDER_CONN *conn
);
~spider_db_handlersocket();
int init();
bool is_connected();
void bg_connect();
int connect(
char *tgt_host,
char *tgt_username,
char *tgt_password,
long tgt_port,
char *tgt_socket,
char *server_name,
int connect_retry_count,
longlong connect_retry_interval
);
int ping();
void bg_disconnect();
void disconnect();
int set_net_timeout();
int exec_query(
const char *query,
uint length,
int quick_mode
);
int get_errno();
const char *get_error();
bool is_server_gone_error(
int error_num
);
bool is_dup_entry_error(
int error_num
);
bool is_xa_nota_error(
int error_num
);
spider_db_result *store_result(
spider_db_result_buffer **spider_res_buf,
st_spider_db_request_key *request_key,
int *error_num
);
spider_db_result *use_result(
st_spider_db_request_key *request_key,
int *error_num
);
int next_result();
uint affected_rows();
ulonglong last_insert_id();
int set_character_set(
const char *csname
);
int select_db(
const char *dbname
);
int consistent_snapshot(
int *need_mon
);
bool trx_start_in_bulk_sql();
int start_transaction(
int *need_mon
);
int commit(
int *need_mon
);
int rollback(
int *need_mon
);
bool xa_start_in_bulk_sql();
int xa_start(
XID *xid,
int *need_mon
);
int xa_end(
XID *xid,
int *need_mon
);
int xa_prepare(
XID *xid,
int *need_mon
);
int xa_commit(
XID *xid,
int *need_mon
);
int xa_rollback(
XID *xid,
int *need_mon
);
bool set_trx_isolation_in_bulk_sql();
int set_trx_isolation(
int trx_isolation,
int *need_mon
);
bool set_autocommit_in_bulk_sql();
int set_autocommit(
bool autocommit,
int *need_mon
);
bool set_sql_log_off_in_bulk_sql();
int set_sql_log_off(
bool sql_log_off,
int *need_mon
);
bool set_time_zone_in_bulk_sql();
int set_time_zone(
Time_zone *time_zone,
int *need_mon
);
int append_sql(
char *sql,
ulong sql_length,
st_spider_db_request_key *request_key
);
int append_open_handler(
uint handler_id,
const char *db_name,
const char *table_name,
const char *index_name,
const char *sql,
st_spider_db_request_key *request_key
);
int append_select(
uint handler_id,
spider_string *sql,
SPIDER_DB_HS_STRING_REF_BUFFER *keys,
int limit,
int skip,
st_spider_db_request_key *request_key
);
int append_insert(
uint handler_id,
SPIDER_DB_HS_STRING_REF_BUFFER *upds,
st_spider_db_request_key *request_key
);
int append_update(
uint handler_id,
spider_string *sql,
SPIDER_DB_HS_STRING_REF_BUFFER *keys,
SPIDER_DB_HS_STRING_REF_BUFFER *upds,
int limit,
int skip,
bool increment,
bool decrement,
st_spider_db_request_key *request_key
);
int append_delete(
uint handler_id,
spider_string *sql,
SPIDER_DB_HS_STRING_REF_BUFFER *keys,
int limit,
int skip,
st_spider_db_request_key *request_key
);
void reset_request_queue();
size_t escape_string(
char *to,
const char *from,
size_t from_length
);
bool have_lock_table_list();
int append_lock_tables(
spider_string *str
);
int append_unlock_tables(
spider_string *str
);
uint get_lock_table_hash_count();
void reset_lock_table_hash();
uint get_opened_handler_count();
void reset_opened_handler();
void set_dup_key_idx(
ha_spider *spider,
int link_idx
);
int append_request_key(
st_spider_db_request_key *request_key
);
void reset_request_key_req();
void reset_request_key_snd();
void move_request_key_to_snd();
int check_request_key(
st_spider_db_request_key *request_key
);
bool cmp_request_key_to_snd(
st_spider_db_request_key *request_key
);
};
class spider_handlersocket_share: public spider_db_share
{
public:
spider_string *table_names_str;
spider_string *db_names_str;
spider_string *db_table_str;
#ifdef SPIDER_HAS_HASH_VALUE_TYPE
my_hash_value_type *db_table_str_hash_value;
#endif
uint table_nm_max_length;
uint db_nm_max_length;
spider_string *column_name_str;
bool same_db_table_name;
int first_all_link_idx;
spider_handlersocket_share(
st_spider_share *share
);
~spider_handlersocket_share();
int init();
int append_table_name(
spider_string *str,
int all_link_idx
);
int create_table_names_str();
void free_table_names_str();
int create_column_name_str();
void free_column_name_str();
uint get_column_name_length(
uint field_index
);
int append_column_name(
spider_string *str,
uint field_index
);
int append_column_name_with_alias(
spider_string *str,
uint field_index,
const char *alias,
uint alias_length
);
bool need_change_db_table_name();
#ifdef SPIDER_HAS_DISCOVER_TABLE_STRUCTURE
int discover_table_structure(
SPIDER_TRX *trx,
SPIDER_SHARE *spider_share,
spider_string *str
);
#endif
};
class spider_handlersocket_handler: public spider_db_handler
{
spider_string hs_sql;
public:
bool hs_adding_keys;
SPIDER_DB_HS_STRING_REF_BUFFER hs_keys;
SPIDER_DB_HS_STRING_REF_BUFFER hs_upds;
SPIDER_DB_HS_STR_BUFFER hs_strs;
uint hs_strs_pos;
int hs_limit;
int hs_skip;
spider_handlersocket_share *handlersocket_share;
SPIDER_LINK_FOR_HASH *link_for_hash;
spider_handlersocket_handler(
ha_spider *spider,
spider_handlersocket_share *db_share
);
~spider_handlersocket_handler();
int init();
int append_table_name_with_adjusting(
spider_string *str,
int link_idx,
ulong sql_type
);
int append_tmp_table_and_sql_for_bka(
const key_range *start_key
);
int reuse_tmp_table_and_sql_for_bka();
int append_union_table_and_sql_for_bka(
const key_range *start_key
);
int reuse_union_table_and_sql_for_bka();
int append_insert_for_recovery(
ulong sql_type,
int link_idx
);
int append_update(
const TABLE *table,
my_ptrdiff_t ptr_diff
);
int append_update(
const TABLE *table,
my_ptrdiff_t ptr_diff,
int link_idx
);
int append_delete(
const TABLE *table,
my_ptrdiff_t ptr_diff
);
int append_delete(
const TABLE *table,
my_ptrdiff_t ptr_diff,
int link_idx
);
int append_insert_part();
int append_update_part();
int append_delete_part();
#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
int append_increment_update_set_part();
#endif
int append_update_set_part();
#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
int append_direct_update_set_part();
#endif
int append_minimum_select_without_quote(
spider_string *str
);
#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
int append_minimum_select_by_field_idx_list(
spider_string *str,
uint32 *field_idxs,
size_t field_idxs_num
);
int append_dup_update_pushdown_part(
const char *alias,
uint alias_length
);
int append_update_columns_part(
const char *alias,
uint alias_length
);
int check_update_columns_part();
int append_select_part(
ulong sql_type
);
#endif
int append_table_select_part(
ulong sql_type
);
int append_key_select_part(
ulong sql_type,
uint idx
);
int append_minimum_select_part(
ulong sql_type
);
int append_hint_after_table_part(
ulong sql_type
);
void set_where_pos(
ulong sql_type
);
void set_where_to_pos(
ulong sql_type
);
int check_item_type(
Item *item
);
int append_values_connector_part(
ulong sql_type
);
int append_values_terminator_part(
ulong sql_type
);
int append_union_table_connector_part(
ulong sql_type
);
int append_union_table_terminator_part(
ulong sql_type
);
int append_key_column_values_part(
const key_range *start_key,
ulong sql_type
);
int append_key_column_values_with_name_part(
const key_range *start_key,
ulong sql_type
);
int append_key_where_part(
const key_range *start_key,
const key_range *end_key,
ulong sql_type
);
int append_key_where(
spider_string *str,
spider_string *str_part,
spider_string *str_part2,
const key_range *start_key,
const key_range *end_key,
ulong sql_type,
bool set_order
);
int append_is_null_part(
ulong sql_type,
KEY_PART_INFO *key_part,
const key_range *key,
const uchar **ptr,
bool key_eq
);
int append_is_null(
ulong sql_type,
spider_string *str,
spider_string *str_part,
spider_string *str_part2,
KEY_PART_INFO *key_part,
const key_range *key,
const uchar **ptr,
bool key_eq
);
int append_where_terminator_part(
ulong sql_type,
bool set_order,
int key_count
);
int append_match_where_part(
ulong sql_type
);
int append_condition_part(
const char *alias,
uint alias_length,
ulong sql_type,
bool test_flg
);
int append_match_select_part(
ulong sql_type,
const char *alias,
uint alias_length
);
#ifdef HANDLER_HAS_DIRECT_AGGREGATE
int append_sum_select_part(
ulong sql_type,
const char *alias,
uint alias_length
);
#endif
void set_order_pos(
ulong sql_type
);
void set_order_to_pos(
ulong sql_type
);
int append_key_order_for_merge_with_alias_part(
const char *alias,
uint alias_length,
ulong sql_type
);
int append_key_order_for_direct_order_limit_with_alias_part(
const char *alias,
uint alias_length,
ulong sql_type
);
int append_key_order_with_alias_part(
const char *alias,
uint alias_length,
ulong sql_type
);
int append_limit_part(
longlong offset,
longlong limit,
ulong sql_type
);
int reappend_limit_part(
longlong offset,
longlong limit,
ulong sql_type
);
int append_select_lock_part(
ulong sql_type
);
int append_union_all_start_part(
ulong sql_type
);
int append_union_all_part(
ulong sql_type
);
int append_union_all_end_part(
ulong sql_type
);
int append_multi_range_cnt_part(
ulong sql_type,
uint multi_range_cnt,
bool with_comma
);
int append_multi_range_cnt_with_name_part(
ulong sql_type,
uint multi_range_cnt
);
int append_open_handler_part(
ulong sql_type,
uint handler_id,
SPIDER_CONN *conn,
int link_idx
);
int append_open_handler(
spider_string *str,
uint handler_id,
SPIDER_CONN *conn,
int link_idx
);
int append_close_handler_part(
ulong sql_type,
int link_idx
);
int append_insert_terminator_part(
ulong sql_type
);
int append_insert_values_part(
ulong sql_type
);
int append_insert_values(
spider_string *str
);
int append_into_part(
ulong sql_type
);
void set_insert_to_pos(
ulong sql_type
);
int append_from_part(
ulong sql_type,
int link_idx
);
int append_delete_all_rows_part(
ulong sql_type
);
int append_explain_select_part(
key_range *start_key,
key_range *end_key,
ulong sql_type,
int link_idx
);
bool is_bulk_insert_exec_period(
bool bulk_end
);
bool sql_is_filled_up(
ulong sql_type
);
bool sql_is_empty(
ulong sql_type
);
bool support_multi_split_read();
bool support_bulk_update();
int bulk_tmp_table_insert();
int bulk_tmp_table_insert(
int link_idx
);
int bulk_tmp_table_end_bulk_insert();
int bulk_tmp_table_rnd_init();
int bulk_tmp_table_rnd_next();
int bulk_tmp_table_rnd_end();
bool need_copy_for_update(
int link_idx
);
bool bulk_tmp_table_created();
int mk_bulk_tmp_table_and_bulk_start();
void rm_bulk_tmp_table();
int insert_lock_tables_list(
SPIDER_CONN *conn,
int link_idx
);
int append_lock_tables_list(
SPIDER_CONN *conn,
int link_idx,
int *appended
);
int realloc_sql(
ulong *realloced
);
int reset_sql(
ulong sql_type
);
int reset_keys(
ulong sql_type
);
int reset_upds(
ulong sql_type
);
int reset_strs(
ulong sql_type
);
int reset_strs_pos(
ulong sql_type
);
int push_back_upds(
SPIDER_HS_STRING_REF &info
);
int request_buf_find(
int link_idx
);
int request_buf_insert(
int link_idx
);
int request_buf_update(
int link_idx
);
int request_buf_delete(
int link_idx
);
bool need_lock_before_set_sql_for_exec(
ulong sql_type
);
int set_sql_for_exec(
ulong sql_type,
int link_idx
);
int set_sql_for_exec(
spider_db_copy_table *tgt_ct,
ulong sql_type
);
int execute_sql(
ulong sql_type,
SPIDER_CONN *conn,
int quick_mode,
int *need_mon
);
int reset();
int sts_mode_exchange(
int sts_mode
);
int show_table_status(
int link_idx,
int sts_mode,
uint flag
);
int crd_mode_exchange(
int crd_mode
);
int show_index(
int link_idx,
int crd_mode
);
int show_records(
int link_idx
);
int show_last_insert_id(
int link_idx,
ulonglong &last_insert_id
);
ha_rows explain_select(
key_range *start_key,
key_range *end_key,
int link_idx
);
int lock_tables(
int link_idx
);
int unlock_tables(
int link_idx
);
int disable_keys(
SPIDER_CONN *conn,
int link_idx
);
int enable_keys(
SPIDER_CONN *conn,
int link_idx
);
int check_table(
SPIDER_CONN *conn,
int link_idx,
HA_CHECK_OPT* check_opt
);
int repair_table(
SPIDER_CONN *conn,
int link_idx,
HA_CHECK_OPT* check_opt
);
int analyze_table(
SPIDER_CONN *conn,
int link_idx
);
int optimize_table(
SPIDER_CONN *conn,
int link_idx
);
int flush_tables(
SPIDER_CONN *conn,
int link_idx,
bool lock
);
int flush_logs(
SPIDER_CONN *conn,
int link_idx
);
int insert_opened_handler(
SPIDER_CONN *conn,
int link_idx
);
int delete_opened_handler(
SPIDER_CONN *conn,
int link_idx
);
int sync_from_clone_source(
spider_db_handler *dbton_hdl
);
bool support_use_handler(
int use_handler
);
bool minimum_select_bit_is_set(
uint field_index
);
void copy_minimum_select_bitmap(
uchar *bitmap
);
int init_union_table_name_pos();
int set_union_table_name_pos();
int reset_union_table_name(
spider_string *str,
int link_idx,
ulong sql_type
);
};
storage/spider/spd_db_mysql.cc
View file @ b5ebf1e2
This source diff could not be displayed because it is too large. You can view the blob instead.
storage/spider/spd_db_mysql.h
View file @ b5ebf1e2
/* Copyright (C) 2012-2013 Kentoku Shiba
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 */
class spider_db_mysql_util: public spider_db_util
{
public:
spider_db_mysql_util();
~spider_db_mysql_util();
int append_name(
spider_string *str,
const char *name,
uint name_length
);
int append_name_with_charset(
spider_string *str,
const char *name,
uint name_length,
CHARSET_INFO *name_charset
);
bool is_name_quote(
const char head_code
);
int append_escaped_name_quote(
spider_string *str
);
int append_column_value(
ha_spider *spider,
spider_string *str,
Field *field,
const uchar *new_ptr,
CHARSET_INFO *access_charset
);
int append_from_with_alias(
spider_string *str,
const char **table_names,
uint *table_name_lengths,
const char **table_aliases,
uint *table_alias_lengths,
uint table_count,
int *table_name_pos,
bool over_write
);
int append_trx_isolation(
spider_string *str,
int trx_isolation
);
int append_autocommit(
spider_string *str,
bool autocommit
);
int append_sql_log_off(
spider_string *str,
bool sql_log_off
);
int append_time_zone(
spider_string *str,
Time_zone *time_zone
);
int append_start_transaction(
spider_string *str
);
int append_xa_start(
spider_string *str,
XID *xid
);
int append_lock_table_head(
spider_string *str
);
int append_lock_table_body(
spider_string *str,
const char *db_name,
uint db_name_length,
CHARSET_INFO *db_name_charset,
const char *table_name,
uint table_name_length,
CHARSET_INFO *table_name_charset,
int lock_type
);
int append_lock_table_tail(
spider_string *str
);
int append_unlock_table(
spider_string *str
);
int open_item_func(
Item_func *item_func,
ha_spider *spider,
spider_string *str,
const char *alias,
uint alias_length
);
#ifdef HANDLER_HAS_DIRECT_AGGREGATE
int open_item_sum_func(
Item_sum *item_sum,
ha_spider *spider,
spider_string *str,
const char *alias,
uint alias_length
);
#endif
int append_escaped_util(
spider_string *to,
String *from
);
};
class spider_db_mysql_row: public spider_db_row
{
public:
MYSQL_ROW row;
MYSQL_ROW row_first;
ulong *lengths;
ulong *lengths_first;
uint field_count;
bool cloned;
spider_db_mysql_row();
~spider_db_mysql_row();
int store_to_field(
Field *field,
CHARSET_INFO *access_charset
);
int append_to_str(
spider_string *str
);
int append_escaped_to_str(
spider_string *str,
uint dbton_id
);
void first();
void next();
bool is_null();
int val_int();
double val_real();
my_decimal *val_decimal(
my_decimal *decimal_value,
CHARSET_INFO *access_charset
);
SPIDER_DB_ROW *clone();
int store_to_tmp_table(
TABLE *tmp_table,
spider_string *str
);
};
class spider_db_mysql_result: public spider_db_result
{
public:
MYSQL_RES *db_result;
spider_db_mysql_row row;
MYSQL_ROW_OFFSET first_row;
int store_error_num;
spider_db_mysql_result();
~spider_db_mysql_result();
bool has_result();
void free_result();
SPIDER_DB_ROW *current_row();
SPIDER_DB_ROW *fetch_row();
SPIDER_DB_ROW *fetch_row_from_result_buffer(
spider_db_result_buffer *spider_res_buf
);
SPIDER_DB_ROW *fetch_row_from_tmp_table(
TABLE *tmp_table
);
int fetch_table_status(
int mode,
ha_rows &records,
ulong &mean_rec_length,
ulonglong &data_file_length,
ulonglong &max_data_file_length,
ulonglong &index_file_length,
ulonglong &auto_increment_value,
time_t &create_time,
time_t &update_time,
time_t &check_time
);
int fetch_table_records(
int mode,
ha_rows &records
);
int fetch_table_cardinality(
int mode,
TABLE *table,
longlong *cardinality,
uchar *cardinality_upd,
int bitmap_size
);
int fetch_table_mon_status(
int &status
);
longlong num_rows();
uint num_fields();
void move_to_pos(
longlong pos
);
int get_errno();
#ifdef SPIDER_HAS_DISCOVER_TABLE_STRUCTURE
int fetch_columns_for_discover_table_structure(
spider_string *str,
CHARSET_INFO *access_charset
);
int fetch_index_for_discover_table_structure(
spider_string *str,
CHARSET_INFO *access_charset
);
#endif
};
class spider_db_mysql: public spider_db_conn
{
MYSQL *db_conn;
int stored_error;
public:
HASH lock_table_hash;
bool lock_table_hash_inited;
uint lock_table_hash_id;
const char *lock_table_hash_func_name;
const char *lock_table_hash_file_name;
ulong lock_table_hash_line_no;
DYNAMIC_ARRAY handler_open_array;
bool handler_open_array_inited;
uint handler_open_array_id;
const char *handler_open_array_func_name;
const char *handler_open_array_file_name;
ulong handler_open_array_line_no;
spider_db_mysql(
SPIDER_CONN *conn
);
~spider_db_mysql();
int init();
bool is_connected();
void bg_connect();
int connect(
char *tgt_host,
char *tgt_username,
char *tgt_password,
long tgt_port,
char *tgt_socket,
char *server_name,
int connect_retry_count,
longlong connect_retry_interval
);
int ping();
void bg_disconnect();
void disconnect();
int set_net_timeout();
int exec_query(
const char *query,
uint length,
int quick_mode
);
int get_errno();
const char *get_error();
bool is_server_gone_error(
int error_num
);
bool is_dup_entry_error(
int error_num
);
bool is_xa_nota_error(
int error_num
);
spider_db_result *store_result(
spider_db_result_buffer **spider_res_buf,
st_spider_db_request_key *request_key,
int *error_num
);
spider_db_result *use_result(
st_spider_db_request_key *request_key,
int *error_num
);
int next_result();
uint affected_rows();
ulonglong last_insert_id();
int set_character_set(
const char *csname
);
int select_db(
const char *dbname
);
int consistent_snapshot(
int *need_mon
);
bool trx_start_in_bulk_sql();
int start_transaction(
int *need_mon
);
int commit(
int *need_mon
);
int rollback(
int *need_mon
);
bool xa_start_in_bulk_sql();
int xa_start(
XID *xid,
int *need_mon
);
int xa_end(
XID *xid,
int *need_mon
);
int xa_prepare(
XID *xid,
int *need_mon
);
int xa_commit(
XID *xid,
int *need_mon
);
int xa_rollback(
XID *xid,
int *need_mon
);
bool set_trx_isolation_in_bulk_sql();
int set_trx_isolation(
int trx_isolation,
int *need_mon
);
bool set_autocommit_in_bulk_sql();
int set_autocommit(
bool autocommit,
int *need_mon
);
bool set_sql_log_off_in_bulk_sql();
int set_sql_log_off(
bool sql_log_off,
int *need_mon
);
bool set_time_zone_in_bulk_sql();
int set_time_zone(
Time_zone *time_zone,
int *need_mon
);
#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
int append_sql(
char *sql,
ulong sql_length,
st_spider_db_request_key *request_key
);
int append_open_handler(
uint handler_id,
const char *db_name,
const char *table_name,
const char *index_name,
const char *sql,
st_spider_db_request_key *request_key
);
int append_select(
uint handler_id,
spider_string *sql,
SPIDER_DB_HS_STRING_REF_BUFFER *keys,
int limit,
int skip,
st_spider_db_request_key *request_key
);
int append_insert(
uint handler_id,
SPIDER_DB_HS_STRING_REF_BUFFER *upds,
st_spider_db_request_key *request_key
);
int append_update(
uint handler_id,
spider_string *sql,
SPIDER_DB_HS_STRING_REF_BUFFER *keys,
SPIDER_DB_HS_STRING_REF_BUFFER *upds,
int limit,
int skip,
bool increment,
bool decrement,
st_spider_db_request_key *request_key
);
int append_delete(
uint handler_id,
spider_string *sql,
SPIDER_DB_HS_STRING_REF_BUFFER *keys,
int limit,
int skip,
st_spider_db_request_key *request_key
);
void reset_request_queue();
#endif
size_t escape_string(
char *to,
const char *from,
size_t from_length
);
bool have_lock_table_list();
int append_lock_tables(
spider_string *str
);
int append_unlock_tables(
spider_string *str
);
uint get_lock_table_hash_count();
void reset_lock_table_hash();
uint get_opened_handler_count();
void reset_opened_handler();
void set_dup_key_idx(
ha_spider *spider,
int link_idx
);
bool cmp_request_key_to_snd(
st_spider_db_request_key *request_key
);
};
class spider_mysql_share: public spider_db_share
{
public:
spider_string *table_select;
int table_select_pos;
spider_string *key_select;
int *key_select_pos;
spider_string *key_hint;
spider_string *show_table_status;
spider_string *show_records;
spider_string *show_index;
spider_string *table_names_str;
spider_string *db_names_str;
spider_string *db_table_str;
#ifdef SPIDER_HAS_HASH_VALUE_TYPE
my_hash_value_type *db_table_str_hash_value;
#endif
uint table_nm_max_length;
uint db_nm_max_length;
spider_string *column_name_str;
bool same_db_table_name;
int first_all_link_idx;
spider_mysql_share(
st_spider_share *share
);
~spider_mysql_share();
int init();
uint get_column_name_length(
uint field_index
);
int append_column_name(
spider_string *str,
uint field_index
);
int append_column_name_with_alias(
spider_string *str,
uint field_index,
const char *alias,
uint alias_length
);
int append_table_name(
spider_string *str,
int all_link_idx
);
int append_table_name_with_adjusting(
spider_string *str,
int all_link_idx
);
int append_from_with_adjusted_table_name(
spider_string *str,
int *table_name_pos
);
bool need_change_db_table_name();
#ifdef SPIDER_HAS_DISCOVER_TABLE_STRUCTURE
int discover_table_structure(
SPIDER_TRX *trx,
SPIDER_SHARE *spider_share,
spider_string *str
);
#endif
private:
int create_table_names_str();
void free_table_names_str();
int create_column_name_str();
void free_column_name_str();
int convert_key_hint_str();
int append_show_table_status();
void free_show_table_status();
int append_show_records();
void free_show_records();
int append_show_index();
void free_show_index();
int append_table_select();
int append_key_select(
uint idx
);
};
class spider_mysql_handler: public spider_db_handler
{
spider_string sql;
spider_string sql_part;
spider_string sql_part2;
spider_string ha_sql;
int where_pos;
int order_pos;
int limit_pos;
int table_name_pos;
int ha_read_pos;
int ha_next_pos;
int ha_where_pos;
int ha_limit_pos;
int ha_table_name_pos;
uint ha_sql_handler_id;
spider_string insert_sql;
int insert_pos;
int insert_table_name_pos;
spider_string update_sql;
TABLE *upd_tmp_tbl;
TMP_TABLE_PARAM upd_tmp_tbl_prm;
spider_string tmp_sql;
int tmp_sql_pos1; /* drop db nm pos at tmp_table_join */
int tmp_sql_pos2; /* create db nm pos at tmp_table_join */
int tmp_sql_pos3; /* insert db nm pos at tmp_table_join */
int tmp_sql_pos4; /* insert val pos at tmp_table_join */
int tmp_sql_pos5; /* end of drop tbl at tmp_table_join */
spider_string dup_update_sql;
spider_string *exec_sql;
spider_string *exec_insert_sql;
spider_string *exec_update_sql;
spider_string *exec_tmp_sql;
spider_string *exec_ha_sql;
bool reading_from_bulk_tmp_table;
bool filled_up;
#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
SPIDER_DB_HS_STRING_REF_BUFFER hs_upds;
#endif
SPIDER_INT_HLD *union_table_name_pos_first;
SPIDER_INT_HLD *union_table_name_pos_current;
public:
spider_mysql_share *mysql_share;
SPIDER_LINK_FOR_HASH *link_for_hash;
spider_mysql_handler(
ha_spider *spider,
spider_mysql_share *share
);
~spider_mysql_handler();
int init();
int append_table_name_with_adjusting(
spider_string *str,
int link_idx,
ulong sql_type
);
int append_key_column_types(
const key_range *start_key,
spider_string *str
);
int append_key_join_columns_for_bka(
const key_range *start_key,
spider_string *str,
const char **table_aliases,
uint *table_alias_lengths
);
int append_tmp_table_and_sql_for_bka(
const key_range *start_key
);
int reuse_tmp_table_and_sql_for_bka();
void create_tmp_bka_table_name(
char *tmp_table_name,
int *tmp_table_name_length,
int link_idx
);
int append_create_tmp_bka_table(
const key_range *start_key,
spider_string *str,
char *tmp_table_name,
int tmp_table_name_length,
int *db_name_pos,
CHARSET_INFO *table_charset
);
int append_drop_tmp_bka_table(
spider_string *str,
char *tmp_table_name,
int tmp_table_name_length,
int *db_name_pos,
int *drop_table_end_pos,
bool with_semicolon
);
int append_insert_tmp_bka_table(
const key_range *start_key,
spider_string *str,
char *tmp_table_name,
int tmp_table_name_length,
int *db_name_pos
);
int append_union_table_and_sql_for_bka(
const key_range *start_key
);
int reuse_union_table_and_sql_for_bka();
int append_insert_for_recovery(
ulong sql_type,
int link_idx
);
int append_update(
const TABLE *table,
my_ptrdiff_t ptr_diff
);
int append_update(
const TABLE *table,
my_ptrdiff_t ptr_diff,
int link_idx
);
int append_delete(
const TABLE *table,
my_ptrdiff_t ptr_diff
);
int append_delete(
const TABLE *table,
my_ptrdiff_t ptr_diff,
int link_idx
);
int append_insert_part();
int append_insert(
spider_string *str,
int link_idx
);
int append_update_part();
int append_update(
spider_string *str,
int link_idx
);
int append_delete_part();
int append_delete(
spider_string *str
);
#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
int append_increment_update_set_part();
int append_increment_update_set(
spider_string *str
);
#endif
#endif
int append_update_set_part();
int append_update_set(
spider_string *str
);
#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
int append_direct_update_set_part();
int append_direct_update_set(
spider_string *str
);
int append_dup_update_pushdown_part(
const char *alias,
uint alias_length
);
int append_update_columns_part(
const char *alias,
uint alias_length
);
int check_update_columns_part();
int append_update_columns(
spider_string *str,
const char *alias,
uint alias_length
);
#endif
int append_select_part(
ulong sql_type
);
int append_select(
spider_string *str,
ulong sql_type
);
int append_table_select_part(
ulong sql_type
);
int append_table_select(
spider_string *str
);
int append_key_select_part(
ulong sql_type,
uint idx
);
int append_key_select(
spider_string *str,
uint idx
);
int append_minimum_select_part(
ulong sql_type
);
int append_minimum_select(
spider_string *str,
ulong sql_type
);
int append_table_select_with_alias(
spider_string *str,
const char *alias,
uint alias_length
);
int append_key_select_with_alias(
spider_string *str,
const KEY *key_info,
const char *alias,
uint alias_length
);
int append_minimum_select_with_alias(
spider_string *str,
const char *alias,
uint alias_length
);
int append_select_columns_with_alias(
spider_string *str,
const char *alias,
uint alias_length
);
int append_hint_after_table_part(
ulong sql_type
);
int append_hint_after_table(
spider_string *str
);
void set_where_pos(
ulong sql_type
);
void set_where_to_pos(
ulong sql_type
);
int check_item_type(
Item *item
);
int append_values_connector_part(
ulong sql_type
);
int append_values_connector(
spider_string *str
);
int append_values_terminator_part(
ulong sql_type
);
int append_values_terminator(
spider_string *str
);
int append_union_table_connector_part(
ulong sql_type
);
int append_union_table_connector(
spider_string *str
);
int append_union_table_terminator_part(
ulong sql_type
);
int append_union_table_terminator(
spider_string *str
);
int append_key_column_values_part(
const key_range *start_key,
ulong sql_type
);
int append_key_column_values(
spider_string *str,
const key_range *start_key
);
int append_key_column_values_with_name_part(
const key_range *start_key,
ulong sql_type
);
int append_key_column_values_with_name(
spider_string *str,
const key_range *start_key
);
int append_key_where_part(
const key_range *start_key,
const key_range *end_key,
ulong sql_type
);
int append_key_where(
spider_string *str,
spider_string *str_part,
spider_string *str_part2,
const key_range *start_key,
const key_range *end_key,
ulong sql_type,
bool set_order
);
int append_is_null_part(
ulong sql_type,
KEY_PART_INFO *key_part,
const key_range *key,
const uchar **ptr,
bool key_eq
);
int append_is_null(
ulong sql_type,
spider_string *str,
spider_string *str_part,
spider_string *str_part2,
KEY_PART_INFO *key_part,
const key_range *key,
const uchar **ptr,
bool key_eq
);
int append_where_terminator_part(
ulong sql_type,
bool set_order,
int key_count
);
int append_where_terminator(
ulong sql_type,
spider_string *str,
spider_string *str_part,
spider_string *str_part2,
bool set_order,
int key_count
);
int append_match_where_part(
ulong sql_type
);
int append_match_where(
spider_string *str
);
int append_update_where(
spider_string *str,
const TABLE *table,
my_ptrdiff_t ptr_diff
);
int append_condition_part(
const char *alias,
uint alias_length,
ulong sql_type,
bool test_flg
);
int append_condition(
spider_string *str,
const char *alias,
uint alias_length,
bool start_where,
ulong sql_type
);
int append_match_against_part(
ulong sql_type,
st_spider_ft_info *ft_info,
const char *alias,
uint alias_length
);
int append_match_against(
spider_string *str,
st_spider_ft_info *ft_info,
const char *alias,
uint alias_length
);
int append_match_select_part(
ulong sql_type,
const char *alias,
uint alias_length
);
int append_match_select(
spider_string *str,
const char *alias,
uint alias_length
);
#ifdef HANDLER_HAS_DIRECT_AGGREGATE
int append_sum_select_part(
ulong sql_type,
const char *alias,
uint alias_length
);
int append_sum_select(
spider_string *str,
const char *alias,
uint alias_length
);
#endif
void set_order_pos(
ulong sql_type
);
void set_order_to_pos(
ulong sql_type
);
#ifdef HANDLER_HAS_DIRECT_AGGREGATE
int append_group_by(
spider_string *str,
const char *alias,
uint alias_length
);
#endif
int append_key_order_for_merge_with_alias_part(
const char *alias,
uint alias_length,
ulong sql_type
);
int append_key_order_for_merge_with_alias(
spider_string *str,
const char *alias,
uint alias_length
);
int append_key_order_for_direct_order_limit_with_alias_part(
const char *alias,
uint alias_length,
ulong sql_type
);
int append_key_order_for_direct_order_limit_with_alias(
spider_string *str,
const char *alias,
uint alias_length
);
int append_key_order_with_alias_part(
const char *alias,
uint alias_length,
ulong sql_type
);
int append_key_order_for_handler(
spider_string *str,
const char *alias,
uint alias_length
);
int append_key_order_with_alias(
spider_string *str,
const char *alias,
uint alias_length
);
int append_limit_part(
longlong offset,
longlong limit,
ulong sql_type
);
int reappend_limit_part(
longlong offset,
longlong limit,
ulong sql_type
);
int append_limit(
spider_string *str,
longlong offset,
longlong limit
);
int append_select_lock_part(
ulong sql_type
);
int append_select_lock(
spider_string *str
);
int append_union_all_start_part(
ulong sql_type
);
int append_union_all_start(
spider_string *str
);
int append_union_all_part(
ulong sql_type
);
int append_union_all(
spider_string *str
);
int append_union_all_end_part(
ulong sql_type
);
int append_union_all_end(
spider_string *str
);
int append_multi_range_cnt_part(
ulong sql_type,
uint multi_range_cnt,
bool with_comma
);
int append_multi_range_cnt(
spider_string *str,
uint multi_range_cnt,
bool with_comma
);
int append_multi_range_cnt_with_name_part(
ulong sql_type,
uint multi_range_cnt
);
int append_multi_range_cnt_with_name(
spider_string *str,
uint multi_range_cnt
);
int append_open_handler_part(
ulong sql_type,
uint handler_id,
SPIDER_CONN *conn,
int link_idx
);
int append_open_handler(
spider_string *str,
uint handler_id,
SPIDER_CONN *conn,
int link_idx
);
int append_close_handler_part(
ulong sql_type,
int link_idx
);
int append_close_handler(
spider_string *str,
int link_idx
);
int append_insert_terminator_part(
ulong sql_type
);
int append_insert_terminator(
spider_string *str
);
int append_insert_values_part(
ulong sql_type
);
int append_insert_values(
spider_string *str
);
int append_into_part(
ulong sql_type
);
int append_into(
spider_string *str
);
void set_insert_to_pos(
ulong sql_type
);
int append_from_part(
ulong sql_type,
int link_idx
);
int append_from(
spider_string *str,
ulong sql_type,
int link_idx
);
int append_flush_tables_part(
ulong sql_type,
int link_idx,
bool lock
);
int append_flush_tables(
spider_string *str,
int link_idx,
bool lock
);
int append_optimize_table_part(
ulong sql_type,
int link_idx
);
int append_optimize_table(
spider_string *str,
int link_idx
);
int append_analyze_table_part(
ulong sql_type,
int link_idx
);
int append_analyze_table(
spider_string *str,
int link_idx
);
int append_repair_table_part(
ulong sql_type,
int link_idx,
HA_CHECK_OPT* check_opt
);
int append_repair_table(
spider_string *str,
int link_idx,
HA_CHECK_OPT* check_opt
);
int append_check_table_part(
ulong sql_type,
int link_idx,
HA_CHECK_OPT* check_opt
);
int append_check_table(
spider_string *str,
int link_idx,
HA_CHECK_OPT* check_opt
);
int append_enable_keys_part(
ulong sql_type,
int link_idx
);
int append_enable_keys(
spider_string *str,
int link_idx
);
int append_disable_keys_part(
ulong sql_type,
int link_idx
);
int append_disable_keys(
spider_string *str,
int link_idx
);
int append_delete_all_rows_part(
ulong sql_type
);
int append_delete_all_rows(
spider_string *str,
ulong sql_type
);
int append_truncate(
spider_string *str,
ulong sql_type,
int link_idx
);
int append_explain_select_part(
key_range *start_key,
key_range *end_key,
ulong sql_type,
int link_idx
);
int append_explain_select(
spider_string *str,
key_range *start_key,
key_range *end_key,
ulong sql_type,
int link_idx
);
bool is_bulk_insert_exec_period(
bool bulk_end
);
bool sql_is_filled_up(
ulong sql_type
);
bool sql_is_empty(
ulong sql_type
);
bool support_multi_split_read();
bool support_bulk_update();
int bulk_tmp_table_insert();
int bulk_tmp_table_insert(
int link_idx
);
int bulk_tmp_table_end_bulk_insert();
int bulk_tmp_table_rnd_init();
int bulk_tmp_table_rnd_next();
int bulk_tmp_table_rnd_end();
bool need_copy_for_update(
int link_idx
);
bool bulk_tmp_table_created();
int mk_bulk_tmp_table_and_bulk_start();
void rm_bulk_tmp_table();
int store_sql_to_bulk_tmp_table(
spider_string *str,
TABLE *tmp_table
);
int restore_sql_from_bulk_tmp_table(
spider_string *str,
TABLE *tmp_table
);
int insert_lock_tables_list(
SPIDER_CONN *conn,
int link_idx
);
int append_lock_tables_list(
SPIDER_CONN *conn,
int link_idx,
int *appended
);
int realloc_sql(
ulong *realloced
);
int reset_sql(
ulong sql_type
);
#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
int reset_keys(
ulong sql_type
);
int reset_upds(
ulong sql_type
);
int reset_strs(
ulong sql_type
);
int reset_strs_pos(
ulong sql_type
);
int push_back_upds(
SPIDER_HS_STRING_REF &info
);
#endif
bool need_lock_before_set_sql_for_exec(
ulong sql_type
);
int set_sql_for_exec(
ulong sql_type,
int link_idx
);
int set_sql_for_exec(
spider_db_copy_table *tgt_ct,
ulong sql_type
);
int execute_sql(
ulong sql_type,
SPIDER_CONN *conn,
int quick_mode,
int *need_mon
);
int reset();
int sts_mode_exchange(
int sts_mode
);
int show_table_status(
int link_idx,
int sts_mode,
uint flag
);
int crd_mode_exchange(
int crd_mode
);
int show_index(
int link_idx,
int crd_mode
);
int show_records(
int link_idx
);
int show_last_insert_id(
int link_idx,
ulonglong &last_insert_id
);
ha_rows explain_select(
key_range *start_key,
key_range *end_key,
int link_idx
);
int lock_tables(
int link_idx
);
int unlock_tables(
int link_idx
);
int disable_keys(
SPIDER_CONN *conn,
int link_idx
);
int enable_keys(
SPIDER_CONN *conn,
int link_idx
);
int check_table(
SPIDER_CONN *conn,
int link_idx,
HA_CHECK_OPT* check_opt
);
int repair_table(
SPIDER_CONN *conn,
int link_idx,
HA_CHECK_OPT* check_opt
);
int analyze_table(
SPIDER_CONN *conn,
int link_idx
);
int optimize_table(
SPIDER_CONN *conn,
int link_idx
);
int flush_tables(
SPIDER_CONN *conn,
int link_idx,
bool lock
);
int flush_logs(
SPIDER_CONN *conn,
int link_idx
);
int insert_opened_handler(
SPIDER_CONN *conn,
int link_idx
);
int delete_opened_handler(
SPIDER_CONN *conn,
int link_idx
);
int sync_from_clone_source(
spider_db_handler *dbton_hdl
);
bool support_use_handler(
int use_handler
);
bool minimum_select_bit_is_set(
uint field_index
);
void copy_minimum_select_bitmap(
uchar *bitmap
);
int init_union_table_name_pos();
int set_union_table_name_pos();
int reset_union_table_name(
spider_string *str,
int link_idx,
ulong sql_type
);
};
class spider_mysql_copy_table: public spider_db_copy_table
{
public:
spider_mysql_share *mysql_share;
spider_string sql;
uint pos;
spider_mysql_copy_table(
spider_mysql_share *db_share
);
~spider_mysql_copy_table();
int init();
void set_sql_charset(
CHARSET_INFO *cs
);
int append_select_str();
int append_insert_str(
int insert_flg
);
int append_table_columns(
TABLE_SHARE *table_share
);
int append_from_str();
int append_table_name(
int link_idx
);
void set_sql_pos();
void set_sql_to_pos();
int append_copy_where(
spider_db_copy_table *source_ct,
KEY *key_info,
ulong *last_row_pos,
ulong *last_lengths
);
int append_key_order_str(
KEY *key_info,
int start_pos,
bool desc_flg
);
int append_limit(
longlong offset,
longlong limit
);
int append_into_str();
int append_open_paren_str();
int append_values_str();
int append_select_lock_str(
int lock_mode
);
int exec_query(
SPIDER_CONN *conn,
int quick_mode,
int *need_mon
);
int copy_key_row(
spider_db_copy_table *source_ct,
Field *field,
ulong *row_pos,
ulong *length,
const char *joint_str,
const int joint_length
);
int copy_row(
Field *field,
SPIDER_DB_ROW *row
);
int copy_rows(
TABLE *table,
SPIDER_DB_ROW *row,
ulong **last_row_pos,
ulong **last_lengths
);
int copy_rows(
TABLE *table,
SPIDER_DB_ROW *row
);
int append_insert_terminator();
int copy_insert_values(
spider_db_copy_table *source_ct
);
};
/* Copyright (C) 2012-2013 Kentoku Shiba
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 */
class spider_db_mysql_util: public spider_db_util
{
public:
spider_db_mysql_util();
~spider_db_mysql_util();
int append_name(
spider_string *str,
const char *name,
uint name_length
);
int append_name_with_charset(
spider_string *str,
const char *name,
uint name_length,
CHARSET_INFO *name_charset
);
bool is_name_quote(
const char head_code
);
int append_escaped_name_quote(
spider_string *str
);
int append_column_value(
ha_spider *spider,
spider_string *str,
Field *field,
const uchar *new_ptr,
CHARSET_INFO *access_charset
);
int append_from_with_alias(
spider_string *str,
const char **table_names,
uint *table_name_lengths,
const char **table_aliases,
uint *table_alias_lengths,
uint table_count,
int *table_name_pos,
bool over_write
);
int append_trx_isolation(
spider_string *str,
int trx_isolation
);
int append_autocommit(
spider_string *str,
bool autocommit
);
int append_sql_log_off(
spider_string *str,
bool sql_log_off
);
int append_time_zone(
spider_string *str,
Time_zone *time_zone
);
int append_start_transaction(
spider_string *str
);
int append_xa_start(
spider_string *str,
XID *xid
);
int append_lock_table_head(
spider_string *str
);
int append_lock_table_body(
spider_string *str,
const char *db_name,
uint db_name_length,
CHARSET_INFO *db_name_charset,
const char *table_name,
uint table_name_length,
CHARSET_INFO *table_name_charset,
int lock_type
);
int append_lock_table_tail(
spider_string *str
);
int append_unlock_table(
spider_string *str
);
int open_item_func(
Item_func *item_func,
ha_spider *spider,
spider_string *str,
const char *alias,
uint alias_length
);
#ifdef HANDLER_HAS_DIRECT_AGGREGATE
int open_item_sum_func(
Item_sum *item_sum,
ha_spider *spider,
spider_string *str,
const char *alias,
uint alias_length
);
#endif
int append_escaped_util(
spider_string *to,
String *from
);
};
class spider_db_mysql_row: public spider_db_row
{
public:
MYSQL_ROW row;
MYSQL_ROW row_first;
ulong *lengths;
ulong *lengths_first;
uint field_count;
bool cloned;
spider_db_mysql_row();
~spider_db_mysql_row();
int store_to_field(
Field *field,
CHARSET_INFO *access_charset
);
int append_to_str(
spider_string *str
);
int append_escaped_to_str(
spider_string *str,
uint dbton_id
);
void first();
void next();
bool is_null();
int val_int();
double val_real();
my_decimal *val_decimal(
my_decimal *decimal_value,
CHARSET_INFO *access_charset
);
SPIDER_DB_ROW *clone();
int store_to_tmp_table(
TABLE *tmp_table,
spider_string *str
);
};
class spider_db_mysql_result: public spider_db_result
{
public:
MYSQL_RES *db_result;
spider_db_mysql_row row;
MYSQL_ROW_OFFSET first_row;
int store_error_num;
spider_db_mysql_result();
~spider_db_mysql_result();
bool has_result();
void free_result();
SPIDER_DB_ROW *current_row();
SPIDER_DB_ROW *fetch_row();
SPIDER_DB_ROW *fetch_row_from_result_buffer(
spider_db_result_buffer *spider_res_buf
);
SPIDER_DB_ROW *fetch_row_from_tmp_table(
TABLE *tmp_table
);
int fetch_table_status(
int mode,
ha_rows &records,
ulong &mean_rec_length,
ulonglong &data_file_length,
ulonglong &max_data_file_length,
ulonglong &index_file_length,
ulonglong &auto_increment_value,
time_t &create_time,
time_t &update_time,
time_t &check_time
);
int fetch_table_records(
int mode,
ha_rows &records
);
int fetch_table_cardinality(
int mode,
TABLE *table,
longlong *cardinality,
uchar *cardinality_upd,
int bitmap_size
);
int fetch_table_mon_status(
int &status
);
longlong num_rows();
uint num_fields();
void move_to_pos(
longlong pos
);
int get_errno();
#ifdef SPIDER_HAS_DISCOVER_TABLE_STRUCTURE
int fetch_columns_for_discover_table_structure(
spider_string *str,
CHARSET_INFO *access_charset
);
int fetch_index_for_discover_table_structure(
spider_string *str,
CHARSET_INFO *access_charset
);
#endif
};
class spider_db_mysql: public spider_db_conn
{
MYSQL *db_conn;
int stored_error;
public:
HASH lock_table_hash;
bool lock_table_hash_inited;
uint lock_table_hash_id;
const char *lock_table_hash_func_name;
const char *lock_table_hash_file_name;
ulong lock_table_hash_line_no;
DYNAMIC_ARRAY handler_open_array;
bool handler_open_array_inited;
uint handler_open_array_id;
const char *handler_open_array_func_name;
const char *handler_open_array_file_name;
ulong handler_open_array_line_no;
spider_db_mysql(
SPIDER_CONN *conn
);
~spider_db_mysql();
int init();
bool is_connected();
void bg_connect();
int connect(
char *tgt_host,
char *tgt_username,
char *tgt_password,
long tgt_port,
char *tgt_socket,
char *server_name,
int connect_retry_count,
longlong connect_retry_interval
);
int ping();
void bg_disconnect();
void disconnect();
int set_net_timeout();
int exec_query(
const char *query,
uint length,
int quick_mode
);
int get_errno();
const char *get_error();
bool is_server_gone_error(
int error_num
);
bool is_dup_entry_error(
int error_num
);
bool is_xa_nota_error(
int error_num
);
spider_db_result *store_result(
spider_db_result_buffer **spider_res_buf,
st_spider_db_request_key *request_key,
int *error_num
);
spider_db_result *use_result(
st_spider_db_request_key *request_key,
int *error_num
);
int next_result();
uint affected_rows();
ulonglong last_insert_id();
int set_character_set(
const char *csname
);
int select_db(
const char *dbname
);
int consistent_snapshot(
int *need_mon
);
bool trx_start_in_bulk_sql();
int start_transaction(
int *need_mon
);
int commit(
int *need_mon
);
int rollback(
int *need_mon
);
bool xa_start_in_bulk_sql();
int xa_start(
XID *xid,
int *need_mon
);
int xa_end(
XID *xid,
int *need_mon
);
int xa_prepare(
XID *xid,
int *need_mon
);
int xa_commit(
XID *xid,
int *need_mon
);
int xa_rollback(
XID *xid,
int *need_mon
);
bool set_trx_isolation_in_bulk_sql();
int set_trx_isolation(
int trx_isolation,
int *need_mon
);
bool set_autocommit_in_bulk_sql();
int set_autocommit(
bool autocommit,
int *need_mon
);
bool set_sql_log_off_in_bulk_sql();
int set_sql_log_off(
bool sql_log_off,
int *need_mon
);
bool set_time_zone_in_bulk_sql();
int set_time_zone(
Time_zone *time_zone,
int *need_mon
);
#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
int append_sql(
char *sql,
ulong sql_length,
st_spider_db_request_key *request_key
);
int append_open_handler(
uint handler_id,
const char *db_name,
const char *table_name,
const char *index_name,
const char *sql,
st_spider_db_request_key *request_key
);
int append_select(
uint handler_id,
spider_string *sql,
SPIDER_DB_HS_STRING_REF_BUFFER *keys,
int limit,
int skip,
st_spider_db_request_key *request_key
);
int append_insert(
uint handler_id,
SPIDER_DB_HS_STRING_REF_BUFFER *upds,
st_spider_db_request_key *request_key
);
int append_update(
uint handler_id,
spider_string *sql,
SPIDER_DB_HS_STRING_REF_BUFFER *keys,
SPIDER_DB_HS_STRING_REF_BUFFER *upds,
int limit,
int skip,
bool increment,
bool decrement,
st_spider_db_request_key *request_key
);
int append_delete(
uint handler_id,
spider_string *sql,
SPIDER_DB_HS_STRING_REF_BUFFER *keys,
int limit,
int skip,
st_spider_db_request_key *request_key
);
void reset_request_queue();
#endif
size_t escape_string(
char *to,
const char *from,
size_t from_length
);
bool have_lock_table_list();
int append_lock_tables(
spider_string *str
);
int append_unlock_tables(
spider_string *str
);
uint get_lock_table_hash_count();
void reset_lock_table_hash();
uint get_opened_handler_count();
void reset_opened_handler();
void set_dup_key_idx(
ha_spider *spider,
int link_idx
);
bool cmp_request_key_to_snd(
st_spider_db_request_key *request_key
);
};
class spider_mysql_share: public spider_db_share
{
public:
spider_string *table_select;
int table_select_pos;
spider_string *key_select;
int *key_select_pos;
spider_string *key_hint;
spider_string *show_table_status;
spider_string *show_records;
spider_string *show_index;
spider_string *table_names_str;
spider_string *db_names_str;
spider_string *db_table_str;
#ifdef SPIDER_HAS_HASH_VALUE_TYPE
my_hash_value_type *db_table_str_hash_value;
#endif
uint table_nm_max_length;
uint db_nm_max_length;
spider_string *column_name_str;
bool same_db_table_name;
int first_all_link_idx;
spider_mysql_share(
st_spider_share *share
);
~spider_mysql_share();
int init();
uint get_column_name_length(
uint field_index
);
int append_column_name(
spider_string *str,
uint field_index
);
int append_column_name_with_alias(
spider_string *str,
uint field_index,
const char *alias,
uint alias_length
);
int append_table_name(
spider_string *str,
int all_link_idx
);
int append_table_name_with_adjusting(
spider_string *str,
int all_link_idx
);
int append_from_with_adjusted_table_name(
spider_string *str,
int *table_name_pos
);
bool need_change_db_table_name();
#ifdef SPIDER_HAS_DISCOVER_TABLE_STRUCTURE
int discover_table_structure(
SPIDER_TRX *trx,
SPIDER_SHARE *spider_share,
spider_string *str
);
#endif
private:
int create_table_names_str();
void free_table_names_str();
int create_column_name_str();
void free_column_name_str();
int convert_key_hint_str();
int append_show_table_status();
void free_show_table_status();
int append_show_records();
void free_show_records();
int append_show_index();
void free_show_index();
int append_table_select();
int append_key_select(
uint idx
);
};
class spider_mysql_handler: public spider_db_handler
{
spider_string sql;
spider_string sql_part;
spider_string sql_part2;
spider_string ha_sql;
int where_pos;
int order_pos;
int limit_pos;
int table_name_pos;
int ha_read_pos;
int ha_next_pos;
int ha_where_pos;
int ha_limit_pos;
int ha_table_name_pos;
uint ha_sql_handler_id;
spider_string insert_sql;
int insert_pos;
int insert_table_name_pos;
spider_string update_sql;
TABLE *upd_tmp_tbl;
TMP_TABLE_PARAM upd_tmp_tbl_prm;
spider_string tmp_sql;
int tmp_sql_pos1; /* drop db nm pos at tmp_table_join */
int tmp_sql_pos2; /* create db nm pos at tmp_table_join */
int tmp_sql_pos3; /* insert db nm pos at tmp_table_join */
int tmp_sql_pos4; /* insert val pos at tmp_table_join */
int tmp_sql_pos5; /* end of drop tbl at tmp_table_join */
spider_string dup_update_sql;
spider_string *exec_sql;
spider_string *exec_insert_sql;
spider_string *exec_update_sql;
spider_string *exec_tmp_sql;
spider_string *exec_ha_sql;
bool reading_from_bulk_tmp_table;
bool filled_up;
#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
SPIDER_DB_HS_STRING_REF_BUFFER hs_upds;
#endif
SPIDER_INT_HLD *union_table_name_pos_first;
SPIDER_INT_HLD *union_table_name_pos_current;
public:
spider_mysql_share *mysql_share;
SPIDER_LINK_FOR_HASH *link_for_hash;
spider_mysql_handler(
ha_spider *spider,
spider_mysql_share *share
);
~spider_mysql_handler();
int init();
int append_table_name_with_adjusting(
spider_string *str,
int link_idx,
ulong sql_type
);
int append_key_column_types(
const key_range *start_key,
spider_string *str
);
int append_key_join_columns_for_bka(
const key_range *start_key,
spider_string *str,
const char **table_aliases,
uint *table_alias_lengths
);
int append_tmp_table_and_sql_for_bka(
const key_range *start_key
);
int reuse_tmp_table_and_sql_for_bka();
void create_tmp_bka_table_name(
char *tmp_table_name,
int *tmp_table_name_length,
int link_idx
);
int append_create_tmp_bka_table(
const key_range *start_key,
spider_string *str,
char *tmp_table_name,
int tmp_table_name_length,
int *db_name_pos,
CHARSET_INFO *table_charset
);
int append_drop_tmp_bka_table(
spider_string *str,
char *tmp_table_name,
int tmp_table_name_length,
int *db_name_pos,
int *drop_table_end_pos,
bool with_semicolon
);
int append_insert_tmp_bka_table(
const key_range *start_key,
spider_string *str,
char *tmp_table_name,
int tmp_table_name_length,
int *db_name_pos
);
int append_union_table_and_sql_for_bka(
const key_range *start_key
);
int reuse_union_table_and_sql_for_bka();
int append_insert_for_recovery(
ulong sql_type,
int link_idx
);
int append_update(
const TABLE *table,
my_ptrdiff_t ptr_diff
);
int append_update(
const TABLE *table,
my_ptrdiff_t ptr_diff,
int link_idx
);
int append_delete(
const TABLE *table,
my_ptrdiff_t ptr_diff
);
int append_delete(
const TABLE *table,
my_ptrdiff_t ptr_diff,
int link_idx
);
int append_insert_part();
int append_insert(
spider_string *str,
int link_idx
);
int append_update_part();
int append_update(
spider_string *str,
int link_idx
);
int append_delete_part();
int append_delete(
spider_string *str
);
#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
int append_increment_update_set_part();
int append_increment_update_set(
spider_string *str
);
#endif
#endif
int append_update_set_part();
int append_update_set(
spider_string *str
);
#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
int append_direct_update_set_part();
int append_direct_update_set(
spider_string *str
);
int append_dup_update_pushdown_part(
const char *alias,
uint alias_length
);
int append_update_columns_part(
const char *alias,
uint alias_length
);
int check_update_columns_part();
int append_update_columns(
spider_string *str,
const char *alias,
uint alias_length
);
#endif
int append_select_part(
ulong sql_type
);
int append_select(
spider_string *str,
ulong sql_type
);
int append_table_select_part(
ulong sql_type
);
int append_table_select(
spider_string *str
);
int append_key_select_part(
ulong sql_type,
uint idx
);
int append_key_select(
spider_string *str,
uint idx
);
int append_minimum_select_part(
ulong sql_type
);
int append_minimum_select(
spider_string *str,
ulong sql_type
);
int append_table_select_with_alias(
spider_string *str,
const char *alias,
uint alias_length
);
int append_key_select_with_alias(
spider_string *str,
const KEY *key_info,
const char *alias,
uint alias_length
);
int append_minimum_select_with_alias(
spider_string *str,
const char *alias,
uint alias_length
);
int append_select_columns_with_alias(
spider_string *str,
const char *alias,
uint alias_length
);
int append_hint_after_table_part(
ulong sql_type
);
int append_hint_after_table(
spider_string *str
);
void set_where_pos(
ulong sql_type
);
void set_where_to_pos(
ulong sql_type
);
int check_item_type(
Item *item
);
int append_values_connector_part(
ulong sql_type
);
int append_values_connector(
spider_string *str
);
int append_values_terminator_part(
ulong sql_type
);
int append_values_terminator(
spider_string *str
);
int append_union_table_connector_part(
ulong sql_type
);
int append_union_table_connector(
spider_string *str
);
int append_union_table_terminator_part(
ulong sql_type
);
int append_union_table_terminator(
spider_string *str
);
int append_key_column_values_part(
const key_range *start_key,
ulong sql_type
);
int append_key_column_values(
spider_string *str,
const key_range *start_key
);
int append_key_column_values_with_name_part(
const key_range *start_key,
ulong sql_type
);
int append_key_column_values_with_name(
spider_string *str,
const key_range *start_key
);
int append_key_where_part(
const key_range *start_key,
const key_range *end_key,
ulong sql_type
);
int append_key_where(
spider_string *str,
spider_string *str_part,
spider_string *str_part2,
const key_range *start_key,
const key_range *end_key,
ulong sql_type,
bool set_order
);
int append_is_null_part(
ulong sql_type,
KEY_PART_INFO *key_part,
const key_range *key,
const uchar **ptr,
bool key_eq
);
int append_is_null(
ulong sql_type,
spider_string *str,
spider_string *str_part,
spider_string *str_part2,
KEY_PART_INFO *key_part,
const key_range *key,
const uchar **ptr,
bool key_eq
);
int append_where_terminator_part(
ulong sql_type,
bool set_order,
int key_count
);
int append_where_terminator(
ulong sql_type,
spider_string *str,
spider_string *str_part,
spider_string *str_part2,
bool set_order,
int key_count
);
int append_match_where_part(
ulong sql_type
);
int append_match_where(
spider_string *str
);
int append_update_where(
spider_string *str,
const TABLE *table,
my_ptrdiff_t ptr_diff
);
int append_condition_part(
const char *alias,
uint alias_length,
ulong sql_type,
bool test_flg
);
int append_condition(
spider_string *str,
const char *alias,
uint alias_length,
bool start_where,
ulong sql_type
);
int append_match_against_part(
ulong sql_type,
st_spider_ft_info *ft_info,
const char *alias,
uint alias_length
);
int append_match_against(
spider_string *str,
st_spider_ft_info *ft_info,
const char *alias,
uint alias_length
);
int append_match_select_part(
ulong sql_type,
const char *alias,
uint alias_length
);
int append_match_select(
spider_string *str,
const char *alias,
uint alias_length
);
#ifdef HANDLER_HAS_DIRECT_AGGREGATE
int append_sum_select_part(
ulong sql_type,
const char *alias,
uint alias_length
);
int append_sum_select(
spider_string *str,
const char *alias,
uint alias_length
);
#endif
void set_order_pos(
ulong sql_type
);
void set_order_to_pos(
ulong sql_type
);
#ifdef HANDLER_HAS_DIRECT_AGGREGATE
int append_group_by(
spider_string *str,
const char *alias,
uint alias_length
);
#endif
int append_key_order_for_merge_with_alias_part(
const char *alias,
uint alias_length,
ulong sql_type
);
int append_key_order_for_merge_with_alias(
spider_string *str,
const char *alias,
uint alias_length
);
int append_key_order_for_direct_order_limit_with_alias_part(
const char *alias,
uint alias_length,
ulong sql_type
);
int append_key_order_for_direct_order_limit_with_alias(
spider_string *str,
const char *alias,
uint alias_length
);
int append_key_order_with_alias_part(
const char *alias,
uint alias_length,
ulong sql_type
);
int append_key_order_for_handler(
spider_string *str,
const char *alias,
uint alias_length
);
int append_key_order_with_alias(
spider_string *str,
const char *alias,
uint alias_length
);
int append_limit_part(
longlong offset,
longlong limit,
ulong sql_type
);
int reappend_limit_part(
longlong offset,
longlong limit,
ulong sql_type
);
int append_limit(
spider_string *str,
longlong offset,
longlong limit
);
int append_select_lock_part(
ulong sql_type
);
int append_select_lock(
spider_string *str
);
int append_union_all_start_part(
ulong sql_type
);
int append_union_all_start(
spider_string *str
);
int append_union_all_part(
ulong sql_type
);
int append_union_all(
spider_string *str
);
int append_union_all_end_part(
ulong sql_type
);
int append_union_all_end(
spider_string *str
);
int append_multi_range_cnt_part(
ulong sql_type,
uint multi_range_cnt,
bool with_comma
);
int append_multi_range_cnt(
spider_string *str,
uint multi_range_cnt,
bool with_comma
);
int append_multi_range_cnt_with_name_part(
ulong sql_type,
uint multi_range_cnt
);
int append_multi_range_cnt_with_name(
spider_string *str,
uint multi_range_cnt
);
int append_open_handler_part(
ulong sql_type,
uint handler_id,
SPIDER_CONN *conn,
int link_idx
);
int append_open_handler(
spider_string *str,
uint handler_id,
SPIDER_CONN *conn,
int link_idx
);
int append_close_handler_part(
ulong sql_type,
int link_idx
);
int append_close_handler(
spider_string *str,
int link_idx
);
int append_insert_terminator_part(
ulong sql_type
);
int append_insert_terminator(
spider_string *str
);
int append_insert_values_part(
ulong sql_type
);
int append_insert_values(
spider_string *str
);
int append_into_part(
ulong sql_type
);
int append_into(
spider_string *str
);
void set_insert_to_pos(
ulong sql_type
);
int append_from_part(
ulong sql_type,
int link_idx
);
int append_from(
spider_string *str,
ulong sql_type,
int link_idx
);
int append_flush_tables_part(
ulong sql_type,
int link_idx,
bool lock
);
int append_flush_tables(
spider_string *str,
int link_idx,
bool lock
);
int append_optimize_table_part(
ulong sql_type,
int link_idx
);
int append_optimize_table(
spider_string *str,
int link_idx
);
int append_analyze_table_part(
ulong sql_type,
int link_idx
);
int append_analyze_table(
spider_string *str,
int link_idx
);
int append_repair_table_part(
ulong sql_type,
int link_idx,
HA_CHECK_OPT* check_opt
);
int append_repair_table(
spider_string *str,
int link_idx,
HA_CHECK_OPT* check_opt
);
int append_check_table_part(
ulong sql_type,
int link_idx,
HA_CHECK_OPT* check_opt
);
int append_check_table(
spider_string *str,
int link_idx,
HA_CHECK_OPT* check_opt
);
int append_enable_keys_part(
ulong sql_type,
int link_idx
);
int append_enable_keys(
spider_string *str,
int link_idx
);
int append_disable_keys_part(
ulong sql_type,
int link_idx
);
int append_disable_keys(
spider_string *str,
int link_idx
);
int append_delete_all_rows_part(
ulong sql_type
);
int append_delete_all_rows(
spider_string *str,
ulong sql_type
);
int append_truncate(
spider_string *str,
ulong sql_type,
int link_idx
);
int append_explain_select_part(
key_range *start_key,
key_range *end_key,
ulong sql_type,
int link_idx
);
int append_explain_select(
spider_string *str,
key_range *start_key,
key_range *end_key,
ulong sql_type,
int link_idx
);
bool is_bulk_insert_exec_period(
bool bulk_end
);
bool sql_is_filled_up(
ulong sql_type
);
bool sql_is_empty(
ulong sql_type
);
bool support_multi_split_read();
bool support_bulk_update();
int bulk_tmp_table_insert();
int bulk_tmp_table_insert(
int link_idx
);
int bulk_tmp_table_end_bulk_insert();
int bulk_tmp_table_rnd_init();
int bulk_tmp_table_rnd_next();
int bulk_tmp_table_rnd_end();
bool need_copy_for_update(
int link_idx
);
bool bulk_tmp_table_created();
int mk_bulk_tmp_table_and_bulk_start();
void rm_bulk_tmp_table();
int store_sql_to_bulk_tmp_table(
spider_string *str,
TABLE *tmp_table
);
int restore_sql_from_bulk_tmp_table(
spider_string *str,
TABLE *tmp_table
);
int insert_lock_tables_list(
SPIDER_CONN *conn,
int link_idx
);
int append_lock_tables_list(
SPIDER_CONN *conn,
int link_idx,
int *appended
);
int realloc_sql(
ulong *realloced
);
int reset_sql(
ulong sql_type
);
#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
int reset_keys(
ulong sql_type
);
int reset_upds(
ulong sql_type
);
int reset_strs(
ulong sql_type
);
int reset_strs_pos(
ulong sql_type
);
int push_back_upds(
SPIDER_HS_STRING_REF &info
);
#endif
bool need_lock_before_set_sql_for_exec(
ulong sql_type
);
int set_sql_for_exec(
ulong sql_type,
int link_idx
);
int set_sql_for_exec(
spider_db_copy_table *tgt_ct,
ulong sql_type
);
int execute_sql(
ulong sql_type,
SPIDER_CONN *conn,
int quick_mode,
int *need_mon
);
int reset();
int sts_mode_exchange(
int sts_mode
);
int show_table_status(
int link_idx,
int sts_mode,
uint flag
);
int crd_mode_exchange(
int crd_mode
);
int show_index(
int link_idx,
int crd_mode
);
int show_records(
int link_idx
);
int show_last_insert_id(
int link_idx,
ulonglong &last_insert_id
);
ha_rows explain_select(
key_range *start_key,
key_range *end_key,
int link_idx
);
int lock_tables(
int link_idx
);
int unlock_tables(
int link_idx
);
int disable_keys(
SPIDER_CONN *conn,
int link_idx
);
int enable_keys(
SPIDER_CONN *conn,
int link_idx
);
int check_table(
SPIDER_CONN *conn,
int link_idx,
HA_CHECK_OPT* check_opt
);
int repair_table(
SPIDER_CONN *conn,
int link_idx,
HA_CHECK_OPT* check_opt
);
int analyze_table(
SPIDER_CONN *conn,
int link_idx
);
int optimize_table(
SPIDER_CONN *conn,
int link_idx
);
int flush_tables(
SPIDER_CONN *conn,
int link_idx,
bool lock
);
int flush_logs(
SPIDER_CONN *conn,
int link_idx
);
int insert_opened_handler(
SPIDER_CONN *conn,
int link_idx
);
int delete_opened_handler(
SPIDER_CONN *conn,
int link_idx
);
int sync_from_clone_source(
spider_db_handler *dbton_hdl
);
bool support_use_handler(
int use_handler
);
bool minimum_select_bit_is_set(
uint field_index
);
void copy_minimum_select_bitmap(
uchar *bitmap
);
int init_union_table_name_pos();
int set_union_table_name_pos();
int reset_union_table_name(
spider_string *str,
int link_idx,
ulong sql_type
);
};
class spider_mysql_copy_table: public spider_db_copy_table
{
public:
spider_mysql_share *mysql_share;
spider_string sql;
uint pos;
spider_mysql_copy_table(
spider_mysql_share *db_share
);
~spider_mysql_copy_table();
int init();
void set_sql_charset(
CHARSET_INFO *cs
);
int append_select_str();
int append_insert_str(
int insert_flg
);
int append_table_columns(
TABLE_SHARE *table_share
);
int append_from_str();
int append_table_name(
int link_idx
);
void set_sql_pos();
void set_sql_to_pos();
int append_copy_where(
spider_db_copy_table *source_ct,
KEY *key_info,
ulong *last_row_pos,
ulong *last_lengths
);
int append_key_order_str(
KEY *key_info,
int start_pos,
bool desc_flg
);
int append_limit(
longlong offset,
longlong limit
);
int append_into_str();
int append_open_paren_str();
int append_values_str();
int append_select_lock_str(
int lock_mode
);
int exec_query(
SPIDER_CONN *conn,
int quick_mode,
int *need_mon
);
int copy_key_row(
spider_db_copy_table *source_ct,
Field *field,
ulong *row_pos,
ulong *length,
const char *joint_str,
const int joint_length
);
int copy_row(
Field *field,
SPIDER_DB_ROW *row
);
int copy_rows(
TABLE *table,
SPIDER_DB_ROW *row,
ulong **last_row_pos,
ulong **last_lengths
);
int copy_rows(
TABLE *table,
SPIDER_DB_ROW *row
);
int append_insert_terminator();
int copy_insert_values(
spider_db_copy_table *source_ct
);
};
storage/spider/spd_db_oracle.cc
View file @ b5ebf1e2
This source diff could not be displayed because it is too large. You can view the blob instead.
storage/spider/spd_db_oracle.h
View file @ b5ebf1e2
/* Copyright (C) 2012-2013 Kentoku Shiba
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 */
class spider_db_oracle;
class spider_db_oracle_result;
class spider_db_oracle_util: public spider_db_util
{
public:
spider_db_oracle_util();
~spider_db_oracle_util();
int append_name(
spider_string *str,
const char *name,
uint name_length
);
int append_name_with_charset(
spider_string *str,
const char *name,
uint name_length,
CHARSET_INFO *name_charset
);
bool is_name_quote(
const char head_code
);
int append_escaped_name_quote(
spider_string *str
);
int append_column_value(
ha_spider *spider,
spider_string *str,
Field *field,
const uchar *new_ptr,
CHARSET_INFO *access_charset
);
int append_from_with_alias(
spider_string *str,
const char **table_names,
uint *table_name_lengths,
const char **table_aliases,
uint *table_alias_lengths,
uint table_count,
int *table_name_pos,
bool over_write
);
int append_trx_isolation(
spider_string *str,
int trx_isolation
);
int append_autocommit(
spider_string *str,
bool autocommit
);
int append_sql_log_off(
spider_string *str,
bool sql_log_off
);
int append_time_zone(
spider_string *str,
Time_zone *time_zone
);
int append_start_transaction(
spider_string *str
);
int append_xa_start(
spider_string *str,
XID *xid
);
int append_lock_table_head(
spider_string *str
);
int append_lock_table_body(
spider_string *str,
const char *db_name,
uint db_name_length,
CHARSET_INFO *db_name_charset,
const char *table_name,
uint table_name_length,
CHARSET_INFO *table_name_charset,
int lock_type
);
int append_lock_table_tail(
spider_string *str
);
int append_unlock_table(
spider_string *str
);
int open_item_func(
Item_func *item_func,
ha_spider *spider,
spider_string *str,
const char *alias,
uint alias_length
);
#ifdef HANDLER_HAS_DIRECT_AGGREGATE
int open_item_sum_func(
Item_sum *item_sum,
ha_spider *spider,
spider_string *str,
const char *alias,
uint alias_length
);
#endif
size_t escape_string(
char *to,
const char *from,
size_t from_length,
CHARSET_INFO *access_charset
);
int append_escaped_util(
spider_string *to,
String *from
);
};
class spider_db_oracle_row: public spider_db_row
{
public:
spider_db_oracle *db_conn;
spider_db_oracle_result *result;
sb2 *ind;
char **val;
ub2 *rlen;
sb2 *ind_first;
char **val_first;
ub2 *rlen_first;
spider_string *val_str;
spider_string *val_str_first;
OCIDefine **defnp;
OCILobLocator **lobhp;
OCIParam **colhp;
ub2 *coltp;
ub2 *colsz;
uint field_count;
ulong *row_size;
ulong *row_size_first;
CHARSET_INFO *access_charset;
bool cloned;
spider_db_oracle_util util;
spider_db_oracle_row();
~spider_db_oracle_row();
int store_to_field(
Field *field,
CHARSET_INFO *access_charset
);
int append_to_str(
spider_string *str
);
int append_escaped_to_str(
spider_string *str,
uint dbton_id
);
void first();
void next();
bool is_null();
int val_int();
double val_real();
my_decimal *val_decimal(
my_decimal *decimal_value,
CHARSET_INFO *access_charset
);
SPIDER_DB_ROW *clone();
int store_to_tmp_table(
TABLE *tmp_table,
spider_string *str
);
/* for oracle */
int init();
void deinit();
int define();
int fetch();
};
class spider_db_oracle_result: public spider_db_result
{
public:
spider_db_oracle *db_conn;
OCIStmt *stmtp;
uint field_count;
CHARSET_INFO *access_charset;
bool fetched;
spider_db_oracle_row row;
int store_error_num;
spider_db_oracle_result();
~spider_db_oracle_result();
bool has_result();
void free_result();
SPIDER_DB_ROW *current_row();
SPIDER_DB_ROW *fetch_row();
SPIDER_DB_ROW *fetch_row_from_result_buffer(
spider_db_result_buffer *spider_res_buf
);
SPIDER_DB_ROW *fetch_row_from_tmp_table(
TABLE *tmp_table
);
int fetch_table_status(
int mode,
ha_rows &records,
ulong &mean_rec_length,
ulonglong &data_file_length,
ulonglong &max_data_file_length,
ulonglong &index_file_length,
ulonglong &auto_increment_value,
time_t &create_time,
time_t &update_time,
time_t &check_time
);
int fetch_table_records(
int mode,
ha_rows &records
);
int fetch_table_cardinality(
int mode,
TABLE *table,
longlong *cardinality,
uchar *cardinality_upd,
int bitmap_size
);
int fetch_table_mon_status(
int &status
);
longlong num_rows();
uint num_fields();
void move_to_pos(
longlong pos
);
int get_errno();
#ifdef SPIDER_HAS_DISCOVER_TABLE_STRUCTURE
int fetch_columns_for_discover_table_structure(
spider_string *str,
CHARSET_INFO *access_charset
);
int fetch_index_for_discover_table_structure(
spider_string *str,
CHARSET_INFO *access_charset
);
#endif
/* for oracle */
int set_column_info();
};
class spider_db_oracle: public spider_db_conn
{
public:
OCIEnv *envhp;
OCIError *errhp;
OCIServer *srvhp;
OCISvcCtx *svchp;
OCISession *usrhp;
OCIStmt *stmtp;
OCITrans *txnhp;
spider_db_oracle_result *result;
int stored_error_num;
const char *stored_error;
uint update_rows;
int table_lock_mode;
spider_string *exec_lock_sql;
spider_db_oracle_util util;
ulonglong stored_last_insert_id;
HASH lock_table_hash;
bool lock_table_hash_inited;
uint lock_table_hash_id;
const char *lock_table_hash_func_name;
const char *lock_table_hash_file_name;
ulong lock_table_hash_line_no;
DYNAMIC_ARRAY handler_open_array;
bool handler_open_array_inited;
uint handler_open_array_id;
const char *handler_open_array_func_name;
const char *handler_open_array_file_name;
ulong handler_open_array_line_no;
/* for bg_connect */
char stored_error_msg[MYSQL_ERRMSG_SIZE];
char *tgt_host;
char *tgt_username;
char *tgt_password;
long tgt_port;
char *tgt_socket;
char *server_name;
int connect_retry_count;
longlong connect_retry_interval;
spider_db_oracle(
SPIDER_CONN *conn
);
~spider_db_oracle();
int init();
bool is_connected();
void bg_connect();
int connect(
char *tgt_host,
char *tgt_username,
char *tgt_password,
long tgt_port,
char *tgt_socket,
char *server_name,
int connect_retry_count,
longlong connect_retry_interval
);
int ping();
void bg_disconnect();
void disconnect();
int set_net_timeout();
int exec_query(
const char *query,
uint length,
int quick_mode
);
int get_errno();
const char *get_error();
bool is_server_gone_error(
int error_num
);
bool is_dup_entry_error(
int error_num
);
bool is_xa_nota_error(
int error_num
);
spider_db_result *store_result(
spider_db_result_buffer **spider_res_buf,
st_spider_db_request_key *request_key,
int *error_num
);
spider_db_result *use_result(
st_spider_db_request_key *request_key,
int *error_num
);
int next_result();
uint affected_rows();
ulonglong last_insert_id();
int set_character_set(
const char *csname
);
int select_db(
const char *dbname
);
int consistent_snapshot(
int *need_mon
);
bool trx_start_in_bulk_sql();
int start_transaction(
int *need_mon
);
int commit(
int *need_mon
);
int rollback(
int *need_mon
);
bool xa_start_in_bulk_sql();
int xa_start(
XID *xid,
int *need_mon
);
int xa_end(
XID *xid,
int *need_mon
);
int xa_prepare(
XID *xid,
int *need_mon
);
int xa_commit(
XID *xid,
int *need_mon
);
int xa_rollback(
XID *xid,
int *need_mon
);
bool set_trx_isolation_in_bulk_sql();
int set_trx_isolation(
int trx_isolation,
int *need_mon
);
bool set_autocommit_in_bulk_sql();
int set_autocommit(
bool autocommit,
int *need_mon
);
bool set_sql_log_off_in_bulk_sql();
int set_sql_log_off(
bool sql_log_off,
int *need_mon
);
bool set_time_zone_in_bulk_sql();
int set_time_zone(
Time_zone *time_zone,
int *need_mon
);
#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
int append_sql(
char *sql,
ulong sql_length,
st_spider_db_request_key *request_key
);
int append_open_handler(
uint handler_id,
const char *db_name,
const char *table_name,
const char *index_name,
const char *sql,
st_spider_db_request_key *request_key
);
int append_select(
uint handler_id,
spider_string *sql,
SPIDER_DB_HS_STRING_REF_BUFFER *keys,
int limit,
int skip,
st_spider_db_request_key *request_key
);
int append_insert(
uint handler_id,
SPIDER_DB_HS_STRING_REF_BUFFER *upds,
st_spider_db_request_key *request_key
);
int append_update(
uint handler_id,
spider_string *sql,
SPIDER_DB_HS_STRING_REF_BUFFER *keys,
SPIDER_DB_HS_STRING_REF_BUFFER *upds,
int limit,
int skip,
bool increment,
bool decrement,
st_spider_db_request_key *request_key
);
int append_delete(
uint handler_id,
spider_string *sql,
SPIDER_DB_HS_STRING_REF_BUFFER *keys,
int limit,
int skip,
st_spider_db_request_key *request_key
);
void reset_request_queue();
#endif
size_t escape_string(
char *to,
const char *from,
size_t from_length
);
bool have_lock_table_list();
int append_lock_tables(
spider_string *str
);
int append_unlock_tables(
spider_string *str
);
uint get_lock_table_hash_count();
void reset_lock_table_hash();
uint get_opened_handler_count();
void reset_opened_handler();
void set_dup_key_idx(
ha_spider *spider,
int link_idx
);
bool cmp_request_key_to_snd(
st_spider_db_request_key *request_key
);
private:
int set_error(
sword res,
dvoid *hndlp,
int error_num,
const char *error1,
const char *error2
);
};
class spider_oracle_share: public spider_db_share
{
public:
spider_string *table_select;
int table_select_pos;
spider_string *key_select;
int *key_select_pos;
spider_string *key_hint;
spider_string *show_table_status;
spider_string *show_records;
spider_string *show_autoinc;
spider_string *show_last_insert_id;
spider_string *show_index;
spider_string *table_names_str;
spider_string *db_names_str;
spider_string *db_table_str;
spider_string *nextval_str;
#ifdef SPIDER_HAS_HASH_VALUE_TYPE
my_hash_value_type *db_table_str_hash_value;
#endif
uint table_nm_max_length;
uint db_nm_max_length;
uint nextval_max_length;
spider_string *column_name_str;
bool same_db_table_name;
int first_all_link_idx;
spider_oracle_share(
st_spider_share *share
);
~spider_oracle_share();
int init();
uint get_column_name_length(
uint field_index
);
int append_column_name(
spider_string *str,
uint field_index
);
int append_column_name_with_alias(
spider_string *str,
uint field_index,
const char *alias,
uint alias_length
);
int append_table_name(
spider_string *str,
int all_link_idx
);
int append_table_name_with_adjusting(
spider_string *str,
int all_link_idx
);
int append_from_with_adjusted_table_name(
spider_string *str,
int *table_name_pos
);
bool need_change_db_table_name();
#ifdef SPIDER_HAS_DISCOVER_TABLE_STRUCTURE
int discover_table_structure(
SPIDER_TRX *trx,
SPIDER_SHARE *spider_share,
spider_string *str
);
#endif
private:
int create_table_names_str();
void free_table_names_str();
int create_column_name_str();
void free_column_name_str();
int convert_key_hint_str();
int append_show_table_status();
void free_show_table_status();
int append_show_records();
void free_show_records();
int append_show_autoinc();
void free_show_autoinc();
int append_show_last_insert_id();
void free_show_last_insert_id();
int append_show_index();
void free_show_index();
int append_table_select();
int append_key_select(
uint idx
);
};
class spider_oracle_handler: public spider_db_handler
{
spider_string sql;
spider_string sql_part;
spider_string sql_part2;
spider_string ha_sql;
int where_pos;
int order_pos;
int limit_pos;
int table_name_pos;
int update_set_pos;
int ha_read_pos;
int ha_next_pos;
int ha_where_pos;
int ha_limit_pos;
int ha_table_name_pos;
uint ha_sql_handler_id;
spider_string insert_sql;
int insert_pos;
int insert_table_name_pos;
int nextval_pos;
spider_string update_sql;
TABLE *upd_tmp_tbl;
TMP_TABLE_PARAM upd_tmp_tbl_prm;
spider_string tmp_sql;
int tmp_sql_pos1; /* drop db nm pos at tmp_table_join */
int tmp_sql_pos2; /* create db nm pos at tmp_table_join */
int tmp_sql_pos3; /* insert db nm pos at tmp_table_join */
int tmp_sql_pos4; /* insert val pos at tmp_table_join */
int tmp_sql_pos5; /* end of drop tbl at tmp_table_join */
spider_string dup_update_sql;
spider_string *exec_sql;
spider_string *exec_insert_sql;
spider_string *exec_update_sql;
spider_string *exec_tmp_sql;
spider_string *exec_ha_sql;
spider_string *exec_lock_sql;
int table_lock_mode;
bool reading_from_bulk_tmp_table;
bool filled_up;
bool select_rownum_appended;
bool update_rownum_appended;
#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
SPIDER_DB_HS_STRING_REF_BUFFER hs_upds;
#endif
SPIDER_INT_HLD *union_table_name_pos_first;
SPIDER_INT_HLD *union_table_name_pos_current;
public:
spider_oracle_share *oracle_share;
SPIDER_LINK_FOR_HASH *link_for_hash;
spider_oracle_handler(
ha_spider *spider,
spider_oracle_share *share
);
~spider_oracle_handler();
int init();
int append_table_name_with_adjusting(
spider_string *str,
int link_idx,
ulong sql_type
);
int append_key_column_types(
const key_range *start_key,
spider_string *str
);
int append_key_join_columns_for_bka(
const key_range *start_key,
spider_string *str,
const char **table_aliases,
uint *table_alias_lengths
);
int append_tmp_table_and_sql_for_bka(
const key_range *start_key
);
int reuse_tmp_table_and_sql_for_bka();
void create_tmp_bka_table_name(
char *tmp_table_name,
int *tmp_table_name_length,
int link_idx
);
int append_create_tmp_bka_table(
const key_range *start_key,
spider_string *str,
char *tmp_table_name,
int tmp_table_name_length,
int *db_name_pos,
CHARSET_INFO *table_charset
);
int append_drop_tmp_bka_table(
spider_string *str,
char *tmp_table_name,
int tmp_table_name_length,
int *db_name_pos,
int *drop_table_end_pos,
bool with_semicolon
);
int append_insert_tmp_bka_table(
const key_range *start_key,
spider_string *str,
char *tmp_table_name,
int tmp_table_name_length,
int *db_name_pos
);
int append_union_table_and_sql_for_bka(
const key_range *start_key
);
int reuse_union_table_and_sql_for_bka();
int append_insert_for_recovery(
ulong sql_type,
int link_idx
);
int append_update(
const TABLE *table,
my_ptrdiff_t ptr_diff
);
int append_update(
const TABLE *table,
my_ptrdiff_t ptr_diff,
int link_idx
);
int append_delete(
const TABLE *table,
my_ptrdiff_t ptr_diff
);
int append_delete(
const TABLE *table,
my_ptrdiff_t ptr_diff,
int link_idx
);
int append_insert_part();
int append_insert(
spider_string *str,
int link_idx
);
int append_update_part();
int append_update(
spider_string *str,
int link_idx
);
int append_delete_part();
int append_delete(
spider_string *str
);
#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
int append_increment_update_set_part();
int append_increment_update_set(
spider_string *str
);
#endif
#endif
int append_update_set_part();
int append_update_set(
spider_string *str
);
#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
int append_direct_update_set_part();
int append_direct_update_set(
spider_string *str
);
int append_dup_update_pushdown_part(
const char *alias,
uint alias_length
);
int append_update_columns_part(
const char *alias,
uint alias_length
);
int check_update_columns_part();
int append_update_columns(
spider_string *str,
const char *alias,
uint alias_length
);
#endif
int append_select_part(
ulong sql_type
);
int append_select(
spider_string *str,
ulong sql_type
);
int append_table_select_part(
ulong sql_type
);
int append_table_select(
spider_string *str
);
int append_key_select_part(
ulong sql_type,
uint idx
);
int append_key_select(
spider_string *str,
uint idx
);
int append_minimum_select_part(
ulong sql_type
);
int append_minimum_select(
spider_string *str,
ulong sql_type
);
int append_table_select_with_alias(
spider_string *str,
const char *alias,
uint alias_length
);
int append_key_select_with_alias(
spider_string *str,
const KEY *key_info,
const char *alias,
uint alias_length
);
int append_minimum_select_with_alias(
spider_string *str,
const char *alias,
uint alias_length
);
int append_select_columns_with_alias(
spider_string *str,
const char *alias,
uint alias_length
);
int append_hint_after_table_part(
ulong sql_type
);
int append_hint_after_table(
spider_string *str
);
void set_where_pos(
ulong sql_type
);
void set_where_to_pos(
ulong sql_type
);
int check_item_type(
Item *item
);
int append_values_connector_part(
ulong sql_type
);
int append_values_connector(
spider_string *str
);
int append_values_terminator_part(
ulong sql_type
);
int append_values_terminator(
spider_string *str
);
int append_union_table_connector_part(
ulong sql_type
);
int append_union_table_connector(
spider_string *str
);
int append_union_table_terminator_part(
ulong sql_type
);
int append_union_table_terminator(
spider_string *str
);
int append_key_column_values_part(
const key_range *start_key,
ulong sql_type
);
int append_key_column_values(
spider_string *str,
const key_range *start_key
);
int append_key_column_values_with_name_part(
const key_range *start_key,
ulong sql_type
);
int append_key_column_values_with_name(
spider_string *str,
const key_range *start_key
);
int append_key_where_part(
const key_range *start_key,
const key_range *end_key,
ulong sql_type
);
int append_key_where(
spider_string *str,
spider_string *str_part,
spider_string *str_part2,
const key_range *start_key,
const key_range *end_key,
ulong sql_type,
bool set_order
);
int append_is_null_part(
ulong sql_type,
KEY_PART_INFO *key_part,
const key_range *key,
const uchar **ptr,
bool key_eq
);
int append_is_null(
ulong sql_type,
spider_string *str,
spider_string *str_part,
spider_string *str_part2,
KEY_PART_INFO *key_part,
const key_range *key,
const uchar **ptr,
bool key_eq
);
int append_where_terminator_part(
ulong sql_type,
bool set_order,
int key_count
);
int append_where_terminator(
ulong sql_type,
spider_string *str,
spider_string *str_part,
spider_string *str_part2,
bool set_order,
int key_count
);
int append_match_where_part(
ulong sql_type
);
int append_match_where(
spider_string *str
);
int append_update_where(
spider_string *str,
const TABLE *table,
my_ptrdiff_t ptr_diff
);
int append_condition_part(
const char *alias,
uint alias_length,
ulong sql_type,
bool test_flg
);
int append_condition(
spider_string *str,
const char *alias,
uint alias_length,
bool start_where,
ulong sql_type
);
int append_match_against_part(
ulong sql_type,
st_spider_ft_info *ft_info,
const char *alias,
uint alias_length
);
int append_match_against(
spider_string *str,
st_spider_ft_info *ft_info,
const char *alias,
uint alias_length
);
int append_match_select_part(
ulong sql_type,
const char *alias,
uint alias_length
);
int append_match_select(
spider_string *str,
const char *alias,
uint alias_length
);
#ifdef HANDLER_HAS_DIRECT_AGGREGATE
int append_sum_select_part(
ulong sql_type,
const char *alias,
uint alias_length
);
int append_sum_select(
spider_string *str,
const char *alias,
uint alias_length
);
#endif
void set_order_pos(
ulong sql_type
);
void set_order_to_pos(
ulong sql_type
);
#ifdef HANDLER_HAS_DIRECT_AGGREGATE
int append_group_by(
spider_string *str,
const char *alias,
uint alias_length
);
#endif
int append_key_order_for_merge_with_alias_part(
const char *alias,
uint alias_length,
ulong sql_type
);
int append_key_order_for_merge_with_alias(
spider_string *str,
const char *alias,
uint alias_length
);
int append_key_order_for_direct_order_limit_with_alias_part(
const char *alias,
uint alias_length,
ulong sql_type
);
int append_key_order_for_direct_order_limit_with_alias(
spider_string *str,
const char *alias,
uint alias_length
);
int append_key_order_with_alias_part(
const char *alias,
uint alias_length,
ulong sql_type
);
int append_key_order_for_handler(
spider_string *str,
const char *alias,
uint alias_length
);
int append_key_order_with_alias(
spider_string *str,
const char *alias,
uint alias_length
);
int append_limit_part(
longlong offset,
longlong limit,
ulong sql_type
);
int reappend_limit_part(
longlong offset,
longlong limit,
ulong sql_type
);
int append_limit(
spider_string *str,
longlong offset,
longlong limit
);
int append_select_lock_part(
ulong sql_type
);
int append_select_lock(
spider_string *str
);
int append_union_all_start_part(
ulong sql_type
);
int append_union_all_start(
spider_string *str
);
int append_union_all_part(
ulong sql_type
);
int append_union_all(
spider_string *str
);
int append_union_all_end_part(
ulong sql_type
);
int append_union_all_end(
spider_string *str
);
int append_multi_range_cnt_part(
ulong sql_type,
uint multi_range_cnt,
bool with_comma
);
int append_multi_range_cnt(
spider_string *str,
uint multi_range_cnt,
bool with_comma
);
int append_multi_range_cnt_with_name_part(
ulong sql_type,
uint multi_range_cnt
);
int append_multi_range_cnt_with_name(
spider_string *str,
uint multi_range_cnt
);
int append_open_handler_part(
ulong sql_type,
uint handler_id,
SPIDER_CONN *conn,
int link_idx
);
int append_open_handler(
spider_string *str,
uint handler_id,
SPIDER_CONN *conn,
int link_idx
);
int append_close_handler_part(
ulong sql_type,
int link_idx
);
int append_close_handler(
spider_string *str,
int link_idx
);
int append_insert_terminator_part(
ulong sql_type
);
int append_insert_terminator(
spider_string *str
);
int append_insert_values_part(
ulong sql_type
);
int append_insert_values(
spider_string *str
);
int append_into_part(
ulong sql_type
);
int append_into(
spider_string *str
);
void set_insert_to_pos(
ulong sql_type
);
int append_from_part(
ulong sql_type,
int link_idx
);
int append_from(
spider_string *str,
ulong sql_type,
int link_idx
);
int append_flush_tables_part(
ulong sql_type,
int link_idx,
bool lock
);
int append_flush_tables(
spider_string *str,
int link_idx,
bool lock
);
int append_optimize_table_part(
ulong sql_type,
int link_idx
);
int append_optimize_table(
spider_string *str,
int link_idx
);
int append_analyze_table_part(
ulong sql_type,
int link_idx
);
int append_analyze_table(
spider_string *str,
int link_idx
);
int append_repair_table_part(
ulong sql_type,
int link_idx,
HA_CHECK_OPT* check_opt
);
int append_repair_table(
spider_string *str,
int link_idx,
HA_CHECK_OPT* check_opt
);
int append_check_table_part(
ulong sql_type,
int link_idx,
HA_CHECK_OPT* check_opt
);
int append_check_table(
spider_string *str,
int link_idx,
HA_CHECK_OPT* check_opt
);
int append_enable_keys_part(
ulong sql_type,
int link_idx
);
int append_enable_keys(
spider_string *str,
int link_idx
);
int append_disable_keys_part(
ulong sql_type,
int link_idx
);
int append_disable_keys(
spider_string *str,
int link_idx
);
int append_delete_all_rows_part(
ulong sql_type
);
int append_delete_all_rows(
spider_string *str,
ulong sql_type
);
int append_truncate(
spider_string *str,
ulong sql_type,
int link_idx
);
int append_explain_select_part(
key_range *start_key,
key_range *end_key,
ulong sql_type,
int link_idx
);
int append_explain_select(
spider_string *str,
key_range *start_key,
key_range *end_key,
ulong sql_type,
int link_idx
);
bool is_bulk_insert_exec_period(
bool bulk_end
);
bool sql_is_filled_up(
ulong sql_type
);
bool sql_is_empty(
ulong sql_type
);
bool support_multi_split_read();
bool support_bulk_update();
int bulk_tmp_table_insert();
int bulk_tmp_table_insert(
int link_idx
);
int bulk_tmp_table_end_bulk_insert();
int bulk_tmp_table_rnd_init();
int bulk_tmp_table_rnd_next();
int bulk_tmp_table_rnd_end();
bool need_copy_for_update(
int link_idx
);
bool bulk_tmp_table_created();
int mk_bulk_tmp_table_and_bulk_start();
void rm_bulk_tmp_table();
int store_sql_to_bulk_tmp_table(
spider_string *str,
TABLE *tmp_table
);
int restore_sql_from_bulk_tmp_table(
spider_string *str,
TABLE *tmp_table
);
int insert_lock_tables_list(
SPIDER_CONN *conn,
int link_idx
);
int append_lock_tables_list(
SPIDER_CONN *conn,
int link_idx,
int *appended
);
int realloc_sql(
ulong *realloced
);
int reset_sql(
ulong sql_type
);
#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
int reset_keys(
ulong sql_type
);
int reset_upds(
ulong sql_type
);
int reset_strs(
ulong sql_type
);
int reset_strs_pos(
ulong sql_type
);
int push_back_upds(
SPIDER_HS_STRING_REF &info
);
#endif
bool need_lock_before_set_sql_for_exec(
ulong sql_type
);
int set_sql_for_exec(
ulong sql_type,
int link_idx
);
int set_sql_for_exec(
spider_db_copy_table *tgt_ct,
ulong sql_type
);
int execute_sql(
ulong sql_type,
SPIDER_CONN *conn,
int quick_mode,
int *need_mon
);
int reset();
int sts_mode_exchange(
int sts_mode
);
int show_table_status(
int link_idx,
int sts_mode,
uint flag
);
int crd_mode_exchange(
int crd_mode
);
int show_index(
int link_idx,
int crd_mode
);
int show_records(
int link_idx
);
int show_autoinc(
int link_idx
);
int show_last_insert_id(
int link_idx,
ulonglong &last_insert_id
);
ha_rows explain_select(
key_range *start_key,
key_range *end_key,
int link_idx
);
int lock_tables(
int link_idx
);
int unlock_tables(
int link_idx
);
int disable_keys(
SPIDER_CONN *conn,
int link_idx
);
int enable_keys(
SPIDER_CONN *conn,
int link_idx
);
int check_table(
SPIDER_CONN *conn,
int link_idx,
HA_CHECK_OPT* check_opt
);
int repair_table(
SPIDER_CONN *conn,
int link_idx,
HA_CHECK_OPT* check_opt
);
int analyze_table(
SPIDER_CONN *conn,
int link_idx
);
int optimize_table(
SPIDER_CONN *conn,
int link_idx
);
int flush_tables(
SPIDER_CONN *conn,
int link_idx,
bool lock
);
int flush_logs(
SPIDER_CONN *conn,
int link_idx
);
int insert_opened_handler(
SPIDER_CONN *conn,
int link_idx
);
int delete_opened_handler(
SPIDER_CONN *conn,
int link_idx
);
int sync_from_clone_source(
spider_db_handler *dbton_hdl
);
bool support_use_handler(
int use_handler
);
bool minimum_select_bit_is_set(
uint field_index
);
void copy_minimum_select_bitmap(
uchar *bitmap
);
int init_union_table_name_pos();
int set_union_table_name_pos();
int reset_union_table_name(
spider_string *str,
int link_idx,
ulong sql_type
);
};
class spider_oracle_copy_table: public spider_db_copy_table
{
public:
spider_oracle_share *oracle_share;
spider_string sql;
spider_string sql_part;
uint pos;
uint table_name_pos;
uint pos_diff;
int table_lock_mode;
int store_link_idx;
bool select_rownum_appended;
spider_string *first_str;
spider_string *current_str;
spider_oracle_copy_table(
spider_oracle_share *db_share
);
~spider_oracle_copy_table();
int init();
void set_sql_charset(
CHARSET_INFO *cs
);
int append_select_str();
int append_insert_str(
int insert_flg
);
int append_table_columns(
TABLE_SHARE *table_share
);
int append_from_str();
int append_table_name(
int link_idx
);
void set_sql_pos();
void set_sql_to_pos();
int append_copy_where(
spider_db_copy_table *source_ct,
KEY *key_info,
ulong *last_row_pos,
ulong *last_lengths
);
int append_key_order_str(
KEY *key_info,
int start_pos,
bool desc_flg
);
int append_limit(
longlong offset,
longlong limit
);
int append_into_str();
int append_open_paren_str();
int append_values_str();
int append_select_lock_str(
int lock_mode
);
int exec_query(
SPIDER_CONN *conn,
int quick_mode,
int *need_mon
);
int copy_key_row(
spider_db_copy_table *source_ct,
Field *field,
ulong *row_pos,
ulong *length,
const char *joint_str,
const int joint_length
);
int copy_row(
Field *field,
SPIDER_DB_ROW *row
);
int copy_rows(
TABLE *table,
SPIDER_DB_ROW *row,
ulong **last_row_pos,
ulong **last_lengths
);
int copy_rows(
TABLE *table,
SPIDER_DB_ROW *row
);
int append_insert_terminator();
int copy_insert_values(
spider_db_copy_table *source_ct
);
};
/* Copyright (C) 2012-2013 Kentoku Shiba
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 */
class spider_db_oracle;
class spider_db_oracle_result;
class spider_db_oracle_util: public spider_db_util
{
public:
spider_db_oracle_util();
~spider_db_oracle_util();
int append_name(
spider_string *str,
const char *name,
uint name_length
);
int append_name_with_charset(
spider_string *str,
const char *name,
uint name_length,
CHARSET_INFO *name_charset
);
bool is_name_quote(
const char head_code
);
int append_escaped_name_quote(
spider_string *str
);
int append_column_value(
ha_spider *spider,
spider_string *str,
Field *field,
const uchar *new_ptr,
CHARSET_INFO *access_charset
);
int append_from_with_alias(
spider_string *str,
const char **table_names,
uint *table_name_lengths,
const char **table_aliases,
uint *table_alias_lengths,
uint table_count,
int *table_name_pos,
bool over_write
);
int append_trx_isolation(
spider_string *str,
int trx_isolation
);
int append_autocommit(
spider_string *str,
bool autocommit
);
int append_sql_log_off(
spider_string *str,
bool sql_log_off
);
int append_time_zone(
spider_string *str,
Time_zone *time_zone
);
int append_start_transaction(
spider_string *str
);
int append_xa_start(
spider_string *str,
XID *xid
);
int append_lock_table_head(
spider_string *str
);
int append_lock_table_body(
spider_string *str,
const char *db_name,
uint db_name_length,
CHARSET_INFO *db_name_charset,
const char *table_name,
uint table_name_length,
CHARSET_INFO *table_name_charset,
int lock_type
);
int append_lock_table_tail(
spider_string *str
);
int append_unlock_table(
spider_string *str
);
int open_item_func(
Item_func *item_func,
ha_spider *spider,
spider_string *str,
const char *alias,
uint alias_length
);
#ifdef HANDLER_HAS_DIRECT_AGGREGATE
int open_item_sum_func(
Item_sum *item_sum,
ha_spider *spider,
spider_string *str,
const char *alias,
uint alias_length
);
#endif
size_t escape_string(
char *to,
const char *from,
size_t from_length,
CHARSET_INFO *access_charset
);
int append_escaped_util(
spider_string *to,
String *from
);
};
class spider_db_oracle_row: public spider_db_row
{
public:
spider_db_oracle *db_conn;
spider_db_oracle_result *result;
sb2 *ind;
char **val;
ub2 *rlen;
sb2 *ind_first;
char **val_first;
ub2 *rlen_first;
spider_string *val_str;
spider_string *val_str_first;
OCIDefine **defnp;
OCILobLocator **lobhp;
OCIParam **colhp;
ub2 *coltp;
ub2 *colsz;
uint field_count;
ulong *row_size;
ulong *row_size_first;
CHARSET_INFO *access_charset;
bool cloned;
spider_db_oracle_util util;
spider_db_oracle_row();
~spider_db_oracle_row();
int store_to_field(
Field *field,
CHARSET_INFO *access_charset
);
int append_to_str(
spider_string *str
);
int append_escaped_to_str(
spider_string *str,
uint dbton_id
);
void first();
void next();
bool is_null();
int val_int();
double val_real();
my_decimal *val_decimal(
my_decimal *decimal_value,
CHARSET_INFO *access_charset
);
SPIDER_DB_ROW *clone();
int store_to_tmp_table(
TABLE *tmp_table,
spider_string *str
);
/* for oracle */
int init();
void deinit();
int define();
int fetch();
};
class spider_db_oracle_result: public spider_db_result
{
public:
spider_db_oracle *db_conn;
OCIStmt *stmtp;
uint field_count;
CHARSET_INFO *access_charset;
bool fetched;
spider_db_oracle_row row;
int store_error_num;
spider_db_oracle_result();
~spider_db_oracle_result();
bool has_result();
void free_result();
SPIDER_DB_ROW *current_row();
SPIDER_DB_ROW *fetch_row();
SPIDER_DB_ROW *fetch_row_from_result_buffer(
spider_db_result_buffer *spider_res_buf
);
SPIDER_DB_ROW *fetch_row_from_tmp_table(
TABLE *tmp_table
);
int fetch_table_status(
int mode,
ha_rows &records,
ulong &mean_rec_length,
ulonglong &data_file_length,
ulonglong &max_data_file_length,
ulonglong &index_file_length,
ulonglong &auto_increment_value,
time_t &create_time,
time_t &update_time,
time_t &check_time
);
int fetch_table_records(
int mode,
ha_rows &records
);
int fetch_table_cardinality(
int mode,
TABLE *table,
longlong *cardinality,
uchar *cardinality_upd,
int bitmap_size
);
int fetch_table_mon_status(
int &status
);
longlong num_rows();
uint num_fields();
void move_to_pos(
longlong pos
);
int get_errno();
#ifdef SPIDER_HAS_DISCOVER_TABLE_STRUCTURE
int fetch_columns_for_discover_table_structure(
spider_string *str,
CHARSET_INFO *access_charset
);
int fetch_index_for_discover_table_structure(
spider_string *str,
CHARSET_INFO *access_charset
);
#endif
/* for oracle */
int set_column_info();
};
class spider_db_oracle: public spider_db_conn
{
public:
OCIEnv *envhp;
OCIError *errhp;
OCIServer *srvhp;
OCISvcCtx *svchp;
OCISession *usrhp;
OCIStmt *stmtp;
OCITrans *txnhp;
spider_db_oracle_result *result;
int stored_error_num;
const char *stored_error;
uint update_rows;
int table_lock_mode;
spider_string *exec_lock_sql;
spider_db_oracle_util util;
ulonglong stored_last_insert_id;
HASH lock_table_hash;
bool lock_table_hash_inited;
uint lock_table_hash_id;
const char *lock_table_hash_func_name;
const char *lock_table_hash_file_name;
ulong lock_table_hash_line_no;
DYNAMIC_ARRAY handler_open_array;
bool handler_open_array_inited;
uint handler_open_array_id;
const char *handler_open_array_func_name;
const char *handler_open_array_file_name;
ulong handler_open_array_line_no;
/* for bg_connect */
char stored_error_msg[MYSQL_ERRMSG_SIZE];
char *tgt_host;
char *tgt_username;
char *tgt_password;
long tgt_port;
char *tgt_socket;
char *server_name;
int connect_retry_count;
longlong connect_retry_interval;
spider_db_oracle(
SPIDER_CONN *conn
);
~spider_db_oracle();
int init();
bool is_connected();
void bg_connect();
int connect(
char *tgt_host,
char *tgt_username,
char *tgt_password,
long tgt_port,
char *tgt_socket,
char *server_name,
int connect_retry_count,
longlong connect_retry_interval
);
int ping();
void bg_disconnect();
void disconnect();
int set_net_timeout();
int exec_query(
const char *query,
uint length,
int quick_mode
);
int get_errno();
const char *get_error();
bool is_server_gone_error(
int error_num
);
bool is_dup_entry_error(
int error_num
);
bool is_xa_nota_error(
int error_num
);
spider_db_result *store_result(
spider_db_result_buffer **spider_res_buf,
st_spider_db_request_key *request_key,
int *error_num
);
spider_db_result *use_result(
st_spider_db_request_key *request_key,
int *error_num
);
int next_result();
uint affected_rows();
ulonglong last_insert_id();
int set_character_set(
const char *csname
);
int select_db(
const char *dbname
);
int consistent_snapshot(
int *need_mon
);
bool trx_start_in_bulk_sql();
int start_transaction(
int *need_mon
);
int commit(
int *need_mon
);
int rollback(
int *need_mon
);
bool xa_start_in_bulk_sql();
int xa_start(
XID *xid,
int *need_mon
);
int xa_end(
XID *xid,
int *need_mon
);
int xa_prepare(
XID *xid,
int *need_mon
);
int xa_commit(
XID *xid,
int *need_mon
);
int xa_rollback(
XID *xid,
int *need_mon
);
bool set_trx_isolation_in_bulk_sql();
int set_trx_isolation(
int trx_isolation,
int *need_mon
);
bool set_autocommit_in_bulk_sql();
int set_autocommit(
bool autocommit,
int *need_mon
);
bool set_sql_log_off_in_bulk_sql();
int set_sql_log_off(
bool sql_log_off,
int *need_mon
);
bool set_time_zone_in_bulk_sql();
int set_time_zone(
Time_zone *time_zone,
int *need_mon
);
#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
int append_sql(
char *sql,
ulong sql_length,
st_spider_db_request_key *request_key
);
int append_open_handler(
uint handler_id,
const char *db_name,
const char *table_name,
const char *index_name,
const char *sql,
st_spider_db_request_key *request_key
);
int append_select(
uint handler_id,
spider_string *sql,
SPIDER_DB_HS_STRING_REF_BUFFER *keys,
int limit,
int skip,
st_spider_db_request_key *request_key
);
int append_insert(
uint handler_id,
SPIDER_DB_HS_STRING_REF_BUFFER *upds,
st_spider_db_request_key *request_key
);
int append_update(
uint handler_id,
spider_string *sql,
SPIDER_DB_HS_STRING_REF_BUFFER *keys,
SPIDER_DB_HS_STRING_REF_BUFFER *upds,
int limit,
int skip,
bool increment,
bool decrement,
st_spider_db_request_key *request_key
);
int append_delete(
uint handler_id,
spider_string *sql,
SPIDER_DB_HS_STRING_REF_BUFFER *keys,
int limit,
int skip,
st_spider_db_request_key *request_key
);
void reset_request_queue();
#endif
size_t escape_string(
char *to,
const char *from,
size_t from_length
);
bool have_lock_table_list();
int append_lock_tables(
spider_string *str
);
int append_unlock_tables(
spider_string *str
);
uint get_lock_table_hash_count();
void reset_lock_table_hash();
uint get_opened_handler_count();
void reset_opened_handler();
void set_dup_key_idx(
ha_spider *spider,
int link_idx
);
bool cmp_request_key_to_snd(
st_spider_db_request_key *request_key
);
private:
int set_error(
sword res,
dvoid *hndlp,
int error_num,
const char *error1,
const char *error2
);
};
class spider_oracle_share: public spider_db_share
{
public:
spider_string *table_select;
int table_select_pos;
spider_string *key_select;
int *key_select_pos;
spider_string *key_hint;
spider_string *show_table_status;
spider_string *show_records;
spider_string *show_autoinc;
spider_string *show_last_insert_id;
spider_string *show_index;
spider_string *table_names_str;
spider_string *db_names_str;
spider_string *db_table_str;
spider_string *nextval_str;
#ifdef SPIDER_HAS_HASH_VALUE_TYPE
my_hash_value_type *db_table_str_hash_value;
#endif
uint table_nm_max_length;
uint db_nm_max_length;
uint nextval_max_length;
spider_string *column_name_str;
bool same_db_table_name;
int first_all_link_idx;
spider_oracle_share(
st_spider_share *share
);
~spider_oracle_share();
int init();
uint get_column_name_length(
uint field_index
);
int append_column_name(
spider_string *str,
uint field_index
);
int append_column_name_with_alias(
spider_string *str,
uint field_index,
const char *alias,
uint alias_length
);
int append_table_name(
spider_string *str,
int all_link_idx
);
int append_table_name_with_adjusting(
spider_string *str,
int all_link_idx
);
int append_from_with_adjusted_table_name(
spider_string *str,
int *table_name_pos
);
bool need_change_db_table_name();
#ifdef SPIDER_HAS_DISCOVER_TABLE_STRUCTURE
int discover_table_structure(
SPIDER_TRX *trx,
SPIDER_SHARE *spider_share,
spider_string *str
);
#endif
private:
int create_table_names_str();
void free_table_names_str();
int create_column_name_str();
void free_column_name_str();
int convert_key_hint_str();
int append_show_table_status();
void free_show_table_status();
int append_show_records();
void free_show_records();
int append_show_autoinc();
void free_show_autoinc();
int append_show_last_insert_id();
void free_show_last_insert_id();
int append_show_index();
void free_show_index();
int append_table_select();
int append_key_select(
uint idx
);
};
class spider_oracle_handler: public spider_db_handler
{
spider_string sql;
spider_string sql_part;
spider_string sql_part2;
spider_string ha_sql;
int where_pos;
int order_pos;
int limit_pos;
int table_name_pos;
int update_set_pos;
int ha_read_pos;
int ha_next_pos;
int ha_where_pos;
int ha_limit_pos;
int ha_table_name_pos;
uint ha_sql_handler_id;
spider_string insert_sql;
int insert_pos;
int insert_table_name_pos;
int nextval_pos;
spider_string update_sql;
TABLE *upd_tmp_tbl;
TMP_TABLE_PARAM upd_tmp_tbl_prm;
spider_string tmp_sql;
int tmp_sql_pos1; /* drop db nm pos at tmp_table_join */
int tmp_sql_pos2; /* create db nm pos at tmp_table_join */
int tmp_sql_pos3; /* insert db nm pos at tmp_table_join */
int tmp_sql_pos4; /* insert val pos at tmp_table_join */
int tmp_sql_pos5; /* end of drop tbl at tmp_table_join */
spider_string dup_update_sql;
spider_string *exec_sql;
spider_string *exec_insert_sql;
spider_string *exec_update_sql;
spider_string *exec_tmp_sql;
spider_string *exec_ha_sql;
spider_string *exec_lock_sql;
int table_lock_mode;
bool reading_from_bulk_tmp_table;
bool filled_up;
bool select_rownum_appended;
bool update_rownum_appended;
#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
SPIDER_DB_HS_STRING_REF_BUFFER hs_upds;
#endif
SPIDER_INT_HLD *union_table_name_pos_first;
SPIDER_INT_HLD *union_table_name_pos_current;
public:
spider_oracle_share *oracle_share;
SPIDER_LINK_FOR_HASH *link_for_hash;
spider_oracle_handler(
ha_spider *spider,
spider_oracle_share *share
);
~spider_oracle_handler();
int init();
int append_table_name_with_adjusting(
spider_string *str,
int link_idx,
ulong sql_type
);
int append_key_column_types(
const key_range *start_key,
spider_string *str
);
int append_key_join_columns_for_bka(
const key_range *start_key,
spider_string *str,
const char **table_aliases,
uint *table_alias_lengths
);
int append_tmp_table_and_sql_for_bka(
const key_range *start_key
);
int reuse_tmp_table_and_sql_for_bka();
void create_tmp_bka_table_name(
char *tmp_table_name,
int *tmp_table_name_length,
int link_idx
);
int append_create_tmp_bka_table(
const key_range *start_key,
spider_string *str,
char *tmp_table_name,
int tmp_table_name_length,
int *db_name_pos,
CHARSET_INFO *table_charset
);
int append_drop_tmp_bka_table(
spider_string *str,
char *tmp_table_name,
int tmp_table_name_length,
int *db_name_pos,
int *drop_table_end_pos,
bool with_semicolon
);
int append_insert_tmp_bka_table(
const key_range *start_key,
spider_string *str,
char *tmp_table_name,
int tmp_table_name_length,
int *db_name_pos
);
int append_union_table_and_sql_for_bka(
const key_range *start_key
);
int reuse_union_table_and_sql_for_bka();
int append_insert_for_recovery(
ulong sql_type,
int link_idx
);
int append_update(
const TABLE *table,
my_ptrdiff_t ptr_diff
);
int append_update(
const TABLE *table,
my_ptrdiff_t ptr_diff,
int link_idx
);
int append_delete(
const TABLE *table,
my_ptrdiff_t ptr_diff
);
int append_delete(
const TABLE *table,
my_ptrdiff_t ptr_diff,
int link_idx
);
int append_insert_part();
int append_insert(
spider_string *str,
int link_idx
);
int append_update_part();
int append_update(
spider_string *str,
int link_idx
);
int append_delete_part();
int append_delete(
spider_string *str
);
#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
int append_increment_update_set_part();
int append_increment_update_set(
spider_string *str
);
#endif
#endif
int append_update_set_part();
int append_update_set(
spider_string *str
);
#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
int append_direct_update_set_part();
int append_direct_update_set(
spider_string *str
);
int append_dup_update_pushdown_part(
const char *alias,
uint alias_length
);
int append_update_columns_part(
const char *alias,
uint alias_length
);
int check_update_columns_part();
int append_update_columns(
spider_string *str,
const char *alias,
uint alias_length
);
#endif
int append_select_part(
ulong sql_type
);
int append_select(
spider_string *str,
ulong sql_type
);
int append_table_select_part(
ulong sql_type
);
int append_table_select(
spider_string *str
);
int append_key_select_part(
ulong sql_type,
uint idx
);
int append_key_select(
spider_string *str,
uint idx
);
int append_minimum_select_part(
ulong sql_type
);
int append_minimum_select(
spider_string *str,
ulong sql_type
);
int append_table_select_with_alias(
spider_string *str,
const char *alias,
uint alias_length
);
int append_key_select_with_alias(
spider_string *str,
const KEY *key_info,
const char *alias,
uint alias_length
);
int append_minimum_select_with_alias(
spider_string *str,
const char *alias,
uint alias_length
);
int append_select_columns_with_alias(
spider_string *str,
const char *alias,
uint alias_length
);
int append_hint_after_table_part(
ulong sql_type
);
int append_hint_after_table(
spider_string *str
);
void set_where_pos(
ulong sql_type
);
void set_where_to_pos(
ulong sql_type
);
int check_item_type(
Item *item
);
int append_values_connector_part(
ulong sql_type
);
int append_values_connector(
spider_string *str
);
int append_values_terminator_part(
ulong sql_type
);
int append_values_terminator(
spider_string *str
);
int append_union_table_connector_part(
ulong sql_type
);
int append_union_table_connector(
spider_string *str
);
int append_union_table_terminator_part(
ulong sql_type
);
int append_union_table_terminator(
spider_string *str
);
int append_key_column_values_part(
const key_range *start_key,
ulong sql_type
);
int append_key_column_values(
spider_string *str,
const key_range *start_key
);
int append_key_column_values_with_name_part(
const key_range *start_key,
ulong sql_type
);
int append_key_column_values_with_name(
spider_string *str,
const key_range *start_key
);
int append_key_where_part(
const key_range *start_key,
const key_range *end_key,
ulong sql_type
);
int append_key_where(
spider_string *str,
spider_string *str_part,
spider_string *str_part2,
const key_range *start_key,
const key_range *end_key,
ulong sql_type,
bool set_order
);
int append_is_null_part(
ulong sql_type,
KEY_PART_INFO *key_part,
const key_range *key,
const uchar **ptr,
bool key_eq
);
int append_is_null(
ulong sql_type,
spider_string *str,
spider_string *str_part,
spider_string *str_part2,
KEY_PART_INFO *key_part,
const key_range *key,
const uchar **ptr,
bool key_eq
);
int append_where_terminator_part(
ulong sql_type,
bool set_order,
int key_count
);
int append_where_terminator(
ulong sql_type,
spider_string *str,
spider_string *str_part,
spider_string *str_part2,
bool set_order,
int key_count
);
int append_match_where_part(
ulong sql_type
);
int append_match_where(
spider_string *str
);
int append_update_where(
spider_string *str,
const TABLE *table,
my_ptrdiff_t ptr_diff
);
int append_condition_part(
const char *alias,
uint alias_length,
ulong sql_type,
bool test_flg
);
int append_condition(
spider_string *str,
const char *alias,
uint alias_length,
bool start_where,
ulong sql_type
);
int append_match_against_part(
ulong sql_type,
st_spider_ft_info *ft_info,
const char *alias,
uint alias_length
);
int append_match_against(
spider_string *str,
st_spider_ft_info *ft_info,
const char *alias,
uint alias_length
);
int append_match_select_part(
ulong sql_type,
const char *alias,
uint alias_length
);
int append_match_select(
spider_string *str,
const char *alias,
uint alias_length
);
#ifdef HANDLER_HAS_DIRECT_AGGREGATE
int append_sum_select_part(
ulong sql_type,
const char *alias,
uint alias_length
);
int append_sum_select(
spider_string *str,
const char *alias,
uint alias_length
);
#endif
void set_order_pos(
ulong sql_type
);
void set_order_to_pos(
ulong sql_type
);
#ifdef HANDLER_HAS_DIRECT_AGGREGATE
int append_group_by(
spider_string *str,
const char *alias,
uint alias_length
);
#endif
int append_key_order_for_merge_with_alias_part(
const char *alias,
uint alias_length,
ulong sql_type
);
int append_key_order_for_merge_with_alias(
spider_string *str,
const char *alias,
uint alias_length
);
int append_key_order_for_direct_order_limit_with_alias_part(
const char *alias,
uint alias_length,
ulong sql_type
);
int append_key_order_for_direct_order_limit_with_alias(
spider_string *str,
const char *alias,
uint alias_length
);
int append_key_order_with_alias_part(
const char *alias,
uint alias_length,
ulong sql_type
);
int append_key_order_for_handler(
spider_string *str,
const char *alias,
uint alias_length
);
int append_key_order_with_alias(
spider_string *str,
const char *alias,
uint alias_length
);
int append_limit_part(
longlong offset,
longlong limit,
ulong sql_type
);
int reappend_limit_part(
longlong offset,
longlong limit,
ulong sql_type
);
int append_limit(
spider_string *str,
longlong offset,
longlong limit
);
int append_select_lock_part(
ulong sql_type
);
int append_select_lock(
spider_string *str
);
int append_union_all_start_part(
ulong sql_type
);
int append_union_all_start(
spider_string *str
);
int append_union_all_part(
ulong sql_type
);
int append_union_all(
spider_string *str
);
int append_union_all_end_part(
ulong sql_type
);
int append_union_all_end(
spider_string *str
);
int append_multi_range_cnt_part(
ulong sql_type,
uint multi_range_cnt,
bool with_comma
);
int append_multi_range_cnt(
spider_string *str,
uint multi_range_cnt,
bool with_comma
);
int append_multi_range_cnt_with_name_part(
ulong sql_type,
uint multi_range_cnt
);
int append_multi_range_cnt_with_name(
spider_string *str,
uint multi_range_cnt
);
int append_open_handler_part(
ulong sql_type,
uint handler_id,
SPIDER_CONN *conn,
int link_idx
);
int append_open_handler(
spider_string *str,
uint handler_id,
SPIDER_CONN *conn,
int link_idx
);
int append_close_handler_part(
ulong sql_type,
int link_idx
);
int append_close_handler(
spider_string *str,
int link_idx
);
int append_insert_terminator_part(
ulong sql_type
);
int append_insert_terminator(
spider_string *str
);
int append_insert_values_part(
ulong sql_type
);
int append_insert_values(
spider_string *str
);
int append_into_part(
ulong sql_type
);
int append_into(
spider_string *str
);
void set_insert_to_pos(
ulong sql_type
);
int append_from_part(
ulong sql_type,
int link_idx
);
int append_from(
spider_string *str,
ulong sql_type,
int link_idx
);
int append_flush_tables_part(
ulong sql_type,
int link_idx,
bool lock
);
int append_flush_tables(
spider_string *str,
int link_idx,
bool lock
);
int append_optimize_table_part(
ulong sql_type,
int link_idx
);
int append_optimize_table(
spider_string *str,
int link_idx
);
int append_analyze_table_part(
ulong sql_type,
int link_idx
);
int append_analyze_table(
spider_string *str,
int link_idx
);
int append_repair_table_part(
ulong sql_type,
int link_idx,
HA_CHECK_OPT* check_opt
);
int append_repair_table(
spider_string *str,
int link_idx,
HA_CHECK_OPT* check_opt
);
int append_check_table_part(
ulong sql_type,
int link_idx,
HA_CHECK_OPT* check_opt
);
int append_check_table(
spider_string *str,
int link_idx,
HA_CHECK_OPT* check_opt
);
int append_enable_keys_part(
ulong sql_type,
int link_idx
);
int append_enable_keys(
spider_string *str,
int link_idx
);
int append_disable_keys_part(
ulong sql_type,
int link_idx
);
int append_disable_keys(
spider_string *str,
int link_idx
);
int append_delete_all_rows_part(
ulong sql_type
);
int append_delete_all_rows(
spider_string *str,
ulong sql_type
);
int append_truncate(
spider_string *str,
ulong sql_type,
int link_idx
);
int append_explain_select_part(
key_range *start_key,
key_range *end_key,
ulong sql_type,
int link_idx
);
int append_explain_select(
spider_string *str,
key_range *start_key,
key_range *end_key,
ulong sql_type,
int link_idx
);
bool is_bulk_insert_exec_period(
bool bulk_end
);
bool sql_is_filled_up(
ulong sql_type
);
bool sql_is_empty(
ulong sql_type
);
bool support_multi_split_read();
bool support_bulk_update();
int bulk_tmp_table_insert();
int bulk_tmp_table_insert(
int link_idx
);
int bulk_tmp_table_end_bulk_insert();
int bulk_tmp_table_rnd_init();
int bulk_tmp_table_rnd_next();
int bulk_tmp_table_rnd_end();
bool need_copy_for_update(
int link_idx
);
bool bulk_tmp_table_created();
int mk_bulk_tmp_table_and_bulk_start();
void rm_bulk_tmp_table();
int store_sql_to_bulk_tmp_table(
spider_string *str,
TABLE *tmp_table
);
int restore_sql_from_bulk_tmp_table(
spider_string *str,
TABLE *tmp_table
);
int insert_lock_tables_list(
SPIDER_CONN *conn,
int link_idx
);
int append_lock_tables_list(
SPIDER_CONN *conn,
int link_idx,
int *appended
);
int realloc_sql(
ulong *realloced
);
int reset_sql(
ulong sql_type
);
#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
int reset_keys(
ulong sql_type
);
int reset_upds(
ulong sql_type
);
int reset_strs(
ulong sql_type
);
int reset_strs_pos(
ulong sql_type
);
int push_back_upds(
SPIDER_HS_STRING_REF &info
);
#endif
bool need_lock_before_set_sql_for_exec(
ulong sql_type
);
int set_sql_for_exec(
ulong sql_type,
int link_idx
);
int set_sql_for_exec(
spider_db_copy_table *tgt_ct,
ulong sql_type
);
int execute_sql(
ulong sql_type,
SPIDER_CONN *conn,
int quick_mode,
int *need_mon
);
int reset();
int sts_mode_exchange(
int sts_mode
);
int show_table_status(
int link_idx,
int sts_mode,
uint flag
);
int crd_mode_exchange(
int crd_mode
);
int show_index(
int link_idx,
int crd_mode
);
int show_records(
int link_idx
);
int show_autoinc(
int link_idx
);
int show_last_insert_id(
int link_idx,
ulonglong &last_insert_id
);
ha_rows explain_select(
key_range *start_key,
key_range *end_key,
int link_idx
);
int lock_tables(
int link_idx
);
int unlock_tables(
int link_idx
);
int disable_keys(
SPIDER_CONN *conn,
int link_idx
);
int enable_keys(
SPIDER_CONN *conn,
int link_idx
);
int check_table(
SPIDER_CONN *conn,
int link_idx,
HA_CHECK_OPT* check_opt
);
int repair_table(
SPIDER_CONN *conn,
int link_idx,
HA_CHECK_OPT* check_opt
);
int analyze_table(
SPIDER_CONN *conn,
int link_idx
);
int optimize_table(
SPIDER_CONN *conn,
int link_idx
);
int flush_tables(
SPIDER_CONN *conn,
int link_idx,
bool lock
);
int flush_logs(
SPIDER_CONN *conn,
int link_idx
);
int insert_opened_handler(
SPIDER_CONN *conn,
int link_idx
);
int delete_opened_handler(
SPIDER_CONN *conn,
int link_idx
);
int sync_from_clone_source(
spider_db_handler *dbton_hdl
);
bool support_use_handler(
int use_handler
);
bool minimum_select_bit_is_set(
uint field_index
);
void copy_minimum_select_bitmap(
uchar *bitmap
);
int init_union_table_name_pos();
int set_union_table_name_pos();
int reset_union_table_name(
spider_string *str,
int link_idx,
ulong sql_type
);
};
class spider_oracle_copy_table: public spider_db_copy_table
{
public:
spider_oracle_share *oracle_share;
spider_string sql;
spider_string sql_part;
uint pos;
uint table_name_pos;
uint pos_diff;
int table_lock_mode;
int store_link_idx;
bool select_rownum_appended;
spider_string *first_str;
spider_string *current_str;
spider_oracle_copy_table(
spider_oracle_share *db_share
);
~spider_oracle_copy_table();
int init();
void set_sql_charset(
CHARSET_INFO *cs
);
int append_select_str();
int append_insert_str(
int insert_flg
);
int append_table_columns(
TABLE_SHARE *table_share
);
int append_from_str();
int append_table_name(
int link_idx
);
void set_sql_pos();
void set_sql_to_pos();
int append_copy_where(
spider_db_copy_table *source_ct,
KEY *key_info,
ulong *last_row_pos,
ulong *last_lengths
);
int append_key_order_str(
KEY *key_info,
int start_pos,
bool desc_flg
);
int append_limit(
longlong offset,
longlong limit
);
int append_into_str();
int append_open_paren_str();
int append_values_str();
int append_select_lock_str(
int lock_mode
);
int exec_query(
SPIDER_CONN *conn,
int quick_mode,
int *need_mon
);
int copy_key_row(
spider_db_copy_table *source_ct,
Field *field,
ulong *row_pos,
ulong *length,
const char *joint_str,
const int joint_length
);
int copy_row(
Field *field,
SPIDER_DB_ROW *row
);
int copy_rows(
TABLE *table,
SPIDER_DB_ROW *row,
ulong **last_row_pos,
ulong **last_lengths
);
int copy_rows(
TABLE *table,
SPIDER_DB_ROW *row
);
int append_insert_terminator();
int copy_insert_values(
spider_db_copy_table *source_ct
);
};
storage/spider/spd_i_s.cc
View file @ b5ebf1e2
/* Copyright (C) 2012-2013 Kentoku Shiba
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 */
#define MYSQL_SERVER 1
#include "mysql_version.h"
#if MYSQL_VERSION_ID < 50500
#include "mysql_priv.h"
#include <mysql/plugin.h>
#else
#include "sql_priv.h"
#include "probes_mysql.h"
#include "sql_class.h"
#include "sql_partition.h"
#include "sql_show.h"
#endif
#include "spd_db_include.h"
#include "spd_include.h"
#include "spd_table.h"
extern pthread_mutex_t spider_mem_calc_mutex;
extern const char *spider_alloc_func_name[SPIDER_MEM_CALC_LIST_NUM];
extern const char *spider_alloc_file_name[SPIDER_MEM_CALC_LIST_NUM];
extern ulong spider_alloc_line_no[SPIDER_MEM_CALC_LIST_NUM];
extern ulonglong spider_total_alloc_mem[SPIDER_MEM_CALC_LIST_NUM];
extern longlong spider_current_alloc_mem[SPIDER_MEM_CALC_LIST_NUM];
extern ulonglong spider_alloc_mem_count[SPIDER_MEM_CALC_LIST_NUM];
extern ulonglong spider_free_mem_count[SPIDER_MEM_CALC_LIST_NUM];
static struct st_mysql_storage_engine spider_i_s_info =
{ MYSQL_INFORMATION_SCHEMA_INTERFACE_VERSION };
static ST_FIELD_INFO spider_i_s_alloc_mem_fields_info[] =
{
{"ID", 10, MYSQL_TYPE_LONG, 0, MY_I_S_UNSIGNED, "id", SKIP_OPEN_TABLE},
{"FUNC_NAME", 64, MYSQL_TYPE_STRING, 0,
MY_I_S_MAYBE_NULL, "func_name", SKIP_OPEN_TABLE},
{"FILE_NAME", 64, MYSQL_TYPE_STRING, 0,
MY_I_S_MAYBE_NULL, "file_name", SKIP_OPEN_TABLE},
{"LINE_NO", 10, MYSQL_TYPE_LONG, 0,
MY_I_S_UNSIGNED | MY_I_S_MAYBE_NULL, "line_no", SKIP_OPEN_TABLE},
{"TOTAL_ALLOC_MEM", 20, MYSQL_TYPE_LONGLONG, 0,
MY_I_S_UNSIGNED | MY_I_S_MAYBE_NULL, "total_alloc_mem", SKIP_OPEN_TABLE},
{"CURRENT_ALLOC_MEM", 20, MYSQL_TYPE_LONGLONG, 0,
MY_I_S_MAYBE_NULL, "current_alloc_mem", SKIP_OPEN_TABLE},
{"ALLOC_MEM_COUNT", 20, MYSQL_TYPE_LONGLONG, 0,
MY_I_S_UNSIGNED | MY_I_S_MAYBE_NULL, "alloc_mem_count", SKIP_OPEN_TABLE},
{"FREE_MEM_COUNT", 20, MYSQL_TYPE_LONGLONG, 0,
MY_I_S_UNSIGNED | MY_I_S_MAYBE_NULL, "free_mem_count", SKIP_OPEN_TABLE},
{NULL, 0, MYSQL_TYPE_STRING, 0, 0, NULL, 0}
};
static int spider_i_s_alloc_mem_fill_table(
THD *thd,
TABLE_LIST *tables,
COND *cond
) {
uint roop_count;
TABLE *table = tables->table;
DBUG_ENTER("spider_i_s_alloc_mem_fill_table");
for (roop_count = 0; roop_count < SPIDER_MEM_CALC_LIST_NUM; roop_count++)
{
table->field[0]->store(roop_count, TRUE);
if (spider_alloc_func_name[roop_count])
{
table->field[1]->set_notnull();
table->field[2]->set_notnull();
table->field[3]->set_notnull();
table->field[4]->set_notnull();
table->field[5]->set_notnull();
table->field[6]->set_notnull();
table->field[7]->set_notnull();
table->field[1]->store(spider_alloc_func_name[roop_count],
strlen(spider_alloc_func_name[roop_count]), system_charset_info);
table->field[2]->store(spider_alloc_file_name[roop_count],
strlen(spider_alloc_file_name[roop_count]), system_charset_info);
table->field[3]->store(spider_alloc_line_no[roop_count], TRUE);
pthread_mutex_lock(&spider_mem_calc_mutex);
table->field[4]->store(spider_total_alloc_mem[roop_count], TRUE);
table->field[5]->store(spider_current_alloc_mem[roop_count], FALSE);
table->field[6]->store(spider_alloc_mem_count[roop_count], TRUE);
table->field[7]->store(spider_free_mem_count[roop_count], TRUE);
pthread_mutex_unlock(&spider_mem_calc_mutex);
} else {
table->field[1]->set_null();
table->field[2]->set_null();
table->field[3]->set_null();
table->field[4]->set_null();
table->field[5]->set_null();
table->field[6]->set_null();
table->field[7]->set_null();
}
if (schema_table_store_record(thd, table))
{
DBUG_RETURN(1);
}
}
DBUG_RETURN(0);
}
static int spider_i_s_alloc_mem_init(
void *p
) {
ST_SCHEMA_TABLE *schema = (ST_SCHEMA_TABLE *) p;
DBUG_ENTER("spider_i_s_alloc_mem_init");
schema->fields_info = spider_i_s_alloc_mem_fields_info;
schema->fill_table = spider_i_s_alloc_mem_fill_table;
schema->idx_field1 = 0;
DBUG_RETURN(0);
}
static int spider_i_s_alloc_mem_deinit(
void *p
) {
DBUG_ENTER("spider_i_s_alloc_mem_deinit");
DBUG_RETURN(0);
}
struct st_mysql_plugin spider_i_s_alloc_mem =
{
MYSQL_INFORMATION_SCHEMA_PLUGIN,
&spider_i_s_info,
"SPIDER_ALLOC_MEM",
"Kentoku Shiba",
"Spider memory allocating viewer",
PLUGIN_LICENSE_GPL,
spider_i_s_alloc_mem_init,
spider_i_s_alloc_mem_deinit,
0x0001,
NULL,
NULL,
NULL,
#if MYSQL_VERSION_ID >= 50600
0,
#endif
};
/* Copyright (C) 2012-2013 Kentoku Shiba
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 */
#define MYSQL_SERVER 1
#include "mysql_version.h"
#if MYSQL_VERSION_ID < 50500
#include "mysql_priv.h"
#include <mysql/plugin.h>
#else
#include "sql_priv.h"
#include "probes_mysql.h"
#include "sql_class.h"
#include "sql_partition.h"
#include "sql_show.h"
#endif
#include "spd_db_include.h"
#include "spd_include.h"
#include "spd_table.h"
extern pthread_mutex_t spider_mem_calc_mutex;
extern const char *spider_alloc_func_name[SPIDER_MEM_CALC_LIST_NUM];
extern const char *spider_alloc_file_name[SPIDER_MEM_CALC_LIST_NUM];
extern ulong spider_alloc_line_no[SPIDER_MEM_CALC_LIST_NUM];
extern ulonglong spider_total_alloc_mem[SPIDER_MEM_CALC_LIST_NUM];
extern longlong spider_current_alloc_mem[SPIDER_MEM_CALC_LIST_NUM];
extern ulonglong spider_alloc_mem_count[SPIDER_MEM_CALC_LIST_NUM];
extern ulonglong spider_free_mem_count[SPIDER_MEM_CALC_LIST_NUM];
static struct st_mysql_storage_engine spider_i_s_info =
{ MYSQL_INFORMATION_SCHEMA_INTERFACE_VERSION };
static ST_FIELD_INFO spider_i_s_alloc_mem_fields_info[] =
{
{"ID", 10, MYSQL_TYPE_LONG, 0, MY_I_S_UNSIGNED, "id", SKIP_OPEN_TABLE},
{"FUNC_NAME", 64, MYSQL_TYPE_STRING, 0,
MY_I_S_MAYBE_NULL, "func_name", SKIP_OPEN_TABLE},
{"FILE_NAME", 64, MYSQL_TYPE_STRING, 0,
MY_I_S_MAYBE_NULL, "file_name", SKIP_OPEN_TABLE},
{"LINE_NO", 10, MYSQL_TYPE_LONG, 0,
MY_I_S_UNSIGNED | MY_I_S_MAYBE_NULL, "line_no", SKIP_OPEN_TABLE},
{"TOTAL_ALLOC_MEM", 20, MYSQL_TYPE_LONGLONG, 0,
MY_I_S_UNSIGNED | MY_I_S_MAYBE_NULL, "total_alloc_mem", SKIP_OPEN_TABLE},
{"CURRENT_ALLOC_MEM", 20, MYSQL_TYPE_LONGLONG, 0,
MY_I_S_MAYBE_NULL, "current_alloc_mem", SKIP_OPEN_TABLE},
{"ALLOC_MEM_COUNT", 20, MYSQL_TYPE_LONGLONG, 0,
MY_I_S_UNSIGNED | MY_I_S_MAYBE_NULL, "alloc_mem_count", SKIP_OPEN_TABLE},
{"FREE_MEM_COUNT", 20, MYSQL_TYPE_LONGLONG, 0,
MY_I_S_UNSIGNED | MY_I_S_MAYBE_NULL, "free_mem_count", SKIP_OPEN_TABLE},
{NULL, 0, MYSQL_TYPE_STRING, 0, 0, NULL, 0}
};
static int spider_i_s_alloc_mem_fill_table(
THD *thd,
TABLE_LIST *tables,
COND *cond
) {
uint roop_count;
TABLE *table = tables->table;
DBUG_ENTER("spider_i_s_alloc_mem_fill_table");
for (roop_count = 0; roop_count < SPIDER_MEM_CALC_LIST_NUM; roop_count++)
{
table->field[0]->store(roop_count, TRUE);
if (spider_alloc_func_name[roop_count])
{
table->field[1]->set_notnull();
table->field[2]->set_notnull();
table->field[3]->set_notnull();
table->field[4]->set_notnull();
table->field[5]->set_notnull();
table->field[6]->set_notnull();
table->field[7]->set_notnull();
table->field[1]->store(spider_alloc_func_name[roop_count],
strlen(spider_alloc_func_name[roop_count]), system_charset_info);
table->field[2]->store(spider_alloc_file_name[roop_count],
strlen(spider_alloc_file_name[roop_count]), system_charset_info);
table->field[3]->store(spider_alloc_line_no[roop_count], TRUE);
pthread_mutex_lock(&spider_mem_calc_mutex);
table->field[4]->store(spider_total_alloc_mem[roop_count], TRUE);
table->field[5]->store(spider_current_alloc_mem[roop_count], FALSE);
table->field[6]->store(spider_alloc_mem_count[roop_count], TRUE);
table->field[7]->store(spider_free_mem_count[roop_count], TRUE);
pthread_mutex_unlock(&spider_mem_calc_mutex);
} else {
table->field[1]->set_null();
table->field[2]->set_null();
table->field[3]->set_null();
table->field[4]->set_null();
table->field[5]->set_null();
table->field[6]->set_null();
table->field[7]->set_null();
}
if (schema_table_store_record(thd, table))
{
DBUG_RETURN(1);
}
}
DBUG_RETURN(0);
}
static int spider_i_s_alloc_mem_init(
void *p
) {
ST_SCHEMA_TABLE *schema = (ST_SCHEMA_TABLE *) p;
DBUG_ENTER("spider_i_s_alloc_mem_init");
schema->fields_info = spider_i_s_alloc_mem_fields_info;
schema->fill_table = spider_i_s_alloc_mem_fill_table;
schema->idx_field1 = 0;
DBUG_RETURN(0);
}
static int spider_i_s_alloc_mem_deinit(
void *p
) {
DBUG_ENTER("spider_i_s_alloc_mem_deinit");
DBUG_RETURN(0);
}
struct st_mysql_plugin spider_i_s_alloc_mem =
{
MYSQL_INFORMATION_SCHEMA_PLUGIN,
&spider_i_s_info,
"SPIDER_ALLOC_MEM",
"Kentoku Shiba",
"Spider memory allocating viewer",
PLUGIN_LICENSE_GPL,
spider_i_s_alloc_mem_init,
spider_i_s_alloc_mem_deinit,
0x0001,
NULL,
NULL,
NULL,
#if MYSQL_VERSION_ID >= 50600
0,
#endif
};
storage/spider/spd_ping_table.cc
View file @ b5ebf1e2
/* Copyright (C) 2009-2013 Kentoku Shiba
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 */
#define MYSQL_SERVER 1
#include "mysql_version.h"
#if MYSQL_VERSION_ID < 50500
#include "mysql_priv.h"
#include <mysql/plugin.h>
#else
#include "sql_priv.h"
#include "probes_mysql.h"
#include "sql_class.h"
#include "sql_partition.h"
#include "sql_acl.h"
#endif
#include "spd_err.h"
#include "spd_param.h"
#include "spd_db_include.h"
#include "spd_include.h"
#include "ha_spider.h"
#include "spd_db_conn.h"
#include "spd_trx.h"
#include "spd_conn.h"
#include "spd_sys_table.h"
#include "spd_table.h"
#include "spd_ping_table.h"
#include "spd_direct_sql.h"
#include "spd_udf.h"
#include "spd_malloc.h"
extern handlerton *spider_hton_ptr;
#ifdef HAVE_PSI_INTERFACE
extern PSI_mutex_key spd_key_mutex_mon_list_caller;
extern PSI_mutex_key spd_key_mutex_mon_list_receptor;
extern PSI_mutex_key spd_key_mutex_mon_list_monitor;
extern PSI_mutex_key spd_key_mutex_mon_list_update_status;
extern PSI_mutex_key spd_key_mutex_mon_table_cache;
#endif
#ifndef WITHOUT_SPIDER_BG_SEARCH
extern pthread_mutex_t spider_global_trx_mutex;
extern SPIDER_TRX *spider_global_trx;
#endif
HASH *spider_udf_table_mon_list_hash;
uint spider_udf_table_mon_list_hash_id;
const char *spider_udf_table_mon_list_hash_func_name;
const char *spider_udf_table_mon_list_hash_file_name;
ulong spider_udf_table_mon_list_hash_line_no;
pthread_mutex_t *spider_udf_table_mon_mutexes;
pthread_cond_t *spider_udf_table_mon_conds;
pthread_mutex_t spider_mon_table_cache_mutex;
DYNAMIC_ARRAY spider_mon_table_cache;
uint spider_mon_table_cache_id;
const char *spider_mon_table_cache_func_name;
const char *spider_mon_table_cache_file_name;
ulong spider_mon_table_cache_line_no;
volatile ulonglong spider_mon_table_cache_version = 0;
volatile ulonglong spider_mon_table_cache_version_req = 1;
SPIDER_TABLE_MON_LIST *spider_get_ping_table_mon_list(
SPIDER_TRX *trx,
THD *thd,
spider_string *str,
uint conv_name_length,
int link_idx,
uint32 server_id,
bool need_lock,
int *error_num
) {
uint mutex_hash;
SPIDER_TABLE_MON_LIST *table_mon_list;
MEM_ROOT mem_root;
ulonglong mon_table_cache_version;
#ifdef SPIDER_HAS_HASH_VALUE_TYPE
my_hash_value_type hash_value;
#endif
DBUG_ENTER("spider_get_ping_table_mon_list");
if (spider_mon_table_cache_version != spider_mon_table_cache_version_req)
{
SPD_INIT_ALLOC_ROOT(&mem_root, 4096, 0, MYF(MY_WME));
if ((*error_num = spider_init_ping_table_mon_cache(thd, &mem_root,
need_lock)))
{
free_root(&mem_root, MYF(0));
goto error;
}
free_root(&mem_root, MYF(0));
}
mutex_hash = spider_udf_calc_hash(str->c_ptr(),
spider_param_udf_table_mon_mutex_count());
DBUG_PRINT("info",("spider hash key=%s", str->c_ptr()));
DBUG_PRINT("info",("spider hash key length=%u", str->length()));
#ifdef SPIDER_HAS_HASH_VALUE_TYPE
hash_value = my_calc_hash(
&spider_udf_table_mon_list_hash[mutex_hash],
(uchar*) str->c_ptr(), str->length());
#endif
pthread_mutex_lock(&spider_udf_table_mon_mutexes[mutex_hash]);
mon_table_cache_version = (ulonglong) spider_mon_table_cache_version;
#ifdef SPIDER_HAS_HASH_VALUE_TYPE
if (!(table_mon_list = (SPIDER_TABLE_MON_LIST *)
my_hash_search_using_hash_value(
&spider_udf_table_mon_list_hash[mutex_hash], hash_value,
(uchar*) str->c_ptr(), str->length())) ||
table_mon_list->mon_table_cache_version != mon_table_cache_version
)
#else
if (!(table_mon_list = (SPIDER_TABLE_MON_LIST *) my_hash_search(
&spider_udf_table_mon_list_hash[mutex_hash],
(uchar*) str->c_ptr(), str->length())) ||
table_mon_list->mon_table_cache_version != mon_table_cache_version
)
#endif
{
DBUG_ASSERT(trx != spider_global_trx);
if (
table_mon_list &&
table_mon_list->mon_table_cache_version != mon_table_cache_version
)
spider_release_ping_table_mon_list_loop(mutex_hash, table_mon_list);
if (!(table_mon_list = spider_get_ping_table_tgt(thd, str->c_ptr(),
conv_name_length, link_idx, server_id, str, need_lock, error_num)))
{
pthread_mutex_unlock(&spider_udf_table_mon_mutexes[mutex_hash]);
goto error;
}
table_mon_list->mutex_hash = mutex_hash;
table_mon_list->mon_table_cache_version = mon_table_cache_version;
uint old_elements =
spider_udf_table_mon_list_hash[mutex_hash].array.max_element;
#ifdef SPIDER_HAS_HASH_VALUE_TYPE
table_mon_list->key_hash_value = hash_value;
#endif
#ifdef HASH_UPDATE_WITH_HASH_VALUE
if (my_hash_insert_with_hash_value(
&spider_udf_table_mon_list_hash[mutex_hash],
hash_value, (uchar*) table_mon_list))
#else
if (my_hash_insert(&spider_udf_table_mon_list_hash[mutex_hash],
(uchar*) table_mon_list))
#endif
{
spider_ping_table_free_mon_list(table_mon_list);
*error_num = HA_ERR_OUT_OF_MEM;
my_error(HA_ERR_OUT_OF_MEM, MYF(0));
pthread_mutex_unlock(&spider_udf_table_mon_mutexes[mutex_hash]);
goto error;
}
if (spider_udf_table_mon_list_hash[mutex_hash].array.max_element >
old_elements)
{
spider_alloc_calc_mem(spider_current_trx,
spider_udf_table_mon_list_hash,
(spider_udf_table_mon_list_hash[mutex_hash].array.max_element -
old_elements) *
spider_udf_table_mon_list_hash[mutex_hash].array.size_of_element);
}
}
table_mon_list->use_count++;
DBUG_PRINT("info",("spider table_mon_list->use_count=%d",
table_mon_list->use_count));
pthread_mutex_unlock(&spider_udf_table_mon_mutexes[mutex_hash]);
DBUG_RETURN(table_mon_list);
error:
DBUG_RETURN(NULL);
}
void spider_free_ping_table_mon_list(
SPIDER_TABLE_MON_LIST *table_mon_list
) {
DBUG_ENTER("spider_free_ping_table_mon_list");
pthread_mutex_lock(&spider_udf_table_mon_mutexes[
table_mon_list->mutex_hash]);
table_mon_list->use_count--;
DBUG_PRINT("info",("spider table_mon_list->use_count=%d", table_mon_list->use_count));
if (!table_mon_list->use_count)
pthread_cond_broadcast(&spider_udf_table_mon_conds[
table_mon_list->mutex_hash]);
pthread_mutex_unlock(&spider_udf_table_mon_mutexes[
table_mon_list->mutex_hash]);
DBUG_VOID_RETURN;
}
void spider_release_ping_table_mon_list_loop(
uint mutex_hash,
SPIDER_TABLE_MON_LIST *table_mon_list
) {
DBUG_ENTER("spider_release_ping_table_mon_list_loop");
#ifdef HASH_UPDATE_WITH_HASH_VALUE
my_hash_delete_with_hash_value(&spider_udf_table_mon_list_hash[mutex_hash],
table_mon_list->key_hash_value, (uchar*) table_mon_list);
#else
my_hash_delete(&spider_udf_table_mon_list_hash[mutex_hash],
(uchar*) table_mon_list);
#endif
while (TRUE)
{
if (table_mon_list->use_count)
pthread_cond_wait(&spider_udf_table_mon_conds[mutex_hash],
&spider_udf_table_mon_mutexes[mutex_hash]);
else {
spider_ping_table_free_mon_list(table_mon_list);
break;
}
}
DBUG_VOID_RETURN;
}
void spider_release_ping_table_mon_list(
const char *conv_name,
uint conv_name_length,
int link_idx
) {
uint mutex_hash;
SPIDER_TABLE_MON_LIST *table_mon_list;
char link_idx_str[SPIDER_SQL_INT_LEN];
int link_idx_str_length;
DBUG_ENTER("spider_release_ping_table_mon_list");
DBUG_PRINT("info", ("spider conv_name=%s", conv_name));
DBUG_PRINT("info", ("spider conv_name_length=%u", conv_name_length));
DBUG_PRINT("info", ("spider link_idx=%d", link_idx));
link_idx_str_length = my_sprintf(link_idx_str, (link_idx_str, "%010d",
link_idx));
#ifdef _MSC_VER
spider_string conv_name_str(conv_name_length + link_idx_str_length + 1);
conv_name_str.set_charset(system_charset_info);
#else
char buf[conv_name_length + link_idx_str_length + 1];
spider_string conv_name_str(buf, conv_name_length + link_idx_str_length + 1,
system_charset_info);
#endif
conv_name_str.init_calc_mem(134);
conv_name_str.length(0);
conv_name_str.q_append(conv_name, conv_name_length);
conv_name_str.q_append(link_idx_str, link_idx_str_length);
mutex_hash = spider_udf_calc_hash(conv_name_str.c_ptr_safe(),
spider_param_udf_table_mon_mutex_count());
#ifdef SPIDER_HAS_HASH_VALUE_TYPE
my_hash_value_type hash_value = my_calc_hash(
&spider_udf_table_mon_list_hash[mutex_hash],
(uchar*) conv_name_str.c_ptr(), conv_name_str.length());
#endif
pthread_mutex_lock(&spider_udf_table_mon_mutexes[mutex_hash]);
#ifdef SPIDER_HAS_HASH_VALUE_TYPE
if ((table_mon_list = (SPIDER_TABLE_MON_LIST *)
my_hash_search_using_hash_value(
&spider_udf_table_mon_list_hash[mutex_hash], hash_value,
(uchar*) conv_name_str.c_ptr(), conv_name_str.length())))
#else
if ((table_mon_list = (SPIDER_TABLE_MON_LIST *) my_hash_search(
&spider_udf_table_mon_list_hash[mutex_hash],
(uchar*) conv_name_str.c_ptr(), conv_name_str.length())))
#endif
spider_release_ping_table_mon_list_loop(mutex_hash, table_mon_list);
pthread_mutex_unlock(&spider_udf_table_mon_mutexes[mutex_hash]);
DBUG_VOID_RETURN;
}
int spider_get_ping_table_mon(
THD *thd,
SPIDER_TABLE_MON_LIST *table_mon_list,
char *name,
uint name_length,
int link_idx,
uint32 server_id,
MEM_ROOT *mem_root,
bool need_lock
) {
int error_num;
TABLE *table_link_mon = NULL;
#if MYSQL_VERSION_ID < 50500
Open_tables_state open_tables_backup;
#else
Open_tables_backup open_tables_backup;
#endif
char table_key[MAX_KEY_LENGTH];
SPIDER_TABLE_MON *table_mon, *table_mon_prev = NULL;
SPIDER_SHARE *tmp_share;
char **tmp_connect_info, *tmp_ptr;
uint *tmp_connect_info_length;
long *tmp_long;
longlong *tmp_longlong;
int list_size = 0;
DBUG_ENTER("spider_get_ping_table_mon");
if (
!(table_link_mon = spider_open_sys_table(
thd, SPIDER_SYS_LINK_MON_TABLE_NAME_STR,
SPIDER_SYS_LINK_MON_TABLE_NAME_LEN, FALSE, &open_tables_backup,
need_lock, &error_num))
) {
my_error(error_num, MYF(0));
goto error;
}
spider_store_tables_name(table_link_mon, name, name_length);
spider_store_tables_link_idx(table_link_mon, link_idx);
if (!(error_num = spider_ping_table_cache_compare(table_link_mon, mem_root)))
goto create_table_mon;
if (error_num == HA_ERR_OUT_OF_MEM)
goto error;
if ((tmp_ptr = strstr(name, "#P#")))
{
*tmp_ptr = '\0';
spider_store_tables_name(table_link_mon, name, strlen(name));
*tmp_ptr = '#';
if (!(error_num = spider_ping_table_cache_compare(table_link_mon,
mem_root)))
goto create_table_mon;
if (error_num == HA_ERR_OUT_OF_MEM)
goto error;
}
error_num = HA_ERR_KEY_NOT_FOUND;
table_link_mon->file->print_error(error_num, MYF(0));
goto error;
create_table_mon:
if ((error_num = spider_get_sys_table_by_idx(table_link_mon, table_key,
table_link_mon->s->primary_key, 3)))
{
table_link_mon->file->print_error(error_num, MYF(0));
goto error;
}
do {
if (!(table_mon = (SPIDER_TABLE_MON *)
spider_bulk_malloc(spider_current_trx, 35, MYF(MY_WME | MY_ZEROFILL),
&table_mon, sizeof(SPIDER_TABLE_MON),
&tmp_share, sizeof(SPIDER_SHARE),
&tmp_connect_info, sizeof(char *) * SPIDER_TMP_SHARE_CHAR_PTR_COUNT,
&tmp_connect_info_length, sizeof(uint) * SPIDER_TMP_SHARE_UINT_COUNT,
&tmp_long, sizeof(long) * SPIDER_TMP_SHARE_LONG_COUNT,
&tmp_longlong, sizeof(longlong) * SPIDER_TMP_SHARE_LONGLONG_COUNT,
NullS))
) {
spider_sys_index_end(table_link_mon);
error_num = HA_ERR_OUT_OF_MEM;
my_error(HA_ERR_OUT_OF_MEM, MYF(0));
goto error;
}
spider_set_tmp_share_pointer(tmp_share, tmp_connect_info,
tmp_connect_info_length, tmp_long, tmp_longlong);
tmp_share->link_statuses[0] = -1;
table_mon->share = tmp_share;
if (table_mon_prev)
table_mon_prev->next = table_mon;
else
table_mon_list->first = table_mon;
table_mon_prev = table_mon;
if (
(error_num = spider_get_sys_link_mon_server_id(
table_link_mon, &table_mon->server_id, mem_root)) ||
(error_num = spider_get_sys_link_mon_connect_info(
table_link_mon, tmp_share, 0, mem_root))
) {
table_link_mon->file->print_error(error_num, MYF(0));
spider_sys_index_end(table_link_mon);
goto error;
}
if (
(error_num = spider_set_connect_info_default(
tmp_share,
#ifdef WITH_PARTITION_STORAGE_ENGINE
NULL,
NULL,
#endif
NULL
)) ||
(error_num = spider_set_connect_info_default_dbtable(
tmp_share, name, name_length
)) ||
(error_num = spider_create_conn_keys(tmp_share))
) {
spider_sys_index_end(table_link_mon);
goto error;
}
DBUG_PRINT("info",("spider table_mon->server_id=%u",
table_mon->server_id));
DBUG_PRINT("info",("spider server_id=%u", server_id));
if (table_mon->server_id == server_id)
table_mon_list->current = table_mon;
list_size++;
error_num = spider_sys_index_next_same(table_link_mon, table_key);
} while (error_num == 0);
spider_sys_index_end(table_link_mon);
spider_close_sys_table(thd, table_link_mon,
&open_tables_backup, need_lock);
table_link_mon = NULL;
table_mon_list->list_size = list_size;
if (!table_mon_list->current)
{
error_num = ER_SPIDER_UDF_PING_TABLE_NO_SERVER_ID_NUM;
my_printf_error(ER_SPIDER_UDF_PING_TABLE_NO_SERVER_ID_NUM,
ER_SPIDER_UDF_PING_TABLE_NO_SERVER_ID_STR, MYF(0));
goto error;
}
DBUG_RETURN(0);
error:
if (table_link_mon)
spider_close_sys_table(thd, table_link_mon,
&open_tables_backup, need_lock);
table_mon = table_mon_list->first;
table_mon_list->first = NULL;
table_mon_list->current = NULL;
while (table_mon)
{
spider_free_tmp_share_alloc(table_mon->share);
table_mon_prev = table_mon->next;
spider_free(spider_current_trx, table_mon, MYF(0));
table_mon = table_mon_prev;
}
DBUG_RETURN(error_num);
}
SPIDER_TABLE_MON_LIST *spider_get_ping_table_tgt(
THD *thd,
char *name,
uint name_length,
int link_idx,
uint32 server_id,
spider_string *str,
bool need_lock,
int *error_num
) {
TABLE *table_tables = NULL;
#if MYSQL_VERSION_ID < 50500
Open_tables_state open_tables_backup;
#else
Open_tables_backup open_tables_backup;
#endif
char table_key[MAX_KEY_LENGTH];
SPIDER_TABLE_MON_LIST *table_mon_list = NULL;
SPIDER_SHARE *tmp_share;
char **tmp_connect_info;
uint *tmp_connect_info_length;
long *tmp_long;
longlong *tmp_longlong;
char *key_str;
MEM_ROOT mem_root;
DBUG_ENTER("spider_get_ping_table_tgt");
SPD_INIT_ALLOC_ROOT(&mem_root, 4096, 0, MYF(MY_WME));
if (!(table_mon_list = (SPIDER_TABLE_MON_LIST *)
spider_bulk_malloc(spider_current_trx, 36, MYF(MY_WME | MY_ZEROFILL),
&table_mon_list, sizeof(SPIDER_TABLE_MON_LIST),
&tmp_share, sizeof(SPIDER_SHARE),
&tmp_connect_info, sizeof(char *) * SPIDER_TMP_SHARE_CHAR_PTR_COUNT,
&tmp_connect_info_length, sizeof(uint) * SPIDER_TMP_SHARE_UINT_COUNT,
&tmp_long, sizeof(long) * SPIDER_TMP_SHARE_LONG_COUNT,
&tmp_longlong, sizeof(longlong) * SPIDER_TMP_SHARE_LONGLONG_COUNT,
&key_str, str->length() + 1,
NullS))
) {
my_error(HA_ERR_OUT_OF_MEM, MYF(0));
goto error;
}
spider_set_tmp_share_pointer(tmp_share, tmp_connect_info,
tmp_connect_info_length, tmp_long, tmp_longlong);
table_mon_list->share = tmp_share;
table_mon_list->key = key_str;
table_mon_list->key_length = str->length();
memcpy(key_str, str->ptr(), table_mon_list->key_length);
tmp_share->access_charset = thd->variables.character_set_client;
if (
!(table_tables = spider_open_sys_table(
thd, SPIDER_SYS_TABLES_TABLE_NAME_STR,
SPIDER_SYS_TABLES_TABLE_NAME_LEN, FALSE, &open_tables_backup, need_lock,
error_num))
) {
my_error(*error_num, MYF(0));
goto error;
}
spider_store_tables_name(table_tables, name, name_length);
spider_store_tables_link_idx(table_tables, link_idx);
if (
(*error_num = spider_check_sys_table(table_tables, table_key)) ||
(*error_num = spider_get_sys_tables_connect_info(
table_tables, tmp_share, 0, &mem_root)) ||
(*error_num = spider_get_sys_tables_link_status(
table_tables, tmp_share, 0, &mem_root))
) {
table_tables->file->print_error(*error_num, MYF(0));
goto error;
}
spider_close_sys_table(thd, table_tables,
&open_tables_backup, need_lock);
table_tables = NULL;
if (
(*error_num = spider_set_connect_info_default(
tmp_share,
#ifdef WITH_PARTITION_STORAGE_ENGINE
NULL,
NULL,
#endif
NULL
)) ||
(*error_num = spider_set_connect_info_default_dbtable(
tmp_share, name, name_length
)) ||
(*error_num = spider_create_conn_keys(tmp_share)) ||
/*
(*error_num = spider_db_create_table_names_str(tmp_share)) ||
*/
(*error_num = spider_get_ping_table_mon(
thd, table_mon_list, name, name_length, link_idx, server_id, &mem_root,
need_lock))
)
goto error;
if (tmp_share->link_statuses[0] == SPIDER_LINK_STATUS_NG)
table_mon_list->mon_status = SPIDER_LINK_MON_NG;
#if MYSQL_VERSION_ID < 50500
if (pthread_mutex_init(&table_mon_list->caller_mutex, MY_MUTEX_INIT_FAST))
#else
if (mysql_mutex_init(spd_key_mutex_mon_list_caller,
&table_mon_list->caller_mutex, MY_MUTEX_INIT_FAST))
#endif
{
*error_num = HA_ERR_OUT_OF_MEM;
goto error_caller_mutex_init;
}
#if MYSQL_VERSION_ID < 50500
if (pthread_mutex_init(&table_mon_list->receptor_mutex, MY_MUTEX_INIT_FAST))
#else
if (mysql_mutex_init(spd_key_mutex_mon_list_receptor,
&table_mon_list->receptor_mutex, MY_MUTEX_INIT_FAST))
#endif
{
*error_num = HA_ERR_OUT_OF_MEM;
goto error_receptor_mutex_init;
}
#if MYSQL_VERSION_ID < 50500
if (pthread_mutex_init(&table_mon_list->monitor_mutex, MY_MUTEX_INIT_FAST))
#else
if (mysql_mutex_init(spd_key_mutex_mon_list_monitor,
&table_mon_list->monitor_mutex, MY_MUTEX_INIT_FAST))
#endif
{
*error_num = HA_ERR_OUT_OF_MEM;
goto error_monitor_mutex_init;
}
#if MYSQL_VERSION_ID < 50500
if (pthread_mutex_init(&table_mon_list->update_status_mutex,
MY_MUTEX_INIT_FAST))
#else
if (mysql_mutex_init(spd_key_mutex_mon_list_update_status,
&table_mon_list->update_status_mutex, MY_MUTEX_INIT_FAST))
#endif
{
*error_num = HA_ERR_OUT_OF_MEM;
goto error_update_status_mutex_init;
}
free_root(&mem_root, MYF(0));
DBUG_RETURN(table_mon_list);
error_update_status_mutex_init:
pthread_mutex_destroy(&table_mon_list->monitor_mutex);
error_monitor_mutex_init:
pthread_mutex_destroy(&table_mon_list->receptor_mutex);
error_receptor_mutex_init:
pthread_mutex_destroy(&table_mon_list->caller_mutex);
error_caller_mutex_init:
error:
if (table_tables)
spider_close_sys_table(thd, table_tables,
&open_tables_backup, need_lock);
free_root(&mem_root, MYF(0));
if (table_mon_list)
{
spider_free_tmp_share_alloc(table_mon_list->share);
spider_free(spider_current_trx, table_mon_list, MYF(0));
}
DBUG_RETURN(NULL);
}
SPIDER_CONN *spider_get_ping_table_tgt_conn(
SPIDER_TRX *trx,
SPIDER_SHARE *share,
int *error_num
) {
SPIDER_CONN *conn;
DBUG_ENTER("spider_get_ping_table_tgt_conn");
#ifndef WITHOUT_SPIDER_BG_SEARCH
if (trx == spider_global_trx)
pthread_mutex_lock(&spider_global_trx_mutex);
#endif
if (
!(conn = spider_get_conn(
share, 0, share->conn_keys[0], trx, NULL, FALSE, FALSE,
SPIDER_CONN_KIND_MYSQL, error_num))
) {
#ifndef WITHOUT_SPIDER_BG_SEARCH
if (trx == spider_global_trx)
pthread_mutex_unlock(&spider_global_trx_mutex);
#endif
my_error(ER_CONNECT_TO_FOREIGN_DATA_SOURCE, MYF(0),
share->server_names[0]);
*error_num = ER_CONNECT_TO_FOREIGN_DATA_SOURCE;
goto error;
}
conn->error_mode = 0;
#ifndef WITHOUT_SPIDER_BG_SEARCH
if (trx == spider_global_trx)
pthread_mutex_unlock(&spider_global_trx_mutex);
#endif
DBUG_RETURN(conn);
error:
DBUG_RETURN(NULL);
}
int spider_init_ping_table_mon_cache(
THD *thd,
MEM_ROOT *mem_root,
bool need_lock
) {
int error_num, same;
TABLE *table_link_mon = NULL;
#if MYSQL_VERSION_ID < 50500
Open_tables_state open_tables_backup;
#else
Open_tables_backup open_tables_backup;
#endif
SPIDER_MON_KEY mon_key;
DBUG_ENTER("spider_init_ping_table_mon_cache");
if (
!(table_link_mon = spider_open_sys_table(
thd, SPIDER_SYS_LINK_MON_TABLE_NAME_STR,
SPIDER_SYS_LINK_MON_TABLE_NAME_LEN, FALSE, &open_tables_backup,
need_lock, &error_num))
) {
my_error(error_num, MYF(0));
goto error_open_sys_table;
}
pthread_mutex_lock(&spider_mon_table_cache_mutex);
if (spider_mon_table_cache_version != spider_mon_table_cache_version_req)
{
/* reset */
spider_mon_table_cache.elements = 0;
if ((error_num = spider_sys_index_first(table_link_mon,
table_link_mon->s->primary_key)))
{
if (error_num != HA_ERR_KEY_NOT_FOUND && error_num != HA_ERR_END_OF_FILE)
{
table_link_mon->file->print_error(error_num, MYF(0));
goto error_sys_index_first;
}
}
if (!error_num)
{
mon_key.db_name_length = SPIDER_SYS_LINK_MON_TABLE_DB_NAME_SIZE + 1;
mon_key.table_name_length = SPIDER_SYS_LINK_MON_TABLE_TABLE_NAME_SIZE + 1;
mon_key.link_id_length = SPIDER_SYS_LINK_MON_TABLE_LINK_ID_SIZE + 1;
do {
if ((error_num = spider_get_sys_link_mon_key(table_link_mon, &mon_key,
mem_root, &same)))
goto error_get_sys_link_mon_key;
if (!same)
{
mon_key.sort = spider_calc_for_sort(3, mon_key.db_name,
mon_key.table_name, mon_key.link_id);
if (push_dynamic(&spider_mon_table_cache, (uchar *) &mon_key))
{
error_num = HA_ERR_OUT_OF_MEM;
goto error_push_dynamic;
}
}
if ((error_num = spider_sys_index_next(table_link_mon)))
{
if (
error_num != HA_ERR_KEY_NOT_FOUND &&
error_num != HA_ERR_END_OF_FILE
) {
table_link_mon->file->print_error(error_num, MYF(0));
goto error_sys_index_next;
}
}
} while (!error_num);
spider_sys_index_end(table_link_mon);
}
my_qsort(
(uchar *) dynamic_element(&spider_mon_table_cache, 0, SPIDER_MON_KEY *),
spider_mon_table_cache.elements, sizeof(SPIDER_MON_KEY),
(qsort_cmp) spider_compare_for_sort);
uint old_elements = spider_mon_table_cache.max_element;
freeze_size(&spider_mon_table_cache);
if (spider_mon_table_cache.max_element < old_elements)
{
spider_free_mem_calc(spider_current_trx,
spider_mon_table_cache_id,
spider_mon_table_cache.max_element *
spider_mon_table_cache.size_of_element);
}
spider_mon_table_cache_version = spider_mon_table_cache_version_req;
}
pthread_mutex_unlock(&spider_mon_table_cache_mutex);
spider_close_sys_table(thd, table_link_mon, &open_tables_backup, need_lock);
DBUG_RETURN(0);
error_push_dynamic:
error_get_sys_link_mon_key:
error_sys_index_next:
spider_sys_index_end(table_link_mon);
error_sys_index_first:
pthread_mutex_unlock(&spider_mon_table_cache_mutex);
spider_close_sys_table(thd, table_link_mon, &open_tables_backup, need_lock);
error_open_sys_table:
DBUG_RETURN(error_num);
}
int spider_ping_table_cache_compare(
TABLE *table,
MEM_ROOT *mem_root
) {
uint32 roop_count;
SPIDER_MON_KEY *mon_key;
char *db_name, *table_name, *link_id;
DBUG_ENTER("spider_ping_table_cache_compare");
if (
!(db_name = get_field(mem_root, table->field[0])) ||
!(table_name = get_field(mem_root, table->field[1])) ||
!(link_id = get_field(mem_root, table->field[2]))
)
DBUG_RETURN(HA_ERR_OUT_OF_MEM);
DBUG_PRINT("info", ("spider db_name=%s", db_name));
DBUG_PRINT("info", ("spider table_name=%s", table_name));
DBUG_PRINT("info", ("spider link_id=%s", link_id));
pthread_mutex_lock(&spider_mon_table_cache_mutex);
for (roop_count = 0; roop_count < spider_mon_table_cache.elements;
roop_count++)
{
mon_key = dynamic_element(&spider_mon_table_cache, roop_count,
SPIDER_MON_KEY *);
DBUG_PRINT("info", ("spider roop_count=%d", roop_count));
DBUG_PRINT("info", ("spider mon_key.db_name=%s", mon_key->db_name));
DBUG_PRINT("info", ("spider mon_key.table_name=%s", mon_key->table_name));
DBUG_PRINT("info", ("spider mon_key.link_id=%s", mon_key->link_id));
if (
!wild_case_compare(system_charset_info, db_name, mon_key->db_name) &&
!wild_case_compare(system_charset_info, table_name,
mon_key->table_name) &&
!wild_case_compare(system_charset_info, link_id, mon_key->link_id)
) {
spider_store_db_and_table_name(
table,
mon_key->db_name,
mon_key->db_name_length,
mon_key->table_name,
mon_key->table_name_length
);
spider_store_tables_link_idx_str(
table,
mon_key->link_id,
mon_key->link_id_length
);
pthread_mutex_unlock(&spider_mon_table_cache_mutex);
DBUG_PRINT("info", ("spider found"));
DBUG_RETURN(0);
}
}
pthread_mutex_unlock(&spider_mon_table_cache_mutex);
DBUG_PRINT("info", ("spider not found"));
DBUG_RETURN(1);
}
long long spider_ping_table_body(
UDF_INIT *initid,
UDF_ARGS *args,
char *is_null,
char *error
) {
int error_num = 0, link_idx, flags, full_mon_count, current_mon_count,
success_count, fault_count, tmp_error_num = 0;
uint32 first_sid;
longlong limit, tmp_sid = -1;
SPIDER_MON_TABLE_RESULT *mon_table_result =
(SPIDER_MON_TABLE_RESULT *) initid->ptr;
SPIDER_TRX *trx = mon_table_result->trx;
THD *thd = trx->thd;
SPIDER_CONN *ping_conn = NULL, *mon_conn;
char *where_clause;
SPIDER_TABLE_MON_LIST *table_mon_list;
SPIDER_TABLE_MON *table_mon;
char buf[MAX_FIELD_WIDTH];
spider_string conv_name(buf, sizeof(buf), system_charset_info);
int conv_name_length;
char link_idx_str[SPIDER_SQL_INT_LEN];
int link_idx_str_length;
bool get_lock = FALSE;
DBUG_ENTER("spider_ping_table_body");
conv_name.init_calc_mem(135);
conv_name.length(0);
if (
thd->open_tables != 0 ||
thd->handler_tables_hash.records != 0 ||
thd->derived_tables != 0 ||
thd->lock != 0 ||
#if MYSQL_VERSION_ID < 50500
thd->locked_tables != 0 ||
thd->prelocked_mode != NON_PRELOCKED
#else
thd->locked_tables_list.locked_tables() ||
thd->locked_tables_mode != LTM_NONE
#endif
) {
if (thd->open_tables != 0)
{
my_printf_error(ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_NUM,
ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_STR_WITH_PTR, MYF(0),
"thd->open_tables", thd->open_tables);
} else if (thd->handler_tables_hash.records != 0)
{
my_printf_error(ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_NUM,
ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_STR_WITH_NUM, MYF(0),
"thd->handler_tables_hash.records",
(longlong) thd->handler_tables_hash.records);
} else if (thd->derived_tables != 0)
{
my_printf_error(ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_NUM,
ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_STR_WITH_PTR, MYF(0),
"thd->derived_tables", thd->derived_tables);
} else if (thd->lock != 0)
{
my_printf_error(ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_NUM,
ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_STR_WITH_PTR, MYF(0),
"thd->lock", thd->lock);
#if MYSQL_VERSION_ID < 50500
} else if (thd->locked_tables != 0)
{
my_printf_error(ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_NUM,
ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_STR_WITH_PTR, MYF(0),
"thd->locked_tables", thd->locked_tables);
} else if (thd->prelocked_mode != NON_PRELOCKED)
{
my_printf_error(ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_NUM,
ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_STR_WITH_NUM, MYF(0),
"thd->prelocked_mode", (longlong) thd->prelocked_mode);
#else
} else if (thd->locked_tables_list.locked_tables())
{
my_printf_error(ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_NUM,
ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_STR_WITH_PTR, MYF(0),
"thd->locked_tables_list.locked_tables()",
thd->locked_tables_list.locked_tables());
} else if (thd->locked_tables_mode != LTM_NONE)
{
my_printf_error(ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_NUM,
ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_STR_WITH_NUM, MYF(0),
"thd->locked_tables_mode", (longlong) thd->locked_tables_mode);
#endif
}
goto error;
}
if (
args->lengths[0] > SPIDER_CONNECT_INFO_MAX_LEN
) {
my_printf_error(ER_SPIDER_UDF_PING_TABLE_PARAM_TOO_LONG_NUM,
ER_SPIDER_UDF_PING_TABLE_PARAM_TOO_LONG_STR, MYF(0));
goto error;
}
if (
args->lengths[0] == 0
) {
my_printf_error(ER_SPIDER_UDF_PING_TABLE_PARAM_REQIRED_NUM,
ER_SPIDER_UDF_PING_TABLE_PARAM_REQIRED_STR, MYF(0));
goto error;
}
link_idx = (int) (args->args[1] ? *((longlong *) args->args[1]) : 0);
flags = (int) (args->args[2] ? *((longlong *) args->args[2]) : 0);
limit = args->args[3] ? *((longlong *) args->args[3]) : 0;
where_clause = args->args[4] ? args->args[4] : (char *) "";
link_idx_str_length = my_sprintf(link_idx_str, (link_idx_str, "%010d",
link_idx));
if (conv_name.append(args->args[0], args->lengths[0],
trx->thd->variables.character_set_client))
{
my_error(HA_ERR_OUT_OF_MEM, MYF(0));
goto error;
}
conv_name_length = conv_name.length();
if (conv_name.reserve(link_idx_str_length + 1))
{
my_error(HA_ERR_OUT_OF_MEM, MYF(0));
goto error;
}
conv_name.q_append(link_idx_str, link_idx_str_length + 1);
conv_name.length(conv_name.length() - 1);
#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100002
if (!(table_mon_list = spider_get_ping_table_mon_list(trx, trx->thd,
&conv_name, conv_name_length, link_idx, global_system_variables.server_id,
TRUE, &error_num)))
#else
if (!(table_mon_list = spider_get_ping_table_mon_list(trx, trx->thd,
&conv_name, conv_name_length, link_idx, thd->server_id, TRUE, &error_num)))
#endif
goto error;
if (table_mon_list->mon_status == SPIDER_LINK_MON_NG)
{
mon_table_result->result_status = SPIDER_LINK_MON_NG;
DBUG_PRINT("info",
("spider mon_table_result->result_status=SPIDER_LINK_MON_NG 1"));
goto end;
}
if (args->args[5])
tmp_sid = *((longlong *) args->args[5]);
if (tmp_sid >= 0)
{
first_sid = (uint32) tmp_sid;
full_mon_count = (int) (args->args[6] ? *((longlong *) args->args[6]) : 0);
current_mon_count =
(int) (args->args[7] ? *((longlong *) args->args[7]) + 1 : 1);
if (full_mon_count != table_mon_list->list_size)
{
my_printf_error(ER_SPIDER_UDF_PING_TABLE_DIFFERENT_MON_NUM,
ER_SPIDER_UDF_PING_TABLE_DIFFERENT_MON_STR, MYF(0));
goto error_with_free_table_mon_list;
}
} else {
#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100002
first_sid = global_system_variables.server_id;
#else
first_sid = thd->server_id;
#endif
full_mon_count = table_mon_list->list_size;
current_mon_count = 1;
}
success_count = (int) (args->args[8] ? *((longlong *) args->args[8]) : 0);
fault_count = (int) (args->args[9] ? *((longlong *) args->args[9]) : 0);
if (
table_mon_list->mon_status != SPIDER_LINK_MON_NG &&
!(ping_conn = spider_get_ping_table_tgt_conn(trx,
table_mon_list->share, &error_num))
) {
if (error_num == HA_ERR_OUT_OF_MEM)
goto error_with_free_table_mon_list;
else
thd->clear_error();
}
if (
table_mon_list->mon_status == SPIDER_LINK_MON_NG ||
error_num ||
(tmp_error_num = spider_db_udf_ping_table(table_mon_list, table_mon_list->share, trx,
ping_conn, where_clause, args->lengths[4],
(flags & SPIDER_UDF_PING_TABLE_PING_ONLY),
(flags & SPIDER_UDF_PING_TABLE_USE_WHERE),
limit
))
) {
if (tmp_error_num == HA_ERR_OUT_OF_MEM)
goto error_with_free_table_mon_list;
else if(tmp_error_num)
thd->clear_error();
fault_count++;
error_num = 0;
if (fault_count > full_mon_count / 2)
{
mon_table_result->result_status = SPIDER_LINK_MON_NG;
DBUG_PRINT("info",("spider mon_table_result->result_status=SPIDER_LINK_MON_NG 2"));
if (table_mon_list->mon_status != SPIDER_LINK_MON_NG)
{
pthread_mutex_lock(&table_mon_list->update_status_mutex);
if (table_mon_list->mon_status != SPIDER_LINK_MON_NG)
{
table_mon_list->mon_status = SPIDER_LINK_MON_NG;
table_mon_list->share->link_statuses[0] = SPIDER_LINK_STATUS_NG;
spider_sys_update_tables_link_status(trx->thd,
conv_name.c_ptr(), conv_name_length, link_idx,
SPIDER_LINK_STATUS_NG, TRUE);
spider_sys_log_tables_link_failed(trx->thd,
conv_name.c_ptr(), conv_name_length, link_idx, TRUE);
}
pthread_mutex_unlock(&table_mon_list->update_status_mutex);
}
goto end;
}
} else {
success_count++;
if (success_count > full_mon_count / 2)
{
mon_table_result->result_status = SPIDER_LINK_MON_OK;
DBUG_PRINT("info",("spider mon_table_result->result_status=SPIDER_LINK_MON_OK 1"));
goto end;
}
}
if (tmp_sid < 0)
{
if (!pthread_mutex_trylock(&table_mon_list->receptor_mutex))
get_lock = TRUE;
}
if (
tmp_sid >= 0 ||
get_lock
) {
table_mon = table_mon_list->current->next;
while (TRUE)
{
if (!table_mon)
table_mon = table_mon_list->first;
if (
table_mon->server_id == first_sid ||
current_mon_count > full_mon_count
) {
if (success_count + fault_count > full_mon_count / 2)
{
mon_table_result->result_status = SPIDER_LINK_MON_DRAW;
DBUG_PRINT("info",(
"spider mon_table_result->result_status=SPIDER_LINK_MON_DRAW 1"));
} else {
mon_table_result->result_status = SPIDER_LINK_MON_DRAW_FEW_MON;
DBUG_PRINT("info",(
"spider mon_table_result->result_status=SPIDER_LINK_MON_DRAW_FEW_MON 1"));
}
table_mon_list->last_receptor_result = mon_table_result->result_status;
break;
}
if ((mon_conn = spider_get_ping_table_tgt_conn(trx,
table_mon->share, &error_num))
) {
if (!spider_db_udf_ping_table_mon_next(
thd, table_mon, mon_conn, mon_table_result, args->args[0],
args->lengths[0], link_idx,
where_clause, args->lengths[4], first_sid, full_mon_count,
current_mon_count, success_count, fault_count, flags, limit))
{
if (
mon_table_result->result_status == SPIDER_LINK_MON_NG &&
table_mon_list->mon_status != SPIDER_LINK_MON_NG
) {
pthread_mutex_lock(&table_mon_list->update_status_mutex);
if (table_mon_list->mon_status != SPIDER_LINK_MON_NG)
{
table_mon_list->mon_status = SPIDER_LINK_MON_NG;
table_mon_list->share->link_statuses[0] = SPIDER_LINK_STATUS_NG;
spider_sys_update_tables_link_status(trx->thd,
conv_name.c_ptr(), conv_name_length, link_idx,
SPIDER_LINK_STATUS_NG, TRUE);
spider_sys_log_tables_link_failed(trx->thd,
conv_name.c_ptr(), conv_name_length, link_idx, TRUE);
}
pthread_mutex_unlock(&table_mon_list->update_status_mutex);
}
table_mon_list->last_receptor_result =
mon_table_result->result_status;
break;
}
}
thd->clear_error();
table_mon = table_mon->next;
current_mon_count++;
}
if (get_lock)
pthread_mutex_unlock(&table_mon_list->receptor_mutex);
} else {
pthread_mutex_lock(&table_mon_list->receptor_mutex);
mon_table_result->result_status = table_mon_list->last_receptor_result;
DBUG_PRINT("info",("spider mon_table_result->result_status=%d 1",
table_mon_list->last_receptor_result));
pthread_mutex_unlock(&table_mon_list->receptor_mutex);
}
end:
spider_free_ping_table_mon_list(table_mon_list);
DBUG_RETURN(mon_table_result->result_status);
error_with_free_table_mon_list:
spider_free_ping_table_mon_list(table_mon_list);
error:
*error = 1;
DBUG_RETURN(0);
}
my_bool spider_ping_table_init_body(
UDF_INIT *initid,
UDF_ARGS *args,
char *message
) {
int error_num;
THD *thd = current_thd;
SPIDER_TRX *trx;
SPIDER_MON_TABLE_RESULT *mon_table_result = NULL;
DBUG_ENTER("spider_ping_table_init_body");
if (args->arg_count != 10)
{
strcpy(message, "spider_ping_table() requires 10 arguments");
goto error;
}
if (
args->arg_type[0] != STRING_RESULT ||
args->arg_type[4] != STRING_RESULT
) {
strcpy(message, "spider_ping_table() requires string 1st "
"and 5th arguments");
goto error;
}
if (
args->arg_type[1] != INT_RESULT ||
args->arg_type[2] != INT_RESULT ||
args->arg_type[3] != INT_RESULT ||
args->arg_type[5] != INT_RESULT ||
args->arg_type[6] != INT_RESULT ||
args->arg_type[7] != INT_RESULT ||
args->arg_type[8] != INT_RESULT ||
args->arg_type[9] != INT_RESULT
) {
strcpy(message, "spider_ping_table() requires integer 2nd, 3rd, 4,6,7,8,"
"9th and 10th argument");
goto error;
}
if (!(trx = spider_get_trx(thd, TRUE, &error_num)))
{
my_error(error_num, MYF(0));
strcpy(message, spider_stmt_da_message(thd));
goto error;
}
if (!(mon_table_result = (SPIDER_MON_TABLE_RESULT *)
spider_malloc(spider_current_trx, 11, sizeof(SPIDER_MON_TABLE_RESULT),
MYF(MY_WME | MY_ZEROFILL)))
) {
strcpy(message, "spider_ping_table() out of memory");
goto error;
}
mon_table_result->trx = trx;
initid->ptr = (char *) mon_table_result;
DBUG_RETURN(FALSE);
error:
if (mon_table_result)
{
spider_free(spider_current_trx, mon_table_result, MYF(0));
}
DBUG_RETURN(TRUE);
}
void spider_ping_table_deinit_body(
UDF_INIT *initid
) {
SPIDER_MON_TABLE_RESULT *mon_table_result =
(SPIDER_MON_TABLE_RESULT *) initid->ptr;
DBUG_ENTER("spider_ping_table_deinit_body");
if (mon_table_result)
{
spider_free(spider_current_trx, mon_table_result, MYF(0));
}
DBUG_VOID_RETURN;
}
long long spider_flush_table_mon_cache_body()
{
DBUG_ENTER("spider_flush_table_mon_cache_body");
spider_mon_table_cache_version_req++;
DBUG_RETURN(1);
}
void spider_ping_table_free_mon_list(
SPIDER_TABLE_MON_LIST *table_mon_list
) {
DBUG_ENTER("spider_ping_table_free_mon_list");
if (table_mon_list)
{
spider_ping_table_free_mon(table_mon_list->first);
spider_free_tmp_share_alloc(table_mon_list->share);
pthread_mutex_destroy(&table_mon_list->update_status_mutex);
pthread_mutex_destroy(&table_mon_list->monitor_mutex);
pthread_mutex_destroy(&table_mon_list->receptor_mutex);
pthread_mutex_destroy(&table_mon_list->caller_mutex);
spider_free(spider_current_trx, table_mon_list, MYF(0));
}
DBUG_VOID_RETURN;
}
void spider_ping_table_free_mon(
SPIDER_TABLE_MON *table_mon
) {
SPIDER_TABLE_MON *table_mon_next;
DBUG_ENTER("spider_ping_table_free_mon");
while (table_mon)
{
spider_free_tmp_share_alloc(table_mon->share);
table_mon_next = table_mon->next;
spider_free(spider_current_trx, table_mon, MYF(0));
table_mon = table_mon_next;
}
DBUG_VOID_RETURN;
}
int spider_ping_table_mon_from_table(
SPIDER_TRX *trx,
THD *thd,
SPIDER_SHARE *share,
uint32 server_id,
char *conv_name,
uint conv_name_length,
int link_idx,
char *where_clause,
uint where_clause_length,
long monitoring_kind,
longlong monitoring_limit,
bool need_lock
) {
int error_num = 0, current_mon_count, flags;
uint32 first_sid;
/*
THD *thd = trx->thd;
*/
SPIDER_TABLE_MON_LIST *table_mon_list;
SPIDER_TABLE_MON *table_mon;
SPIDER_MON_TABLE_RESULT mon_table_result;
SPIDER_CONN *mon_conn;
TABLE_SHARE *table_share = share->table_share;
char link_idx_str[SPIDER_SQL_INT_LEN];
int link_idx_str_length;
uint sql_command = thd_sql_command(thd);
DBUG_ENTER("spider_ping_table_mon_from_table");
if (table_share->tmp_table != NO_TMP_TABLE)
{
my_printf_error(ER_SPIDER_TMP_TABLE_MON_NUM,
ER_SPIDER_TMP_TABLE_MON_STR, MYF(0));
DBUG_RETURN(ER_SPIDER_TMP_TABLE_MON_NUM);
}
if (
sql_command == SQLCOM_DROP_TABLE ||
sql_command == SQLCOM_ALTER_TABLE
) {
my_printf_error(ER_SPIDER_MON_AT_ALTER_TABLE_NUM,
ER_SPIDER_MON_AT_ALTER_TABLE_STR, MYF(0));
DBUG_RETURN(ER_SPIDER_MON_AT_ALTER_TABLE_NUM);
}
link_idx_str_length = my_sprintf(link_idx_str, (link_idx_str, "%010d",
link_idx));
#ifdef _MSC_VER
spider_string conv_name_str(conv_name_length + link_idx_str_length + 1);
conv_name_str.set_charset(system_charset_info);
*((char *)(conv_name_str.ptr() + conv_name_length + link_idx_str_length)) =
'\0';
#else
char buf[conv_name_length + link_idx_str_length + 1];
buf[conv_name_length + link_idx_str_length] = '\0';
spider_string conv_name_str(buf, conv_name_length + link_idx_str_length + 1,
system_charset_info);
#endif
conv_name_str.init_calc_mem(136);
conv_name_str.length(0);
conv_name_str.q_append(conv_name, conv_name_length);
conv_name_str.q_append(link_idx_str, link_idx_str_length + 1);
conv_name_str.length(conv_name_str.length() - 1);
if (monitoring_kind == 1)
flags = SPIDER_UDF_PING_TABLE_PING_ONLY;
else if (monitoring_kind == 3)
flags = SPIDER_UDF_PING_TABLE_USE_WHERE;
else
flags = 0;
if (!(table_mon_list = spider_get_ping_table_mon_list(trx, thd,
&conv_name_str, conv_name_length, link_idx, server_id, need_lock,
&error_num)))
goto end;
if (table_mon_list->mon_status == SPIDER_LINK_MON_NG)
{
DBUG_PRINT("info",
("spider share->link_statuses[%d]=SPIDER_LINK_STATUS_NG", link_idx));
share->link_statuses[link_idx] = SPIDER_LINK_STATUS_NG;
error_num = ER_SPIDER_LINK_MON_NG_NUM;
my_printf_error(error_num,
ER_SPIDER_LINK_MON_NG_STR, MYF(0),
table_mon_list->share->tgt_dbs[0],
table_mon_list->share->tgt_table_names[0]);
goto end_with_free_table_mon_list;
}
if (!pthread_mutex_trylock(&table_mon_list->caller_mutex))
{
table_mon = table_mon_list->current;
first_sid = table_mon->server_id;
current_mon_count = 1;
while (TRUE)
{
if (!table_mon)
table_mon = table_mon_list->first;
if (
current_mon_count > table_mon_list->list_size ||
(current_mon_count > 1 && table_mon->server_id == first_sid)
) {
table_mon_list->last_caller_result = SPIDER_LINK_MON_DRAW_FEW_MON;
mon_table_result.result_status = SPIDER_LINK_MON_DRAW_FEW_MON;
DBUG_PRINT("info",(
"spider mon_table_result->result_status=SPIDER_LINK_MON_DRAW_FEW_MON 1"));
error_num = ER_SPIDER_LINK_MON_DRAW_FEW_MON_NUM;
my_printf_error(error_num,
ER_SPIDER_LINK_MON_DRAW_FEW_MON_STR, MYF(0),
table_mon_list->share->tgt_dbs[0],
table_mon_list->share->tgt_table_names[0]);
break;
}
thd->clear_error();
if ((mon_conn = spider_get_ping_table_tgt_conn(trx,
table_mon->share, &error_num))
) {
if (!spider_db_udf_ping_table_mon_next(
thd, table_mon, mon_conn, &mon_table_result, conv_name,
conv_name_length, link_idx,
where_clause, where_clause_length, -1, table_mon_list->list_size,
0, 0, 0, flags, monitoring_limit))
{
if (
mon_table_result.result_status == SPIDER_LINK_MON_NG &&
table_mon_list->mon_status != SPIDER_LINK_MON_NG
) {
pthread_mutex_lock(&table_mon_list->update_status_mutex);
if (table_mon_list->mon_status != SPIDER_LINK_MON_NG)
{
table_mon_list->mon_status = SPIDER_LINK_MON_NG;
table_mon_list->share->link_statuses[0] = SPIDER_LINK_STATUS_NG;
DBUG_PRINT("info", (
"spider share->link_statuses[%d]=SPIDER_LINK_STATUS_NG",
link_idx));
share->link_statuses[link_idx] = SPIDER_LINK_STATUS_NG;
spider_sys_update_tables_link_status(thd, conv_name,
conv_name_length, link_idx, SPIDER_LINK_STATUS_NG, need_lock);
spider_sys_log_tables_link_failed(thd, conv_name,
conv_name_length, link_idx, need_lock);
}
pthread_mutex_unlock(&table_mon_list->update_status_mutex);
}
table_mon_list->last_caller_result = mon_table_result.result_status;
if (mon_table_result.result_status == SPIDER_LINK_MON_OK)
{
error_num = ER_SPIDER_LINK_MON_OK_NUM;
my_printf_error(error_num,
ER_SPIDER_LINK_MON_OK_STR, MYF(0),
table_mon_list->share->tgt_dbs[0],
table_mon_list->share->tgt_table_names[0]);
break;
}
if (mon_table_result.result_status == SPIDER_LINK_MON_NG)
{
error_num = ER_SPIDER_LINK_MON_NG_NUM;
my_printf_error(error_num,
ER_SPIDER_LINK_MON_NG_STR, MYF(0),
table_mon_list->share->tgt_dbs[0],
table_mon_list->share->tgt_table_names[0]);
break;
}
if (mon_table_result.result_status ==
SPIDER_LINK_MON_DRAW_FEW_MON)
{
error_num = ER_SPIDER_LINK_MON_DRAW_FEW_MON_NUM;
my_printf_error(error_num,
ER_SPIDER_LINK_MON_DRAW_FEW_MON_STR, MYF(0),
table_mon_list->share->tgt_dbs[0],
table_mon_list->share->tgt_table_names[0]);
break;
}
error_num = ER_SPIDER_LINK_MON_DRAW_NUM;
my_printf_error(error_num,
ER_SPIDER_LINK_MON_DRAW_STR, MYF(0),
table_mon_list->share->tgt_dbs[0],
table_mon_list->share->tgt_table_names[0]);
break;
}
}
table_mon = table_mon->next;
current_mon_count++;
}
pthread_mutex_unlock(&table_mon_list->caller_mutex);
} else {
pthread_mutex_lock(&table_mon_list->caller_mutex);
switch (table_mon_list->last_caller_result)
{
case SPIDER_LINK_MON_OK:
error_num = ER_SPIDER_LINK_MON_OK_NUM;
my_printf_error(error_num,
ER_SPIDER_LINK_MON_OK_STR, MYF(0),
table_mon_list->share->tgt_dbs[0],
table_mon_list->share->tgt_table_names[0]);
break;
case SPIDER_LINK_MON_NG:
error_num = ER_SPIDER_LINK_MON_NG_NUM;
my_printf_error(error_num,
ER_SPIDER_LINK_MON_NG_STR, MYF(0),
table_mon_list->share->tgt_dbs[0],
table_mon_list->share->tgt_table_names[0]);
break;
case SPIDER_LINK_MON_DRAW_FEW_MON:
error_num = ER_SPIDER_LINK_MON_DRAW_FEW_MON_NUM;
my_printf_error(error_num,
ER_SPIDER_LINK_MON_DRAW_FEW_MON_STR, MYF(0),
table_mon_list->share->tgt_dbs[0],
table_mon_list->share->tgt_table_names[0]);
break;
default:
error_num = ER_SPIDER_LINK_MON_DRAW_NUM;
my_printf_error(error_num,
ER_SPIDER_LINK_MON_DRAW_STR, MYF(0),
table_mon_list->share->tgt_dbs[0],
table_mon_list->share->tgt_table_names[0]);
break;
}
pthread_mutex_unlock(&table_mon_list->caller_mutex);
}
end_with_free_table_mon_list:
spider_free_ping_table_mon_list(table_mon_list);
end:
DBUG_RETURN(error_num);
}
/* Copyright (C) 2009-2013 Kentoku Shiba
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 */
#define MYSQL_SERVER 1
#include "mysql_version.h"
#if MYSQL_VERSION_ID < 50500
#include "mysql_priv.h"
#include <mysql/plugin.h>
#else
#include "sql_priv.h"
#include "probes_mysql.h"
#include "sql_class.h"
#include "sql_partition.h"
#include "sql_acl.h"
#endif
#include "spd_err.h"
#include "spd_param.h"
#include "spd_db_include.h"
#include "spd_include.h"
#include "ha_spider.h"
#include "spd_db_conn.h"
#include "spd_trx.h"
#include "spd_conn.h"
#include "spd_sys_table.h"
#include "spd_table.h"
#include "spd_ping_table.h"
#include "spd_direct_sql.h"
#include "spd_udf.h"
#include "spd_malloc.h"
extern handlerton *spider_hton_ptr;
#ifdef HAVE_PSI_INTERFACE
extern PSI_mutex_key spd_key_mutex_mon_list_caller;
extern PSI_mutex_key spd_key_mutex_mon_list_receptor;
extern PSI_mutex_key spd_key_mutex_mon_list_monitor;
extern PSI_mutex_key spd_key_mutex_mon_list_update_status;
extern PSI_mutex_key spd_key_mutex_mon_table_cache;
#endif
#ifndef WITHOUT_SPIDER_BG_SEARCH
extern pthread_mutex_t spider_global_trx_mutex;
extern SPIDER_TRX *spider_global_trx;
#endif
HASH *spider_udf_table_mon_list_hash;
uint spider_udf_table_mon_list_hash_id;
const char *spider_udf_table_mon_list_hash_func_name;
const char *spider_udf_table_mon_list_hash_file_name;
ulong spider_udf_table_mon_list_hash_line_no;
pthread_mutex_t *spider_udf_table_mon_mutexes;
pthread_cond_t *spider_udf_table_mon_conds;
pthread_mutex_t spider_mon_table_cache_mutex;
DYNAMIC_ARRAY spider_mon_table_cache;
uint spider_mon_table_cache_id;
const char *spider_mon_table_cache_func_name;
const char *spider_mon_table_cache_file_name;
ulong spider_mon_table_cache_line_no;
volatile ulonglong spider_mon_table_cache_version = 0;
volatile ulonglong spider_mon_table_cache_version_req = 1;
SPIDER_TABLE_MON_LIST *spider_get_ping_table_mon_list(
SPIDER_TRX *trx,
THD *thd,
spider_string *str,
uint conv_name_length,
int link_idx,
uint32 server_id,
bool need_lock,
int *error_num
) {
uint mutex_hash;
SPIDER_TABLE_MON_LIST *table_mon_list;
MEM_ROOT mem_root;
ulonglong mon_table_cache_version;
#ifdef SPIDER_HAS_HASH_VALUE_TYPE
my_hash_value_type hash_value;
#endif
DBUG_ENTER("spider_get_ping_table_mon_list");
if (spider_mon_table_cache_version != spider_mon_table_cache_version_req)
{
SPD_INIT_ALLOC_ROOT(&mem_root, 4096, 0, MYF(MY_WME));
if ((*error_num = spider_init_ping_table_mon_cache(thd, &mem_root,
need_lock)))
{
free_root(&mem_root, MYF(0));
goto error;
}
free_root(&mem_root, MYF(0));
}
mutex_hash = spider_udf_calc_hash(str->c_ptr(),
spider_param_udf_table_mon_mutex_count());
DBUG_PRINT("info",("spider hash key=%s", str->c_ptr()));
DBUG_PRINT("info",("spider hash key length=%u", str->length()));
#ifdef SPIDER_HAS_HASH_VALUE_TYPE
hash_value = my_calc_hash(
&spider_udf_table_mon_list_hash[mutex_hash],
(uchar*) str->c_ptr(), str->length());
#endif
pthread_mutex_lock(&spider_udf_table_mon_mutexes[mutex_hash]);
mon_table_cache_version = (ulonglong) spider_mon_table_cache_version;
#ifdef SPIDER_HAS_HASH_VALUE_TYPE
if (!(table_mon_list = (SPIDER_TABLE_MON_LIST *)
my_hash_search_using_hash_value(
&spider_udf_table_mon_list_hash[mutex_hash], hash_value,
(uchar*) str->c_ptr(), str->length())) ||
table_mon_list->mon_table_cache_version != mon_table_cache_version
)
#else
if (!(table_mon_list = (SPIDER_TABLE_MON_LIST *) my_hash_search(
&spider_udf_table_mon_list_hash[mutex_hash],
(uchar*) str->c_ptr(), str->length())) ||
table_mon_list->mon_table_cache_version != mon_table_cache_version
)
#endif
{
DBUG_ASSERT(trx != spider_global_trx);
if (
table_mon_list &&
table_mon_list->mon_table_cache_version != mon_table_cache_version
)
spider_release_ping_table_mon_list_loop(mutex_hash, table_mon_list);
if (!(table_mon_list = spider_get_ping_table_tgt(thd, str->c_ptr(),
conv_name_length, link_idx, server_id, str, need_lock, error_num)))
{
pthread_mutex_unlock(&spider_udf_table_mon_mutexes[mutex_hash]);
goto error;
}
table_mon_list->mutex_hash = mutex_hash;
table_mon_list->mon_table_cache_version = mon_table_cache_version;
uint old_elements =
spider_udf_table_mon_list_hash[mutex_hash].array.max_element;
#ifdef SPIDER_HAS_HASH_VALUE_TYPE
table_mon_list->key_hash_value = hash_value;
#endif
#ifdef HASH_UPDATE_WITH_HASH_VALUE
if (my_hash_insert_with_hash_value(
&spider_udf_table_mon_list_hash[mutex_hash],
hash_value, (uchar*) table_mon_list))
#else
if (my_hash_insert(&spider_udf_table_mon_list_hash[mutex_hash],
(uchar*) table_mon_list))
#endif
{
spider_ping_table_free_mon_list(table_mon_list);
*error_num = HA_ERR_OUT_OF_MEM;
my_error(HA_ERR_OUT_OF_MEM, MYF(0));
pthread_mutex_unlock(&spider_udf_table_mon_mutexes[mutex_hash]);
goto error;
}
if (spider_udf_table_mon_list_hash[mutex_hash].array.max_element >
old_elements)
{
spider_alloc_calc_mem(spider_current_trx,
spider_udf_table_mon_list_hash,
(spider_udf_table_mon_list_hash[mutex_hash].array.max_element -
old_elements) *
spider_udf_table_mon_list_hash[mutex_hash].array.size_of_element);
}
}
table_mon_list->use_count++;
DBUG_PRINT("info",("spider table_mon_list->use_count=%d",
table_mon_list->use_count));
pthread_mutex_unlock(&spider_udf_table_mon_mutexes[mutex_hash]);
DBUG_RETURN(table_mon_list);
error:
DBUG_RETURN(NULL);
}
void spider_free_ping_table_mon_list(
SPIDER_TABLE_MON_LIST *table_mon_list
) {
DBUG_ENTER("spider_free_ping_table_mon_list");
pthread_mutex_lock(&spider_udf_table_mon_mutexes[
table_mon_list->mutex_hash]);
table_mon_list->use_count--;
DBUG_PRINT("info",("spider table_mon_list->use_count=%d", table_mon_list->use_count));
if (!table_mon_list->use_count)
pthread_cond_broadcast(&spider_udf_table_mon_conds[
table_mon_list->mutex_hash]);
pthread_mutex_unlock(&spider_udf_table_mon_mutexes[
table_mon_list->mutex_hash]);
DBUG_VOID_RETURN;
}
void spider_release_ping_table_mon_list_loop(
uint mutex_hash,
SPIDER_TABLE_MON_LIST *table_mon_list
) {
DBUG_ENTER("spider_release_ping_table_mon_list_loop");
#ifdef HASH_UPDATE_WITH_HASH_VALUE
my_hash_delete_with_hash_value(&spider_udf_table_mon_list_hash[mutex_hash],
table_mon_list->key_hash_value, (uchar*) table_mon_list);
#else
my_hash_delete(&spider_udf_table_mon_list_hash[mutex_hash],
(uchar*) table_mon_list);
#endif
while (TRUE)
{
if (table_mon_list->use_count)
pthread_cond_wait(&spider_udf_table_mon_conds[mutex_hash],
&spider_udf_table_mon_mutexes[mutex_hash]);
else {
spider_ping_table_free_mon_list(table_mon_list);
break;
}
}
DBUG_VOID_RETURN;
}
void spider_release_ping_table_mon_list(
const char *conv_name,
uint conv_name_length,
int link_idx
) {
uint mutex_hash;
SPIDER_TABLE_MON_LIST *table_mon_list;
char link_idx_str[SPIDER_SQL_INT_LEN];
int link_idx_str_length;
DBUG_ENTER("spider_release_ping_table_mon_list");
DBUG_PRINT("info", ("spider conv_name=%s", conv_name));
DBUG_PRINT("info", ("spider conv_name_length=%u", conv_name_length));
DBUG_PRINT("info", ("spider link_idx=%d", link_idx));
link_idx_str_length = my_sprintf(link_idx_str, (link_idx_str, "%010d",
link_idx));
#ifdef _MSC_VER
spider_string conv_name_str(conv_name_length + link_idx_str_length + 1);
conv_name_str.set_charset(system_charset_info);
#else
char buf[conv_name_length + link_idx_str_length + 1];
spider_string conv_name_str(buf, conv_name_length + link_idx_str_length + 1,
system_charset_info);
#endif
conv_name_str.init_calc_mem(134);
conv_name_str.length(0);
conv_name_str.q_append(conv_name, conv_name_length);
conv_name_str.q_append(link_idx_str, link_idx_str_length);
mutex_hash = spider_udf_calc_hash(conv_name_str.c_ptr_safe(),
spider_param_udf_table_mon_mutex_count());
#ifdef SPIDER_HAS_HASH_VALUE_TYPE
my_hash_value_type hash_value = my_calc_hash(
&spider_udf_table_mon_list_hash[mutex_hash],
(uchar*) conv_name_str.c_ptr(), conv_name_str.length());
#endif
pthread_mutex_lock(&spider_udf_table_mon_mutexes[mutex_hash]);
#ifdef SPIDER_HAS_HASH_VALUE_TYPE
if ((table_mon_list = (SPIDER_TABLE_MON_LIST *)
my_hash_search_using_hash_value(
&spider_udf_table_mon_list_hash[mutex_hash], hash_value,
(uchar*) conv_name_str.c_ptr(), conv_name_str.length())))
#else
if ((table_mon_list = (SPIDER_TABLE_MON_LIST *) my_hash_search(
&spider_udf_table_mon_list_hash[mutex_hash],
(uchar*) conv_name_str.c_ptr(), conv_name_str.length())))
#endif
spider_release_ping_table_mon_list_loop(mutex_hash, table_mon_list);
pthread_mutex_unlock(&spider_udf_table_mon_mutexes[mutex_hash]);
DBUG_VOID_RETURN;
}
int spider_get_ping_table_mon(
THD *thd,
SPIDER_TABLE_MON_LIST *table_mon_list,
char *name,
uint name_length,
int link_idx,
uint32 server_id,
MEM_ROOT *mem_root,
bool need_lock
) {
int error_num;
TABLE *table_link_mon = NULL;
#if MYSQL_VERSION_ID < 50500
Open_tables_state open_tables_backup;
#else
Open_tables_backup open_tables_backup;
#endif
char table_key[MAX_KEY_LENGTH];
SPIDER_TABLE_MON *table_mon, *table_mon_prev = NULL;
SPIDER_SHARE *tmp_share;
char **tmp_connect_info, *tmp_ptr;
uint *tmp_connect_info_length;
long *tmp_long;
longlong *tmp_longlong;
int list_size = 0;
DBUG_ENTER("spider_get_ping_table_mon");
if (
!(table_link_mon = spider_open_sys_table(
thd, SPIDER_SYS_LINK_MON_TABLE_NAME_STR,
SPIDER_SYS_LINK_MON_TABLE_NAME_LEN, FALSE, &open_tables_backup,
need_lock, &error_num))
) {
my_error(error_num, MYF(0));
goto error;
}
spider_store_tables_name(table_link_mon, name, name_length);
spider_store_tables_link_idx(table_link_mon, link_idx);
if (!(error_num = spider_ping_table_cache_compare(table_link_mon, mem_root)))
goto create_table_mon;
if (error_num == HA_ERR_OUT_OF_MEM)
goto error;
if ((tmp_ptr = strstr(name, "#P#")))
{
*tmp_ptr = '\0';
spider_store_tables_name(table_link_mon, name, strlen(name));
*tmp_ptr = '#';
if (!(error_num = spider_ping_table_cache_compare(table_link_mon,
mem_root)))
goto create_table_mon;
if (error_num == HA_ERR_OUT_OF_MEM)
goto error;
}
error_num = HA_ERR_KEY_NOT_FOUND;
table_link_mon->file->print_error(error_num, MYF(0));
goto error;
create_table_mon:
if ((error_num = spider_get_sys_table_by_idx(table_link_mon, table_key,
table_link_mon->s->primary_key, 3)))
{
table_link_mon->file->print_error(error_num, MYF(0));
goto error;
}
do {
if (!(table_mon = (SPIDER_TABLE_MON *)
spider_bulk_malloc(spider_current_trx, 35, MYF(MY_WME | MY_ZEROFILL),
&table_mon, sizeof(SPIDER_TABLE_MON),
&tmp_share, sizeof(SPIDER_SHARE),
&tmp_connect_info, sizeof(char *) * SPIDER_TMP_SHARE_CHAR_PTR_COUNT,
&tmp_connect_info_length, sizeof(uint) * SPIDER_TMP_SHARE_UINT_COUNT,
&tmp_long, sizeof(long) * SPIDER_TMP_SHARE_LONG_COUNT,
&tmp_longlong, sizeof(longlong) * SPIDER_TMP_SHARE_LONGLONG_COUNT,
NullS))
) {
spider_sys_index_end(table_link_mon);
error_num = HA_ERR_OUT_OF_MEM;
my_error(HA_ERR_OUT_OF_MEM, MYF(0));
goto error;
}
spider_set_tmp_share_pointer(tmp_share, tmp_connect_info,
tmp_connect_info_length, tmp_long, tmp_longlong);
tmp_share->link_statuses[0] = -1;
table_mon->share = tmp_share;
if (table_mon_prev)
table_mon_prev->next = table_mon;
else
table_mon_list->first = table_mon;
table_mon_prev = table_mon;
if (
(error_num = spider_get_sys_link_mon_server_id(
table_link_mon, &table_mon->server_id, mem_root)) ||
(error_num = spider_get_sys_link_mon_connect_info(
table_link_mon, tmp_share, 0, mem_root))
) {
table_link_mon->file->print_error(error_num, MYF(0));
spider_sys_index_end(table_link_mon);
goto error;
}
if (
(error_num = spider_set_connect_info_default(
tmp_share,
#ifdef WITH_PARTITION_STORAGE_ENGINE
NULL,
NULL,
#endif
NULL
)) ||
(error_num = spider_set_connect_info_default_dbtable(
tmp_share, name, name_length
)) ||
(error_num = spider_create_conn_keys(tmp_share))
) {
spider_sys_index_end(table_link_mon);
goto error;
}
DBUG_PRINT("info",("spider table_mon->server_id=%u",
table_mon->server_id));
DBUG_PRINT("info",("spider server_id=%u", server_id));
if (table_mon->server_id == server_id)
table_mon_list->current = table_mon;
list_size++;
error_num = spider_sys_index_next_same(table_link_mon, table_key);
} while (error_num == 0);
spider_sys_index_end(table_link_mon);
spider_close_sys_table(thd, table_link_mon,
&open_tables_backup, need_lock);
table_link_mon = NULL;
table_mon_list->list_size = list_size;
if (!table_mon_list->current)
{
error_num = ER_SPIDER_UDF_PING_TABLE_NO_SERVER_ID_NUM;
my_printf_error(ER_SPIDER_UDF_PING_TABLE_NO_SERVER_ID_NUM,
ER_SPIDER_UDF_PING_TABLE_NO_SERVER_ID_STR, MYF(0));
goto error;
}
DBUG_RETURN(0);
error:
if (table_link_mon)
spider_close_sys_table(thd, table_link_mon,
&open_tables_backup, need_lock);
table_mon = table_mon_list->first;
table_mon_list->first = NULL;
table_mon_list->current = NULL;
while (table_mon)
{
spider_free_tmp_share_alloc(table_mon->share);
table_mon_prev = table_mon->next;
spider_free(spider_current_trx, table_mon, MYF(0));
table_mon = table_mon_prev;
}
DBUG_RETURN(error_num);
}
SPIDER_TABLE_MON_LIST *spider_get_ping_table_tgt(
THD *thd,
char *name,
uint name_length,
int link_idx,
uint32 server_id,
spider_string *str,
bool need_lock,
int *error_num
) {
TABLE *table_tables = NULL;
#if MYSQL_VERSION_ID < 50500
Open_tables_state open_tables_backup;
#else
Open_tables_backup open_tables_backup;
#endif
char table_key[MAX_KEY_LENGTH];
SPIDER_TABLE_MON_LIST *table_mon_list = NULL;
SPIDER_SHARE *tmp_share;
char **tmp_connect_info;
uint *tmp_connect_info_length;
long *tmp_long;
longlong *tmp_longlong;
char *key_str;
MEM_ROOT mem_root;
DBUG_ENTER("spider_get_ping_table_tgt");
SPD_INIT_ALLOC_ROOT(&mem_root, 4096, 0, MYF(MY_WME));
if (!(table_mon_list = (SPIDER_TABLE_MON_LIST *)
spider_bulk_malloc(spider_current_trx, 36, MYF(MY_WME | MY_ZEROFILL),
&table_mon_list, sizeof(SPIDER_TABLE_MON_LIST),
&tmp_share, sizeof(SPIDER_SHARE),
&tmp_connect_info, sizeof(char *) * SPIDER_TMP_SHARE_CHAR_PTR_COUNT,
&tmp_connect_info_length, sizeof(uint) * SPIDER_TMP_SHARE_UINT_COUNT,
&tmp_long, sizeof(long) * SPIDER_TMP_SHARE_LONG_COUNT,
&tmp_longlong, sizeof(longlong) * SPIDER_TMP_SHARE_LONGLONG_COUNT,
&key_str, str->length() + 1,
NullS))
) {
my_error(HA_ERR_OUT_OF_MEM, MYF(0));
goto error;
}
spider_set_tmp_share_pointer(tmp_share, tmp_connect_info,
tmp_connect_info_length, tmp_long, tmp_longlong);
table_mon_list->share = tmp_share;
table_mon_list->key = key_str;
table_mon_list->key_length = str->length();
memcpy(key_str, str->ptr(), table_mon_list->key_length);
tmp_share->access_charset = thd->variables.character_set_client;
if (
!(table_tables = spider_open_sys_table(
thd, SPIDER_SYS_TABLES_TABLE_NAME_STR,
SPIDER_SYS_TABLES_TABLE_NAME_LEN, FALSE, &open_tables_backup, need_lock,
error_num))
) {
my_error(*error_num, MYF(0));
goto error;
}
spider_store_tables_name(table_tables, name, name_length);
spider_store_tables_link_idx(table_tables, link_idx);
if (
(*error_num = spider_check_sys_table(table_tables, table_key)) ||
(*error_num = spider_get_sys_tables_connect_info(
table_tables, tmp_share, 0, &mem_root)) ||
(*error_num = spider_get_sys_tables_link_status(
table_tables, tmp_share, 0, &mem_root))
) {
table_tables->file->print_error(*error_num, MYF(0));
goto error;
}
spider_close_sys_table(thd, table_tables,
&open_tables_backup, need_lock);
table_tables = NULL;
if (
(*error_num = spider_set_connect_info_default(
tmp_share,
#ifdef WITH_PARTITION_STORAGE_ENGINE
NULL,
NULL,
#endif
NULL
)) ||
(*error_num = spider_set_connect_info_default_dbtable(
tmp_share, name, name_length
)) ||
(*error_num = spider_create_conn_keys(tmp_share)) ||
/*
(*error_num = spider_db_create_table_names_str(tmp_share)) ||
*/
(*error_num = spider_get_ping_table_mon(
thd, table_mon_list, name, name_length, link_idx, server_id, &mem_root,
need_lock))
)
goto error;
if (tmp_share->link_statuses[0] == SPIDER_LINK_STATUS_NG)
table_mon_list->mon_status = SPIDER_LINK_MON_NG;
#if MYSQL_VERSION_ID < 50500
if (pthread_mutex_init(&table_mon_list->caller_mutex, MY_MUTEX_INIT_FAST))
#else
if (mysql_mutex_init(spd_key_mutex_mon_list_caller,
&table_mon_list->caller_mutex, MY_MUTEX_INIT_FAST))
#endif
{
*error_num = HA_ERR_OUT_OF_MEM;
goto error_caller_mutex_init;
}
#if MYSQL_VERSION_ID < 50500
if (pthread_mutex_init(&table_mon_list->receptor_mutex, MY_MUTEX_INIT_FAST))
#else
if (mysql_mutex_init(spd_key_mutex_mon_list_receptor,
&table_mon_list->receptor_mutex, MY_MUTEX_INIT_FAST))
#endif
{
*error_num = HA_ERR_OUT_OF_MEM;
goto error_receptor_mutex_init;
}
#if MYSQL_VERSION_ID < 50500
if (pthread_mutex_init(&table_mon_list->monitor_mutex, MY_MUTEX_INIT_FAST))
#else
if (mysql_mutex_init(spd_key_mutex_mon_list_monitor,
&table_mon_list->monitor_mutex, MY_MUTEX_INIT_FAST))
#endif
{
*error_num = HA_ERR_OUT_OF_MEM;
goto error_monitor_mutex_init;
}
#if MYSQL_VERSION_ID < 50500
if (pthread_mutex_init(&table_mon_list->update_status_mutex,
MY_MUTEX_INIT_FAST))
#else
if (mysql_mutex_init(spd_key_mutex_mon_list_update_status,
&table_mon_list->update_status_mutex, MY_MUTEX_INIT_FAST))
#endif
{
*error_num = HA_ERR_OUT_OF_MEM;
goto error_update_status_mutex_init;
}
free_root(&mem_root, MYF(0));
DBUG_RETURN(table_mon_list);
error_update_status_mutex_init:
pthread_mutex_destroy(&table_mon_list->monitor_mutex);
error_monitor_mutex_init:
pthread_mutex_destroy(&table_mon_list->receptor_mutex);
error_receptor_mutex_init:
pthread_mutex_destroy(&table_mon_list->caller_mutex);
error_caller_mutex_init:
error:
if (table_tables)
spider_close_sys_table(thd, table_tables,
&open_tables_backup, need_lock);
free_root(&mem_root, MYF(0));
if (table_mon_list)
{
spider_free_tmp_share_alloc(table_mon_list->share);
spider_free(spider_current_trx, table_mon_list, MYF(0));
}
DBUG_RETURN(NULL);
}
SPIDER_CONN *spider_get_ping_table_tgt_conn(
SPIDER_TRX *trx,
SPIDER_SHARE *share,
int *error_num
) {
SPIDER_CONN *conn;
DBUG_ENTER("spider_get_ping_table_tgt_conn");
#ifndef WITHOUT_SPIDER_BG_SEARCH
if (trx == spider_global_trx)
pthread_mutex_lock(&spider_global_trx_mutex);
#endif
if (
!(conn = spider_get_conn(
share, 0, share->conn_keys[0], trx, NULL, FALSE, FALSE,
SPIDER_CONN_KIND_MYSQL, error_num))
) {
#ifndef WITHOUT_SPIDER_BG_SEARCH
if (trx == spider_global_trx)
pthread_mutex_unlock(&spider_global_trx_mutex);
#endif
my_error(ER_CONNECT_TO_FOREIGN_DATA_SOURCE, MYF(0),
share->server_names[0]);
*error_num = ER_CONNECT_TO_FOREIGN_DATA_SOURCE;
goto error;
}
conn->error_mode = 0;
#ifndef WITHOUT_SPIDER_BG_SEARCH
if (trx == spider_global_trx)
pthread_mutex_unlock(&spider_global_trx_mutex);
#endif
DBUG_RETURN(conn);
error:
DBUG_RETURN(NULL);
}
int spider_init_ping_table_mon_cache(
THD *thd,
MEM_ROOT *mem_root,
bool need_lock
) {
int error_num, same;
TABLE *table_link_mon = NULL;
#if MYSQL_VERSION_ID < 50500
Open_tables_state open_tables_backup;
#else
Open_tables_backup open_tables_backup;
#endif
SPIDER_MON_KEY mon_key;
DBUG_ENTER("spider_init_ping_table_mon_cache");
if (
!(table_link_mon = spider_open_sys_table(
thd, SPIDER_SYS_LINK_MON_TABLE_NAME_STR,
SPIDER_SYS_LINK_MON_TABLE_NAME_LEN, FALSE, &open_tables_backup,
need_lock, &error_num))
) {
my_error(error_num, MYF(0));
goto error_open_sys_table;
}
pthread_mutex_lock(&spider_mon_table_cache_mutex);
if (spider_mon_table_cache_version != spider_mon_table_cache_version_req)
{
/* reset */
spider_mon_table_cache.elements = 0;
if ((error_num = spider_sys_index_first(table_link_mon,
table_link_mon->s->primary_key)))
{
if (error_num != HA_ERR_KEY_NOT_FOUND && error_num != HA_ERR_END_OF_FILE)
{
table_link_mon->file->print_error(error_num, MYF(0));
goto error_sys_index_first;
}
}
if (!error_num)
{
mon_key.db_name_length = SPIDER_SYS_LINK_MON_TABLE_DB_NAME_SIZE + 1;
mon_key.table_name_length = SPIDER_SYS_LINK_MON_TABLE_TABLE_NAME_SIZE + 1;
mon_key.link_id_length = SPIDER_SYS_LINK_MON_TABLE_LINK_ID_SIZE + 1;
do {
if ((error_num = spider_get_sys_link_mon_key(table_link_mon, &mon_key,
mem_root, &same)))
goto error_get_sys_link_mon_key;
if (!same)
{
mon_key.sort = spider_calc_for_sort(3, mon_key.db_name,
mon_key.table_name, mon_key.link_id);
if (push_dynamic(&spider_mon_table_cache, (uchar *) &mon_key))
{
error_num = HA_ERR_OUT_OF_MEM;
goto error_push_dynamic;
}
}
if ((error_num = spider_sys_index_next(table_link_mon)))
{
if (
error_num != HA_ERR_KEY_NOT_FOUND &&
error_num != HA_ERR_END_OF_FILE
) {
table_link_mon->file->print_error(error_num, MYF(0));
goto error_sys_index_next;
}
}
} while (!error_num);
spider_sys_index_end(table_link_mon);
}
my_qsort(
(uchar *) dynamic_element(&spider_mon_table_cache, 0, SPIDER_MON_KEY *),
spider_mon_table_cache.elements, sizeof(SPIDER_MON_KEY),
(qsort_cmp) spider_compare_for_sort);
uint old_elements = spider_mon_table_cache.max_element;
freeze_size(&spider_mon_table_cache);
if (spider_mon_table_cache.max_element < old_elements)
{
spider_free_mem_calc(spider_current_trx,
spider_mon_table_cache_id,
spider_mon_table_cache.max_element *
spider_mon_table_cache.size_of_element);
}
spider_mon_table_cache_version = spider_mon_table_cache_version_req;
}
pthread_mutex_unlock(&spider_mon_table_cache_mutex);
spider_close_sys_table(thd, table_link_mon, &open_tables_backup, need_lock);
DBUG_RETURN(0);
error_push_dynamic:
error_get_sys_link_mon_key:
error_sys_index_next:
spider_sys_index_end(table_link_mon);
error_sys_index_first:
pthread_mutex_unlock(&spider_mon_table_cache_mutex);
spider_close_sys_table(thd, table_link_mon, &open_tables_backup, need_lock);
error_open_sys_table:
DBUG_RETURN(error_num);
}
int spider_ping_table_cache_compare(
TABLE *table,
MEM_ROOT *mem_root
) {
uint32 roop_count;
SPIDER_MON_KEY *mon_key;
char *db_name, *table_name, *link_id;
DBUG_ENTER("spider_ping_table_cache_compare");
if (
!(db_name = get_field(mem_root, table->field[0])) ||
!(table_name = get_field(mem_root, table->field[1])) ||
!(link_id = get_field(mem_root, table->field[2]))
)
DBUG_RETURN(HA_ERR_OUT_OF_MEM);
DBUG_PRINT("info", ("spider db_name=%s", db_name));
DBUG_PRINT("info", ("spider table_name=%s", table_name));
DBUG_PRINT("info", ("spider link_id=%s", link_id));
pthread_mutex_lock(&spider_mon_table_cache_mutex);
for (roop_count = 0; roop_count < spider_mon_table_cache.elements;
roop_count++)
{
mon_key = dynamic_element(&spider_mon_table_cache, roop_count,
SPIDER_MON_KEY *);
DBUG_PRINT("info", ("spider roop_count=%d", roop_count));
DBUG_PRINT("info", ("spider mon_key.db_name=%s", mon_key->db_name));
DBUG_PRINT("info", ("spider mon_key.table_name=%s", mon_key->table_name));
DBUG_PRINT("info", ("spider mon_key.link_id=%s", mon_key->link_id));
if (
!wild_case_compare(system_charset_info, db_name, mon_key->db_name) &&
!wild_case_compare(system_charset_info, table_name,
mon_key->table_name) &&
!wild_case_compare(system_charset_info, link_id, mon_key->link_id)
) {
spider_store_db_and_table_name(
table,
mon_key->db_name,
mon_key->db_name_length,
mon_key->table_name,
mon_key->table_name_length
);
spider_store_tables_link_idx_str(
table,
mon_key->link_id,
mon_key->link_id_length
);
pthread_mutex_unlock(&spider_mon_table_cache_mutex);
DBUG_PRINT("info", ("spider found"));
DBUG_RETURN(0);
}
}
pthread_mutex_unlock(&spider_mon_table_cache_mutex);
DBUG_PRINT("info", ("spider not found"));
DBUG_RETURN(1);
}
long long spider_ping_table_body(
UDF_INIT *initid,
UDF_ARGS *args,
char *is_null,
char *error
) {
int error_num = 0, link_idx, flags, full_mon_count, current_mon_count,
success_count, fault_count, tmp_error_num = 0;
uint32 first_sid;
longlong limit, tmp_sid = -1;
SPIDER_MON_TABLE_RESULT *mon_table_result =
(SPIDER_MON_TABLE_RESULT *) initid->ptr;
SPIDER_TRX *trx = mon_table_result->trx;
THD *thd = trx->thd;
SPIDER_CONN *ping_conn = NULL, *mon_conn;
char *where_clause;
SPIDER_TABLE_MON_LIST *table_mon_list;
SPIDER_TABLE_MON *table_mon;
char buf[MAX_FIELD_WIDTH];
spider_string conv_name(buf, sizeof(buf), system_charset_info);
int conv_name_length;
char link_idx_str[SPIDER_SQL_INT_LEN];
int link_idx_str_length;
bool get_lock = FALSE;
DBUG_ENTER("spider_ping_table_body");
conv_name.init_calc_mem(135);
conv_name.length(0);
if (
thd->open_tables != 0 ||
thd->handler_tables_hash.records != 0 ||
thd->derived_tables != 0 ||
thd->lock != 0 ||
#if MYSQL_VERSION_ID < 50500
thd->locked_tables != 0 ||
thd->prelocked_mode != NON_PRELOCKED
#else
thd->locked_tables_list.locked_tables() ||
thd->locked_tables_mode != LTM_NONE
#endif
) {
if (thd->open_tables != 0)
{
my_printf_error(ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_NUM,
ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_STR_WITH_PTR, MYF(0),
"thd->open_tables", thd->open_tables);
} else if (thd->handler_tables_hash.records != 0)
{
my_printf_error(ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_NUM,
ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_STR_WITH_NUM, MYF(0),
"thd->handler_tables_hash.records",
(longlong) thd->handler_tables_hash.records);
} else if (thd->derived_tables != 0)
{
my_printf_error(ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_NUM,
ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_STR_WITH_PTR, MYF(0),
"thd->derived_tables", thd->derived_tables);
} else if (thd->lock != 0)
{
my_printf_error(ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_NUM,
ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_STR_WITH_PTR, MYF(0),
"thd->lock", thd->lock);
#if MYSQL_VERSION_ID < 50500
} else if (thd->locked_tables != 0)
{
my_printf_error(ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_NUM,
ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_STR_WITH_PTR, MYF(0),
"thd->locked_tables", thd->locked_tables);
} else if (thd->prelocked_mode != NON_PRELOCKED)
{
my_printf_error(ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_NUM,
ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_STR_WITH_NUM, MYF(0),
"thd->prelocked_mode", (longlong) thd->prelocked_mode);
#else
} else if (thd->locked_tables_list.locked_tables())
{
my_printf_error(ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_NUM,
ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_STR_WITH_PTR, MYF(0),
"thd->locked_tables_list.locked_tables()",
thd->locked_tables_list.locked_tables());
} else if (thd->locked_tables_mode != LTM_NONE)
{
my_printf_error(ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_NUM,
ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_STR_WITH_NUM, MYF(0),
"thd->locked_tables_mode", (longlong) thd->locked_tables_mode);
#endif
}
goto error;
}
if (
args->lengths[0] > SPIDER_CONNECT_INFO_MAX_LEN
) {
my_printf_error(ER_SPIDER_UDF_PING_TABLE_PARAM_TOO_LONG_NUM,
ER_SPIDER_UDF_PING_TABLE_PARAM_TOO_LONG_STR, MYF(0));
goto error;
}
if (
args->lengths[0] == 0
) {
my_printf_error(ER_SPIDER_UDF_PING_TABLE_PARAM_REQIRED_NUM,
ER_SPIDER_UDF_PING_TABLE_PARAM_REQIRED_STR, MYF(0));
goto error;
}
link_idx = (int) (args->args[1] ? *((longlong *) args->args[1]) : 0);
flags = (int) (args->args[2] ? *((longlong *) args->args[2]) : 0);
limit = args->args[3] ? *((longlong *) args->args[3]) : 0;
where_clause = args->args[4] ? args->args[4] : (char *) "";
link_idx_str_length = my_sprintf(link_idx_str, (link_idx_str, "%010d",
link_idx));
if (conv_name.append(args->args[0], args->lengths[0],
trx->thd->variables.character_set_client))
{
my_error(HA_ERR_OUT_OF_MEM, MYF(0));
goto error;
}
conv_name_length = conv_name.length();
if (conv_name.reserve(link_idx_str_length + 1))
{
my_error(HA_ERR_OUT_OF_MEM, MYF(0));
goto error;
}
conv_name.q_append(link_idx_str, link_idx_str_length + 1);
conv_name.length(conv_name.length() - 1);
#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100002
if (!(table_mon_list = spider_get_ping_table_mon_list(trx, trx->thd,
&conv_name, conv_name_length, link_idx, global_system_variables.server_id,
TRUE, &error_num)))
#else
if (!(table_mon_list = spider_get_ping_table_mon_list(trx, trx->thd,
&conv_name, conv_name_length, link_idx, thd->server_id, TRUE, &error_num)))
#endif
goto error;
if (table_mon_list->mon_status == SPIDER_LINK_MON_NG)
{
mon_table_result->result_status = SPIDER_LINK_MON_NG;
DBUG_PRINT("info",
("spider mon_table_result->result_status=SPIDER_LINK_MON_NG 1"));
goto end;
}
if (args->args[5])
tmp_sid = *((longlong *) args->args[5]);
if (tmp_sid >= 0)
{
first_sid = (uint32) tmp_sid;
full_mon_count = (int) (args->args[6] ? *((longlong *) args->args[6]) : 0);
current_mon_count =
(int) (args->args[7] ? *((longlong *) args->args[7]) + 1 : 1);
if (full_mon_count != table_mon_list->list_size)
{
my_printf_error(ER_SPIDER_UDF_PING_TABLE_DIFFERENT_MON_NUM,
ER_SPIDER_UDF_PING_TABLE_DIFFERENT_MON_STR, MYF(0));
goto error_with_free_table_mon_list;
}
} else {
#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100002
first_sid = global_system_variables.server_id;
#else
first_sid = thd->server_id;
#endif
full_mon_count = table_mon_list->list_size;
current_mon_count = 1;
}
success_count = (int) (args->args[8] ? *((longlong *) args->args[8]) : 0);
fault_count = (int) (args->args[9] ? *((longlong *) args->args[9]) : 0);
if (
table_mon_list->mon_status != SPIDER_LINK_MON_NG &&
!(ping_conn = spider_get_ping_table_tgt_conn(trx,
table_mon_list->share, &error_num))
) {
if (error_num == HA_ERR_OUT_OF_MEM)
goto error_with_free_table_mon_list;
else
thd->clear_error();
}
if (
table_mon_list->mon_status == SPIDER_LINK_MON_NG ||
error_num ||
(tmp_error_num = spider_db_udf_ping_table(table_mon_list, table_mon_list->share, trx,
ping_conn, where_clause, args->lengths[4],
(flags & SPIDER_UDF_PING_TABLE_PING_ONLY),
(flags & SPIDER_UDF_PING_TABLE_USE_WHERE),
limit
))
) {
if (tmp_error_num == HA_ERR_OUT_OF_MEM)
goto error_with_free_table_mon_list;
else if(tmp_error_num)
thd->clear_error();
fault_count++;
error_num = 0;
if (fault_count > full_mon_count / 2)
{
mon_table_result->result_status = SPIDER_LINK_MON_NG;
DBUG_PRINT("info",("spider mon_table_result->result_status=SPIDER_LINK_MON_NG 2"));
if (table_mon_list->mon_status != SPIDER_LINK_MON_NG)
{
pthread_mutex_lock(&table_mon_list->update_status_mutex);
if (table_mon_list->mon_status != SPIDER_LINK_MON_NG)
{
table_mon_list->mon_status = SPIDER_LINK_MON_NG;
table_mon_list->share->link_statuses[0] = SPIDER_LINK_STATUS_NG;
spider_sys_update_tables_link_status(trx->thd,
conv_name.c_ptr(), conv_name_length, link_idx,
SPIDER_LINK_STATUS_NG, TRUE);
spider_sys_log_tables_link_failed(trx->thd,
conv_name.c_ptr(), conv_name_length, link_idx, TRUE);
}
pthread_mutex_unlock(&table_mon_list->update_status_mutex);
}
goto end;
}
} else {
success_count++;
if (success_count > full_mon_count / 2)
{
mon_table_result->result_status = SPIDER_LINK_MON_OK;
DBUG_PRINT("info",("spider mon_table_result->result_status=SPIDER_LINK_MON_OK 1"));
goto end;
}
}
if (tmp_sid < 0)
{
if (!pthread_mutex_trylock(&table_mon_list->receptor_mutex))
get_lock = TRUE;
}
if (
tmp_sid >= 0 ||
get_lock
) {
table_mon = table_mon_list->current->next;
while (TRUE)
{
if (!table_mon)
table_mon = table_mon_list->first;
if (
table_mon->server_id == first_sid ||
current_mon_count > full_mon_count
) {
if (success_count + fault_count > full_mon_count / 2)
{
mon_table_result->result_status = SPIDER_LINK_MON_DRAW;
DBUG_PRINT("info",(
"spider mon_table_result->result_status=SPIDER_LINK_MON_DRAW 1"));
} else {
mon_table_result->result_status = SPIDER_LINK_MON_DRAW_FEW_MON;
DBUG_PRINT("info",(
"spider mon_table_result->result_status=SPIDER_LINK_MON_DRAW_FEW_MON 1"));
}
table_mon_list->last_receptor_result = mon_table_result->result_status;
break;
}
if ((mon_conn = spider_get_ping_table_tgt_conn(trx,
table_mon->share, &error_num))
) {
if (!spider_db_udf_ping_table_mon_next(
thd, table_mon, mon_conn, mon_table_result, args->args[0],
args->lengths[0], link_idx,
where_clause, args->lengths[4], first_sid, full_mon_count,
current_mon_count, success_count, fault_count, flags, limit))
{
if (
mon_table_result->result_status == SPIDER_LINK_MON_NG &&
table_mon_list->mon_status != SPIDER_LINK_MON_NG
) {
pthread_mutex_lock(&table_mon_list->update_status_mutex);
if (table_mon_list->mon_status != SPIDER_LINK_MON_NG)
{
table_mon_list->mon_status = SPIDER_LINK_MON_NG;
table_mon_list->share->link_statuses[0] = SPIDER_LINK_STATUS_NG;
spider_sys_update_tables_link_status(trx->thd,
conv_name.c_ptr(), conv_name_length, link_idx,
SPIDER_LINK_STATUS_NG, TRUE);
spider_sys_log_tables_link_failed(trx->thd,
conv_name.c_ptr(), conv_name_length, link_idx, TRUE);
}
pthread_mutex_unlock(&table_mon_list->update_status_mutex);
}
table_mon_list->last_receptor_result =
mon_table_result->result_status;
break;
}
}
thd->clear_error();
table_mon = table_mon->next;
current_mon_count++;
}
if (get_lock)
pthread_mutex_unlock(&table_mon_list->receptor_mutex);
} else {
pthread_mutex_lock(&table_mon_list->receptor_mutex);
mon_table_result->result_status = table_mon_list->last_receptor_result;
DBUG_PRINT("info",("spider mon_table_result->result_status=%d 1",
table_mon_list->last_receptor_result));
pthread_mutex_unlock(&table_mon_list->receptor_mutex);
}
end:
spider_free_ping_table_mon_list(table_mon_list);
DBUG_RETURN(mon_table_result->result_status);
error_with_free_table_mon_list:
spider_free_ping_table_mon_list(table_mon_list);
error:
*error = 1;
DBUG_RETURN(0);
}
my_bool spider_ping_table_init_body(
UDF_INIT *initid,
UDF_ARGS *args,
char *message
) {
int error_num;
THD *thd = current_thd;
SPIDER_TRX *trx;
SPIDER_MON_TABLE_RESULT *mon_table_result = NULL;
DBUG_ENTER("spider_ping_table_init_body");
if (args->arg_count != 10)
{
strcpy(message, "spider_ping_table() requires 10 arguments");
goto error;
}
if (
args->arg_type[0] != STRING_RESULT ||
args->arg_type[4] != STRING_RESULT
) {
strcpy(message, "spider_ping_table() requires string 1st "
"and 5th arguments");
goto error;
}
if (
args->arg_type[1] != INT_RESULT ||
args->arg_type[2] != INT_RESULT ||
args->arg_type[3] != INT_RESULT ||
args->arg_type[5] != INT_RESULT ||
args->arg_type[6] != INT_RESULT ||
args->arg_type[7] != INT_RESULT ||
args->arg_type[8] != INT_RESULT ||
args->arg_type[9] != INT_RESULT
) {
strcpy(message, "spider_ping_table() requires integer 2nd, 3rd, 4,6,7,8,"
"9th and 10th argument");
goto error;
}
if (!(trx = spider_get_trx(thd, TRUE, &error_num)))
{
my_error(error_num, MYF(0));
strcpy(message, spider_stmt_da_message(thd));
goto error;
}
if (!(mon_table_result = (SPIDER_MON_TABLE_RESULT *)
spider_malloc(spider_current_trx, 11, sizeof(SPIDER_MON_TABLE_RESULT),
MYF(MY_WME | MY_ZEROFILL)))
) {
strcpy(message, "spider_ping_table() out of memory");
goto error;
}
mon_table_result->trx = trx;
initid->ptr = (char *) mon_table_result;
DBUG_RETURN(FALSE);
error:
if (mon_table_result)
{
spider_free(spider_current_trx, mon_table_result, MYF(0));
}
DBUG_RETURN(TRUE);
}
void spider_ping_table_deinit_body(
UDF_INIT *initid
) {
SPIDER_MON_TABLE_RESULT *mon_table_result =
(SPIDER_MON_TABLE_RESULT *) initid->ptr;
DBUG_ENTER("spider_ping_table_deinit_body");
if (mon_table_result)
{
spider_free(spider_current_trx, mon_table_result, MYF(0));
}
DBUG_VOID_RETURN;
}
long long spider_flush_table_mon_cache_body()
{
DBUG_ENTER("spider_flush_table_mon_cache_body");
spider_mon_table_cache_version_req++;
DBUG_RETURN(1);
}
void spider_ping_table_free_mon_list(
SPIDER_TABLE_MON_LIST *table_mon_list
) {
DBUG_ENTER("spider_ping_table_free_mon_list");
if (table_mon_list)
{
spider_ping_table_free_mon(table_mon_list->first);
spider_free_tmp_share_alloc(table_mon_list->share);
pthread_mutex_destroy(&table_mon_list->update_status_mutex);
pthread_mutex_destroy(&table_mon_list->monitor_mutex);
pthread_mutex_destroy(&table_mon_list->receptor_mutex);
pthread_mutex_destroy(&table_mon_list->caller_mutex);
spider_free(spider_current_trx, table_mon_list, MYF(0));
}
DBUG_VOID_RETURN;
}
void spider_ping_table_free_mon(
SPIDER_TABLE_MON *table_mon
) {
SPIDER_TABLE_MON *table_mon_next;
DBUG_ENTER("spider_ping_table_free_mon");
while (table_mon)
{
spider_free_tmp_share_alloc(table_mon->share);
table_mon_next = table_mon->next;
spider_free(spider_current_trx, table_mon, MYF(0));
table_mon = table_mon_next;
}
DBUG_VOID_RETURN;
}
int spider_ping_table_mon_from_table(
SPIDER_TRX *trx,
THD *thd,
SPIDER_SHARE *share,
uint32 server_id,
char *conv_name,
uint conv_name_length,
int link_idx,
char *where_clause,
uint where_clause_length,
long monitoring_kind,
longlong monitoring_limit,
bool need_lock
) {
int error_num = 0, current_mon_count, flags;
uint32 first_sid;
/*
THD *thd = trx->thd;
*/
SPIDER_TABLE_MON_LIST *table_mon_list;
SPIDER_TABLE_MON *table_mon;
SPIDER_MON_TABLE_RESULT mon_table_result;
SPIDER_CONN *mon_conn;
TABLE_SHARE *table_share = share->table_share;
char link_idx_str[SPIDER_SQL_INT_LEN];
int link_idx_str_length;
uint sql_command = thd_sql_command(thd);
DBUG_ENTER("spider_ping_table_mon_from_table");
if (table_share->tmp_table != NO_TMP_TABLE)
{
my_printf_error(ER_SPIDER_TMP_TABLE_MON_NUM,
ER_SPIDER_TMP_TABLE_MON_STR, MYF(0));
DBUG_RETURN(ER_SPIDER_TMP_TABLE_MON_NUM);
}
if (
sql_command == SQLCOM_DROP_TABLE ||
sql_command == SQLCOM_ALTER_TABLE
) {
my_printf_error(ER_SPIDER_MON_AT_ALTER_TABLE_NUM,
ER_SPIDER_MON_AT_ALTER_TABLE_STR, MYF(0));
DBUG_RETURN(ER_SPIDER_MON_AT_ALTER_TABLE_NUM);
}
link_idx_str_length = my_sprintf(link_idx_str, (link_idx_str, "%010d",
link_idx));
#ifdef _MSC_VER
spider_string conv_name_str(conv_name_length + link_idx_str_length + 1);
conv_name_str.set_charset(system_charset_info);
*((char *)(conv_name_str.ptr() + conv_name_length + link_idx_str_length)) =
'\0';
#else
char buf[conv_name_length + link_idx_str_length + 1];
buf[conv_name_length + link_idx_str_length] = '\0';
spider_string conv_name_str(buf, conv_name_length + link_idx_str_length + 1,
system_charset_info);
#endif
conv_name_str.init_calc_mem(136);
conv_name_str.length(0);
conv_name_str.q_append(conv_name, conv_name_length);
conv_name_str.q_append(link_idx_str, link_idx_str_length + 1);
conv_name_str.length(conv_name_str.length() - 1);
if (monitoring_kind == 1)
flags = SPIDER_UDF_PING_TABLE_PING_ONLY;
else if (monitoring_kind == 3)
flags = SPIDER_UDF_PING_TABLE_USE_WHERE;
else
flags = 0;
if (!(table_mon_list = spider_get_ping_table_mon_list(trx, thd,
&conv_name_str, conv_name_length, link_idx, server_id, need_lock,
&error_num)))
goto end;
if (table_mon_list->mon_status == SPIDER_LINK_MON_NG)
{
DBUG_PRINT("info",
("spider share->link_statuses[%d]=SPIDER_LINK_STATUS_NG", link_idx));
share->link_statuses[link_idx] = SPIDER_LINK_STATUS_NG;
error_num = ER_SPIDER_LINK_MON_NG_NUM;
my_printf_error(error_num,
ER_SPIDER_LINK_MON_NG_STR, MYF(0),
table_mon_list->share->tgt_dbs[0],
table_mon_list->share->tgt_table_names[0]);
goto end_with_free_table_mon_list;
}
if (!pthread_mutex_trylock(&table_mon_list->caller_mutex))
{
table_mon = table_mon_list->current;
first_sid = table_mon->server_id;
current_mon_count = 1;
while (TRUE)
{
if (!table_mon)
table_mon = table_mon_list->first;
if (
current_mon_count > table_mon_list->list_size ||
(current_mon_count > 1 && table_mon->server_id == first_sid)
) {
table_mon_list->last_caller_result = SPIDER_LINK_MON_DRAW_FEW_MON;
mon_table_result.result_status = SPIDER_LINK_MON_DRAW_FEW_MON;
DBUG_PRINT("info",(
"spider mon_table_result->result_status=SPIDER_LINK_MON_DRAW_FEW_MON 1"));
error_num = ER_SPIDER_LINK_MON_DRAW_FEW_MON_NUM;
my_printf_error(error_num,
ER_SPIDER_LINK_MON_DRAW_FEW_MON_STR, MYF(0),
table_mon_list->share->tgt_dbs[0],
table_mon_list->share->tgt_table_names[0]);
break;
}
thd->clear_error();
if ((mon_conn = spider_get_ping_table_tgt_conn(trx,
table_mon->share, &error_num))
) {
if (!spider_db_udf_ping_table_mon_next(
thd, table_mon, mon_conn, &mon_table_result, conv_name,
conv_name_length, link_idx,
where_clause, where_clause_length, -1, table_mon_list->list_size,
0, 0, 0, flags, monitoring_limit))
{
if (
mon_table_result.result_status == SPIDER_LINK_MON_NG &&
table_mon_list->mon_status != SPIDER_LINK_MON_NG
) {
pthread_mutex_lock(&table_mon_list->update_status_mutex);
if (table_mon_list->mon_status != SPIDER_LINK_MON_NG)
{
table_mon_list->mon_status = SPIDER_LINK_MON_NG;
table_mon_list->share->link_statuses[0] = SPIDER_LINK_STATUS_NG;
DBUG_PRINT("info", (
"spider share->link_statuses[%d]=SPIDER_LINK_STATUS_NG",
link_idx));
share->link_statuses[link_idx] = SPIDER_LINK_STATUS_NG;
spider_sys_update_tables_link_status(thd, conv_name,
conv_name_length, link_idx, SPIDER_LINK_STATUS_NG, need_lock);
spider_sys_log_tables_link_failed(thd, conv_name,
conv_name_length, link_idx, need_lock);
}
pthread_mutex_unlock(&table_mon_list->update_status_mutex);
}
table_mon_list->last_caller_result = mon_table_result.result_status;
if (mon_table_result.result_status == SPIDER_LINK_MON_OK)
{
error_num = ER_SPIDER_LINK_MON_OK_NUM;
my_printf_error(error_num,
ER_SPIDER_LINK_MON_OK_STR, MYF(0),
table_mon_list->share->tgt_dbs[0],
table_mon_list->share->tgt_table_names[0]);
break;
}
if (mon_table_result.result_status == SPIDER_LINK_MON_NG)
{
error_num = ER_SPIDER_LINK_MON_NG_NUM;
my_printf_error(error_num,
ER_SPIDER_LINK_MON_NG_STR, MYF(0),
table_mon_list->share->tgt_dbs[0],
table_mon_list->share->tgt_table_names[0]);
break;
}
if (mon_table_result.result_status ==
SPIDER_LINK_MON_DRAW_FEW_MON)
{
error_num = ER_SPIDER_LINK_MON_DRAW_FEW_MON_NUM;
my_printf_error(error_num,
ER_SPIDER_LINK_MON_DRAW_FEW_MON_STR, MYF(0),
table_mon_list->share->tgt_dbs[0],
table_mon_list->share->tgt_table_names[0]);
break;
}
error_num = ER_SPIDER_LINK_MON_DRAW_NUM;
my_printf_error(error_num,
ER_SPIDER_LINK_MON_DRAW_STR, MYF(0),
table_mon_list->share->tgt_dbs[0],
table_mon_list->share->tgt_table_names[0]);
break;
}
}
table_mon = table_mon->next;
current_mon_count++;
}
pthread_mutex_unlock(&table_mon_list->caller_mutex);
} else {
pthread_mutex_lock(&table_mon_list->caller_mutex);
switch (table_mon_list->last_caller_result)
{
case SPIDER_LINK_MON_OK:
error_num = ER_SPIDER_LINK_MON_OK_NUM;
my_printf_error(error_num,
ER_SPIDER_LINK_MON_OK_STR, MYF(0),
table_mon_list->share->tgt_dbs[0],
table_mon_list->share->tgt_table_names[0]);
break;
case SPIDER_LINK_MON_NG:
error_num = ER_SPIDER_LINK_MON_NG_NUM;
my_printf_error(error_num,
ER_SPIDER_LINK_MON_NG_STR, MYF(0),
table_mon_list->share->tgt_dbs[0],
table_mon_list->share->tgt_table_names[0]);
break;
case SPIDER_LINK_MON_DRAW_FEW_MON:
error_num = ER_SPIDER_LINK_MON_DRAW_FEW_MON_NUM;
my_printf_error(error_num,
ER_SPIDER_LINK_MON_DRAW_FEW_MON_STR, MYF(0),
table_mon_list->share->tgt_dbs[0],
table_mon_list->share->tgt_table_names[0]);
break;
default:
error_num = ER_SPIDER_LINK_MON_DRAW_NUM;
my_printf_error(error_num,
ER_SPIDER_LINK_MON_DRAW_STR, MYF(0),
table_mon_list->share->tgt_dbs[0],
table_mon_list->share->tgt_table_names[0]);
break;
}
pthread_mutex_unlock(&table_mon_list->caller_mutex);
}
end_with_free_table_mon_list:
spider_free_ping_table_mon_list(table_mon_list);
end:
DBUG_RETURN(error_num);
}
storage/spider/spd_ping_table.h
View file @ b5ebf1e2
/* Copyright (C) 2009-2013 Kentoku Shiba
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 */
SPIDER_TABLE_MON_LIST *spider_get_ping_table_mon_list(
SPIDER_TRX *trx,
THD *thd,
spider_string *str,
uint conv_name_length,
int link_idx,
uint32 server_id,
bool need_lock,
int *error_num
);
void spider_free_ping_table_mon_list(
SPIDER_TABLE_MON_LIST *table_mon_list
);
void spider_release_ping_table_mon_list_loop(
uint mutex_hash,
SPIDER_TABLE_MON_LIST *table_mon_list
);
void spider_release_ping_table_mon_list(
const char *conv_name,
uint conv_name_length,
int link_idx
);
int spider_get_ping_table_mon(
THD *thd,
SPIDER_TABLE_MON_LIST *table_mon_list,
char *name,
uint name_length,
int link_idx,
uint32 server_id,
MEM_ROOT *mem_root,
bool need_lock
);
SPIDER_TABLE_MON_LIST *spider_get_ping_table_tgt(
THD *thd,
char *name,
uint name_length,
int link_idx,
uint32 server_id,
spider_string *str,
bool need_lock,
int *error_num
);
SPIDER_CONN *spider_get_ping_table_tgt_conn(
SPIDER_TRX *trx,
SPIDER_SHARE *share,
int *error_num
);
int spider_init_ping_table_mon_cache(
THD *thd,
MEM_ROOT *mem_root,
bool need_lock
);
int spider_ping_table_cache_compare(
TABLE *table,
MEM_ROOT *mem_root
);
void spider_ping_table_free_mon_list(
SPIDER_TABLE_MON_LIST *table_mon_list
);
void spider_ping_table_free_mon(
SPIDER_TABLE_MON *table_mon
);
int spider_ping_table_mon_from_table(
SPIDER_TRX *trx,
THD *thd,
SPIDER_SHARE *share,
uint32 server_id,
char *conv_name,
uint conv_name_length,
int link_idx,
char *where_clause,
uint where_clause_length,
long monitoring_kind,
longlong monitoring_limit,
bool need_lock
);
/* Copyright (C) 2009-2013 Kentoku Shiba
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 */
SPIDER_TABLE_MON_LIST *spider_get_ping_table_mon_list(
SPIDER_TRX *trx,
THD *thd,
spider_string *str,
uint conv_name_length,
int link_idx,
uint32 server_id,
bool need_lock,
int *error_num
);
void spider_free_ping_table_mon_list(
SPIDER_TABLE_MON_LIST *table_mon_list
);
void spider_release_ping_table_mon_list_loop(
uint mutex_hash,
SPIDER_TABLE_MON_LIST *table_mon_list
);
void spider_release_ping_table_mon_list(
const char *conv_name,
uint conv_name_length,
int link_idx
);
int spider_get_ping_table_mon(
THD *thd,
SPIDER_TABLE_MON_LIST *table_mon_list,
char *name,
uint name_length,
int link_idx,
uint32 server_id,
MEM_ROOT *mem_root,
bool need_lock
);
SPIDER_TABLE_MON_LIST *spider_get_ping_table_tgt(
THD *thd,
char *name,
uint name_length,
int link_idx,
uint32 server_id,
spider_string *str,
bool need_lock,
int *error_num
);
SPIDER_CONN *spider_get_ping_table_tgt_conn(
SPIDER_TRX *trx,
SPIDER_SHARE *share,
int *error_num
);
int spider_init_ping_table_mon_cache(
THD *thd,
MEM_ROOT *mem_root,
bool need_lock
);
int spider_ping_table_cache_compare(
TABLE *table,
MEM_ROOT *mem_root
);
void spider_ping_table_free_mon_list(
SPIDER_TABLE_MON_LIST *table_mon_list
);
void spider_ping_table_free_mon(
SPIDER_TABLE_MON *table_mon
);
int spider_ping_table_mon_from_table(
SPIDER_TRX *trx,
THD *thd,
SPIDER_SHARE *share,
uint32 server_id,
char *conv_name,
uint conv_name_length,
int link_idx,
char *where_clause,
uint where_clause_length,
long monitoring_kind,
longlong monitoring_limit,
bool need_lock
);
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7