diff options
Diffstat (limited to 'storage/spider/spd_table.cc')
| -rw-r--r-- | storage/spider/spd_table.cc | 10811 |
1 files changed, 10811 insertions, 0 deletions
diff --git a/storage/spider/spd_table.cc b/storage/spider/spd_table.cc new file mode 100644 index 00000000..8efa5d25 --- /dev/null +++ b/storage/spider/spd_table.cc @@ -0,0 +1,10811 @@ +/* Copyright (C) 2008-2020 Kentoku Shiba + Copyright (C) 2019-2020 MariaDB corp + + 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */ + +#define MYSQL_SERVER 1 +#include <my_global.h> +#include "mysql_version.h" +#include "spd_environ.h" +#if MYSQL_VERSION_ID < 50500 +#include "mysql_priv.h" +#include <mysql/plugin.h> +#else +#include "sql_priv.h" +#include "probes_mysql.h" +#include "my_getopt.h" +#include "sql_class.h" +#include "sql_partition.h" +#include "sql_servers.h" +#include "sql_select.h" +#include "tztime.h" +#include "sql_parse.h" +#endif +#include "spd_err.h" +#include "spd_param.h" +#include "spd_db_include.h" +#include "spd_include.h" +#include "spd_sys_table.h" +#include "ha_spider.h" +#include "spd_trx.h" +#include "spd_db_conn.h" +#include "spd_table.h" +#include "spd_conn.h" +#include "spd_ping_table.h" +#include "spd_direct_sql.h" +#include "spd_malloc.h" +#include "spd_group_by_handler.h" +#include "spd_init_query.h" + +/* Background thread management */ +#ifdef SPIDER_HAS_NEXT_THREAD_ID +#define SPIDER_set_next_thread_id(A) +MYSQL_THD create_thd(); +void destroy_thd(MYSQL_THD thd); +#else +ulong *spd_db_att_thread_id; +inline void SPIDER_set_next_thread_id(THD *A) +{ + pthread_mutex_lock(&LOCK_thread_count); + A->thread_id = (*spd_db_att_thread_id)++; + pthread_mutex_unlock(&LOCK_thread_count); +} +MYSQL_THD create_thd() +{ + THD *thd = SPIDER_new_THD(next_thread_id()); + if (thd) + { + thd->thread_stack = (char*) &thd; + thd->store_globals(); + thd->set_command(COM_DAEMON); + thd->security_ctx->host_or_ip = ""; + } + return thd; +} +void destroy_thd(MYSQL_THD thd) +{ + delete thd; +} +#endif +inline MYSQL_THD spider_create_sys_thd(SPIDER_THREAD *thread) +{ + THD *thd = create_thd(); + if (thd) + { + SPIDER_set_next_thread_id(thd); + thd->mysys_var->current_cond = &thread->cond; + thd->mysys_var->current_mutex = &thread->mutex; + } + return thd; +} +inline void spider_destroy_sys_thd(MYSQL_THD thd) +{ + destroy_thd(thd); +} +inline MYSQL_THD spider_create_thd() +{ + THD *thd; + my_thread_init(); + if (!(thd = new THD(next_thread_id()))) + my_thread_end(); + else + { +#ifdef HAVE_PSI_INTERFACE + mysql_thread_set_psi_id(thd->thread_id); +#endif + thd->thread_stack = (char *) &thd; + thd->store_globals(); + } + return thd; +} +inline void spider_destroy_thd(MYSQL_THD thd) +{ + delete thd; +} + +#ifdef SPIDER_XID_USES_xid_cache_iterate +#else +#ifdef XID_CACHE_IS_SPLITTED +uint *spd_db_att_xid_cache_split_num; +#endif +pthread_mutex_t *spd_db_att_LOCK_xid_cache; +HASH *spd_db_att_xid_cache; +#endif +struct charset_info_st *spd_charset_utf8mb3_bin; +const char **spd_defaults_extra_file; +const char **spd_defaults_file; +const char **spd_mysqld_unix_port; +uint *spd_mysqld_port; +bool volatile *spd_abort_loop; +Time_zone *spd_tz_system; +static int *spd_mysqld_server_started; +static pthread_mutex_t *spd_LOCK_server_started; +static pthread_cond_t *spd_COND_server_started; +extern long spider_conn_mutex_id; +handlerton *spider_hton_ptr; +SPIDER_DBTON spider_dbton[SPIDER_DBTON_SIZE]; +extern SPIDER_DBTON spider_dbton_mysql; +extern SPIDER_DBTON spider_dbton_mariadb; +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) +extern SPIDER_DBTON spider_dbton_handlersocket; +#endif +#ifdef HAVE_ORACLE_OCI +extern SPIDER_DBTON spider_dbton_oracle; +#endif +#ifndef WITHOUT_SPIDER_BG_SEARCH +SPIDER_THREAD *spider_table_sts_threads; +SPIDER_THREAD *spider_table_crd_threads; +#endif + +#ifdef HAVE_PSI_INTERFACE +PSI_mutex_key spd_key_mutex_tbl; +PSI_mutex_key spd_key_mutex_init_error_tbl; +#ifdef WITH_PARTITION_STORAGE_ENGINE +PSI_mutex_key spd_key_mutex_wide_share; +#endif +PSI_mutex_key spd_key_mutex_lgtm_tblhnd_share; +PSI_mutex_key spd_key_mutex_conn; +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) +PSI_mutex_key spd_key_mutex_hs_r_conn; +PSI_mutex_key spd_key_mutex_hs_w_conn; +#endif +PSI_mutex_key spd_key_mutex_open_conn; +PSI_mutex_key spd_key_mutex_allocated_thds; +PSI_mutex_key spd_key_mutex_mon_table_cache; +PSI_mutex_key spd_key_mutex_udf_table_mon; +PSI_mutex_key spd_key_mutex_mta_conn; +#ifndef WITHOUT_SPIDER_BG_SEARCH +PSI_mutex_key spd_key_mutex_bg_conn_chain; +PSI_mutex_key spd_key_mutex_bg_conn_sync; +PSI_mutex_key spd_key_mutex_bg_conn; +PSI_mutex_key spd_key_mutex_bg_job_stack; +PSI_mutex_key spd_key_mutex_bg_mon; +PSI_mutex_key spd_key_mutex_bg_direct_sql; +#endif +PSI_mutex_key spd_key_mutex_mon_list_caller; +PSI_mutex_key spd_key_mutex_mon_list_receptor; +PSI_mutex_key spd_key_mutex_mon_list_monitor; +PSI_mutex_key spd_key_mutex_mon_list_update_status; +PSI_mutex_key spd_key_mutex_share; +PSI_mutex_key spd_key_mutex_share_sts; +PSI_mutex_key spd_key_mutex_share_crd; +PSI_mutex_key spd_key_mutex_share_auto_increment; +#ifdef WITH_PARTITION_STORAGE_ENGINE +PSI_mutex_key spd_key_mutex_wide_share_sts; +PSI_mutex_key spd_key_mutex_wide_share_crd; +PSI_mutex_key spd_key_mutex_pt_handler; +#endif +PSI_mutex_key spd_key_mutex_udf_table; +PSI_mutex_key spd_key_mutex_mem_calc; +PSI_mutex_key spd_key_thread_id; +PSI_mutex_key spd_key_conn_id; +PSI_mutex_key spd_key_mutex_ipport_count; +PSI_mutex_key spd_key_mutex_conn_i; +#ifndef WITHOUT_SPIDER_BG_SEARCH +PSI_mutex_key spd_key_mutex_bg_stss; +PSI_mutex_key spd_key_mutex_bg_crds; +#endif +PSI_mutex_key spd_key_mutex_conn_loop_check; + +static PSI_mutex_info all_spider_mutexes[]= +{ + { &spd_key_mutex_tbl, "tbl", PSI_FLAG_GLOBAL}, + { &spd_key_mutex_init_error_tbl, "init_error_tbl", PSI_FLAG_GLOBAL}, +#ifdef WITH_PARTITION_STORAGE_ENGINE + { &spd_key_mutex_wide_share, "wide_share", PSI_FLAG_GLOBAL}, +#endif + { &spd_key_mutex_lgtm_tblhnd_share, "lgtm_tblhnd_share", PSI_FLAG_GLOBAL}, + { &spd_key_mutex_conn, "conn", PSI_FLAG_GLOBAL}, +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + { &spd_key_mutex_hs_r_conn, "hs_r_conn", PSI_FLAG_GLOBAL}, + { &spd_key_mutex_hs_w_conn, "hs_w_conn", PSI_FLAG_GLOBAL}, +#endif + { &spd_key_mutex_open_conn, "open_conn", PSI_FLAG_GLOBAL}, + { &spd_key_mutex_allocated_thds, "allocated_thds", PSI_FLAG_GLOBAL}, + { &spd_key_mutex_mon_table_cache, "mon_table_cache", PSI_FLAG_GLOBAL}, + { &spd_key_mutex_udf_table_mon, "udf_table_mon", PSI_FLAG_GLOBAL}, + { &spd_key_mutex_mem_calc, "mem_calc", PSI_FLAG_GLOBAL}, + { &spd_key_thread_id, "thread_id", PSI_FLAG_GLOBAL}, + { &spd_key_conn_id, "conn_id", PSI_FLAG_GLOBAL}, + { &spd_key_mutex_ipport_count, "ipport_count", PSI_FLAG_GLOBAL}, +#ifndef WITHOUT_SPIDER_BG_SEARCH + { &spd_key_mutex_bg_stss, "bg_stss", PSI_FLAG_GLOBAL}, + { &spd_key_mutex_bg_crds, "bg_crds", PSI_FLAG_GLOBAL}, +#endif + { &spd_key_mutex_conn_i, "conn_i", 0}, + { &spd_key_mutex_mta_conn, "mta_conn", 0}, +#ifndef WITHOUT_SPIDER_BG_SEARCH + { &spd_key_mutex_bg_conn_chain, "bg_conn_chain", 0}, + { &spd_key_mutex_bg_conn_sync, "bg_conn_sync", 0}, + { &spd_key_mutex_bg_conn, "bg_conn", 0}, + { &spd_key_mutex_bg_job_stack, "bg_job_stack", 0}, + { &spd_key_mutex_bg_mon, "bg_mon", 0}, + { &spd_key_mutex_bg_direct_sql, "bg_direct_sql", 0}, +#endif + { &spd_key_mutex_mon_list_caller, "mon_list_caller", 0}, + { &spd_key_mutex_mon_list_receptor, "mon_list_receptor", 0}, + { &spd_key_mutex_mon_list_monitor, "mon_list_monitor", 0}, + { &spd_key_mutex_mon_list_update_status, "mon_list_update_status", 0}, + { &spd_key_mutex_share, "share", 0}, + { &spd_key_mutex_share_sts, "share_sts", 0}, + { &spd_key_mutex_share_crd, "share_crd", 0}, + { &spd_key_mutex_share_auto_increment, "share_auto_increment", 0}, +#ifdef WITH_PARTITION_STORAGE_ENGINE + { &spd_key_mutex_wide_share_sts, "wide_share_sts", 0}, + { &spd_key_mutex_wide_share_crd, "wide_share_crd", 0}, + { &spd_key_mutex_pt_handler, "pt_handler", 0}, +#endif + { &spd_key_mutex_udf_table, "udf_table", 0}, + { &spd_key_mutex_conn_loop_check, "conn_loop_check", 0}, +}; + +#ifndef WITHOUT_SPIDER_BG_SEARCH +PSI_cond_key spd_key_cond_bg_conn_sync; +PSI_cond_key spd_key_cond_bg_conn; +PSI_cond_key spd_key_cond_bg_sts; +PSI_cond_key spd_key_cond_bg_sts_sync; +PSI_cond_key spd_key_cond_bg_crd; +PSI_cond_key spd_key_cond_bg_crd_sync; +PSI_cond_key spd_key_cond_bg_mon; +PSI_cond_key spd_key_cond_bg_mon_sleep; +PSI_cond_key spd_key_cond_bg_direct_sql; +#endif +PSI_cond_key spd_key_cond_udf_table_mon; +PSI_cond_key spd_key_cond_conn_i; +#ifndef WITHOUT_SPIDER_BG_SEARCH +PSI_cond_key spd_key_cond_bg_stss; +PSI_cond_key spd_key_cond_bg_sts_syncs; +PSI_cond_key spd_key_cond_bg_crds; +PSI_cond_key spd_key_cond_bg_crd_syncs; +#endif + +static PSI_cond_info all_spider_conds[] = { +#ifndef WITHOUT_SPIDER_BG_SEARCH + {&spd_key_cond_bg_conn_sync, "bg_conn_sync", 0}, + {&spd_key_cond_bg_conn, "bg_conn", 0}, + {&spd_key_cond_bg_sts, "bg_sts", 0}, + {&spd_key_cond_bg_sts_sync, "bg_sts_sync", 0}, + {&spd_key_cond_bg_crd, "bg_crd", 0}, + {&spd_key_cond_bg_crd_sync, "bg_crd_sync", 0}, + {&spd_key_cond_bg_mon, "bg_mon", 0}, + {&spd_key_cond_bg_mon_sleep, "bg_mon_sleep", 0}, + {&spd_key_cond_bg_direct_sql, "bg_direct_sql", 0}, +#endif + {&spd_key_cond_udf_table_mon, "udf_table_mon", 0}, + {&spd_key_cond_conn_i, "conn_i", 0}, +#ifndef WITHOUT_SPIDER_BG_SEARCH + {&spd_key_cond_bg_stss, "bg_stss", 0}, + {&spd_key_cond_bg_sts_syncs, "bg_sts_syncs", 0}, + {&spd_key_cond_bg_crds, "bg_crds", 0}, + {&spd_key_cond_bg_crd_syncs, "bg_crd_syncs", 0}, +#endif +}; + +#ifndef WITHOUT_SPIDER_BG_SEARCH +PSI_thread_key spd_key_thd_bg; +PSI_thread_key spd_key_thd_bg_sts; +PSI_thread_key spd_key_thd_bg_crd; +PSI_thread_key spd_key_thd_bg_mon; +PSI_thread_key spd_key_thd_bg_stss; +PSI_thread_key spd_key_thd_bg_crds; +#endif + +static PSI_thread_info all_spider_threads[] = { +#ifndef WITHOUT_SPIDER_BG_SEARCH + {&spd_key_thd_bg, "bg", 0}, + {&spd_key_thd_bg_sts, "bg_sts", 0}, + {&spd_key_thd_bg_crd, "bg_crd", 0}, + {&spd_key_thd_bg_mon, "bg_mon", 0}, + {&spd_key_thd_bg_stss, "bg_stss", 0}, + {&spd_key_thd_bg_crds, "bg_crds", 0}, +#endif +}; +#endif + +extern HASH spider_open_connections; +extern HASH spider_ipport_conns; +extern uint spider_open_connections_id; +extern const char *spider_open_connections_func_name; +extern const char *spider_open_connections_file_name; +extern ulong spider_open_connections_line_no; +extern pthread_mutex_t spider_conn_mutex; +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) +extern HASH spider_hs_r_conn_hash; +extern uint spider_hs_r_conn_hash_id; +extern const char *spider_hs_r_conn_hash_func_name; +extern const char *spider_hs_r_conn_hash_file_name; +extern ulong spider_hs_r_conn_hash_line_no; +extern pthread_mutex_t spider_hs_r_conn_mutex; +extern HASH spider_hs_w_conn_hash; +extern uint spider_hs_w_conn_hash_id; +extern const char *spider_hs_w_conn_hash_func_name; +extern const char *spider_hs_w_conn_hash_file_name; +extern ulong spider_hs_w_conn_hash_line_no; +extern pthread_mutex_t spider_hs_w_conn_mutex; +#endif +extern HASH *spider_udf_table_mon_list_hash; +extern uint spider_udf_table_mon_list_hash_id; +extern const char *spider_udf_table_mon_list_hash_func_name; +extern const char *spider_udf_table_mon_list_hash_file_name; +extern ulong spider_udf_table_mon_list_hash_line_no; +extern pthread_mutex_t *spider_udf_table_mon_mutexes; +extern pthread_cond_t *spider_udf_table_mon_conds; +extern pthread_mutex_t spider_open_conn_mutex; +extern pthread_mutex_t spider_mon_table_cache_mutex; +extern DYNAMIC_ARRAY spider_mon_table_cache; +extern uint spider_mon_table_cache_id; +extern const char *spider_mon_table_cache_func_name; +extern const char *spider_mon_table_cache_file_name; +extern ulong spider_mon_table_cache_line_no; + +HASH spider_open_tables; +uint spider_open_tables_id; +const char *spider_open_tables_func_name; +const char *spider_open_tables_file_name; +ulong spider_open_tables_line_no; +pthread_mutex_t spider_tbl_mutex; +HASH spider_init_error_tables; +uint spider_init_error_tables_id; +const char *spider_init_error_tables_func_name; +const char *spider_init_error_tables_file_name; +ulong spider_init_error_tables_line_no; +pthread_mutex_t spider_init_error_tbl_mutex; + +extern pthread_mutex_t spider_thread_id_mutex; +extern pthread_mutex_t spider_conn_id_mutex; +extern pthread_mutex_t spider_ipport_conn_mutex; + +#ifdef WITH_PARTITION_STORAGE_ENGINE +HASH spider_open_wide_share; +uint spider_open_wide_share_id; +const char *spider_open_wide_share_func_name; +const char *spider_open_wide_share_file_name; +ulong spider_open_wide_share_line_no; +pthread_mutex_t spider_wide_share_mutex; +#endif + +HASH spider_lgtm_tblhnd_share_hash; +uint spider_lgtm_tblhnd_share_hash_id; +const char *spider_lgtm_tblhnd_share_hash_func_name; +const char *spider_lgtm_tblhnd_share_hash_file_name; +ulong spider_lgtm_tblhnd_share_hash_line_no; +pthread_mutex_t spider_lgtm_tblhnd_share_mutex; + +HASH spider_allocated_thds; +uint spider_allocated_thds_id; +const char *spider_allocated_thds_func_name; +const char *spider_allocated_thds_file_name; +ulong spider_allocated_thds_line_no; +pthread_mutex_t spider_allocated_thds_mutex; + +#ifndef WITHOUT_SPIDER_BG_SEARCH +pthread_attr_t spider_pt_attr; +#endif + +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 char spider_wild_many = '%', spider_wild_one = '_', + spider_wild_prefix='\\'; + +static char spider_unique_id_buf[1 + 12 + 1 + (16 * 2) + 1 + 1]; +LEX_CSTRING spider_unique_id; + +// for spider_open_tables +uchar *spider_tbl_get_key( + SPIDER_SHARE *share, + size_t *length, + my_bool not_used __attribute__ ((unused)) +) { + DBUG_ENTER("spider_tbl_get_key"); + *length = share->table_name_length; + DBUG_RETURN((uchar*) share->table_name); +} + +uchar *spider_wide_share_get_key( + SPIDER_WIDE_SHARE *share, + size_t *length, + my_bool not_used __attribute__ ((unused)) +) { + DBUG_ENTER("spider_wide_share_get_key"); + *length = share->table_name_length; + DBUG_RETURN((uchar*) share->table_name); +} + +#ifdef WITH_PARTITION_STORAGE_ENGINE +uchar *spider_pt_handler_share_get_key( + SPIDER_PARTITION_HANDLER_SHARE *share, + size_t *length, + my_bool not_used __attribute__ ((unused)) +) { + DBUG_ENTER("spider_pt_handler_share_get_key"); + *length = sizeof(ha_spider *); + DBUG_RETURN((uchar*) share->owner); +} +#endif + +uchar *spider_lgtm_tblhnd_share_hash_get_key( + SPIDER_LGTM_TBLHND_SHARE *share, + size_t *length, + my_bool not_used __attribute__ ((unused)) +) { + DBUG_ENTER("spider_lgtm_tblhnd_share_hash_get_key"); + *length = share->table_name_length; + DBUG_RETURN((uchar*) share->table_name); +} + +uchar *spider_link_get_key( + SPIDER_LINK_FOR_HASH *link_for_hash, + size_t *length, + my_bool not_used __attribute__ ((unused)) +) { + DBUG_ENTER("spider_link_get_key"); + *length = link_for_hash->db_table_str->length(); + DBUG_RETURN((uchar*) link_for_hash->db_table_str->ptr()); +} + +uchar *spider_ha_get_key( + ha_spider *spider, + size_t *length, + my_bool not_used __attribute__ ((unused)) +) { + DBUG_ENTER("spider_ha_get_key"); + *length = spider->share->table_name_length; + DBUG_RETURN((uchar*) spider->share->table_name); +} + +uchar *spider_udf_tbl_mon_list_key( + SPIDER_TABLE_MON_LIST *table_mon_list, + size_t *length, + my_bool not_used __attribute__ ((unused)) +) { + DBUG_ENTER("spider_udf_tbl_mon_list_key"); + DBUG_PRINT("info",("spider hash key=%s", table_mon_list->key)); + DBUG_PRINT("info",("spider hash key length=%u", table_mon_list->key_length)); + *length = table_mon_list->key_length; + DBUG_RETURN((uchar*) table_mon_list->key); +} + +uchar *spider_allocated_thds_get_key( + THD *thd, + size_t *length, + my_bool not_used __attribute__ ((unused)) +) { + DBUG_ENTER("spider_allocated_thds_get_key"); + *length = sizeof(THD *); + DBUG_RETURN((uchar*) thd); +} + +#ifdef HAVE_PSI_INTERFACE +static void init_spider_psi_keys() +{ + DBUG_ENTER("init_spider_psi_keys"); + if (PSI_server == NULL) + DBUG_VOID_RETURN; + + PSI_server->register_mutex("spider", all_spider_mutexes, + array_elements(all_spider_mutexes)); + PSI_server->register_cond("spider", all_spider_conds, + array_elements(all_spider_conds)); + PSI_server->register_thread("spider", all_spider_threads, + array_elements(all_spider_threads)); + DBUG_VOID_RETURN; +} +#endif + +int spider_get_server( + SPIDER_SHARE *share, + int link_idx +) { + MEM_ROOT mem_root; + int error_num, length; + FOREIGN_SERVER *server, server_buf; + DBUG_ENTER("spider_get_server"); + SPD_INIT_ALLOC_ROOT(&mem_root, 128, 0, MYF(MY_WME)); + + if (!(server + = get_server_by_name(&mem_root, share->server_names[link_idx], + &server_buf))) + { + error_num = ER_FOREIGN_SERVER_DOESNT_EXIST; + goto error; + } + + if (!share->tgt_wrappers[link_idx] && server->scheme) + { + share->tgt_wrappers_lengths[link_idx] = strlen(server->scheme); + if (!(share->tgt_wrappers[link_idx] = + spider_create_string(server->scheme, + share->tgt_wrappers_lengths[link_idx]))) + { + error_num = HA_ERR_OUT_OF_MEM; + goto error; + } + DBUG_PRINT("info",("spider tgt_wrappers=%s", + share->tgt_wrappers[link_idx])); + } + + if (!share->tgt_hosts[link_idx] && server->host) + { + share->tgt_hosts_lengths[link_idx] = strlen(server->host); + if (!(share->tgt_hosts[link_idx] = + spider_create_string(server->host, share->tgt_hosts_lengths[link_idx]))) + { + error_num = HA_ERR_OUT_OF_MEM; + goto error; + } + DBUG_PRINT("info",("spider tgt_hosts=%s", share->tgt_hosts[link_idx])); + } + + if (share->tgt_ports[link_idx] == -1) + { + share->tgt_ports[link_idx] = server->port; + DBUG_PRINT("info",("spider tgt_ports=%ld", share->tgt_ports[link_idx])); + } + + if (!share->tgt_sockets[link_idx] && server->socket) + { + share->tgt_sockets_lengths[link_idx] = strlen(server->socket); + if (!(share->tgt_sockets[link_idx] = + spider_create_string(server->socket, + share->tgt_sockets_lengths[link_idx]))) + { + error_num = HA_ERR_OUT_OF_MEM; + goto error; + } + DBUG_PRINT("info",("spider tgt_sockets=%s", share->tgt_sockets[link_idx])); + } + + if (!share->tgt_dbs[link_idx] && server->db && (length = strlen(server->db))) + { + share->tgt_dbs_lengths[link_idx] = length; + if (!(share->tgt_dbs[link_idx] = + spider_create_string(server->db, length))) + { + error_num = HA_ERR_OUT_OF_MEM; + goto error; + } + DBUG_PRINT("info",("spider tgt_dbs=%s", share->tgt_dbs[link_idx])); + } + + if (!share->tgt_usernames[link_idx] && server->username) + { + share->tgt_usernames_lengths[link_idx] = strlen(server->username); + if (!(share->tgt_usernames[link_idx] = + spider_create_string(server->username, + share->tgt_usernames_lengths[link_idx]))) + { + error_num = HA_ERR_OUT_OF_MEM; + goto error; + } + DBUG_PRINT("info",("spider tgt_usernames=%s", + share->tgt_usernames[link_idx])); + } + + if (!share->tgt_passwords[link_idx] && server->password) + { + share->tgt_passwords_lengths[link_idx] = strlen(server->password); + if (!(share->tgt_passwords[link_idx] = + spider_create_string(server->password, + share->tgt_passwords_lengths[link_idx]))) + { + error_num = HA_ERR_OUT_OF_MEM; + goto error; + } + DBUG_PRINT("info",("spider tgt_passwords=%s", + share->tgt_passwords[link_idx])); + } + + free_root(&mem_root, MYF(0)); + DBUG_RETURN(0); + +error: + free_root(&mem_root, MYF(0)); + my_error(error_num, MYF(0), share->server_names[link_idx]); + DBUG_RETURN(error_num); +} + +int spider_free_share_alloc( + SPIDER_SHARE *share +) { + int roop_count; + DBUG_ENTER("spider_free_share_alloc"); + for (roop_count = SPIDER_DBTON_SIZE - 1; roop_count >= 0; roop_count--) + { + if (share->dbton_share[roop_count]) + { + delete share->dbton_share[roop_count]; + share->dbton_share[roop_count] = NULL; + } + } + if (share->server_names) + { + for (roop_count = 0; roop_count < (int) share->server_names_length; + roop_count++) + { + if (share->server_names[roop_count]) + spider_free(spider_current_trx, share->server_names[roop_count], + MYF(0)); + } + spider_free(spider_current_trx, share->server_names, MYF(0)); + } + if (share->tgt_table_names) + { + for (roop_count = 0; roop_count < (int) share->tgt_table_names_length; + roop_count++) + { + if (share->tgt_table_names[roop_count]) + spider_free(spider_current_trx, share->tgt_table_names[roop_count], + MYF(0)); + } + spider_free(spider_current_trx, share->tgt_table_names, MYF(0)); + } + if (share->tgt_dbs) + { + for (roop_count = 0; roop_count < (int) share->tgt_dbs_length; + roop_count++) + { + if (share->tgt_dbs[roop_count]) + spider_free(spider_current_trx, share->tgt_dbs[roop_count], MYF(0)); + } + spider_free(spider_current_trx, share->tgt_dbs, MYF(0)); + } + if (share->tgt_hosts) + { + for (roop_count = 0; roop_count < (int) share->tgt_hosts_length; + roop_count++) + { + if (share->tgt_hosts[roop_count]) + spider_free(spider_current_trx, share->tgt_hosts[roop_count], MYF(0)); + } + spider_free(spider_current_trx, share->tgt_hosts, MYF(0)); + } + if (share->tgt_usernames) + { + for (roop_count = 0; roop_count < (int) share->tgt_usernames_length; + roop_count++) + { + if (share->tgt_usernames[roop_count]) + spider_free(spider_current_trx, share->tgt_usernames[roop_count], + MYF(0)); + } + spider_free(spider_current_trx, share->tgt_usernames, MYF(0)); + } + if (share->tgt_passwords) + { + for (roop_count = 0; roop_count < (int) share->tgt_passwords_length; + roop_count++) + { + if (share->tgt_passwords[roop_count]) + spider_free(spider_current_trx, share->tgt_passwords[roop_count], + MYF(0)); + } + spider_free(spider_current_trx, share->tgt_passwords, MYF(0)); + } + if (share->tgt_sockets) + { + for (roop_count = 0; roop_count < (int) share->tgt_sockets_length; + roop_count++) + { + if (share->tgt_sockets[roop_count]) + spider_free(spider_current_trx, share->tgt_sockets[roop_count], + MYF(0)); + } + spider_free(spider_current_trx, share->tgt_sockets, MYF(0)); + } + if (share->tgt_wrappers) + { + for (roop_count = 0; roop_count < (int) share->tgt_wrappers_length; + roop_count++) + { + if (share->tgt_wrappers[roop_count]) + spider_free(spider_current_trx, share->tgt_wrappers[roop_count], + MYF(0)); + } + spider_free(spider_current_trx, share->tgt_wrappers, MYF(0)); + } + if (share->tgt_ssl_cas) + { + for (roop_count = 0; roop_count < (int) share->tgt_ssl_cas_length; + roop_count++) + { + if (share->tgt_ssl_cas[roop_count]) + spider_free(spider_current_trx, share->tgt_ssl_cas[roop_count], + MYF(0)); + } + spider_free(spider_current_trx, share->tgt_ssl_cas, MYF(0)); + } + if (share->tgt_ssl_capaths) + { + for (roop_count = 0; roop_count < (int) share->tgt_ssl_capaths_length; + roop_count++) + { + if (share->tgt_ssl_capaths[roop_count]) + spider_free(spider_current_trx, share->tgt_ssl_capaths[roop_count], + MYF(0)); + } + spider_free(spider_current_trx, share->tgt_ssl_capaths, MYF(0)); + } + if (share->tgt_ssl_certs) + { + for (roop_count = 0; roop_count < (int) share->tgt_ssl_certs_length; + roop_count++) + { + if (share->tgt_ssl_certs[roop_count]) + spider_free(spider_current_trx, share->tgt_ssl_certs[roop_count], + MYF(0)); + } + spider_free(spider_current_trx, share->tgt_ssl_certs, MYF(0)); + } + if (share->tgt_ssl_ciphers) + { + for (roop_count = 0; roop_count < (int) share->tgt_ssl_ciphers_length; + roop_count++) + { + if (share->tgt_ssl_ciphers[roop_count]) + spider_free(spider_current_trx, share->tgt_ssl_ciphers[roop_count], + MYF(0)); + } + spider_free(spider_current_trx, share->tgt_ssl_ciphers, MYF(0)); + } + if (share->tgt_ssl_keys) + { + for (roop_count = 0; roop_count < (int) share->tgt_ssl_keys_length; + roop_count++) + { + if (share->tgt_ssl_keys[roop_count]) + spider_free(spider_current_trx, share->tgt_ssl_keys[roop_count], + MYF(0)); + } + spider_free(spider_current_trx, share->tgt_ssl_keys, MYF(0)); + } + if (share->tgt_default_files) + { + for (roop_count = 0; roop_count < (int) share->tgt_default_files_length; + roop_count++) + { + if (share->tgt_default_files[roop_count]) + spider_free(spider_current_trx, share->tgt_default_files[roop_count], + MYF(0)); + } + spider_free(spider_current_trx, share->tgt_default_files, MYF(0)); + } + if (share->tgt_default_groups) + { + for (roop_count = 0; roop_count < (int) share->tgt_default_groups_length; + roop_count++) + { + if (share->tgt_default_groups[roop_count]) + spider_free(spider_current_trx, share->tgt_default_groups[roop_count], + MYF(0)); + } + spider_free(spider_current_trx, share->tgt_default_groups, MYF(0)); + } + if (share->tgt_dsns) + { + for (roop_count = 0; roop_count < (int) share->tgt_dsns_length; + roop_count++) + { + if (share->tgt_dsns[roop_count]) + spider_free(spider_current_trx, share->tgt_dsns[roop_count], + MYF(0)); + } + spider_free(spider_current_trx, share->tgt_dsns, MYF(0)); + } + if (share->tgt_pk_names) + { + for (roop_count = 0; roop_count < (int) share->tgt_pk_names_length; + roop_count++) + { + if (share->tgt_pk_names[roop_count]) + spider_free(spider_current_trx, share->tgt_pk_names[roop_count], + MYF(0)); + } + spider_free(spider_current_trx, share->tgt_pk_names, MYF(0)); + } + if (share->tgt_sequence_names) + { + for (roop_count = 0; roop_count < (int) share->tgt_sequence_names_length; + roop_count++) + { + if (share->tgt_sequence_names[roop_count]) + spider_free(spider_current_trx, share->tgt_sequence_names[roop_count], + MYF(0)); + } + spider_free(spider_current_trx, share->tgt_sequence_names, MYF(0)); + } + if (share->static_link_ids) + { + for (roop_count = 0; roop_count < (int) share->static_link_ids_length; + roop_count++) + { + if (share->static_link_ids[roop_count]) + spider_free(spider_current_trx, share->static_link_ids[roop_count], + MYF(0)); + } + spider_free(spider_current_trx, share->static_link_ids, MYF(0)); + } +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + if (share->hs_read_socks) + { + for (roop_count = 0; roop_count < (int) share->hs_read_socks_length; + roop_count++) + { + if (share->hs_read_socks[roop_count]) + spider_free(spider_current_trx, share->hs_read_socks[roop_count], + MYF(0)); + } + spider_free(spider_current_trx, share->hs_read_socks, MYF(0)); + } + if (share->hs_write_socks) + { + for (roop_count = 0; roop_count < (int) share->hs_write_socks_length; + roop_count++) + { + if (share->hs_write_socks[roop_count]) + spider_free(spider_current_trx, share->hs_write_socks[roop_count], + MYF(0)); + } + spider_free(spider_current_trx, share->hs_write_socks, MYF(0)); + } +#endif + if (share->bka_engine) + spider_free(spider_current_trx, share->bka_engine, MYF(0)); + if (share->conn_keys) + spider_free(spider_current_trx, share->conn_keys, MYF(0)); + if (share->tgt_ports) + spider_free(spider_current_trx, share->tgt_ports, MYF(0)); + if (share->tgt_ssl_vscs) + spider_free(spider_current_trx, share->tgt_ssl_vscs, MYF(0)); + if (share->link_statuses) + spider_free(spider_current_trx, share->link_statuses, MYF(0)); +#ifndef WITHOUT_SPIDER_BG_SEARCH + if (share->monitoring_bg_flag) + spider_free(spider_current_trx, share->monitoring_bg_flag, MYF(0)); + if (share->monitoring_bg_kind) + spider_free(spider_current_trx, share->monitoring_bg_kind, MYF(0)); +#endif + if (share->monitoring_binlog_pos_at_failing) + spider_free(spider_current_trx, share->monitoring_binlog_pos_at_failing, MYF(0)); + if (share->monitoring_flag) + spider_free(spider_current_trx, share->monitoring_flag, MYF(0)); + if (share->monitoring_kind) + spider_free(spider_current_trx, share->monitoring_kind, MYF(0)); +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + if (share->use_hs_reads) + spider_free(spider_current_trx, share->use_hs_reads, MYF(0)); + if (share->use_hs_writes) + spider_free(spider_current_trx, share->use_hs_writes, MYF(0)); + if (share->hs_read_ports) + spider_free(spider_current_trx, share->hs_read_ports, MYF(0)); + if (share->hs_write_ports) + spider_free(spider_current_trx, share->hs_write_ports, MYF(0)); + if (share->hs_write_to_reads) + spider_free(spider_current_trx, share->hs_write_to_reads, MYF(0)); +#endif + if (share->use_handlers) + spider_free(spider_current_trx, share->use_handlers, MYF(0)); + if (share->connect_timeouts) + spider_free(spider_current_trx, share->connect_timeouts, MYF(0)); + if (share->net_read_timeouts) + spider_free(spider_current_trx, share->net_read_timeouts, MYF(0)); + if (share->net_write_timeouts) + spider_free(spider_current_trx, share->net_write_timeouts, MYF(0)); + if (share->access_balances) + spider_free(spider_current_trx, share->access_balances, MYF(0)); + if (share->bka_table_name_types) + spider_free(spider_current_trx, share->bka_table_name_types, MYF(0)); + if (share->strict_group_bys) + spider_free(spider_current_trx, share->strict_group_bys, MYF(0)); +#ifndef WITHOUT_SPIDER_BG_SEARCH + if (share->monitoring_bg_interval) + spider_free(spider_current_trx, share->monitoring_bg_interval, MYF(0)); +#endif + if (share->monitoring_limit) + spider_free(spider_current_trx, share->monitoring_limit, MYF(0)); + if (share->monitoring_sid) + spider_free(spider_current_trx, share->monitoring_sid, MYF(0)); + if (share->alter_table.tmp_server_names) + spider_free(spider_current_trx, share->alter_table.tmp_server_names, + MYF(0)); + if (share->key_hint) + { + delete [] share->key_hint; + share->key_hint = NULL; + } + if (share->wide_share) + spider_free_wide_share(share->wide_share); + DBUG_RETURN(0); +} + +void spider_free_tmp_share_alloc( + SPIDER_SHARE *share +) { + DBUG_ENTER("spider_free_tmp_share_alloc"); + if (share->server_names && share->server_names[0]) + { + spider_free(spider_current_trx, share->server_names[0], MYF(0)); + share->server_names[0] = NULL; + } + if (share->tgt_table_names && share->tgt_table_names[0]) + { + spider_free(spider_current_trx, share->tgt_table_names[0], MYF(0)); + share->tgt_table_names[0] = NULL; + } + if (share->tgt_dbs && share->tgt_dbs[0]) + { + spider_free(spider_current_trx, share->tgt_dbs[0], MYF(0)); + share->tgt_dbs[0] = NULL; + } + if (share->tgt_hosts && share->tgt_hosts[0]) + { + spider_free(spider_current_trx, share->tgt_hosts[0], MYF(0)); + share->tgt_hosts[0] = NULL; + } + if (share->tgt_usernames && share->tgt_usernames[0]) + { + spider_free(spider_current_trx, share->tgt_usernames[0], MYF(0)); + share->tgt_usernames[0] = NULL; + } + if (share->tgt_passwords && share->tgt_passwords[0]) + { + spider_free(spider_current_trx, share->tgt_passwords[0], MYF(0)); + share->tgt_passwords[0] = NULL; + } + if (share->tgt_sockets && share->tgt_sockets[0]) + { + spider_free(spider_current_trx, share->tgt_sockets[0], MYF(0)); + share->tgt_sockets[0] = NULL; + } + if (share->tgt_wrappers && share->tgt_wrappers[0]) + { + spider_free(spider_current_trx, share->tgt_wrappers[0], MYF(0)); + share->tgt_wrappers[0] = NULL; + } + if (share->tgt_ssl_cas && share->tgt_ssl_cas[0]) + { + spider_free(spider_current_trx, share->tgt_ssl_cas[0], MYF(0)); + share->tgt_ssl_cas[0] = NULL; + } + if (share->tgt_ssl_capaths && share->tgt_ssl_capaths[0]) + { + spider_free(spider_current_trx, share->tgt_ssl_capaths[0], MYF(0)); + share->tgt_ssl_capaths[0] = NULL; + } + if (share->tgt_ssl_certs && share->tgt_ssl_certs[0]) + { + spider_free(spider_current_trx, share->tgt_ssl_certs[0], MYF(0)); + share->tgt_ssl_certs[0] = NULL; + } + if (share->tgt_ssl_ciphers && share->tgt_ssl_ciphers[0]) + { + spider_free(spider_current_trx, share->tgt_ssl_ciphers[0], MYF(0)); + share->tgt_ssl_ciphers[0] = NULL; + } + if (share->tgt_ssl_keys && share->tgt_ssl_keys[0]) + { + spider_free(spider_current_trx, share->tgt_ssl_keys[0], MYF(0)); + share->tgt_ssl_keys[0] = NULL; + } + if (share->tgt_default_files && share->tgt_default_files[0]) + { + spider_free(spider_current_trx, share->tgt_default_files[0], MYF(0)); + share->tgt_default_files[0] = NULL; + } + if (share->tgt_default_groups && share->tgt_default_groups[0]) + { + spider_free(spider_current_trx, share->tgt_default_groups[0], MYF(0)); + share->tgt_default_groups[0] = NULL; + } + if (share->tgt_dsns && share->tgt_dsns[0]) + { + spider_free(spider_current_trx, share->tgt_dsns[0], MYF(0)); + share->tgt_dsns[0] = NULL; + } + if (share->tgt_pk_names && share->tgt_pk_names[0]) + { + spider_free(spider_current_trx, share->tgt_pk_names[0], MYF(0)); + share->tgt_pk_names[0] = NULL; + } + if (share->tgt_sequence_names && share->tgt_sequence_names[0]) + { + spider_free(spider_current_trx, share->tgt_sequence_names[0], MYF(0)); + share->tgt_sequence_names[0] = NULL; + } + if (share->static_link_ids && share->static_link_ids[0]) + { + spider_free(spider_current_trx, share->static_link_ids[0], MYF(0)); + share->static_link_ids[0] = NULL; + } +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + if (share->hs_read_socks && share->hs_read_socks[0]) + { + spider_free(spider_current_trx, share->hs_read_socks[0], MYF(0)); + share->hs_read_socks[0] = NULL; + } + if (share->hs_write_socks && share->hs_write_socks[0]) + { + spider_free(spider_current_trx, share->hs_write_socks[0], MYF(0)); + share->hs_write_socks[0] = NULL; + } +#endif + if (share->bka_engine) + { + spider_free(spider_current_trx, share->bka_engine, MYF(0)); + share->bka_engine = NULL; + } + if (share->conn_keys) + { + spider_free(spider_current_trx, share->conn_keys, MYF(0)); + share->conn_keys = NULL; + } + if (share->static_key_cardinality) + spider_free(spider_current_trx, share->static_key_cardinality, MYF(0)); + if (share->key_hint) + { + delete [] share->key_hint; + share->key_hint = NULL; + } + DBUG_VOID_RETURN; +} + +char *spider_get_string_between_quote( + char *ptr, + bool alloc, + SPIDER_PARAM_STRING_PARSE *param_string_parse +) { + char *start_ptr, *end_ptr, *tmp_ptr, *esc_ptr; + bool find_flg = FALSE; + DBUG_ENTER("spider_get_string_between_quote"); + + start_ptr = strchr(ptr, '\''); + end_ptr = strchr(ptr, '"'); + if (start_ptr && (!end_ptr || start_ptr < end_ptr)) + { + tmp_ptr = ++start_ptr; + while (!find_flg) + { + if (!(end_ptr = strchr(tmp_ptr, '\''))) + DBUG_RETURN(NULL); + esc_ptr = tmp_ptr; + while (!find_flg) + { + esc_ptr = strchr(esc_ptr, '\\'); + if (!esc_ptr || esc_ptr > end_ptr) + find_flg = TRUE; + else if (esc_ptr == end_ptr - 1) + { + tmp_ptr = end_ptr + 1; + break; + } else { + esc_ptr += 2; + } + } + } + } else if (end_ptr) + { + start_ptr = end_ptr; + tmp_ptr = ++start_ptr; + while (!find_flg) + { + if (!(end_ptr = strchr(tmp_ptr, '"'))) + DBUG_RETURN(NULL); + esc_ptr = tmp_ptr; + while (!find_flg) + { + esc_ptr = strchr(esc_ptr, '\\'); + if (!esc_ptr || esc_ptr > end_ptr) + find_flg = TRUE; + else if (esc_ptr == end_ptr - 1) + { + tmp_ptr = end_ptr + 1; + break; + } else { + esc_ptr += 2; + } + } + } + } else + DBUG_RETURN(NULL); + + *end_ptr = '\0'; + + if (param_string_parse) + param_string_parse->set_param_value(start_ptr, start_ptr + strlen(start_ptr) + 1); + + if (alloc) + { + DBUG_RETURN( + spider_create_string( + start_ptr, + strlen(start_ptr)) + ); + } else { + DBUG_RETURN(start_ptr); + } +} + +int spider_create_string_list( + char ***string_list, + uint **string_length_list, + uint *list_length, + char *str, + uint length, + SPIDER_PARAM_STRING_PARSE *param_string_parse +) { + int roop_count; + char *tmp_ptr, *tmp_ptr2, *tmp_ptr3, *tmp_ptr4, *esc_ptr; + bool find_flg = FALSE; + DBUG_ENTER("spider_create_string_list"); + + *list_length = 0; + param_string_parse->init_param_value(); + if (!str) + { + *string_list = NULL; + DBUG_RETURN(0); + } + + tmp_ptr = str; + while (*tmp_ptr == ' ') + tmp_ptr++; + if (*tmp_ptr) + *list_length = 1; + else { + *string_list = NULL; + DBUG_RETURN(0); + } + + bool last_esc_flg = FALSE; + while (TRUE) + { + if ((tmp_ptr2 = strchr(tmp_ptr, ' '))) + { + find_flg = FALSE; + last_esc_flg = FALSE; + esc_ptr = tmp_ptr; + while (!find_flg) + { + esc_ptr = strchr(esc_ptr, '\\'); + if (!esc_ptr || esc_ptr > tmp_ptr2) + { + find_flg = TRUE; + } + else if (esc_ptr == tmp_ptr2 - 1) + { + last_esc_flg = TRUE; + tmp_ptr = tmp_ptr2 + 1; + break; + } else { + last_esc_flg = TRUE; + esc_ptr += 2; + } + } + if (find_flg) + { + (*list_length)++; + tmp_ptr = tmp_ptr2 + 1; + while (*tmp_ptr == ' ') + tmp_ptr++; + } + } else + break; + } + + if (!(*string_list = (char**) + spider_bulk_malloc(spider_current_trx, 37, MYF(MY_WME | MY_ZEROFILL), + string_list, (uint) (sizeof(char*) * (*list_length)), + string_length_list, (uint) (sizeof(int) * (*list_length)), + NullS)) + ) { + my_error(ER_OUT_OF_RESOURCES, MYF(0), HA_ERR_OUT_OF_MEM); + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + } + + tmp_ptr = str; + while (*tmp_ptr == ' ') + { + *tmp_ptr = '\0'; + tmp_ptr++; + } + tmp_ptr3 = tmp_ptr; + + for (roop_count = 0; roop_count < (int) *list_length - 1; roop_count++) + { + bool esc_flg = FALSE; + find_flg = FALSE; + while (TRUE) + { + tmp_ptr2 = strchr(tmp_ptr, ' '); + + esc_ptr = tmp_ptr; + while (!find_flg) + { + esc_ptr = strchr(esc_ptr, '\\'); + if (!esc_ptr || esc_ptr > tmp_ptr2) + { + find_flg = TRUE; + } + else if (esc_ptr == tmp_ptr2 - 1) + { + esc_flg = TRUE; + tmp_ptr = tmp_ptr2 + 1; + break; + } else { + esc_flg = TRUE; + esc_ptr += 2; + } + } + if (find_flg) + break; + } + tmp_ptr = tmp_ptr2; + + while (*tmp_ptr == ' ') + { + *tmp_ptr = '\0'; + tmp_ptr++; + } + + (*string_length_list)[roop_count] = strlen(tmp_ptr3); + if (!((*string_list)[roop_count] = spider_create_string( + tmp_ptr3, (*string_length_list)[roop_count])) + ) { + my_error(ER_OUT_OF_RESOURCES, MYF(0), HA_ERR_OUT_OF_MEM); + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + } + + if (esc_flg) + { + esc_ptr = (*string_list)[roop_count]; + while (TRUE) + { + esc_ptr = strchr(esc_ptr, '\\'); + if (!esc_ptr) + break; + switch(*(esc_ptr + 1)) + { + case 'b': + *esc_ptr = '\b'; + break; + case 'n': + *esc_ptr = '\n'; + break; + case 'r': + *esc_ptr = '\r'; + break; + case 't': + *esc_ptr = '\t'; + break; + default: + *esc_ptr = *(esc_ptr + 1); + break; + } + esc_ptr++; + tmp_ptr4 = esc_ptr; + do + { + *tmp_ptr4 = *(tmp_ptr4 + 1); + tmp_ptr4++; + } while (*tmp_ptr4); + (*string_length_list)[roop_count] -= 1; + } + } + DBUG_PRINT("info",("spider string_list[%d]=%s", roop_count, + (*string_list)[roop_count])); + tmp_ptr3 = tmp_ptr; + } + (*string_length_list)[roop_count] = strlen(tmp_ptr3); + if (!((*string_list)[roop_count] = spider_create_string( + tmp_ptr3, (*string_length_list)[roop_count])) + ) { + my_error(ER_OUT_OF_RESOURCES, MYF(0), HA_ERR_OUT_OF_MEM); + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + } + if (last_esc_flg) + { + esc_ptr = (*string_list)[roop_count]; + while (TRUE) + { + esc_ptr = strchr(esc_ptr, '\\'); + if (!esc_ptr) + break; + switch(*(esc_ptr + 1)) + { + case 'b': + *esc_ptr = '\b'; + break; + case 'n': + *esc_ptr = '\n'; + break; + case 'r': + *esc_ptr = '\r'; + break; + case 't': + *esc_ptr = '\t'; + break; + default: + *esc_ptr = *(esc_ptr + 1); + break; + } + esc_ptr++; + tmp_ptr4 = esc_ptr; + do + { + *tmp_ptr4 = *(tmp_ptr4 + 1); + tmp_ptr4++; + } while (*tmp_ptr4); + (*string_length_list)[roop_count] -= 1; + } + } + + param_string_parse->set_param_value(tmp_ptr3, + tmp_ptr3 + strlen(tmp_ptr3) + 1); + + DBUG_PRINT("info",("spider string_list[%d]=%s", roop_count, + (*string_list)[roop_count])); + + DBUG_RETURN(0); +} + +int spider_create_long_list( + long **long_list, + uint *list_length, + char *str, + uint length, + long min_val, + long max_val, + SPIDER_PARAM_STRING_PARSE *param_string_parse +) { + int roop_count; + char *tmp_ptr; + DBUG_ENTER("spider_create_long_list"); + + *list_length = 0; + param_string_parse->init_param_value(); + if (!str) + { + *long_list = NULL; + DBUG_RETURN(0); + } + + tmp_ptr = str; + while (*tmp_ptr == ' ') + tmp_ptr++; + if (*tmp_ptr) + *list_length = 1; + else { + *long_list = NULL; + DBUG_RETURN(0); + } + + while (TRUE) + { + if ((tmp_ptr = strchr(tmp_ptr, ' '))) + { + (*list_length)++; + tmp_ptr = tmp_ptr + 1; + while (*tmp_ptr == ' ') + tmp_ptr++; + } else + break; + } + + if (!(*long_list = (long*) + spider_bulk_malloc(spider_current_trx, 38, MYF(MY_WME | MY_ZEROFILL), + long_list, (uint) (sizeof(long) * (*list_length)), + NullS)) + ) { + my_error(ER_OUT_OF_RESOURCES, MYF(0), HA_ERR_OUT_OF_MEM); + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + } + + tmp_ptr = str; + for (roop_count = 0; roop_count < (int) *list_length; roop_count++) + { + if (roop_count != 0) + tmp_ptr = strchr(tmp_ptr, ' '); + + while (*tmp_ptr == ' ') + { + *tmp_ptr = '\0'; + tmp_ptr++; + } + (*long_list)[roop_count] = atol(tmp_ptr); + if ((*long_list)[roop_count] < min_val) + (*long_list)[roop_count] = min_val; + else if ((*long_list)[roop_count] > max_val) + (*long_list)[roop_count] = max_val; + } + + param_string_parse->set_param_value(tmp_ptr, + tmp_ptr + strlen(tmp_ptr) + 1); + +#ifndef DBUG_OFF + for (roop_count = 0; roop_count < (int) *list_length; roop_count++) + { + DBUG_PRINT("info",("spider long_list[%d]=%ld", roop_count, + (*long_list)[roop_count])); + } +#endif + + DBUG_RETURN(0); +} + +int spider_create_longlong_list( + longlong **longlong_list, + uint *list_length, + char *str, + uint length, + longlong min_val, + longlong max_val, + SPIDER_PARAM_STRING_PARSE *param_string_parse +) { + int error_num, roop_count; + char *tmp_ptr; + DBUG_ENTER("spider_create_longlong_list"); + + *list_length = 0; + param_string_parse->init_param_value(); + if (!str) + { + *longlong_list = NULL; + DBUG_RETURN(0); + } + + tmp_ptr = str; + while (*tmp_ptr == ' ') + tmp_ptr++; + if (*tmp_ptr) + *list_length = 1; + else { + *longlong_list = NULL; + DBUG_RETURN(0); + } + + while (TRUE) + { + if ((tmp_ptr = strchr(tmp_ptr, ' '))) + { + (*list_length)++; + tmp_ptr = tmp_ptr + 1; + while (*tmp_ptr == ' ') + tmp_ptr++; + } else + break; + } + + if (!(*longlong_list = (longlong *) + spider_bulk_malloc(spider_current_trx, 39, MYF(MY_WME | MY_ZEROFILL), + longlong_list, (uint) (sizeof(longlong) * (*list_length)), + NullS)) + ) { + my_error(ER_OUT_OF_RESOURCES, MYF(0), HA_ERR_OUT_OF_MEM); + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + } + + tmp_ptr = str; + for (roop_count = 0; roop_count < (int) *list_length; roop_count++) + { + if (roop_count != 0) + tmp_ptr = strchr(tmp_ptr, ' '); + + while (*tmp_ptr == ' ') + { + *tmp_ptr = '\0'; + tmp_ptr++; + } + (*longlong_list)[roop_count] = my_strtoll10(tmp_ptr, (char**) NULL, + &error_num); + if ((*longlong_list)[roop_count] < min_val) + (*longlong_list)[roop_count] = min_val; + else if ((*longlong_list)[roop_count] > max_val) + (*longlong_list)[roop_count] = max_val; + } + + param_string_parse->set_param_value(tmp_ptr, + tmp_ptr + strlen(tmp_ptr) + 1); + +#ifndef DBUG_OFF + for (roop_count = 0; roop_count < (int) *list_length; roop_count++) + { + DBUG_PRINT("info",("spider longlong_list[%d]=%lld", roop_count, + (*longlong_list)[roop_count])); + } +#endif + + DBUG_RETURN(0); +} + +int spider_increase_string_list( + char ***string_list, + uint **string_length_list, + uint *list_length, + uint *list_charlen, + uint link_count +) { + int roop_count; + char **tmp_str_list, *tmp_str; + uint *tmp_length_list, tmp_length; + DBUG_ENTER("spider_increase_string_list"); + if (*list_length == link_count) + DBUG_RETURN(0); + if (*list_length > 1) + { + my_printf_error(ER_SPIDER_DIFFERENT_LINK_COUNT_NUM, + ER_SPIDER_DIFFERENT_LINK_COUNT_STR, MYF(0)); + DBUG_RETURN(ER_SPIDER_DIFFERENT_LINK_COUNT_NUM); + } + + if (*string_list) + { + tmp_str = (*string_list)[0]; + tmp_length = (*string_length_list)[0]; + } else { + tmp_str = NULL; + tmp_length = 0; + } + + if (!(tmp_str_list = (char**) + spider_bulk_malloc(spider_current_trx, 40, MYF(MY_WME | MY_ZEROFILL), + &tmp_str_list, (uint) (sizeof(char*) * link_count), + &tmp_length_list, (uint) (sizeof(uint) * link_count), + NullS)) + ) { + my_error(ER_OUT_OF_RESOURCES, MYF(0), HA_ERR_OUT_OF_MEM); + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + } + + for (roop_count = 0; roop_count < (int) link_count; roop_count++) + { + tmp_length_list[roop_count] = tmp_length; + if (tmp_str) + { + if (!(tmp_str_list[roop_count] = spider_create_string( + tmp_str, tmp_length)) + ) + goto error; + DBUG_PRINT("info",("spider string_list[%d]=%s", roop_count, + tmp_str_list[roop_count])); + } else + tmp_str_list[roop_count] = NULL; + } + if (*string_list) + { + if ((*string_list)[0]) + spider_free(spider_current_trx, (*string_list)[0], MYF(0)); + spider_free(spider_current_trx, *string_list, MYF(0)); + } + *list_charlen = (tmp_length + 1) * link_count - 1; + *list_length = link_count; + *string_list = tmp_str_list; + *string_length_list = tmp_length_list; + + DBUG_RETURN(0); + +error: + for (roop_count = 0; roop_count < (int) link_count; roop_count++) + { + if (tmp_str_list[roop_count]) + spider_free(spider_current_trx, tmp_str_list[roop_count], MYF(0)); + } + if (tmp_str_list) + spider_free(spider_current_trx, tmp_str_list, MYF(0)); + my_error(ER_OUT_OF_RESOURCES, MYF(0), HA_ERR_OUT_OF_MEM); + DBUG_RETURN(HA_ERR_OUT_OF_MEM); +} + +int spider_increase_null_string_list( + char ***string_list, + uint **string_length_list, + uint *list_length, + uint *list_charlen, + uint link_count +) { + int roop_count; + char **tmp_str_list; + uint *tmp_length_list; + DBUG_ENTER("spider_increase_null_string_list"); + if (*list_length == link_count) + DBUG_RETURN(0); + + if (!(tmp_str_list = (char**) + spider_bulk_malloc(spider_current_trx, 247, MYF(MY_WME | MY_ZEROFILL), + &tmp_str_list, (uint) (sizeof(char*) * link_count), + &tmp_length_list, (uint) (sizeof(uint) * link_count), + NullS)) + ) { + my_error(ER_OUT_OF_RESOURCES, MYF(0), HA_ERR_OUT_OF_MEM); + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + } + + for (roop_count = 0; roop_count < (int) *list_length; roop_count++) + { + tmp_str_list[roop_count] = (*string_list)[roop_count]; + tmp_length_list[roop_count] = (*string_length_list)[roop_count]; + } + if (*string_list) + { + spider_free(spider_current_trx, *string_list, MYF(0)); + } + *list_length = link_count; + *string_list = tmp_str_list; + *string_length_list = tmp_length_list; +#ifndef DBUG_OFF + DBUG_PRINT("info",("spider list_length=%u", *list_length)); + for (roop_count = 0; roop_count < (int) *list_length; roop_count++) + { + DBUG_PRINT("info",("spider string_list[%d]=%s", roop_count, + (*string_list)[roop_count] ? (*string_list)[roop_count] : "NULL")); + DBUG_PRINT("info",("spider string_length_list[%d]=%u", roop_count, + (*string_length_list)[roop_count])); + } +#endif + + DBUG_RETURN(0); +} + +int spider_increase_long_list( + long **long_list, + uint *list_length, + uint link_count +) { + int roop_count; + long *tmp_long_list, tmp_long; + DBUG_ENTER("spider_increase_long_list"); + if (*list_length == link_count) + DBUG_RETURN(0); + if (*list_length > 1) + { + my_printf_error(ER_SPIDER_DIFFERENT_LINK_COUNT_NUM, + ER_SPIDER_DIFFERENT_LINK_COUNT_STR, MYF(0)); + DBUG_RETURN(ER_SPIDER_DIFFERENT_LINK_COUNT_NUM); + } + + if (*long_list) + tmp_long = (*long_list)[0]; + else + tmp_long = -1; + + if (!(tmp_long_list = (long*) + spider_bulk_malloc(spider_current_trx, 41, MYF(MY_WME | MY_ZEROFILL), + &tmp_long_list, (uint) (sizeof(long) * link_count), + NullS)) + ) { + my_error(ER_OUT_OF_RESOURCES, MYF(0), HA_ERR_OUT_OF_MEM); + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + } + + for (roop_count = 0; roop_count < (int) link_count; roop_count++) + { + tmp_long_list[roop_count] = tmp_long; + DBUG_PRINT("info",("spider long_list[%d]=%ld", roop_count, + tmp_long)); + } + if (*long_list) + spider_free(spider_current_trx, *long_list, MYF(0)); + *list_length = link_count; + *long_list = tmp_long_list; + + DBUG_RETURN(0); +} + +int spider_increase_longlong_list( + longlong **longlong_list, + uint *list_length, + uint link_count +) { + int roop_count; + longlong *tmp_longlong_list, tmp_longlong; + DBUG_ENTER("spider_increase_longlong_list"); + if (*list_length == link_count) + DBUG_RETURN(0); + if (*list_length > 1) + { + my_printf_error(ER_SPIDER_DIFFERENT_LINK_COUNT_NUM, + ER_SPIDER_DIFFERENT_LINK_COUNT_STR, MYF(0)); + DBUG_RETURN(ER_SPIDER_DIFFERENT_LINK_COUNT_NUM); + } + + if (*longlong_list) + tmp_longlong = (*longlong_list)[0]; + else + tmp_longlong = -1; + + if (!(tmp_longlong_list = (longlong*) + spider_bulk_malloc(spider_current_trx, 42, MYF(MY_WME | MY_ZEROFILL), + &tmp_longlong_list, (uint) (sizeof(longlong) * link_count), + NullS)) + ) { + my_error(ER_OUT_OF_RESOURCES, MYF(0), HA_ERR_OUT_OF_MEM); + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + } + + for (roop_count = 0; roop_count < (int) link_count; roop_count++) + { + tmp_longlong_list[roop_count] = tmp_longlong; + DBUG_PRINT("info",("spider longlong_list[%d]=%lld", roop_count, + tmp_longlong)); + } + if (*longlong_list) + spider_free(spider_current_trx, *longlong_list, MYF(0)); + *list_length = link_count; + *longlong_list = tmp_longlong_list; + + DBUG_RETURN(0); +} + +static int spider_set_ll_value( + longlong *value, + char *str +) { + int error_num = 0; + DBUG_ENTER("spider_set_ll_value"); + *value = my_strtoll10(str, (char**) NULL, &error_num); + DBUG_RETURN(error_num); +} + +/** + Print a parameter string error message. + + @return Error code. +*/ + +int st_spider_param_string_parse::print_param_error() +{ + if (start_title_ptr) + { + /* Restore the input delimiter characters */ + restore_delims(); + + /* Print the error message */ + switch (error_num) + { + case ER_SPIDER_INVALID_UDF_PARAM_NUM: + my_printf_error(error_num, ER_SPIDER_INVALID_UDF_PARAM_STR, + MYF(0), start_title_ptr); + break; + case ER_SPIDER_INVALID_CONNECT_INFO_NUM: + default: + my_printf_error(error_num, ER_SPIDER_INVALID_CONNECT_INFO_STR, + MYF(0), start_title_ptr); + } + + return error_num; + } + else + return 0; +} + +#define SPIDER_PARAM_STR_LEN(name) name ## _length +#define SPIDER_PARAM_STR(title_name, param_name) \ + if (!strncasecmp(tmp_ptr, title_name, title_length)) \ + { \ + DBUG_PRINT("info",("spider " title_name " start")); \ + if (!share->param_name) \ + { \ + if ((share->param_name = spider_get_string_between_quote( \ + start_ptr, TRUE, &connect_string_parse))) \ + share->SPIDER_PARAM_STR_LEN(param_name) = strlen(share->param_name); \ + else { \ + error_num = connect_string_parse.print_param_error(); \ + goto error; \ + } \ + DBUG_PRINT("info",("spider " title_name "=%s", share->param_name)); \ + } \ + break; \ + } +#define SPIDER_PARAM_STR_LENS(name) name ## _lengths +#define SPIDER_PARAM_STR_CHARLEN(name) name ## _charlen +#define SPIDER_PARAM_STR_LIST(title_name, param_name) \ + if (!strncasecmp(tmp_ptr, title_name, title_length)) \ + { \ + DBUG_PRINT("info",("spider " title_name " start")); \ + if (!share->param_name) \ + { \ + if ((tmp_ptr2 = spider_get_string_between_quote( \ + start_ptr, FALSE))) \ + { \ + share->SPIDER_PARAM_STR_CHARLEN(param_name) = strlen(tmp_ptr2); \ + if ((error_num = spider_create_string_list( \ + &share->param_name, \ + &share->SPIDER_PARAM_STR_LENS(param_name), \ + &share->SPIDER_PARAM_STR_LEN(param_name), \ + tmp_ptr2, \ + share->SPIDER_PARAM_STR_CHARLEN(param_name), \ + &connect_string_parse))) \ + goto error; \ + } else { \ + error_num = connect_string_parse.print_param_error(); \ + goto error; \ + } \ + } \ + break; \ + } +#define SPIDER_PARAM_HINT(title_name, param_name, check_length, max_size, append_method) \ + if (!strncasecmp(tmp_ptr, title_name, check_length)) \ + { \ + DBUG_PRINT("info",("spider " title_name " start")); \ + DBUG_PRINT("info",("spider max_size=%d", max_size)); \ + int hint_num = atoi(tmp_ptr + check_length); \ + DBUG_PRINT("info",("spider hint_num=%d", hint_num)); \ + DBUG_PRINT("info",("spider share->param_name=%p", share->param_name)); \ + if (share->param_name) \ + { \ + if (hint_num < 0 || hint_num >= max_size) \ + { \ + error_num = connect_string_parse.print_param_error(); \ + goto error; \ + } else if (share->param_name[hint_num].length() > 0) \ + break; \ + char *hint_str = spider_get_string_between_quote(start_ptr, FALSE); \ + if ((error_num = \ + append_method(&share->param_name[hint_num], hint_str))) \ + goto error; \ + DBUG_PRINT("info",("spider " title_name "[%d]=%s", hint_num, \ + share->param_name[hint_num].ptr())); \ + } else { \ + error_num = connect_string_parse.print_param_error(); \ + goto error; \ + } \ + break; \ + } +#define SPIDER_PARAM_NUMHINT(title_name, param_name, check_length, max_size, append_method) \ + if (!strncasecmp(tmp_ptr, title_name, check_length)) \ + { \ + DBUG_PRINT("info",("spider " title_name " start")); \ + DBUG_PRINT("info",("spider max_size=%d", max_size)); \ + int hint_num = atoi(tmp_ptr + check_length); \ + DBUG_PRINT("info",("spider hint_num=%d", hint_num)); \ + DBUG_PRINT("info",("spider share->param_name=%p", share->param_name)); \ + if (share->param_name) \ + { \ + if (hint_num < 0 || hint_num >= max_size) \ + { \ + error_num = connect_string_parse.print_param_error(); \ + goto error; \ + } else if (share->param_name[hint_num] != -1) \ + break; \ + char *hint_str = spider_get_string_between_quote(start_ptr, FALSE); \ + if ((error_num = \ + append_method(&share->param_name[hint_num], hint_str))) \ + goto error; \ + DBUG_PRINT("info",("spider " title_name "[%d]=%lld", hint_num, \ + share->param_name[hint_num])); \ + } else { \ + error_num = connect_string_parse.print_param_error(); \ + goto error; \ + } \ + break; \ + } +#define SPIDER_PARAM_LONG_LEN(name) name ## _length +#define SPIDER_PARAM_LONG_LIST_WITH_MAX(title_name, param_name, \ + min_val, max_val) \ + if (!strncasecmp(tmp_ptr, title_name, title_length)) \ + { \ + DBUG_PRINT("info",("spider " title_name " start")); \ + if (!share->param_name) \ + { \ + if ((tmp_ptr2 = spider_get_string_between_quote( \ + start_ptr, FALSE))) \ + { \ + if ((error_num = spider_create_long_list( \ + &share->param_name, \ + &share->SPIDER_PARAM_LONG_LEN(param_name), \ + tmp_ptr2, \ + strlen(tmp_ptr2), \ + min_val, max_val, \ + &connect_string_parse))) \ + goto error; \ + } else { \ + error_num = connect_string_parse.print_param_error(); \ + goto error; \ + } \ + } \ + break; \ + } +#define SPIDER_PARAM_LONGLONG_LEN(name) name ## _length +#define SPIDER_PARAM_LONGLONG_LIST_WITH_MAX(title_name, param_name, \ + min_val, max_val) \ + if (!strncasecmp(tmp_ptr, title_name, title_length)) \ + { \ + DBUG_PRINT("info",("spider " title_name " start")); \ + if (!share->param_name) \ + { \ + if ((tmp_ptr2 = spider_get_string_between_quote( \ + start_ptr, FALSE))) \ + { \ + if ((error_num = spider_create_longlong_list( \ + &share->param_name, \ + &share->SPIDER_PARAM_LONGLONG_LEN(param_name), \ + tmp_ptr2, \ + strlen(tmp_ptr2), \ + min_val, max_val, \ + &connect_string_parse))) \ + goto error; \ + } else { \ + error_num = connect_string_parse.print_param_error(); \ + goto error; \ + } \ + } \ + break; \ + } +#define SPIDER_PARAM_INT_WITH_MAX(title_name, param_name, min_val, max_val) \ + if (!strncasecmp(tmp_ptr, title_name, title_length)) \ + { \ + DBUG_PRINT("info",("spider " title_name " start")); \ + if (share->param_name == -1) \ + { \ + if ((tmp_ptr2 = spider_get_string_between_quote( \ + start_ptr, FALSE))) \ + { \ + share->param_name = atoi(tmp_ptr2); \ + if (share->param_name < min_val) \ + share->param_name = min_val; \ + else if (share->param_name > max_val) \ + share->param_name = max_val; \ + connect_string_parse.set_param_value(tmp_ptr2, \ + tmp_ptr2 + \ + strlen(tmp_ptr2) + 1); \ + } else { \ + error_num = connect_string_parse.print_param_error(); \ + goto error; \ + } \ + DBUG_PRINT("info",("spider " title_name "=%d", share->param_name)); \ + } \ + break; \ + } +#define SPIDER_PARAM_INT(title_name, param_name, min_val) \ + if (!strncasecmp(tmp_ptr, title_name, title_length)) \ + { \ + DBUG_PRINT("info",("spider " title_name " start")); \ + if (share->param_name == -1) \ + { \ + if ((tmp_ptr2 = spider_get_string_between_quote( \ + start_ptr, FALSE))) \ + { \ + share->param_name = atoi(tmp_ptr2); \ + if (share->param_name < min_val) \ + share->param_name = min_val; \ + connect_string_parse.set_param_value(tmp_ptr2, \ + tmp_ptr2 + \ + strlen(tmp_ptr2) + 1); \ + } else { \ + error_num = connect_string_parse.print_param_error(); \ + goto error; \ + } \ + DBUG_PRINT("info",("spider " title_name "=%d", share->param_name)); \ + } \ + break; \ + } +#define SPIDER_PARAM_DOUBLE(title_name, param_name, min_val) \ + if (!strncasecmp(tmp_ptr, title_name, title_length)) \ + { \ + DBUG_PRINT("info",("spider " title_name " start")); \ + if (share->param_name == -1) \ + { \ + if ((tmp_ptr2 = spider_get_string_between_quote( \ + start_ptr, FALSE))) \ + { \ + share->param_name = my_atof(tmp_ptr2); \ + if (share->param_name < min_val) \ + share->param_name = min_val; \ + connect_string_parse.set_param_value(tmp_ptr2, \ + tmp_ptr2 + \ + strlen(tmp_ptr2) + 1); \ + } else { \ + error_num = connect_string_parse.print_param_error(); \ + goto error; \ + } \ + DBUG_PRINT("info",("spider " title_name "=%f", share->param_name)); \ + } \ + break; \ + } +#define SPIDER_PARAM_LONGLONG(title_name, param_name, min_val) \ + if (!strncasecmp(tmp_ptr, title_name, title_length)) \ + { \ + DBUG_PRINT("info",("spider " title_name " start")); \ + if (share->param_name == -1) \ + { \ + if ((tmp_ptr2 = spider_get_string_between_quote( \ + start_ptr, FALSE))) \ + { \ + share->param_name = my_strtoll10(tmp_ptr2, (char**) NULL, &error_num); \ + if (share->param_name < min_val) \ + share->param_name = min_val; \ + connect_string_parse.set_param_value(tmp_ptr2, \ + tmp_ptr2 + \ + strlen(tmp_ptr2) + 1); \ + } else { \ + error_num = connect_string_parse.print_param_error(); \ + goto error; \ + } \ + DBUG_PRINT("info",("spider " title_name "=%lld", share->param_name)); \ + } \ + break; \ + } + +int spider_parse_connect_info( + SPIDER_SHARE *share, + TABLE_SHARE *table_share, +#ifdef WITH_PARTITION_STORAGE_ENGINE + partition_info *part_info, +#endif + uint create_table +) { + int error_num = 0; + char *connect_string = NULL; + char *sprit_ptr; + char *tmp_ptr, *tmp_ptr2, *start_ptr; + int roop_count; + int title_length; + SPIDER_PARAM_STRING_PARSE connect_string_parse; + SPIDER_ALTER_TABLE *share_alter; +#ifdef WITH_PARTITION_STORAGE_ENGINE + partition_element *part_elem; + partition_element *sub_elem; +#endif + DBUG_ENTER("spider_parse_connect_info"); +#ifdef WITH_PARTITION_STORAGE_ENGINE +#if MYSQL_VERSION_ID < 50500 + DBUG_PRINT("info",("spider partition_info=%s", table_share->partition_info)); +#else + DBUG_PRINT("info",("spider partition_info=%s", + table_share->partition_info_str)); +#endif + DBUG_PRINT("info",("spider part_info=%p", part_info)); +#endif + DBUG_PRINT("info",("spider s->db=%s", table_share->db.str)); + DBUG_PRINT("info",("spider s->table_name=%s", table_share->table_name.str)); + DBUG_PRINT("info",("spider s->path=%s", table_share->path.str)); + DBUG_PRINT("info", + ("spider s->normalized_path=%s", table_share->normalized_path.str)); +#ifdef WITH_PARTITION_STORAGE_ENGINE + spider_get_partition_info(share->table_name, share->table_name_length, + table_share, part_info, &part_elem, &sub_elem); +#endif +#ifndef WITHOUT_SPIDER_BG_SEARCH + share->sts_bg_mode = -1; +#endif + share->sts_interval = -1; + share->sts_mode = -1; +#ifdef WITH_PARTITION_STORAGE_ENGINE + share->sts_sync = -1; +#endif + share->store_last_sts = -1; + share->load_sts_at_startup = -1; +#ifndef WITHOUT_SPIDER_BG_SEARCH + share->crd_bg_mode = -1; +#endif + share->crd_interval = -1; + share->crd_mode = -1; +#ifdef WITH_PARTITION_STORAGE_ENGINE + share->crd_sync = -1; +#endif + share->store_last_crd = -1; + share->load_crd_at_startup = -1; + share->crd_type = -1; + share->crd_weight = -1; + share->internal_offset = -1; + share->internal_limit = -1; + share->split_read = -1; + share->semi_split_read = -1; + share->semi_split_read_limit = -1; + share->init_sql_alloc_size = -1; + share->reset_sql_alloc = -1; + share->multi_split_read = -1; + share->max_order = -1; + share->semi_table_lock = -1; + share->semi_table_lock_conn = -1; + share->selupd_lock_mode = -1; + share->query_cache = -1; + share->query_cache_sync = -1; + share->internal_delayed = -1; + share->bulk_size = -1; + share->bulk_update_mode = -1; + share->bulk_update_size = -1; + share->buffer_size = -1; + share->internal_optimize = -1; + share->internal_optimize_local = -1; + share->scan_rate = -1; + share->read_rate = -1; + share->priority = -1; + share->quick_mode = -1; + share->quick_page_size = -1; + share->quick_page_byte = -1; + share->low_mem_read = -1; + share->table_count_mode = -1; + share->select_column_mode = -1; +#ifndef WITHOUT_SPIDER_BG_SEARCH + share->bgs_mode = -1; + share->bgs_first_read = -1; + share->bgs_second_read = -1; +#endif + share->first_read = -1; + share->second_read = -1; + share->auto_increment_mode = -1; + share->use_table_charset = -1; + share->use_pushdown_udf = -1; + share->skip_default_condition = -1; + share->skip_parallel_search = -1; + share->direct_dup_insert = -1; + share->direct_order_limit = -1; + share->bka_mode = -1; + share->read_only_mode = -1; + share->error_read_mode = -1; + share->error_write_mode = -1; + share->active_link_count = -1; +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + share->hs_result_free_size = -1; +#endif +#ifdef HA_CAN_BULK_ACCESS + share->bulk_access_free = -1; +#endif +#ifdef HA_CAN_FORCE_BULK_UPDATE + share->force_bulk_update = -1; +#endif +#ifdef HA_CAN_FORCE_BULK_DELETE + share->force_bulk_delete = -1; +#endif + share->casual_read = -1; + share->delete_all_rows_type = -1; + share->static_records_for_status = -1; + share->static_mean_rec_length = -1; + for (roop_count = 0; roop_count < (int) table_share->keys; roop_count++) + { + share->static_key_cardinality[roop_count] = -1; + } + +#ifdef WITH_PARTITION_STORAGE_ENGINE + for (roop_count = 4; roop_count > 0; roop_count--) +#else + for (roop_count = 2; roop_count > 0; roop_count--) +#endif + { + if (connect_string) + { + spider_free(spider_current_trx, connect_string, MYF(0)); + connect_string = NULL; + } + switch (roop_count) + { +#ifdef WITH_PARTITION_STORAGE_ENGINE + case 4: + if (!sub_elem || !sub_elem->part_comment) + continue; + DBUG_PRINT("info",("spider create sub comment string")); + if ( + !(connect_string = spider_create_string( + sub_elem->part_comment, + strlen(sub_elem->part_comment))) + ) { + error_num = HA_ERR_OUT_OF_MEM; + goto error_alloc_conn_string; + } + DBUG_PRINT("info",("spider sub comment string=%s", connect_string)); + break; + case 3: + if (!part_elem || !part_elem->part_comment) + continue; + DBUG_PRINT("info",("spider create part comment string")); + if ( + !(connect_string = spider_create_string( + part_elem->part_comment, + strlen(part_elem->part_comment))) + ) { + error_num = HA_ERR_OUT_OF_MEM; + goto error_alloc_conn_string; + } + DBUG_PRINT("info",("spider part comment string=%s", connect_string)); + break; +#endif + case 2: + if (table_share->comment.length == 0) + continue; + DBUG_PRINT("info",("spider create comment string")); + if ( + !(connect_string = spider_create_string( + table_share->comment.str, + table_share->comment.length)) + ) { + error_num = HA_ERR_OUT_OF_MEM; + goto error_alloc_conn_string; + } + DBUG_PRINT("info",("spider comment string=%s", connect_string)); + break; + default: + if (table_share->connect_string.length == 0) + continue; + DBUG_PRINT("info",("spider create connect_string string")); + if ( + !(connect_string = spider_create_string( + table_share->connect_string.str, + table_share->connect_string.length)) + ) { + error_num = HA_ERR_OUT_OF_MEM; + goto error_alloc_conn_string; + } + DBUG_PRINT("info",("spider connect_string=%s", connect_string)); + break; + } + + sprit_ptr = connect_string; + connect_string_parse.init(connect_string, ER_SPIDER_INVALID_CONNECT_INFO_NUM); + while (sprit_ptr) + { + tmp_ptr = sprit_ptr; + while (*tmp_ptr == ' ' || *tmp_ptr == '\r' || + *tmp_ptr == '\n' || *tmp_ptr == '\t') + tmp_ptr++; + + if (*tmp_ptr == '\0') + break; + + title_length = 0; + start_ptr = tmp_ptr; + while (*start_ptr != ' ' && *start_ptr != '\'' && + *start_ptr != '"' && *start_ptr != '\0' && + *start_ptr != '\r' && *start_ptr != '\n' && + *start_ptr != '\t') + { + title_length++; + start_ptr++; + } + connect_string_parse.set_param_title(tmp_ptr, tmp_ptr + title_length); + if ((error_num = connect_string_parse.get_next_parameter_head( + start_ptr, &sprit_ptr))) + { + goto error; + } + + switch (title_length) + { + case 0: + error_num = connect_string_parse.print_param_error(); + if (error_num) + goto error; + continue; + case 3: + SPIDER_PARAM_LONG_LIST_WITH_MAX("abl", access_balances, 0, + 2147483647); + SPIDER_PARAM_INT_WITH_MAX("aim", auto_increment_mode, 0, 3); + SPIDER_PARAM_INT("alc", active_link_count, 1); +#ifdef HA_CAN_BULK_ACCESS + SPIDER_PARAM_INT_WITH_MAX("baf", bulk_access_free, 0, 1); +#endif + SPIDER_PARAM_INT("bfz", buffer_size, 0); +#ifndef WITHOUT_SPIDER_BG_SEARCH + SPIDER_PARAM_LONGLONG("bfr", bgs_first_read, 0); + SPIDER_PARAM_INT("bmd", bgs_mode, 0); + SPIDER_PARAM_LONGLONG("bsr", bgs_second_read, 0); +#endif + SPIDER_PARAM_STR("bke", bka_engine); + SPIDER_PARAM_INT_WITH_MAX("bkm", bka_mode, 0, 2); + SPIDER_PARAM_INT("bsz", bulk_size, 0); + SPIDER_PARAM_LONG_LIST_WITH_MAX("btt", bka_table_name_types, + 0, 1); + SPIDER_PARAM_INT_WITH_MAX("bum", bulk_update_mode, 0, 2); + SPIDER_PARAM_INT("bus", bulk_update_size, 0); +#ifndef WITHOUT_SPIDER_BG_SEARCH + SPIDER_PARAM_INT_WITH_MAX("cbm", crd_bg_mode, 0, 2); +#endif + SPIDER_PARAM_DOUBLE("civ", crd_interval, 0); + SPIDER_PARAM_INT_WITH_MAX("cmd", crd_mode, 0, 3); + SPIDER_PARAM_INT_WITH_MAX("csr", casual_read, 0, 63); +#ifdef WITH_PARTITION_STORAGE_ENGINE + SPIDER_PARAM_INT_WITH_MAX("csy", crd_sync, 0, 2); +#endif + SPIDER_PARAM_LONG_LIST_WITH_MAX("cto", connect_timeouts, 0, + 2147483647); + SPIDER_PARAM_INT_WITH_MAX("ctp", crd_type, 0, 2); + SPIDER_PARAM_DOUBLE("cwg", crd_weight, 1); + SPIDER_PARAM_INT_WITH_MAX("dat", delete_all_rows_type, 0, 1); + SPIDER_PARAM_INT_WITH_MAX("ddi", direct_dup_insert, 0, 1); + SPIDER_PARAM_STR_LIST("dff", tgt_default_files); + SPIDER_PARAM_STR_LIST("dfg", tgt_default_groups); + SPIDER_PARAM_LONGLONG("dol", direct_order_limit, 0); + SPIDER_PARAM_STR_LIST("dsn", tgt_dsns); + SPIDER_PARAM_INT_WITH_MAX("erm", error_read_mode, 0, 1); + SPIDER_PARAM_INT_WITH_MAX("ewm", error_write_mode, 0, 1); +#ifdef HA_CAN_FORCE_BULK_DELETE + SPIDER_PARAM_INT_WITH_MAX("fbd", force_bulk_delete, 0, 1); +#endif +#ifdef HA_CAN_FORCE_BULK_UPDATE + SPIDER_PARAM_INT_WITH_MAX("fbu", force_bulk_update, 0, 1); +#endif + SPIDER_PARAM_LONGLONG("frd", first_read, 0); +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + SPIDER_PARAM_LONGLONG("hrf", hs_result_free_size, 0); + SPIDER_PARAM_LONG_LIST_WITH_MAX( + "hrp", hs_read_ports, 0, 65535); + SPIDER_PARAM_STR_LIST("hrs", hs_read_socks); + SPIDER_PARAM_LONG_LIST_WITH_MAX( + "hwp", hs_write_ports, 0, 65535); + SPIDER_PARAM_LONG_LIST_WITH_MAX( + "hwr", hs_write_to_reads, 0, 1); + SPIDER_PARAM_STR_LIST("hws", hs_write_socks); +#endif + SPIDER_PARAM_INT("isa", init_sql_alloc_size, 0); + SPIDER_PARAM_INT_WITH_MAX("idl", internal_delayed, 0, 1); + SPIDER_PARAM_LONGLONG("ilm", internal_limit, 0); + SPIDER_PARAM_LONGLONG("ios", internal_offset, 0); + SPIDER_PARAM_INT_WITH_MAX("iom", internal_optimize, 0, 1); + SPIDER_PARAM_INT_WITH_MAX("iol", internal_optimize_local, 0, 1); + SPIDER_PARAM_INT_WITH_MAX("lmr", low_mem_read, 0, 1); + SPIDER_PARAM_INT_WITH_MAX("lcs", load_crd_at_startup, 0, 1); + SPIDER_PARAM_INT_WITH_MAX("lss", load_sts_at_startup, 0, 1); + SPIDER_PARAM_LONG_LIST_WITH_MAX("lst", link_statuses, 0, 3); +#ifndef WITHOUT_SPIDER_BG_SEARCH + SPIDER_PARAM_LONG_LIST_WITH_MAX("mbf", monitoring_bg_flag, 0, 1); + SPIDER_PARAM_LONGLONG_LIST_WITH_MAX( + "mbi", monitoring_bg_interval, 0, 4294967295LL); + SPIDER_PARAM_LONG_LIST_WITH_MAX("mbk", monitoring_bg_kind, 0, 3); +#endif + SPIDER_PARAM_LONG_LIST_WITH_MAX("mbp", monitoring_binlog_pos_at_failing, 0, 2); + SPIDER_PARAM_LONG_LIST_WITH_MAX("mfg", monitoring_flag, 0, 1); + SPIDER_PARAM_LONG_LIST_WITH_MAX("mkd", monitoring_kind, 0, 3); + SPIDER_PARAM_LONGLONG_LIST_WITH_MAX( + "mlt", monitoring_limit, 0, 9223372036854775807LL); + SPIDER_PARAM_INT("mod", max_order, 0); + SPIDER_PARAM_LONGLONG_LIST_WITH_MAX( + "msi", monitoring_sid, 0, 4294967295LL); + SPIDER_PARAM_INT_WITH_MAX("msr", multi_split_read, 0, 2147483647); + SPIDER_PARAM_LONG_LIST_WITH_MAX("nrt", net_read_timeouts, 0, + 2147483647); + SPIDER_PARAM_LONG_LIST_WITH_MAX("nwt", net_write_timeouts, 0, + 2147483647); + SPIDER_PARAM_STR_LIST("pkn", tgt_pk_names); + SPIDER_PARAM_LONGLONG("prt", priority, 0); + SPIDER_PARAM_INT_WITH_MAX("qch", query_cache, 0, 2); + SPIDER_PARAM_INT_WITH_MAX("qcs", query_cache_sync, 0, 3); + SPIDER_PARAM_INT_WITH_MAX("qmd", quick_mode, 0, 3); + SPIDER_PARAM_LONGLONG("qpb", quick_page_byte, 0); + SPIDER_PARAM_LONGLONG("qps", quick_page_size, 0); + SPIDER_PARAM_INT_WITH_MAX("rom", read_only_mode, 0, 1); + SPIDER_PARAM_DOUBLE("rrt", read_rate, 0); + SPIDER_PARAM_INT_WITH_MAX("rsa", reset_sql_alloc, 0, 1); +#ifndef WITHOUT_SPIDER_BG_SEARCH + SPIDER_PARAM_INT_WITH_MAX("sbm", sts_bg_mode, 0, 2); +#endif + SPIDER_PARAM_STR_LIST("sca", tgt_ssl_cas); + SPIDER_PARAM_STR_LIST("sch", tgt_ssl_ciphers); + SPIDER_PARAM_INT_WITH_MAX("scm", select_column_mode, 0, 1); + SPIDER_PARAM_STR_LIST("scp", tgt_ssl_capaths); + SPIDER_PARAM_STR_LIST("scr", tgt_ssl_certs); + SPIDER_PARAM_INT_WITH_MAX("sdc", skip_default_condition, 0, 1); + SPIDER_PARAM_LONG_LIST_WITH_MAX("sgb", strict_group_bys, 0, 1); + SPIDER_PARAM_DOUBLE("siv", sts_interval, 0); + SPIDER_PARAM_STR_LIST("sky", tgt_ssl_keys); + SPIDER_PARAM_STR_LIST("sli", static_link_ids); + SPIDER_PARAM_INT_WITH_MAX("slc", store_last_crd, 0, 1); + SPIDER_PARAM_INT_WITH_MAX("slm", selupd_lock_mode, 0, 2); + SPIDER_PARAM_INT_WITH_MAX("sls", store_last_sts, 0, 1); + SPIDER_PARAM_INT_WITH_MAX("smd", sts_mode, 1, 2); + SPIDER_PARAM_LONGLONG("smr", static_mean_rec_length, 0); + SPIDER_PARAM_LONGLONG("spr", split_read, 0); + SPIDER_PARAM_INT_WITH_MAX("sps", skip_parallel_search, 0, 3); + SPIDER_PARAM_STR_LIST("sqn", tgt_sequence_names); + SPIDER_PARAM_LONGLONG("srd", second_read, 0); + SPIDER_PARAM_DOUBLE("srt", scan_rate, 0); + SPIDER_PARAM_STR_LIST("srv", server_names); + SPIDER_PARAM_DOUBLE("ssr", semi_split_read, 0); + SPIDER_PARAM_LONGLONG("ssl", semi_split_read_limit, 0); +#ifdef WITH_PARTITION_STORAGE_ENGINE + SPIDER_PARAM_INT_WITH_MAX("ssy", sts_sync, 0, 2); +#endif + SPIDER_PARAM_INT_WITH_MAX("stc", semi_table_lock_conn, 0, 1); + SPIDER_PARAM_INT_WITH_MAX("stl", semi_table_lock, 0, 1); + SPIDER_PARAM_LONGLONG("srs", static_records_for_status, 0); + SPIDER_PARAM_LONG_LIST_WITH_MAX("svc", tgt_ssl_vscs, 0, 1); + SPIDER_PARAM_STR_LIST("tbl", tgt_table_names); + SPIDER_PARAM_INT_WITH_MAX("tcm", table_count_mode, 0, 3); + SPIDER_PARAM_LONG_LIST_WITH_MAX("uhd", use_handlers, 0, 3); +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + SPIDER_PARAM_LONG_LIST_WITH_MAX( + "uhr", use_hs_reads, 0, 1); + SPIDER_PARAM_LONG_LIST_WITH_MAX( + "uhw", use_hs_writes, 0, 1); +#endif + SPIDER_PARAM_INT_WITH_MAX("upu", use_pushdown_udf, 0, 1); + SPIDER_PARAM_INT_WITH_MAX("utc", use_table_charset, 0, 1); + error_num = connect_string_parse.print_param_error(); + goto error; + case 4: + SPIDER_PARAM_STR_LIST("host", tgt_hosts); + SPIDER_PARAM_STR_LIST("user", tgt_usernames); + SPIDER_PARAM_LONG_LIST_WITH_MAX("port", tgt_ports, 0, 65535); + error_num = connect_string_parse.print_param_error(); + goto error; + case 5: + SPIDER_PARAM_STR_LIST("table", tgt_table_names); + error_num = connect_string_parse.print_param_error(); + goto error; + case 6: + SPIDER_PARAM_STR_LIST("server", server_names); + SPIDER_PARAM_STR_LIST("socket", tgt_sockets); + SPIDER_PARAM_HINT("idx", key_hint, 3, (int) table_share->keys, + spider_db_append_key_hint); + SPIDER_PARAM_STR_LIST("ssl_ca", tgt_ssl_cas); + SPIDER_PARAM_NUMHINT("skc", static_key_cardinality, 3, + (int) table_share->keys, spider_set_ll_value); + error_num = connect_string_parse.print_param_error(); + goto error; + case 7: + SPIDER_PARAM_STR_LIST("wrapper", tgt_wrappers); + SPIDER_PARAM_STR_LIST("ssl_key", tgt_ssl_keys); + SPIDER_PARAM_STR_LIST("pk_name", tgt_pk_names); + error_num = connect_string_parse.print_param_error(); + goto error; + case 8: + SPIDER_PARAM_STR_LIST("database", tgt_dbs); + SPIDER_PARAM_STR_LIST("password", tgt_passwords); + SPIDER_PARAM_INT_WITH_MAX("sts_mode", sts_mode, 1, 2); +#ifdef WITH_PARTITION_STORAGE_ENGINE + SPIDER_PARAM_INT_WITH_MAX("sts_sync", sts_sync, 0, 2); +#endif + SPIDER_PARAM_INT_WITH_MAX("crd_mode", crd_mode, 0, 3); +#ifdef WITH_PARTITION_STORAGE_ENGINE + SPIDER_PARAM_INT_WITH_MAX("crd_sync", crd_sync, 0, 2); +#endif + SPIDER_PARAM_INT_WITH_MAX("crd_type", crd_type, 0, 2); + SPIDER_PARAM_LONGLONG("priority", priority, 0); +#ifndef WITHOUT_SPIDER_BG_SEARCH + SPIDER_PARAM_INT("bgs_mode", bgs_mode, 0); +#endif + SPIDER_PARAM_STR_LIST("ssl_cert", tgt_ssl_certs); + SPIDER_PARAM_INT_WITH_MAX("bka_mode", bka_mode, 0, 2); + error_num = connect_string_parse.print_param_error(); + goto error; + case 9: + SPIDER_PARAM_INT("max_order", max_order, 0); + SPIDER_PARAM_INT("bulk_size", bulk_size, 0); + SPIDER_PARAM_DOUBLE("scan_rate", scan_rate, 0); + SPIDER_PARAM_DOUBLE("read_rate", read_rate, 0); + error_num = connect_string_parse.print_param_error(); + goto error; + case 10: + SPIDER_PARAM_DOUBLE("crd_weight", crd_weight, 1); + SPIDER_PARAM_LONGLONG("split_read", split_read, 0); + SPIDER_PARAM_INT_WITH_MAX("quick_mode", quick_mode, 0, 3); + SPIDER_PARAM_STR_LIST("ssl_cipher", tgt_ssl_ciphers); + SPIDER_PARAM_STR_LIST("ssl_capath", tgt_ssl_capaths); + SPIDER_PARAM_STR("bka_engine", bka_engine); + SPIDER_PARAM_LONGLONG("first_read", first_read, 0); + error_num = connect_string_parse.print_param_error(); + goto error; + case 11: + SPIDER_PARAM_INT_WITH_MAX("query_cache", query_cache, 0, 2); +#ifndef WITHOUT_SPIDER_BG_SEARCH + SPIDER_PARAM_INT_WITH_MAX("crd_bg_mode", crd_bg_mode, 0, 2); + SPIDER_PARAM_INT_WITH_MAX("sts_bg_mode", sts_bg_mode, 0, 2); +#endif + SPIDER_PARAM_LONG_LIST_WITH_MAX("link_status", link_statuses, 0, 3); + SPIDER_PARAM_LONG_LIST_WITH_MAX("use_handler", use_handlers, 0, 3); +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + SPIDER_PARAM_LONG_LIST_WITH_MAX("use_hs_read", use_hs_reads, 0, 1); +#endif + SPIDER_PARAM_INT_WITH_MAX("casual_read", casual_read, 0, 63); + SPIDER_PARAM_INT("buffer_size", buffer_size, 0); + error_num = connect_string_parse.print_param_error(); + goto error; + case 12: + SPIDER_PARAM_DOUBLE("sts_interval", sts_interval, 0); + SPIDER_PARAM_DOUBLE("crd_interval", crd_interval, 0); + SPIDER_PARAM_INT_WITH_MAX("low_mem_read", low_mem_read, 0, 1); + SPIDER_PARAM_STR_LIST("default_file", tgt_default_files); +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + SPIDER_PARAM_LONG_LIST_WITH_MAX( + "use_hs_write", use_hs_writes, 0, 1); + SPIDER_PARAM_LONG_LIST_WITH_MAX( + "hs_read_port", hs_read_ports, 0, 65535); +#endif + error_num = connect_string_parse.print_param_error(); + goto error; + case 13: + SPIDER_PARAM_STR_LIST("default_group", tgt_default_groups); +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + SPIDER_PARAM_LONG_LIST_WITH_MAX( + "hs_write_port", hs_write_ports, 0, 65535); +#endif + SPIDER_PARAM_STR_LIST("sequence_name", tgt_sequence_names); + error_num = connect_string_parse.print_param_error(); + goto error; + case 14: + SPIDER_PARAM_LONGLONG("internal_limit", internal_limit, 0); +#ifndef WITHOUT_SPIDER_BG_SEARCH + SPIDER_PARAM_LONGLONG("bgs_first_read", bgs_first_read, 0); +#endif +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + SPIDER_PARAM_STR_LIST( + "hs_read_socket", hs_read_socks); +#endif + SPIDER_PARAM_INT_WITH_MAX("read_only_mode", read_only_mode, 0, 1); + SPIDER_PARAM_LONG_LIST_WITH_MAX("access_balance", access_balances, 0, + 2147483647); + SPIDER_PARAM_STR_LIST("static_link_id", static_link_ids); + SPIDER_PARAM_INT_WITH_MAX("store_last_crd", store_last_crd, 0, 1); + SPIDER_PARAM_INT_WITH_MAX("store_last_sts", store_last_sts, 0, 1); + error_num = connect_string_parse.print_param_error(); + goto error; + case 15: + SPIDER_PARAM_LONGLONG("internal_offset", internal_offset, 0); + SPIDER_PARAM_INT_WITH_MAX("reset_sql_alloc", reset_sql_alloc, 0, 1); + SPIDER_PARAM_INT_WITH_MAX("semi_table_lock", semi_table_lock, 0, 1); + SPIDER_PARAM_LONGLONG("quick_page_byte", quick_page_byte, 0); + SPIDER_PARAM_LONGLONG("quick_page_size", quick_page_size, 0); +#ifndef WITHOUT_SPIDER_BG_SEARCH + SPIDER_PARAM_LONGLONG("bgs_second_read", bgs_second_read, 0); +#endif + SPIDER_PARAM_LONG_LIST_WITH_MAX("monitoring_flag", monitoring_flag, 0, 1); + SPIDER_PARAM_LONG_LIST_WITH_MAX("monitoring_kind", monitoring_kind, 0, 3); + SPIDER_PARAM_DOUBLE("semi_split_read", semi_split_read, 0); +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + SPIDER_PARAM_STR_LIST( + "hs_write_socket", hs_write_socks); +#endif + SPIDER_PARAM_LONG_LIST_WITH_MAX("connect_timeout", connect_timeouts, + 0, 2147483647); + SPIDER_PARAM_LONG_LIST_WITH_MAX("strict_group_by", + strict_group_bys, 0, 1); + SPIDER_PARAM_INT_WITH_MAX("error_read_mode", error_read_mode, 0, 1); + error_num = connect_string_parse.print_param_error(); + goto error; + case 16: + SPIDER_PARAM_INT_WITH_MAX( + "multi_split_read", multi_split_read, 0, 2147483647); + SPIDER_PARAM_INT_WITH_MAX( + "selupd_lock_mode", selupd_lock_mode, 0, 2); + SPIDER_PARAM_INT_WITH_MAX( + "internal_delayed", internal_delayed, 0, 1); + SPIDER_PARAM_INT_WITH_MAX( + "table_count_mode", table_count_mode, 0, 3); + SPIDER_PARAM_INT_WITH_MAX( + "use_pushdown_udf", use_pushdown_udf, 0, 1); + SPIDER_PARAM_LONGLONG_LIST_WITH_MAX( + "monitoring_limit", monitoring_limit, 0, 9223372036854775807LL); + SPIDER_PARAM_INT_WITH_MAX( + "bulk_update_mode", bulk_update_mode, 0, 2); + SPIDER_PARAM_INT("bulk_update_size", bulk_update_size, 0); + SPIDER_PARAM_LONG_LIST_WITH_MAX("net_read_timeout", + net_read_timeouts, 0, 2147483647); +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + SPIDER_PARAM_LONG_LIST_WITH_MAX( + "hs_write_to_read", hs_write_to_reads, 0, 1); +#endif + SPIDER_PARAM_INT_WITH_MAX( + "error_write_mode", error_write_mode, 0, 1); +#ifdef HA_CAN_BULK_ACCESS + SPIDER_PARAM_INT_WITH_MAX( + "bulk_access_free", bulk_access_free, 0, 1); +#endif + SPIDER_PARAM_INT_WITH_MAX( + "query_cache_sync", query_cache_sync, 0, 3); + error_num = connect_string_parse.print_param_error(); + goto error; + case 17: + SPIDER_PARAM_INT_WITH_MAX( + "internal_optimize", internal_optimize, 0, 1); + SPIDER_PARAM_INT_WITH_MAX( + "use_table_charset", use_table_charset, 0, 1); + SPIDER_PARAM_INT_WITH_MAX( + "direct_dup_insert", direct_dup_insert, 0, 1); + SPIDER_PARAM_INT("active_link_count", active_link_count, 1); + SPIDER_PARAM_LONG_LIST_WITH_MAX("net_write_timeout", + net_write_timeouts, 0, 2147483647); +#ifdef HA_CAN_FORCE_BULK_DELETE + SPIDER_PARAM_INT_WITH_MAX( + "force_bulk_delete", force_bulk_delete, 0, 1); +#endif +#ifdef HA_CAN_FORCE_BULK_UPDATE + SPIDER_PARAM_INT_WITH_MAX( + "force_bulk_update", force_bulk_update, 0, 1); +#endif + error_num = connect_string_parse.print_param_error(); + goto error; + case 18: + SPIDER_PARAM_INT_WITH_MAX( + "select_column_mode", select_column_mode, 0, 1); +#ifndef WITHOUT_SPIDER_BG_SEARCH + SPIDER_PARAM_LONG_LIST_WITH_MAX( + "monitoring_bg_flag", monitoring_bg_flag, 0, 1); + SPIDER_PARAM_LONG_LIST_WITH_MAX( + "monitoring_bg_kind", monitoring_bg_kind, 0, 3); +#endif + SPIDER_PARAM_LONGLONG( + "direct_order_limit", direct_order_limit, 0); + error_num = connect_string_parse.print_param_error(); + goto error; + case 19: + SPIDER_PARAM_INT("init_sql_alloc_size", init_sql_alloc_size, 0); + SPIDER_PARAM_INT_WITH_MAX( + "auto_increment_mode", auto_increment_mode, 0, 3); +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + SPIDER_PARAM_LONGLONG("hs_result_free_size", hs_result_free_size, 0); +#endif + SPIDER_PARAM_LONG_LIST_WITH_MAX("bka_table_name_type", + bka_table_name_types, 0, 1); + SPIDER_PARAM_INT_WITH_MAX( + "load_crd_at_startup", load_crd_at_startup, 0, 1); + SPIDER_PARAM_INT_WITH_MAX( + "load_sts_at_startup", load_sts_at_startup, 0, 1); + error_num = connect_string_parse.print_param_error(); + goto error; + case 20: + SPIDER_PARAM_LONGLONG_LIST_WITH_MAX( + "monitoring_server_id", monitoring_sid, 0, 4294967295LL); + SPIDER_PARAM_INT_WITH_MAX( + "delete_all_rows_type", delete_all_rows_type, 0, 1); + SPIDER_PARAM_INT_WITH_MAX( + "skip_parallel_search", skip_parallel_search, 0, 3); + error_num = connect_string_parse.print_param_error(); + goto error; + case 21: + SPIDER_PARAM_LONGLONG( + "semi_split_read_limit", semi_split_read_limit, 0); + error_num = connect_string_parse.print_param_error(); + goto error; + case 22: + SPIDER_PARAM_LONG_LIST_WITH_MAX( + "ssl_verify_server_cert", tgt_ssl_vscs, 0, 1); +#ifndef WITHOUT_SPIDER_BG_SEARCH + SPIDER_PARAM_LONGLONG_LIST_WITH_MAX( + "monitoring_bg_interval", monitoring_bg_interval, 0, 4294967295LL); +#endif + SPIDER_PARAM_INT_WITH_MAX( + "skip_default_condition", skip_default_condition, 0, 1); + SPIDER_PARAM_LONGLONG( + "static_mean_rec_length", static_mean_rec_length, 0); + error_num = connect_string_parse.print_param_error(); + goto error; + case 23: + SPIDER_PARAM_INT_WITH_MAX( + "internal_optimize_local", internal_optimize_local, 0, 1); + error_num = connect_string_parse.print_param_error(); + goto error; + case 25: + SPIDER_PARAM_LONGLONG("static_records_for_status", + static_records_for_status, 0); + SPIDER_PARAM_NUMHINT("static_key_cardinality", static_key_cardinality, + 3, (int) table_share->keys, spider_set_ll_value); + error_num = connect_string_parse.print_param_error(); + goto error; + case 26: + SPIDER_PARAM_INT_WITH_MAX( + "semi_table_lock_connection", semi_table_lock_conn, 0, 1); + error_num = connect_string_parse.print_param_error(); + goto error; + case 32: + SPIDER_PARAM_LONG_LIST_WITH_MAX("monitoring_binlog_pos_at_failing", + monitoring_binlog_pos_at_failing, 0, 2); + error_num = connect_string_parse.print_param_error(); + goto error; + default: + error_num = connect_string_parse.print_param_error(); + goto error; + } + + /* Verify that the remainder of the parameter value is whitespace */ + if ((error_num = connect_string_parse.has_extra_parameter_values())) + goto error; + } + } + + /* check all_link_count */ + share->all_link_count = 1; + if (share->all_link_count < share->server_names_length) + share->all_link_count = share->server_names_length; + if (share->all_link_count < share->tgt_table_names_length) + share->all_link_count = share->tgt_table_names_length; + if (share->all_link_count < share->tgt_dbs_length) + share->all_link_count = share->tgt_dbs_length; + if (share->all_link_count < share->tgt_hosts_length) + share->all_link_count = share->tgt_hosts_length; + if (share->all_link_count < share->tgt_usernames_length) + share->all_link_count = share->tgt_usernames_length; + if (share->all_link_count < share->tgt_passwords_length) + share->all_link_count = share->tgt_passwords_length; + if (share->all_link_count < share->tgt_sockets_length) + share->all_link_count = share->tgt_sockets_length; + if (share->all_link_count < share->tgt_wrappers_length) + share->all_link_count = share->tgt_wrappers_length; + if (share->all_link_count < share->tgt_ssl_cas_length) + share->all_link_count = share->tgt_ssl_cas_length; + if (share->all_link_count < share->tgt_ssl_capaths_length) + share->all_link_count = share->tgt_ssl_capaths_length; + if (share->all_link_count < share->tgt_ssl_certs_length) + share->all_link_count = share->tgt_ssl_certs_length; + if (share->all_link_count < share->tgt_ssl_ciphers_length) + share->all_link_count = share->tgt_ssl_ciphers_length; + if (share->all_link_count < share->tgt_ssl_keys_length) + share->all_link_count = share->tgt_ssl_keys_length; + if (share->all_link_count < share->tgt_default_files_length) + share->all_link_count = share->tgt_default_files_length; + if (share->all_link_count < share->tgt_default_groups_length) + share->all_link_count = share->tgt_default_groups_length; + if (share->all_link_count < share->tgt_dsns_length) + share->all_link_count = share->tgt_dsns_length; + if (share->all_link_count < share->tgt_pk_names_length) + share->all_link_count = share->tgt_pk_names_length; + if (share->all_link_count < share->tgt_sequence_names_length) + share->all_link_count = share->tgt_sequence_names_length; + if (share->all_link_count < share->static_link_ids_length) + share->all_link_count = share->static_link_ids_length; + if (share->all_link_count < share->tgt_ports_length) + share->all_link_count = share->tgt_ports_length; + if (share->all_link_count < share->tgt_ssl_vscs_length) + share->all_link_count = share->tgt_ssl_vscs_length; + if (share->all_link_count < share->link_statuses_length) + share->all_link_count = share->link_statuses_length; + if (share->all_link_count < share->monitoring_binlog_pos_at_failing_length) + share->all_link_count = share->monitoring_binlog_pos_at_failing_length; + if (share->all_link_count < share->monitoring_flag_length) + share->all_link_count = share->monitoring_flag_length; + if (share->all_link_count < share->monitoring_kind_length) + share->all_link_count = share->monitoring_kind_length; + if (share->all_link_count < share->monitoring_limit_length) + share->all_link_count = share->monitoring_limit_length; + if (share->all_link_count < share->monitoring_sid_length) + share->all_link_count = share->monitoring_sid_length; +#ifndef WITHOUT_SPIDER_BG_SEARCH + if (share->all_link_count < share->monitoring_bg_flag_length) + share->all_link_count = share->monitoring_bg_flag_length; + if (share->all_link_count < share->monitoring_bg_kind_length) + share->all_link_count = share->monitoring_bg_kind_length; + if (share->all_link_count < share->monitoring_bg_interval_length) + share->all_link_count = share->monitoring_bg_interval_length; +#endif +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + if (share->all_link_count < share->use_hs_reads_length) + share->all_link_count = share->use_hs_reads_length; + if (share->all_link_count < share->use_hs_writes_length) + share->all_link_count = share->use_hs_writes_length; + if (share->all_link_count < share->hs_read_ports_length) + share->all_link_count = share->hs_read_ports_length; + if (share->all_link_count < share->hs_write_ports_length) + share->all_link_count = share->hs_write_ports_length; + if (share->all_link_count < share->hs_read_socks_length) + share->all_link_count = share->hs_read_socks_length; + if (share->all_link_count < share->hs_write_socks_length) + share->all_link_count = share->hs_write_socks_length; + if (share->all_link_count < share->hs_write_to_reads_length) + share->all_link_count = share->hs_write_to_reads_length; +#endif + if (share->all_link_count < share->use_handlers_length) + share->all_link_count = share->use_handlers_length; + if (share->all_link_count < share->connect_timeouts_length) + share->all_link_count = share->connect_timeouts_length; + if (share->all_link_count < share->net_read_timeouts_length) + share->all_link_count = share->net_read_timeouts_length; + if (share->all_link_count < share->net_write_timeouts_length) + share->all_link_count = share->net_write_timeouts_length; + if (share->all_link_count < share->access_balances_length) + share->all_link_count = share->access_balances_length; + if (share->all_link_count < share->bka_table_name_types_length) + share->all_link_count = share->bka_table_name_types_length; + if (share->all_link_count < share->strict_group_bys_length) + share->all_link_count = share->strict_group_bys_length; + if ((error_num = spider_increase_string_list( + &share->server_names, + &share->server_names_lengths, + &share->server_names_length, + &share->server_names_charlen, + share->all_link_count))) + goto error; + if ((error_num = spider_increase_string_list( + &share->tgt_table_names, + &share->tgt_table_names_lengths, + &share->tgt_table_names_length, + &share->tgt_table_names_charlen, + share->all_link_count))) + goto error; + if ((error_num = spider_increase_string_list( + &share->tgt_dbs, + &share->tgt_dbs_lengths, + &share->tgt_dbs_length, + &share->tgt_dbs_charlen, + share->all_link_count))) + goto error; + if ((error_num = spider_increase_string_list( + &share->tgt_hosts, + &share->tgt_hosts_lengths, + &share->tgt_hosts_length, + &share->tgt_hosts_charlen, + share->all_link_count))) + goto error; + if ((error_num = spider_increase_string_list( + &share->tgt_usernames, + &share->tgt_usernames_lengths, + &share->tgt_usernames_length, + &share->tgt_usernames_charlen, + share->all_link_count))) + goto error; + if ((error_num = spider_increase_string_list( + &share->tgt_passwords, + &share->tgt_passwords_lengths, + &share->tgt_passwords_length, + &share->tgt_passwords_charlen, + share->all_link_count))) + goto error; + if ((error_num = spider_increase_string_list( + &share->tgt_sockets, + &share->tgt_sockets_lengths, + &share->tgt_sockets_length, + &share->tgt_sockets_charlen, + share->all_link_count))) + goto error; + if ((error_num = spider_increase_string_list( + &share->tgt_wrappers, + &share->tgt_wrappers_lengths, + &share->tgt_wrappers_length, + &share->tgt_wrappers_charlen, + share->all_link_count))) + goto error; + if ((error_num = spider_increase_string_list( + &share->tgt_ssl_cas, + &share->tgt_ssl_cas_lengths, + &share->tgt_ssl_cas_length, + &share->tgt_ssl_cas_charlen, + share->all_link_count))) + goto error; + if ((error_num = spider_increase_string_list( + &share->tgt_ssl_capaths, + &share->tgt_ssl_capaths_lengths, + &share->tgt_ssl_capaths_length, + &share->tgt_ssl_capaths_charlen, + share->all_link_count))) + goto error; + if ((error_num = spider_increase_string_list( + &share->tgt_ssl_certs, + &share->tgt_ssl_certs_lengths, + &share->tgt_ssl_certs_length, + &share->tgt_ssl_certs_charlen, + share->all_link_count))) + goto error; + if ((error_num = spider_increase_string_list( + &share->tgt_ssl_ciphers, + &share->tgt_ssl_ciphers_lengths, + &share->tgt_ssl_ciphers_length, + &share->tgt_ssl_ciphers_charlen, + share->all_link_count))) + goto error; + if ((error_num = spider_increase_string_list( + &share->tgt_ssl_keys, + &share->tgt_ssl_keys_lengths, + &share->tgt_ssl_keys_length, + &share->tgt_ssl_keys_charlen, + share->all_link_count))) + goto error; + if ((error_num = spider_increase_string_list( + &share->tgt_default_files, + &share->tgt_default_files_lengths, + &share->tgt_default_files_length, + &share->tgt_default_files_charlen, + share->all_link_count))) + goto error; + if ((error_num = spider_increase_string_list( + &share->tgt_default_groups, + &share->tgt_default_groups_lengths, + &share->tgt_default_groups_length, + &share->tgt_default_groups_charlen, + share->all_link_count))) + goto error; + if ((error_num = spider_increase_string_list( + &share->tgt_dsns, + &share->tgt_dsns_lengths, + &share->tgt_dsns_length, + &share->tgt_dsns_charlen, + share->all_link_count))) + goto error; + if ((error_num = spider_increase_string_list( + &share->tgt_pk_names, + &share->tgt_pk_names_lengths, + &share->tgt_pk_names_length, + &share->tgt_pk_names_charlen, + share->all_link_count))) + goto error; + if ((error_num = spider_increase_string_list( + &share->tgt_sequence_names, + &share->tgt_sequence_names_lengths, + &share->tgt_sequence_names_length, + &share->tgt_sequence_names_charlen, + share->all_link_count))) + goto error; + if ((error_num = spider_increase_null_string_list( + &share->static_link_ids, + &share->static_link_ids_lengths, + &share->static_link_ids_length, + &share->static_link_ids_charlen, + share->all_link_count))) + goto error; + if ((error_num = spider_increase_long_list( + &share->tgt_ports, + &share->tgt_ports_length, + share->all_link_count))) + goto error; + if ((error_num = spider_increase_long_list( + &share->tgt_ssl_vscs, + &share->tgt_ssl_vscs_length, + share->all_link_count))) + goto error; + if ((error_num = spider_increase_long_list( + &share->link_statuses, + &share->link_statuses_length, + share->all_link_count))) + goto error; +#ifndef WITHOUT_SPIDER_BG_SEARCH + if ((error_num = spider_increase_long_list( + &share->monitoring_bg_flag, + &share->monitoring_bg_flag_length, + share->all_link_count))) + goto error; + if ((error_num = spider_increase_long_list( + &share->monitoring_bg_kind, + &share->monitoring_bg_kind_length, + share->all_link_count))) + goto error; +#endif + if ((error_num = spider_increase_long_list( + &share->monitoring_binlog_pos_at_failing, + &share->monitoring_binlog_pos_at_failing_length, + share->all_link_count))) + goto error; + if ((error_num = spider_increase_long_list( + &share->monitoring_flag, + &share->monitoring_flag_length, + share->all_link_count))) + goto error; + if ((error_num = spider_increase_long_list( + &share->monitoring_kind, + &share->monitoring_kind_length, + share->all_link_count))) + goto error; +#ifndef WITHOUT_SPIDER_BG_SEARCH + if ((error_num = spider_increase_longlong_list( + &share->monitoring_bg_interval, + &share->monitoring_bg_interval_length, + share->all_link_count))) + goto error; +#endif + if ((error_num = spider_increase_longlong_list( + &share->monitoring_limit, + &share->monitoring_limit_length, + share->all_link_count))) + goto error; + if ((error_num = spider_increase_longlong_list( + &share->monitoring_sid, + &share->monitoring_sid_length, + share->all_link_count))) + goto error; +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + if ((error_num = spider_increase_long_list( + &share->use_hs_reads, + &share->use_hs_reads_length, + share->all_link_count))) + goto error; + if ((error_num = spider_increase_long_list( + &share->use_hs_writes, + &share->use_hs_writes_length, + share->all_link_count))) + goto error; + if ((error_num = spider_increase_long_list( + &share->hs_read_ports, + &share->hs_read_ports_length, + share->all_link_count))) + goto error; + if ((error_num = spider_increase_long_list( + &share->hs_write_ports, + &share->hs_write_ports_length, + share->all_link_count))) + goto error; + if ((error_num = spider_increase_string_list( + &share->hs_read_socks, + &share->hs_read_socks_lengths, + &share->hs_read_socks_length, + &share->hs_read_socks_charlen, + share->all_link_count))) + goto error; + if ((error_num = spider_increase_string_list( + &share->hs_write_socks, + &share->hs_write_socks_lengths, + &share->hs_write_socks_length, + &share->hs_write_socks_charlen, + share->all_link_count))) + goto error; + if ((error_num = spider_increase_long_list( + &share->hs_write_to_reads, + &share->hs_write_to_reads_length, + share->all_link_count))) + goto error; +#endif + if ((error_num = spider_increase_long_list( + &share->use_handlers, + &share->use_handlers_length, + share->all_link_count))) + goto error; + if ((error_num = spider_increase_long_list( + &share->connect_timeouts, + &share->connect_timeouts_length, + share->all_link_count))) + goto error; + if ((error_num = spider_increase_long_list( + &share->net_read_timeouts, + &share->net_read_timeouts_length, + share->all_link_count))) + goto error; + if ((error_num = spider_increase_long_list( + &share->net_write_timeouts, + &share->net_write_timeouts_length, + share->all_link_count))) + goto error; + if ((error_num = spider_increase_long_list( + &share->access_balances, + &share->access_balances_length, + share->all_link_count))) + goto error; + if ((error_num = spider_increase_long_list( + &share->bka_table_name_types, + &share->bka_table_name_types_length, + share->all_link_count))) + goto error; + if ((error_num = spider_increase_long_list( + &share->strict_group_bys, + &share->strict_group_bys_length, + share->all_link_count))) + goto error; + + /* copy for tables start */ + share_alter = &share->alter_table; + share_alter->all_link_count = share->all_link_count; + if (!(share_alter->tmp_server_names = (char **) + spider_bulk_malloc(spider_current_trx, 43, MYF(MY_WME | MY_ZEROFILL), + &share_alter->tmp_server_names, + (uint) (sizeof(char *) * share->all_link_count), + &share_alter->tmp_tgt_table_names, + (uint) (sizeof(char *) * share->all_link_count), + &share_alter->tmp_tgt_dbs, + (uint) (sizeof(char *) * share->all_link_count), + &share_alter->tmp_tgt_hosts, + (uint) (sizeof(char *) * share->all_link_count), + &share_alter->tmp_tgt_usernames, + (uint) (sizeof(char *) * share->all_link_count), + &share_alter->tmp_tgt_passwords, + (uint) (sizeof(char *) * share->all_link_count), + &share_alter->tmp_tgt_sockets, + (uint) (sizeof(char *) * share->all_link_count), + &share_alter->tmp_tgt_wrappers, + (uint) (sizeof(char *) * share->all_link_count), + &share_alter->tmp_tgt_ssl_cas, + (uint) (sizeof(char *) * share->all_link_count), + &share_alter->tmp_tgt_ssl_capaths, + (uint) (sizeof(char *) * share->all_link_count), + &share_alter->tmp_tgt_ssl_certs, + (uint) (sizeof(char *) * share->all_link_count), + &share_alter->tmp_tgt_ssl_ciphers, + (uint) (sizeof(char *) * share->all_link_count), + &share_alter->tmp_tgt_ssl_keys, + (uint) (sizeof(char *) * share->all_link_count), + &share_alter->tmp_tgt_default_files, + (uint) (sizeof(char *) * share->all_link_count), + &share_alter->tmp_tgt_default_groups, + (uint) (sizeof(char *) * share->all_link_count), + &share_alter->tmp_tgt_dsns, + (uint) (sizeof(char *) * share->all_link_count), + &share_alter->tmp_static_link_ids, + (uint) (sizeof(char *) * share->all_link_count), + &share_alter->tmp_server_names_lengths, + (uint) (sizeof(uint *) * share->all_link_count), + &share_alter->tmp_tgt_table_names_lengths, + (uint) (sizeof(uint *) * share->all_link_count), + &share_alter->tmp_tgt_dbs_lengths, + (uint) (sizeof(uint *) * share->all_link_count), + &share_alter->tmp_tgt_hosts_lengths, + (uint) (sizeof(uint *) * share->all_link_count), + &share_alter->tmp_tgt_usernames_lengths, + (uint) (sizeof(uint *) * share->all_link_count), + &share_alter->tmp_tgt_passwords_lengths, + (uint) (sizeof(uint *) * share->all_link_count), + &share_alter->tmp_tgt_sockets_lengths, + (uint) (sizeof(uint *) * share->all_link_count), + &share_alter->tmp_tgt_wrappers_lengths, + (uint) (sizeof(uint *) * share->all_link_count), + &share_alter->tmp_tgt_ssl_cas_lengths, + (uint) (sizeof(uint *) * share->all_link_count), + &share_alter->tmp_tgt_ssl_capaths_lengths, + (uint) (sizeof(uint *) * share->all_link_count), + &share_alter->tmp_tgt_ssl_certs_lengths, + (uint) (sizeof(uint *) * share->all_link_count), + &share_alter->tmp_tgt_ssl_ciphers_lengths, + (uint) (sizeof(uint *) * share->all_link_count), + &share_alter->tmp_tgt_ssl_keys_lengths, + (uint) (sizeof(uint *) * share->all_link_count), + &share_alter->tmp_tgt_default_files_lengths, + (uint) (sizeof(uint *) * share->all_link_count), + &share_alter->tmp_tgt_default_groups_lengths, + (uint) (sizeof(uint *) * share->all_link_count), + &share_alter->tmp_tgt_dsns_lengths, + (uint) (sizeof(uint *) * share->all_link_count), + &share_alter->tmp_static_link_ids_lengths, + (uint) (sizeof(uint *) * share->all_link_count), + &share_alter->tmp_tgt_ports, + (uint) (sizeof(long) * share->all_link_count), + &share_alter->tmp_tgt_ssl_vscs, + (uint) (sizeof(long) * share->all_link_count), + &share_alter->tmp_monitoring_binlog_pos_at_failing, + (uint) (sizeof(long) * share->all_link_count), + &share_alter->tmp_link_statuses, + (uint) (sizeof(long) * share->all_link_count), + NullS)) + ) { + error_num = HA_ERR_OUT_OF_MEM; + goto error; + } + + + memcpy(share_alter->tmp_server_names, share->server_names, + sizeof(char *) * share->all_link_count); + memcpy(share_alter->tmp_tgt_table_names, share->tgt_table_names, + sizeof(char *) * share->all_link_count); + memcpy(share_alter->tmp_tgt_dbs, share->tgt_dbs, + sizeof(char *) * share->all_link_count); + memcpy(share_alter->tmp_tgt_hosts, share->tgt_hosts, + sizeof(char *) * share->all_link_count); + memcpy(share_alter->tmp_tgt_usernames, share->tgt_usernames, + sizeof(char *) * share->all_link_count); + memcpy(share_alter->tmp_tgt_passwords, share->tgt_passwords, + sizeof(char *) * share->all_link_count); + memcpy(share_alter->tmp_tgt_sockets, share->tgt_sockets, + sizeof(char *) * share->all_link_count); + memcpy(share_alter->tmp_tgt_wrappers, share->tgt_wrappers, + sizeof(char *) * share->all_link_count); + memcpy(share_alter->tmp_tgt_ssl_cas, share->tgt_ssl_cas, + sizeof(char *) * share->all_link_count); + memcpy(share_alter->tmp_tgt_ssl_capaths, share->tgt_ssl_capaths, + sizeof(char *) * share->all_link_count); + memcpy(share_alter->tmp_tgt_ssl_certs, share->tgt_ssl_certs, + sizeof(char *) * share->all_link_count); + memcpy(share_alter->tmp_tgt_ssl_ciphers, share->tgt_ssl_ciphers, + sizeof(char *) * share->all_link_count); + memcpy(share_alter->tmp_tgt_ssl_keys, share->tgt_ssl_keys, + sizeof(char *) * share->all_link_count); + memcpy(share_alter->tmp_tgt_default_files, share->tgt_default_files, + sizeof(char *) * share->all_link_count); + memcpy(share_alter->tmp_tgt_default_groups, share->tgt_default_groups, + sizeof(char *) * share->all_link_count); + memcpy(share_alter->tmp_tgt_dsns, share->tgt_dsns, + sizeof(char *) * share->all_link_count); + memcpy(share_alter->tmp_static_link_ids, share->static_link_ids, + sizeof(char *) * share->all_link_count); + + memcpy(share_alter->tmp_tgt_ports, share->tgt_ports, + sizeof(long) * share->all_link_count); + memcpy(share_alter->tmp_tgt_ssl_vscs, share->tgt_ssl_vscs, + sizeof(long) * share->all_link_count); + memcpy(share_alter->tmp_monitoring_binlog_pos_at_failing, + share->monitoring_binlog_pos_at_failing, + sizeof(long) * share->all_link_count); + memcpy(share_alter->tmp_link_statuses, share->link_statuses, + sizeof(long) * share->all_link_count); + + memcpy(share_alter->tmp_server_names_lengths, + share->server_names_lengths, + sizeof(uint) * share->all_link_count); + memcpy(share_alter->tmp_tgt_table_names_lengths, + share->tgt_table_names_lengths, + sizeof(uint) * share->all_link_count); + memcpy(share_alter->tmp_tgt_dbs_lengths, share->tgt_dbs_lengths, + sizeof(uint) * share->all_link_count); + memcpy(share_alter->tmp_tgt_hosts_lengths, share->tgt_hosts_lengths, + sizeof(uint) * share->all_link_count); + memcpy(share_alter->tmp_tgt_usernames_lengths, + share->tgt_usernames_lengths, + sizeof(uint) * share->all_link_count); + memcpy(share_alter->tmp_tgt_passwords_lengths, + share->tgt_passwords_lengths, + sizeof(uint) * share->all_link_count); + memcpy(share_alter->tmp_tgt_sockets_lengths, share->tgt_sockets_lengths, + sizeof(uint) * share->all_link_count); + memcpy(share_alter->tmp_tgt_wrappers_lengths, + share->tgt_wrappers_lengths, + sizeof(uint) * share->all_link_count); + memcpy(share_alter->tmp_tgt_ssl_cas_lengths, + share->tgt_ssl_cas_lengths, + sizeof(uint) * share->all_link_count); + memcpy(share_alter->tmp_tgt_ssl_capaths_lengths, + share->tgt_ssl_capaths_lengths, + sizeof(uint) * share->all_link_count); + memcpy(share_alter->tmp_tgt_ssl_certs_lengths, + share->tgt_ssl_certs_lengths, + sizeof(uint) * share->all_link_count); + memcpy(share_alter->tmp_tgt_ssl_ciphers_lengths, + share->tgt_ssl_ciphers_lengths, + sizeof(uint) * share->all_link_count); + memcpy(share_alter->tmp_tgt_ssl_keys_lengths, + share->tgt_ssl_keys_lengths, + sizeof(uint) * share->all_link_count); + memcpy(share_alter->tmp_tgt_default_files_lengths, + share->tgt_default_files_lengths, + sizeof(uint) * share->all_link_count); + memcpy(share_alter->tmp_tgt_default_groups_lengths, + share->tgt_default_groups_lengths, + sizeof(uint) * share->all_link_count); + memcpy(share_alter->tmp_tgt_dsns_lengths, + share->tgt_dsns_lengths, + sizeof(uint) * share->all_link_count); + memcpy(share_alter->tmp_static_link_ids_lengths, + share->static_link_ids_lengths, + sizeof(uint) * share->all_link_count); + + share_alter->tmp_server_names_charlen = share->server_names_charlen; + share_alter->tmp_tgt_table_names_charlen = share->tgt_table_names_charlen; + share_alter->tmp_tgt_dbs_charlen = share->tgt_dbs_charlen; + share_alter->tmp_tgt_hosts_charlen = share->tgt_hosts_charlen; + share_alter->tmp_tgt_usernames_charlen = share->tgt_usernames_charlen; + share_alter->tmp_tgt_passwords_charlen = share->tgt_passwords_charlen; + share_alter->tmp_tgt_sockets_charlen = share->tgt_sockets_charlen; + share_alter->tmp_tgt_wrappers_charlen = share->tgt_wrappers_charlen; + share_alter->tmp_tgt_ssl_cas_charlen = share->tgt_ssl_cas_charlen; + share_alter->tmp_tgt_ssl_capaths_charlen = share->tgt_ssl_capaths_charlen; + share_alter->tmp_tgt_ssl_certs_charlen = share->tgt_ssl_certs_charlen; + share_alter->tmp_tgt_ssl_ciphers_charlen = share->tgt_ssl_ciphers_charlen; + share_alter->tmp_tgt_ssl_keys_charlen = share->tgt_ssl_keys_charlen; + share_alter->tmp_tgt_default_files_charlen = + share->tgt_default_files_charlen; + share_alter->tmp_tgt_default_groups_charlen = + share->tgt_default_groups_charlen; + share_alter->tmp_tgt_dsns_charlen = + share->tgt_dsns_charlen; + share_alter->tmp_static_link_ids_charlen = + share->static_link_ids_charlen; + + share_alter->tmp_server_names_length = share->server_names_length; + share_alter->tmp_tgt_table_names_length = share->tgt_table_names_length; + share_alter->tmp_tgt_dbs_length = share->tgt_dbs_length; + share_alter->tmp_tgt_hosts_length = share->tgt_hosts_length; + share_alter->tmp_tgt_usernames_length = share->tgt_usernames_length; + share_alter->tmp_tgt_passwords_length = share->tgt_passwords_length; + share_alter->tmp_tgt_sockets_length = share->tgt_sockets_length; + share_alter->tmp_tgt_wrappers_length = share->tgt_wrappers_length; + share_alter->tmp_tgt_ssl_cas_length = share->tgt_ssl_cas_length; + share_alter->tmp_tgt_ssl_capaths_length = share->tgt_ssl_capaths_length; + share_alter->tmp_tgt_ssl_certs_length = share->tgt_ssl_certs_length; + share_alter->tmp_tgt_ssl_ciphers_length = share->tgt_ssl_ciphers_length; + share_alter->tmp_tgt_ssl_keys_length = share->tgt_ssl_keys_length; + share_alter->tmp_tgt_default_files_length = share->tgt_default_files_length; + share_alter->tmp_tgt_default_groups_length = + share->tgt_default_groups_length; + share_alter->tmp_tgt_dsns_length = + share->tgt_dsns_length; + share_alter->tmp_static_link_ids_length = + share->static_link_ids_length; + share_alter->tmp_tgt_ports_length = share->tgt_ports_length; + share_alter->tmp_tgt_ssl_vscs_length = share->tgt_ssl_vscs_length; + share_alter->tmp_monitoring_binlog_pos_at_failing_length = + share->monitoring_binlog_pos_at_failing_length; + share_alter->tmp_link_statuses_length = share->link_statuses_length; + /* copy for tables end */ + + if ((error_num = spider_set_connect_info_default( + share, +#ifdef WITH_PARTITION_STORAGE_ENGINE + part_elem, + sub_elem, +#endif + table_share + ))) + goto error; + + if (create_table) + { + for (roop_count = 0; roop_count < (int) share->all_link_count; + roop_count++) + { + int roop_count2; + for (roop_count2 = 0; roop_count2 < SPIDER_DBTON_SIZE; roop_count2++) + { + if ( + spider_dbton[roop_count2].wrapper && + !strcmp(share->tgt_wrappers[roop_count], + spider_dbton[roop_count2].wrapper) + ) { + break; + } + } + if (roop_count2 == SPIDER_DBTON_SIZE) + { + DBUG_PRINT("info",("spider err tgt_wrappers[%d]=%s", roop_count, + share->tgt_wrappers[roop_count])); + error_num = ER_SPIDER_INVALID_CONNECT_INFO_NUM; + my_printf_error(error_num, ER_SPIDER_INVALID_CONNECT_INFO_STR, + MYF(0), share->tgt_wrappers[roop_count]); + goto error; + } + + DBUG_PRINT("info", + ("spider server_names_lengths[%d] = %u", roop_count, + share->server_names_lengths[roop_count])); + if (share->server_names_lengths[roop_count] > SPIDER_CONNECT_INFO_MAX_LEN) + { + error_num = ER_SPIDER_INVALID_CONNECT_INFO_TOO_LONG_NUM; + my_printf_error(error_num, ER_SPIDER_INVALID_CONNECT_INFO_TOO_LONG_STR, + MYF(0), share->server_names[roop_count], "server"); + goto error; + } + + DBUG_PRINT("info", + ("spider tgt_table_names_lengths[%d] = %u", roop_count, + share->tgt_table_names_lengths[roop_count])); + if (share->tgt_table_names_lengths[roop_count] > + SPIDER_CONNECT_INFO_MAX_LEN) + { + error_num = ER_SPIDER_INVALID_CONNECT_INFO_TOO_LONG_NUM; + my_printf_error(error_num, ER_SPIDER_INVALID_CONNECT_INFO_TOO_LONG_STR, + MYF(0), share->tgt_table_names[roop_count], "table"); + goto error; + } + + DBUG_PRINT("info", + ("spider tgt_dbs_lengths[%d] = %u", roop_count, + share->tgt_dbs_lengths[roop_count])); + if (share->tgt_dbs_lengths[roop_count] > SPIDER_CONNECT_INFO_MAX_LEN) + { + error_num = ER_SPIDER_INVALID_CONNECT_INFO_TOO_LONG_NUM; + my_printf_error(error_num, ER_SPIDER_INVALID_CONNECT_INFO_TOO_LONG_STR, + MYF(0), share->tgt_dbs[roop_count], "database"); + goto error; + } + + DBUG_PRINT("info", + ("spider tgt_hosts_lengths[%d] = %u", roop_count, + share->tgt_hosts_lengths[roop_count])); + if (share->tgt_hosts_lengths[roop_count] > SPIDER_CONNECT_INFO_MAX_LEN) + { + error_num = ER_SPIDER_INVALID_CONNECT_INFO_TOO_LONG_NUM; + my_printf_error(error_num, ER_SPIDER_INVALID_CONNECT_INFO_TOO_LONG_STR, + MYF(0), share->tgt_hosts[roop_count], "host"); + goto error; + } + + DBUG_PRINT("info", + ("spider tgt_usernames_lengths[%d] = %u", roop_count, + share->tgt_usernames_lengths[roop_count])); + if (share->tgt_usernames_lengths[roop_count] > + SPIDER_CONNECT_INFO_MAX_LEN) + { + error_num = ER_SPIDER_INVALID_CONNECT_INFO_TOO_LONG_NUM; + my_printf_error(error_num, ER_SPIDER_INVALID_CONNECT_INFO_TOO_LONG_STR, + MYF(0), share->tgt_usernames[roop_count], "user"); + goto error; + } + + DBUG_PRINT("info", + ("spider tgt_passwords_lengths[%d] = %u", roop_count, + share->tgt_passwords_lengths[roop_count])); + if (share->tgt_passwords_lengths[roop_count] > + SPIDER_CONNECT_INFO_MAX_LEN) + { + error_num = ER_SPIDER_INVALID_CONNECT_INFO_TOO_LONG_NUM; + my_printf_error(error_num, ER_SPIDER_INVALID_CONNECT_INFO_TOO_LONG_STR, + MYF(0), share->tgt_passwords[roop_count], "password"); + goto error; + } + + DBUG_PRINT("info", + ("spider tgt_sockets_lengths[%d] = %u", roop_count, + share->tgt_sockets_lengths[roop_count])); + if (share->tgt_sockets_lengths[roop_count] > + SPIDER_CONNECT_INFO_PATH_MAX_LEN) + { + error_num = ER_SPIDER_INVALID_CONNECT_INFO_TOO_LONG_NUM; + my_printf_error(error_num, ER_SPIDER_INVALID_CONNECT_INFO_TOO_LONG_STR, + MYF(0), share->tgt_sockets[roop_count], "socket"); + goto error; + } + + DBUG_PRINT("info", + ("spider tgt_wrappers_lengths[%d] = %u", roop_count, + share->tgt_wrappers_lengths[roop_count])); + if (share->tgt_wrappers_lengths[roop_count] > + SPIDER_CONNECT_INFO_MAX_LEN) + { + error_num = ER_SPIDER_INVALID_CONNECT_INFO_TOO_LONG_NUM; + my_printf_error(error_num, ER_SPIDER_INVALID_CONNECT_INFO_TOO_LONG_STR, + MYF(0), share->tgt_wrappers[roop_count], "wrapper"); + goto error; + } + + DBUG_PRINT("info", + ("spider tgt_ssl_cas_lengths[%d] = %u", roop_count, + share->tgt_ssl_cas_lengths[roop_count])); + if (share->tgt_ssl_cas_lengths[roop_count] > + SPIDER_CONNECT_INFO_PATH_MAX_LEN) + { + error_num = ER_SPIDER_INVALID_CONNECT_INFO_TOO_LONG_NUM; + my_printf_error(error_num, ER_SPIDER_INVALID_CONNECT_INFO_TOO_LONG_STR, + MYF(0), share->tgt_ssl_cas[roop_count], "ssl_ca"); + goto error; + } + + DBUG_PRINT("info", + ("spider tgt_ssl_capaths_lengths[%d] = %u", roop_count, + share->tgt_ssl_capaths_lengths[roop_count])); + if (share->tgt_ssl_capaths_lengths[roop_count] > + SPIDER_CONNECT_INFO_PATH_MAX_LEN) + { + error_num = ER_SPIDER_INVALID_CONNECT_INFO_TOO_LONG_NUM; + my_printf_error(error_num, ER_SPIDER_INVALID_CONNECT_INFO_TOO_LONG_STR, + MYF(0), share->tgt_ssl_capaths[roop_count], "ssl_capath"); + goto error; + } + + DBUG_PRINT("info", + ("spider tgt_ssl_certs_lengths[%d] = %u", roop_count, + share->tgt_ssl_certs_lengths[roop_count])); + if (share->tgt_ssl_certs_lengths[roop_count] > + SPIDER_CONNECT_INFO_PATH_MAX_LEN) + { + error_num = ER_SPIDER_INVALID_CONNECT_INFO_TOO_LONG_NUM; + my_printf_error(error_num, ER_SPIDER_INVALID_CONNECT_INFO_TOO_LONG_STR, + MYF(0), share->tgt_ssl_certs[roop_count], "ssl_cert"); + goto error; + } + + DBUG_PRINT("info", + ("spider tgt_ssl_ciphers_lengths[%d] = %u", roop_count, + share->tgt_ssl_ciphers_lengths[roop_count])); + if (share->tgt_ssl_ciphers_lengths[roop_count] > + SPIDER_CONNECT_INFO_MAX_LEN) + { + error_num = ER_SPIDER_INVALID_CONNECT_INFO_TOO_LONG_NUM; + my_printf_error(error_num, ER_SPIDER_INVALID_CONNECT_INFO_TOO_LONG_STR, + MYF(0), share->tgt_ssl_ciphers[roop_count], "ssl_cipher"); + goto error; + } + + DBUG_PRINT("info", + ("spider tgt_ssl_keys_lengths[%d] = %u", roop_count, + share->tgt_ssl_keys_lengths[roop_count])); + if (share->tgt_ssl_keys_lengths[roop_count] > + SPIDER_CONNECT_INFO_PATH_MAX_LEN) + { + error_num = ER_SPIDER_INVALID_CONNECT_INFO_TOO_LONG_NUM; + my_printf_error(error_num, ER_SPIDER_INVALID_CONNECT_INFO_TOO_LONG_STR, + MYF(0), share->tgt_ssl_keys[roop_count], "ssl_key"); + goto error; + } + + DBUG_PRINT("info", + ("spider tgt_default_files_lengths[%d] = %u", roop_count, + share->tgt_default_files_lengths[roop_count])); + if (share->tgt_default_files_lengths[roop_count] > + SPIDER_CONNECT_INFO_PATH_MAX_LEN) + { + error_num = ER_SPIDER_INVALID_CONNECT_INFO_TOO_LONG_NUM; + my_printf_error(error_num, ER_SPIDER_INVALID_CONNECT_INFO_TOO_LONG_STR, + MYF(0), share->tgt_default_files[roop_count], "default_file"); + goto error; + } + + DBUG_PRINT("info", + ("spider tgt_default_groups_lengths[%d] = %u", roop_count, + share->tgt_default_groups_lengths[roop_count])); + if (share->tgt_default_groups_lengths[roop_count] > + SPIDER_CONNECT_INFO_MAX_LEN) + { + error_num = ER_SPIDER_INVALID_CONNECT_INFO_TOO_LONG_NUM; + my_printf_error(error_num, ER_SPIDER_INVALID_CONNECT_INFO_TOO_LONG_STR, + MYF(0), share->tgt_default_groups[roop_count], "default_group"); + goto error; + } + + DBUG_PRINT("info", + ("spider tgt_dsns_lengths[%d] = %u", roop_count, + share->tgt_dsns_lengths[roop_count])); + if (share->tgt_dsns_lengths[roop_count] > + SPIDER_CONNECT_INFO_MAX_LEN) + { + error_num = ER_SPIDER_INVALID_CONNECT_INFO_TOO_LONG_NUM; + my_printf_error(error_num, ER_SPIDER_INVALID_CONNECT_INFO_TOO_LONG_STR, + MYF(0), share->tgt_dsns[roop_count], "default_group"); + goto error; + } + + DBUG_PRINT("info", + ("spider tgt_pk_names_lengths[%d] = %u", roop_count, + share->tgt_pk_names_lengths[roop_count])); + if (share->tgt_pk_names_lengths[roop_count] > + SPIDER_CONNECT_INFO_MAX_LEN) + { + error_num = ER_SPIDER_INVALID_CONNECT_INFO_TOO_LONG_NUM; + my_printf_error(error_num, ER_SPIDER_INVALID_CONNECT_INFO_TOO_LONG_STR, + MYF(0), share->tgt_pk_names[roop_count], "pk_name"); + goto error; + } + + DBUG_PRINT("info", + ("spider tgt_sequence_names_lengths[%d] = %u", roop_count, + share->tgt_sequence_names_lengths[roop_count])); + if (share->tgt_sequence_names_lengths[roop_count] > + SPIDER_CONNECT_INFO_MAX_LEN) + { + error_num = ER_SPIDER_INVALID_CONNECT_INFO_TOO_LONG_NUM; + my_printf_error(error_num, ER_SPIDER_INVALID_CONNECT_INFO_TOO_LONG_STR, + MYF(0), share->tgt_sequence_names[roop_count], "sequence_name"); + goto error; + } + + DBUG_PRINT("info", + ("spider static_link_ids_lengths[%d] = %u", roop_count, + share->static_link_ids_lengths[roop_count])); + if (share->static_link_ids_lengths[roop_count] > + SPIDER_CONNECT_INFO_MAX_LEN) + { + error_num = ER_SPIDER_INVALID_CONNECT_INFO_TOO_LONG_NUM; + my_printf_error(error_num, ER_SPIDER_INVALID_CONNECT_INFO_TOO_LONG_STR, + MYF(0), share->static_link_ids[roop_count], "static_link_id"); + goto error; + } + if (share->static_link_ids[roop_count]) + { + if ( + share->static_link_ids_lengths[roop_count] > 0 && + share->static_link_ids[roop_count][0] >= '0' && + share->static_link_ids[roop_count][0] <= '9' + ) { + error_num = ER_SPIDER_INVALID_CONNECT_INFO_START_WITH_NUM_NUM; + my_printf_error(error_num, + ER_SPIDER_INVALID_CONNECT_INFO_START_WITH_NUM_STR, + MYF(0), share->static_link_ids[roop_count], "static_link_id"); + goto error; + } + for (roop_count2 = roop_count + 1; + roop_count2 < (int) share->all_link_count; + roop_count2++) + { + if ( + share->static_link_ids_lengths[roop_count] == + share->static_link_ids_lengths[roop_count2] && + !memcmp(share->static_link_ids[roop_count], + share->static_link_ids[roop_count2], + share->static_link_ids_lengths[roop_count]) + ) { + error_num = ER_SPIDER_INVALID_CONNECT_INFO_SAME_NUM; + my_printf_error(error_num, + ER_SPIDER_INVALID_CONNECT_INFO_SAME_STR, + MYF(0), share->static_link_ids[roop_count], + "static_link_id"); + goto error; + } + } + } + } + } + + DBUG_PRINT("info", ("spider share->active_link_count = %d", + share->active_link_count)); + share->link_count = (uint) share->active_link_count; + share_alter->link_count = share->link_count; + share->link_bitmap_size = (share->link_count + 7) / 8; + + if (connect_string) + spider_free(spider_current_trx, connect_string, MYF(0)); + DBUG_RETURN(0); + +error: + if (connect_string) + spider_free(spider_current_trx, connect_string, MYF(0)); +error_alloc_conn_string: + DBUG_RETURN(error_num); +} + +int spider_set_connect_info_default( + SPIDER_SHARE *share, +#ifdef WITH_PARTITION_STORAGE_ENGINE + partition_element *part_elem, + partition_element *sub_elem, +#endif + TABLE_SHARE *table_share +) { + bool check_socket; + bool check_database; + bool socket_has_default_value; + bool database_has_default_value; + int error_num, roop_count, roop_count2; + DBUG_ENTER("spider_set_connect_info_default"); + for (roop_count = 0; roop_count < (int) share->all_link_count; roop_count++) + { + if (share->server_names[roop_count]) + { + if ((error_num = spider_get_server(share, roop_count))) + DBUG_RETURN(error_num); + } + + if ( + !share->tgt_sockets[roop_count] && + ( + !share->tgt_hosts[roop_count] || + !strcmp(share->tgt_hosts[roop_count], my_localhost) + ) + ) { + check_socket = TRUE; + } else { + check_socket = FALSE; + } + if (!share->tgt_dbs[roop_count] && table_share) + { + check_database = TRUE; + } else { + check_database = FALSE; + } + if (check_socket || check_database) + { + socket_has_default_value = check_socket; + database_has_default_value = check_database; + if (share->tgt_wrappers[roop_count]) + { + for (roop_count2 = 0; roop_count2 < SPIDER_DBTON_SIZE; roop_count2++) + { + DBUG_PRINT("info",("spider share->tgt_wrappers[%d]=%s", roop_count, + share->tgt_wrappers[roop_count])); + DBUG_PRINT("info",("spider spider_dbton[%d].wrapper=%s", roop_count2, + spider_dbton[roop_count2].wrapper ? + spider_dbton[roop_count2].wrapper : "NULL")); + if ( + spider_dbton[roop_count2].wrapper && + !strcmp(share->tgt_wrappers[roop_count], + spider_dbton[roop_count2].wrapper) + ) { + if (spider_dbton[roop_count2].db_access_type == + SPIDER_DB_ACCESS_TYPE_SQL) + { + if (check_socket) + { + socket_has_default_value = spider_dbton[roop_count2]. + db_util->socket_has_default_value(); + } + if (check_database) + { + database_has_default_value = spider_dbton[roop_count2]. + db_util->database_has_default_value(); + } + break; + } + } + } + } + } else { + socket_has_default_value = FALSE; + database_has_default_value = FALSE; + } + + if (!share->tgt_wrappers[roop_count]) + { + DBUG_PRINT("info",("spider create default tgt_wrappers")); + share->tgt_wrappers_lengths[roop_count] = SPIDER_DB_WRAPPER_LEN; + if ( + !(share->tgt_wrappers[roop_count] = spider_create_string( + SPIDER_DB_WRAPPER_STR, + share->tgt_wrappers_lengths[roop_count])) + ) { + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + } + } + + if (!share->tgt_hosts[roop_count]) + { + DBUG_PRINT("info",("spider create default tgt_hosts")); + share->tgt_hosts_lengths[roop_count] = strlen(my_localhost); + if ( + !(share->tgt_hosts[roop_count] = spider_create_string( + my_localhost, + share->tgt_hosts_lengths[roop_count])) + ) { + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + } + } + + if (database_has_default_value) + { + DBUG_PRINT("info",("spider create default tgt_dbs")); + share->tgt_dbs_lengths[roop_count] = table_share->db.length; + if ( + !(share->tgt_dbs[roop_count] = spider_create_string( + table_share->db.str, + table_share->db.length)) + ) { + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + } + } + + if (!share->tgt_table_names[roop_count] && table_share) + { + DBUG_PRINT("info",("spider create default tgt_table_names")); + share->tgt_table_names_lengths[roop_count] = + table_share->table_name.length; + if ( + !(share->tgt_table_names[roop_count] = spider_create_table_name_string( + table_share->table_name.str, +#ifdef WITH_PARTITION_STORAGE_ENGINE + (part_elem ? part_elem->partition_name : NULL), + (sub_elem ? sub_elem->partition_name : NULL) +#else + NULL, + NULL +#endif + )) + ) { + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + } + } + + if ( + !share->tgt_default_files[roop_count] && + share->tgt_default_groups[roop_count] && + (*spd_defaults_file || *spd_defaults_extra_file) + ) { + DBUG_PRINT("info",("spider create default tgt_default_files")); + if (*spd_defaults_extra_file) + { + share->tgt_default_files_lengths[roop_count] = + strlen(*spd_defaults_extra_file); + if ( + !(share->tgt_default_files[roop_count] = spider_create_string( + *spd_defaults_extra_file, + share->tgt_default_files_lengths[roop_count])) + ) { + my_error(ER_OUT_OF_RESOURCES, MYF(0), HA_ERR_OUT_OF_MEM); + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + } + } else { + share->tgt_default_files_lengths[roop_count] = + strlen(*spd_defaults_file); + if ( + !(share->tgt_default_files[roop_count] = spider_create_string( + *spd_defaults_file, + share->tgt_default_files_lengths[roop_count])) + ) { + my_error(ER_OUT_OF_RESOURCES, MYF(0), HA_ERR_OUT_OF_MEM); + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + } + } + } + + if (!share->tgt_pk_names[roop_count]) + { + DBUG_PRINT("info",("spider create default tgt_pk_names")); + share->tgt_pk_names_lengths[roop_count] = SPIDER_DB_PK_NAME_LEN; + if ( + !(share->tgt_pk_names[roop_count] = spider_create_string( + SPIDER_DB_PK_NAME_STR, + share->tgt_pk_names_lengths[roop_count])) + ) { + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + } + } + + if (!share->tgt_sequence_names[roop_count]) + { + DBUG_PRINT("info",("spider create default tgt_sequence_names")); + share->tgt_sequence_names_lengths[roop_count] = + SPIDER_DB_SEQUENCE_NAME_LEN; + if ( + !(share->tgt_sequence_names[roop_count] = spider_create_string( + SPIDER_DB_SEQUENCE_NAME_STR, + share->tgt_sequence_names_lengths[roop_count])) + ) { + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + } + } + +/* + if (!share->static_link_ids[roop_count]) + { + DBUG_PRINT("info",("spider create default static_link_ids")); + share->static_link_ids_lengths[roop_count] = + SPIDER_DB_STATIC_LINK_ID_LEN; + if ( + !(share->static_link_ids[roop_count] = spider_create_string( + SPIDER_DB_STATIC_LINK_ID_STR, + share->static_link_ids_lengths[roop_count])) + ) { + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + } + } +*/ + + if (share->tgt_ports[roop_count] == -1) + { + share->tgt_ports[roop_count] = MYSQL_PORT; + } else if (share->tgt_ports[roop_count] < 0) + { + share->tgt_ports[roop_count] = 0; + } else if (share->tgt_ports[roop_count] > 65535) + { + share->tgt_ports[roop_count] = 65535; + } + + if (share->tgt_ssl_vscs[roop_count] == -1) + share->tgt_ssl_vscs[roop_count] = 0; + + if (socket_has_default_value) + { + DBUG_PRINT("info",("spider create default tgt_sockets")); + share->tgt_sockets_lengths[roop_count] = + strlen((char *) MYSQL_UNIX_ADDR); + if ( + !(share->tgt_sockets[roop_count] = spider_create_string( + (char *) MYSQL_UNIX_ADDR, + share->tgt_sockets_lengths[roop_count])) + ) { + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + } + } + + if (share->link_statuses[roop_count] == -1) + share->link_statuses[roop_count] = SPIDER_LINK_STATUS_NO_CHANGE; + +#ifndef WITHOUT_SPIDER_BG_SEARCH + if (share->monitoring_bg_flag[roop_count] == -1) + share->monitoring_bg_flag[roop_count] = 0; + if (share->monitoring_bg_kind[roop_count] == -1) + share->monitoring_bg_kind[roop_count] = 0; +#endif + if (share->monitoring_binlog_pos_at_failing[roop_count] == -1) + share->monitoring_binlog_pos_at_failing[roop_count] = 0; + if (share->monitoring_flag[roop_count] == -1) + share->monitoring_flag[roop_count] = 0; + if (share->monitoring_kind[roop_count] == -1) + share->monitoring_kind[roop_count] = 0; +#ifndef WITHOUT_SPIDER_BG_SEARCH + if (share->monitoring_bg_interval[roop_count] == -1) + share->monitoring_bg_interval[roop_count] = 10000000; +#endif + if (share->monitoring_limit[roop_count] == -1) + share->monitoring_limit[roop_count] = 1; + if (share->monitoring_sid[roop_count] == -1) +#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100002 + share->monitoring_sid[roop_count] = global_system_variables.server_id; +#else + share->monitoring_sid[roop_count] = current_thd->server_id; +#endif + +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + if (share->use_hs_reads[roop_count] == -1) + share->use_hs_reads[roop_count] = 0; + if (share->use_hs_writes[roop_count] == -1) + share->use_hs_writes[roop_count] = 0; + if (share->hs_read_ports[roop_count] == -1) + { + share->hs_read_ports[roop_count] = 9998; + } else if (share->hs_read_ports[roop_count] < 0) + { + share->hs_read_ports[roop_count] = 0; + } else if (share->hs_read_ports[roop_count] > 65535) + { + share->hs_read_ports[roop_count] = 65535; + } + if (share->hs_write_ports[roop_count] == -1) + { + share->hs_write_ports[roop_count] = 9999; + } else if (share->hs_write_ports[roop_count] < 0) + { + share->hs_write_ports[roop_count] = 0; + } else if (share->hs_write_ports[roop_count] > 65535) + { + share->hs_write_ports[roop_count] = 65535; + } + if (share->hs_write_to_reads[roop_count] == -1) + { + share->hs_write_to_reads[roop_count] = 1; + } else if (share->hs_write_to_reads[roop_count] < 0) + { + share->hs_write_to_reads[roop_count] = 0; + } else if (share->hs_write_to_reads[roop_count] > 1) + { + share->hs_write_to_reads[roop_count] = 1; + } +#endif + if (share->use_handlers[roop_count] == -1) + share->use_handlers[roop_count] = 0; + if (share->connect_timeouts[roop_count] == -1) + share->connect_timeouts[roop_count] = 6; + if (share->net_read_timeouts[roop_count] == -1) + share->net_read_timeouts[roop_count] = 600; + if (share->net_write_timeouts[roop_count] == -1) + share->net_write_timeouts[roop_count] = 600; + if (share->access_balances[roop_count] == -1) + share->access_balances[roop_count] = 100; + if (share->bka_table_name_types[roop_count] == -1) + share->bka_table_name_types[roop_count] = 0; + if (share->strict_group_bys[roop_count] == -1) + share->strict_group_bys[roop_count] = 1; + } + +#ifndef WITHOUT_SPIDER_BG_SEARCH + if (share->sts_bg_mode == -1) + share->sts_bg_mode = 2; +#endif + if (share->sts_interval == -1) + share->sts_interval = 10; + if (share->sts_mode == -1) + share->sts_mode = 1; +#ifdef WITH_PARTITION_STORAGE_ENGINE + if (share->sts_sync == -1) + share->sts_sync = 0; +#endif + if (share->store_last_sts == -1) + share->store_last_sts = 1; + if (share->load_sts_at_startup == -1) + share->load_sts_at_startup = 1; +#ifndef WITHOUT_SPIDER_BG_SEARCH + if (share->crd_bg_mode == -1) + share->crd_bg_mode = 2; +#endif + if (share->crd_interval == -1) + share->crd_interval = 51; + if (share->crd_mode == -1) + share->crd_mode = 1; +#ifdef WITH_PARTITION_STORAGE_ENGINE + if (share->crd_sync == -1) + share->crd_sync = 0; +#endif + if (share->store_last_crd == -1) + share->store_last_crd = 1; + if (share->load_crd_at_startup == -1) + share->load_crd_at_startup = 1; + if (share->crd_type == -1) + share->crd_type = 2; + if (share->crd_weight == -1) + share->crd_weight = 2; + if (share->internal_offset == -1) + share->internal_offset = 0; + if (share->internal_limit == -1) + share->internal_limit = 9223372036854775807LL; + if (share->split_read == -1) + share->split_read = 9223372036854775807LL; + if (share->semi_split_read == -1) + share->semi_split_read = 2; + if (share->semi_split_read_limit == -1) + share->semi_split_read_limit = 9223372036854775807LL; + if (share->init_sql_alloc_size == -1) + share->init_sql_alloc_size = 1024; + if (share->reset_sql_alloc == -1) + share->reset_sql_alloc = 1; + if (share->multi_split_read == -1) + share->multi_split_read = 100; + if (share->max_order == -1) + share->max_order = 32767; + if (share->semi_table_lock == -1) + share->semi_table_lock = 0; + if (share->semi_table_lock_conn == -1) + share->semi_table_lock_conn = 1; + if (share->selupd_lock_mode == -1) + share->selupd_lock_mode = 1; + if (share->query_cache == -1) + share->query_cache = 0; + if (share->query_cache_sync == -1) + share->query_cache_sync = 0; + if (share->internal_delayed == -1) + share->internal_delayed = 0; + if (share->bulk_size == -1) + share->bulk_size = 16000; + if (share->bulk_update_mode == -1) + share->bulk_update_mode = 0; + if (share->bulk_update_size == -1) + share->bulk_update_size = 16000; + if (share->buffer_size == -1) + share->buffer_size = 16000; + if (share->internal_optimize == -1) + share->internal_optimize = 0; + if (share->internal_optimize_local == -1) + share->internal_optimize_local = 0; + if (share->scan_rate == -1) + share->scan_rate = 1; + if (share->read_rate == -1) + share->read_rate = 0.0002; + if (share->priority == -1) + share->priority = 1000000; + if (share->quick_mode == -1) + share->quick_mode = 3; + if (share->quick_page_size == -1) + share->quick_page_size = 1024; + if (share->quick_page_byte == -1) + share->quick_page_byte = 10485760; + if (share->low_mem_read == -1) + share->low_mem_read = 1; + if (share->table_count_mode == -1) + share->table_count_mode = 0; + if (share->select_column_mode == -1) + share->select_column_mode = 1; +#ifndef WITHOUT_SPIDER_BG_SEARCH + if (share->bgs_mode == -1) + share->bgs_mode = 0; + if (share->bgs_first_read == -1) + share->bgs_first_read = 2; + if (share->bgs_second_read == -1) + share->bgs_second_read = 100; +#endif + if (share->first_read == -1) + share->first_read = 0; + if (share->second_read == -1) + share->second_read = 0; + if (share->auto_increment_mode == -1) + share->auto_increment_mode = 0; + if (share->use_table_charset == -1) + share->use_table_charset = 1; + if (share->use_pushdown_udf == -1) + share->use_pushdown_udf = 1; + if (share->skip_default_condition == -1) + share->skip_default_condition = 0; + if (share->skip_parallel_search == -1) + share->skip_parallel_search = 0; + if (share->direct_dup_insert == -1) + share->direct_dup_insert = 0; + if (share->direct_order_limit == -1) + share->direct_order_limit = 9223372036854775807LL; + if (share->read_only_mode == -1) + share->read_only_mode = 0; + if (share->error_read_mode == -1) + share->error_read_mode = 0; + if (share->error_write_mode == -1) + share->error_write_mode = 0; + if (share->active_link_count == -1) + share->active_link_count = share->all_link_count; +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + if (share->hs_result_free_size == -1) + share->hs_result_free_size = 1048576; +#endif +#ifdef HA_CAN_BULK_ACCESS + if (share->bulk_access_free == -1) + share->bulk_access_free = 0; +#endif +#ifdef HA_CAN_FORCE_BULK_UPDATE + if (share->force_bulk_update == -1) + share->force_bulk_update = 0; +#endif +#ifdef HA_CAN_FORCE_BULK_DELETE + if (share->force_bulk_delete == -1) + share->force_bulk_delete = 0; +#endif + if (share->casual_read == -1) + share->casual_read = 0; + if (share->delete_all_rows_type == -1) + { +#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS + share->delete_all_rows_type = 1; +#else + share->delete_all_rows_type = 0; +#endif + } + if (share->bka_mode == -1) + share->bka_mode = 1; + if (!share->bka_engine) + { + DBUG_PRINT("info",("spider create default bka_engine")); + share->bka_engine_length = SPIDER_SQL_TMP_BKA_ENGINE_LEN; + if ( + !(share->bka_engine = spider_create_string( + SPIDER_SQL_TMP_BKA_ENGINE_STR, + SPIDER_SQL_TMP_BKA_ENGINE_LEN)) + ) { + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + } + } + DBUG_RETURN(0); +} + +int spider_set_connect_info_default_db_table( + SPIDER_SHARE *share, + const char *db_name, + uint db_name_length, + const char *table_name, + uint table_name_length +) { + uint roop_count, roop_count2; + bool check_database; + bool database_has_default_value; + DBUG_ENTER("spider_set_connect_info_default_db_table"); + for (roop_count = 0; roop_count < share->link_count; roop_count++) + { + if (!share->tgt_dbs[roop_count] && db_name) + { + check_database = TRUE; + } else { + check_database = FALSE; + } + if (check_database) + { + database_has_default_value = check_database; + if (share->tgt_wrappers[roop_count]) + { + for (roop_count2 = 0; roop_count2 < SPIDER_DBTON_SIZE; roop_count2++) + { + DBUG_PRINT("info",("spider share->tgt_wrappers[%d]=%s", roop_count, + share->tgt_wrappers[roop_count])); + DBUG_PRINT("info",("spider spider_dbton[%d].wrapper=%s", roop_count2, + spider_dbton[roop_count2].wrapper ? + spider_dbton[roop_count2].wrapper : "NULL")); + if ( + spider_dbton[roop_count2].wrapper && + !strcmp(share->tgt_wrappers[roop_count], + spider_dbton[roop_count2].wrapper) + ) { + if (spider_dbton[roop_count2].db_access_type == + SPIDER_DB_ACCESS_TYPE_SQL) + { + if (check_database) + { + database_has_default_value = spider_dbton[roop_count2]. + db_util->database_has_default_value(); + } + break; + } + } + } + } + } else { + database_has_default_value = FALSE; + } + + if (database_has_default_value) + { + DBUG_PRINT("info",("spider create default tgt_dbs")); + share->tgt_dbs_lengths[roop_count] = db_name_length; + if ( + !(share->tgt_dbs[roop_count] = spider_create_string( + db_name, + db_name_length)) + ) { + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + } + } + + if (!share->tgt_table_names[roop_count] && table_name) + { + const char *tmp_ptr; + DBUG_PRINT("info",("spider create default tgt_table_names")); + if ((tmp_ptr = strstr(table_name, "#P#"))) + table_name_length = (uint) PTR_BYTE_DIFF(tmp_ptr, table_name); + share->tgt_table_names_lengths[roop_count] = table_name_length; + if ( + !(share->tgt_table_names[roop_count] = spider_create_string( + table_name, + table_name_length)) + ) { + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + } + } + } + DBUG_RETURN(0); +} + +int spider_set_connect_info_default_dbtable( + SPIDER_SHARE *share, + const char *dbtable_name, + int dbtable_name_length +) { + const char *ptr_db, *ptr_table; + my_ptrdiff_t ptr_diff_db, ptr_diff_table; + DBUG_ENTER("spider_set_connect_info_default_dbtable"); + ptr_db = strchr(dbtable_name, FN_LIBCHAR); + ptr_db++; + ptr_diff_db = PTR_BYTE_DIFF(ptr_db, dbtable_name); + DBUG_PRINT("info",("spider ptr_diff_db = %lld", (longlong) ptr_diff_db)); + ptr_table = strchr(ptr_db, FN_LIBCHAR); + ptr_table++; + ptr_diff_table = PTR_BYTE_DIFF(ptr_table, ptr_db); + DBUG_PRINT("info",("spider ptr_diff_table = %lld", (longlong) ptr_diff_table)); + DBUG_RETURN(spider_set_connect_info_default_db_table( + share, + ptr_db, + (uint)(ptr_diff_table - 1), + ptr_table, + (uint)(dbtable_name_length - ptr_diff_db - ptr_diff_table) + )); +} + +#ifndef DBUG_OFF +void spider_print_keys( + const char *key, + uint length +) { + const char *end_ptr; + uint roop_count = 1; + DBUG_ENTER("spider_print_keys"); + DBUG_PRINT("info",("spider key_length=%u", length)); + end_ptr = key + length; + while (key < end_ptr) + { + DBUG_PRINT("info",("spider key[%u]=%s", roop_count, key)); + key = strchr(key, '\0') + 1; + roop_count++; + } + DBUG_VOID_RETURN; +} +#endif + +int spider_create_conn_keys( + SPIDER_SHARE *share +) { + int roop_count, roop_count2; + char *tmp_name, port_str[6]; +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + char *tmp_hs_r_name, *tmp_hs_w_name; +#endif + uint length_base = sizeof(uint) * share->all_link_count; + uint *conn_keys_lengths; + uint *sql_dbton_ids; +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + uint *hs_dbton_ids; + uint *hs_r_conn_keys_lengths; + uint *hs_w_conn_keys_lengths; +#endif + DBUG_ENTER("spider_create_conn_keys"); + char *ptr; + uint length = length_base * 2; +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + length += length_base * 3; +#endif + ptr = (char *) my_alloca(length); + if (!ptr) + { + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + } + conn_keys_lengths = (uint *) ptr; + ptr += length_base; + sql_dbton_ids = (uint *) ptr; +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + ptr += length_base; + hs_dbton_ids = (uint *) ptr; + ptr += length_base; + hs_r_conn_keys_lengths = (uint *) ptr; + ptr += length_base; + hs_w_conn_keys_lengths = (uint *) ptr; +#endif + + share->conn_keys_charlen = 0; +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + share->hs_read_conn_keys_charlen = 0; + share->hs_write_conn_keys_charlen = 0; +#endif + for (roop_count = 0; roop_count < (int) share->all_link_count; roop_count++) + { + bool get_sql_id = FALSE; +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + bool get_nosql_id = FALSE; +#endif + for (roop_count2 = 0; roop_count2 < SPIDER_DBTON_SIZE; roop_count2++) + { + DBUG_PRINT("info",("spider share->tgt_wrappers[%d]=%s", roop_count, + share->tgt_wrappers[roop_count])); + DBUG_PRINT("info",("spider spider_dbton[%d].wrapper=%s", roop_count2, + spider_dbton[roop_count2].wrapper ? + spider_dbton[roop_count2].wrapper : "NULL")); + if ( + spider_dbton[roop_count2].wrapper && + !strcmp(share->tgt_wrappers[roop_count], + spider_dbton[roop_count2].wrapper) + ) { + spider_set_bit(share->dbton_bitmap, roop_count2); + if ( + !get_sql_id && + spider_dbton[roop_count2].db_access_type == SPIDER_DB_ACCESS_TYPE_SQL + ) { + sql_dbton_ids[roop_count] = roop_count2; + get_sql_id = TRUE; +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + if (get_nosql_id) +#endif + break; +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + else + continue; +#endif + } +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + if ( + !get_nosql_id && + spider_dbton[roop_count2].db_access_type == + SPIDER_DB_ACCESS_TYPE_NOSQL + ) { + hs_dbton_ids[roop_count] = roop_count2; + get_nosql_id = TRUE; + if (get_sql_id) + break; + } +#endif + } + } + if (!get_sql_id) + sql_dbton_ids[roop_count] = SPIDER_DBTON_SIZE; +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + if (!get_nosql_id) + hs_dbton_ids[roop_count] = SPIDER_DBTON_SIZE; +#endif + + bool tables_on_different_db_are_joinable; + if (get_sql_id) + { + tables_on_different_db_are_joinable = + spider_dbton[sql_dbton_ids[roop_count]].db_util-> + tables_on_different_db_are_joinable(); + } else { + tables_on_different_db_are_joinable = TRUE; + } + conn_keys_lengths[roop_count] + = 1 + + share->tgt_wrappers_lengths[roop_count] + 1 + + share->tgt_hosts_lengths[roop_count] + 1 + + 5 + 1 + + share->tgt_sockets_lengths[roop_count] + 1 + + (tables_on_different_db_are_joinable ? + 0 : share->tgt_dbs_lengths[roop_count] + 1) + + share->tgt_usernames_lengths[roop_count] + 1 + + share->tgt_passwords_lengths[roop_count] + 1 + + share->tgt_ssl_cas_lengths[roop_count] + 1 + + share->tgt_ssl_capaths_lengths[roop_count] + 1 + + share->tgt_ssl_certs_lengths[roop_count] + 1 + + share->tgt_ssl_ciphers_lengths[roop_count] + 1 + + share->tgt_ssl_keys_lengths[roop_count] + 1 + + 1 + 1 + + share->tgt_default_files_lengths[roop_count] + 1 + + share->tgt_default_groups_lengths[roop_count] + 1 + + share->tgt_dsns_lengths[roop_count]; + share->conn_keys_charlen += conn_keys_lengths[roop_count] + 2; +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + hs_r_conn_keys_lengths[roop_count] + = 1 + + share->tgt_wrappers_lengths[roop_count] + 1 + + share->tgt_hosts_lengths[roop_count] + 1 + + 5 + 1 + + share->hs_read_socks_lengths[roop_count]; + share->hs_read_conn_keys_charlen += + hs_r_conn_keys_lengths[roop_count] + 2; + hs_w_conn_keys_lengths[roop_count] + = 1 + + share->tgt_wrappers_lengths[roop_count] + 1 + + share->tgt_hosts_lengths[roop_count] + 1 + + 5 + 1 + + share->hs_write_socks_lengths[roop_count]; + share->hs_write_conn_keys_charlen += + hs_w_conn_keys_lengths[roop_count] + 2; +#endif + } + if (!(share->conn_keys = (char **) + spider_bulk_alloc_mem(spider_current_trx, 45, + __func__, __FILE__, __LINE__, MYF(MY_WME | MY_ZEROFILL), + &share->conn_keys, sizeof(char *) * share->all_link_count, + &share->conn_keys_lengths, length_base, +#ifdef SPIDER_HAS_HASH_VALUE_TYPE + &share->conn_keys_hash_value, + sizeof(my_hash_value_type) * share->all_link_count, +#endif + &tmp_name, sizeof(char) * share->conn_keys_charlen, +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + &share->hs_read_conn_keys, sizeof(char *) * share->all_link_count, + &share->hs_read_conn_keys_lengths, length_base, +#ifdef SPIDER_HAS_HASH_VALUE_TYPE + &share->hs_read_conn_keys_hash_value, + sizeof(my_hash_value_type) * share->all_link_count, +#endif + &tmp_hs_r_name, sizeof(char) * share->hs_read_conn_keys_charlen, + &share->hs_write_conn_keys, sizeof(char *) * share->all_link_count, + &share->hs_write_conn_keys_lengths, length_base, +#ifdef SPIDER_HAS_HASH_VALUE_TYPE + &share->hs_write_conn_keys_hash_value, + sizeof(my_hash_value_type) * share->all_link_count, +#endif + &tmp_hs_w_name, sizeof(char) * share->hs_write_conn_keys_charlen, +#endif + &share->sql_dbton_ids, length_base, +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + &share->hs_dbton_ids, length_base, +#endif + NullS)) + ) { + my_afree(conn_keys_lengths); + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + } + share->conn_keys_length = share->all_link_count; + memcpy(share->conn_keys_lengths, conn_keys_lengths, + length_base); + memcpy(share->sql_dbton_ids, sql_dbton_ids, length_base); +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + share->hs_read_conn_keys_length = share->all_link_count; + share->hs_write_conn_keys_length = share->all_link_count; + memcpy(share->hs_read_conn_keys_lengths, hs_r_conn_keys_lengths, + length_base); + memcpy(share->hs_write_conn_keys_lengths, hs_w_conn_keys_lengths, + length_base); + memcpy(share->hs_dbton_ids, hs_dbton_ids, length_base); +#endif + + my_afree(conn_keys_lengths); + + for (roop_count = 0; roop_count < (int) share->all_link_count; roop_count++) + { + bool tables_on_different_db_are_joinable; + if (share->sql_dbton_ids[roop_count] != SPIDER_DBTON_SIZE) + { + tables_on_different_db_are_joinable = + spider_dbton[share->sql_dbton_ids[roop_count]].db_util-> + tables_on_different_db_are_joinable(); + } else { + tables_on_different_db_are_joinable = TRUE; + } + + share->conn_keys[roop_count] = tmp_name; + *tmp_name = '0'; + DBUG_PRINT("info",("spider tgt_wrappers[%d]=%s", roop_count, + share->tgt_wrappers[roop_count])); + tmp_name = strmov(tmp_name + 1, share->tgt_wrappers[roop_count]); + DBUG_PRINT("info",("spider tgt_hosts[%d]=%s", roop_count, + share->tgt_hosts[roop_count])); + tmp_name = strmov(tmp_name + 1, share->tgt_hosts[roop_count]); + my_sprintf(port_str, (port_str, "%05ld", share->tgt_ports[roop_count])); + DBUG_PRINT("info",("spider port_str=%s", port_str)); + tmp_name = strmov(tmp_name + 1, port_str); + if (share->tgt_sockets[roop_count]) + { + DBUG_PRINT("info",("spider tgt_sockets[%d]=%s", roop_count, + share->tgt_sockets[roop_count])); + tmp_name = strmov(tmp_name + 1, share->tgt_sockets[roop_count]); + } else + tmp_name++; + if (!tables_on_different_db_are_joinable) + { + if (share->tgt_dbs[roop_count]) + { + DBUG_PRINT("info",("spider tgt_dbs[%d]=%s", roop_count, + share->tgt_dbs[roop_count])); + tmp_name = strmov(tmp_name + 1, share->tgt_dbs[roop_count]); + } else + tmp_name++; + } + if (share->tgt_usernames[roop_count]) + { + DBUG_PRINT("info",("spider tgt_usernames[%d]=%s", roop_count, + share->tgt_usernames[roop_count])); + tmp_name = strmov(tmp_name + 1, share->tgt_usernames[roop_count]); + } else + tmp_name++; + if (share->tgt_passwords[roop_count]) + { + DBUG_PRINT("info",("spider tgt_passwords[%d]=%s", roop_count, + share->tgt_passwords[roop_count])); + tmp_name = strmov(tmp_name + 1, share->tgt_passwords[roop_count]); + } else + tmp_name++; + if (share->tgt_ssl_cas[roop_count]) + { + DBUG_PRINT("info",("spider tgt_ssl_cas[%d]=%s", roop_count, + share->tgt_ssl_cas[roop_count])); + tmp_name = strmov(tmp_name + 1, share->tgt_ssl_cas[roop_count]); + } else + tmp_name++; + if (share->tgt_ssl_capaths[roop_count]) + { + DBUG_PRINT("info",("spider tgt_ssl_capaths[%d]=%s", roop_count, + share->tgt_ssl_capaths[roop_count])); + tmp_name = strmov(tmp_name + 1, share->tgt_ssl_capaths[roop_count]); + } else + tmp_name++; + if (share->tgt_ssl_certs[roop_count]) + { + DBUG_PRINT("info",("spider tgt_ssl_certs[%d]=%s", roop_count, + share->tgt_ssl_certs[roop_count])); + tmp_name = strmov(tmp_name + 1, share->tgt_ssl_certs[roop_count]); + } else + tmp_name++; + if (share->tgt_ssl_ciphers[roop_count]) + { + DBUG_PRINT("info",("spider tgt_ssl_ciphers[%d]=%s", roop_count, + share->tgt_ssl_ciphers[roop_count])); + tmp_name = strmov(tmp_name + 1, share->tgt_ssl_ciphers[roop_count]); + } else + tmp_name++; + if (share->tgt_ssl_keys[roop_count]) + { + DBUG_PRINT("info",("spider tgt_ssl_keys[%d]=%s", roop_count, + share->tgt_ssl_keys[roop_count])); + tmp_name = strmov(tmp_name + 1, share->tgt_ssl_keys[roop_count]); + } else + tmp_name++; + tmp_name++; + *tmp_name = '0' + ((char) share->tgt_ssl_vscs[roop_count]); + if (share->tgt_default_files[roop_count]) + { + DBUG_PRINT("info",("spider tgt_default_files[%d]=%s", roop_count, + share->tgt_default_files[roop_count])); + tmp_name = strmov(tmp_name + 1, share->tgt_default_files[roop_count]); + } else + tmp_name++; + if (share->tgt_default_groups[roop_count]) + { + DBUG_PRINT("info",("spider tgt_default_groups[%d]=%s", roop_count, + share->tgt_default_groups[roop_count])); + tmp_name = strmov(tmp_name + 1, share->tgt_default_groups[roop_count]); + } else + tmp_name++; + if (share->tgt_dsns[roop_count]) + { + DBUG_PRINT("info",("spider tgt_dsns[%d]=%s", roop_count, + share->tgt_dsns[roop_count])); + tmp_name = strmov(tmp_name + 1, share->tgt_dsns[roop_count]); + } else + tmp_name++; + tmp_name++; + tmp_name++; +#ifdef SPIDER_HAS_HASH_VALUE_TYPE + share->conn_keys_hash_value[roop_count] = my_calc_hash( + &spider_open_connections, (uchar*) share->conn_keys[roop_count], + share->conn_keys_lengths[roop_count]); +#endif +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + share->hs_read_conn_keys[roop_count] = tmp_hs_r_name; + *tmp_hs_r_name = '0'; + DBUG_PRINT("info",("spider tgt_wrappers[%d]=%s", roop_count, + share->tgt_wrappers[roop_count])); + tmp_hs_r_name = strmov(tmp_hs_r_name + 1, share->tgt_wrappers[roop_count]); + DBUG_PRINT("info",("spider tgt_hosts[%d]=%s", roop_count, + share->tgt_hosts[roop_count])); + tmp_hs_r_name = strmov(tmp_hs_r_name + 1, share->tgt_hosts[roop_count]); + my_sprintf(port_str, (port_str, "%05ld", + share->hs_read_ports[roop_count])); + DBUG_PRINT("info",("spider port_str=%s", port_str)); + tmp_hs_r_name = strmov(tmp_hs_r_name + 1, port_str); + if (share->hs_read_socks[roop_count]) + { + DBUG_PRINT("info",("spider hs_read_socks[%d]=%s", roop_count, + share->hs_read_socks[roop_count])); + tmp_hs_r_name = strmov(tmp_hs_r_name + 1, + share->hs_read_socks[roop_count]); + } else + tmp_hs_r_name++; + tmp_hs_r_name++; + tmp_hs_r_name++; +#ifdef SPIDER_HAS_HASH_VALUE_TYPE + share->hs_read_conn_keys_hash_value[roop_count] = my_calc_hash( + &spider_open_connections, (uchar*) share->hs_read_conn_keys[roop_count], + share->hs_read_conn_keys_lengths[roop_count]); +#endif + share->hs_write_conn_keys[roop_count] = tmp_hs_w_name; + *tmp_hs_w_name = '0'; + DBUG_PRINT("info",("spider tgt_wrappers[%d]=%s", roop_count, + share->tgt_wrappers[roop_count])); + tmp_hs_w_name = strmov(tmp_hs_w_name + 1, share->tgt_wrappers[roop_count]); + DBUG_PRINT("info",("spider tgt_hosts[%d]=%s", roop_count, + share->tgt_hosts[roop_count])); + tmp_hs_w_name = strmov(tmp_hs_w_name + 1, share->tgt_hosts[roop_count]); + my_sprintf(port_str, (port_str, "%05ld", + share->hs_write_ports[roop_count])); + DBUG_PRINT("info",("spider port_str=%s", port_str)); + tmp_hs_w_name = strmov(tmp_hs_w_name + 1, port_str); + if (share->hs_write_socks[roop_count]) + { + DBUG_PRINT("info",("spider hs_write_socks[%d]=%s", roop_count, + share->hs_write_socks[roop_count])); + tmp_hs_w_name = strmov(tmp_hs_w_name + 1, + share->hs_write_socks[roop_count]); + } else + tmp_hs_w_name++; + tmp_hs_w_name++; + tmp_hs_w_name++; +#ifdef SPIDER_HAS_HASH_VALUE_TYPE + share->hs_write_conn_keys_hash_value[roop_count] = my_calc_hash( + &spider_open_connections, (uchar*) share->hs_write_conn_keys[roop_count], + share->hs_write_conn_keys_lengths[roop_count]); +#endif +#endif + } + for (roop_count2 = 0; roop_count2 < SPIDER_DBTON_SIZE; roop_count2++) + { + if (spider_bit_is_set(share->dbton_bitmap, roop_count2)) + { +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + if (spider_dbton[roop_count2].db_access_type == + SPIDER_DB_ACCESS_TYPE_SQL) + { +#endif + share->use_sql_dbton_ids[share->use_dbton_count] = roop_count2; + share->sql_dbton_id_to_seq[roop_count2] = share->use_dbton_count; + share->use_sql_dbton_count++; +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + } else { + share->use_hs_dbton_ids[share->use_hs_dbton_count] = roop_count2; + share->hs_dbton_id_to_seq[roop_count2] = share->use_hs_dbton_count; + share->use_hs_dbton_count++; + } +#endif + share->use_dbton_ids[share->use_dbton_count] = roop_count2; + share->dbton_id_to_seq[roop_count2] = share->use_dbton_count; + share->use_dbton_count++; + } + } + DBUG_RETURN(0); +} + +SPIDER_SHARE *spider_create_share( + const char *table_name, + TABLE_SHARE *table_share, +#ifdef WITH_PARTITION_STORAGE_ENGINE + partition_info *part_info, +#endif +#ifdef SPIDER_HAS_HASH_VALUE_TYPE + my_hash_value_type hash_value, +#endif + int *error_num +) { + int bitmap_size, roop_count; + uint length; + int use_table_charset; + SPIDER_SHARE *share; + char *tmp_name; + longlong *tmp_cardinality, *tmp_static_key_cardinality; + uchar *tmp_cardinality_upd, *tmp_table_mon_mutex_bitmap; + char buf[MAX_FIELD_WIDTH], *buf_pos; + char link_idx_str[SPIDER_SQL_INT_LEN]; +#ifdef HA_HAS_CHECKSUM_EXTENDED + bool checksum_support = TRUE; +#endif + DBUG_ENTER("spider_create_share"); + length = (uint) strlen(table_name); + bitmap_size = spider_bitmap_size(table_share->fields); + if (!(share = (SPIDER_SHARE *) + spider_bulk_malloc(spider_current_trx, 46, MYF(MY_WME | MY_ZEROFILL), + &share, (uint) (sizeof(*share)), + &tmp_name, (uint) (length + 1), + &tmp_static_key_cardinality, + (uint) (sizeof(*tmp_static_key_cardinality) * table_share->keys), + &tmp_cardinality, + (uint) (sizeof(*tmp_cardinality) * table_share->fields), + &tmp_cardinality_upd, + (uint) (sizeof(*tmp_cardinality_upd) * bitmap_size), + &tmp_table_mon_mutex_bitmap, + (uint) (sizeof(*tmp_table_mon_mutex_bitmap) * + ((spider_param_udf_table_mon_mutex_count() + 7) / 8)), + NullS)) + ) { + *error_num = HA_ERR_OUT_OF_MEM; + goto error_alloc_share; + } + + SPD_INIT_ALLOC_ROOT(&share->mem_root, 4096, 0, MYF(MY_WME)); + share->use_count = 0; + share->use_dbton_count = 0; +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + share->use_hs_dbton_count = 0; +#endif + share->table_name_length = length; + share->table_name = tmp_name; + strmov(share->table_name, table_name); + share->static_key_cardinality = tmp_static_key_cardinality; + share->cardinality = tmp_cardinality; + share->cardinality_upd = tmp_cardinality_upd; + share->table_mon_mutex_bitmap = tmp_table_mon_mutex_bitmap; + share->bitmap_size = bitmap_size; + share->table_share = table_share; +#ifdef SPIDER_HAS_HASH_VALUE_TYPE + share->table_name_hash_value = hash_value; +#ifdef WITH_PARTITION_STORAGE_ENGINE + share->table_path_hash_value = my_calc_hash(&spider_open_tables, + (uchar*) table_share->path.str, table_share->path.length); +#endif +#endif +#ifndef WITHOUT_SPIDER_BG_SEARCH + share->table.s = table_share; + share->table.field = table_share->field; + share->table.key_info = table_share->key_info; + share->table.read_set = &table_share->all_set; +#endif + + if (table_share->keys > 0 && + !(share->key_hint = new spider_string[table_share->keys]) + ) { + *error_num = HA_ERR_OUT_OF_MEM; + goto error_init_hint_string; + } + for (roop_count = 0; roop_count < (int) table_share->keys; roop_count++) + share->key_hint[roop_count].init_calc_mem(95); + DBUG_PRINT("info",("spider share->key_hint=%p", share->key_hint)); + + if ((*error_num = spider_parse_connect_info(share, table_share, +#ifdef WITH_PARTITION_STORAGE_ENGINE + part_info, +#endif + 0))) + goto error_parse_connect_string; + + for (roop_count = 0; roop_count < (int) share->all_link_count; + roop_count++) + { + my_sprintf(link_idx_str, (link_idx_str, "%010d", roop_count)); + buf_pos = strmov(buf, share->table_name); + buf_pos = strmov(buf_pos, link_idx_str); + *buf_pos = '\0'; + spider_set_bit(tmp_table_mon_mutex_bitmap, + spider_udf_calc_hash(buf, spider_param_udf_table_mon_mutex_count()) + ); + } + + use_table_charset = spider_param_use_table_charset( + share->use_table_charset); + if (table_share->table_charset && use_table_charset) + share->access_charset = table_share->table_charset; + else + share->access_charset = system_charset_info; + + if ((*error_num = spider_create_conn_keys(share))) + goto error_create_conn_keys; + + if (share->table_count_mode & 1) + share->additional_table_flags |= HA_STATS_RECORDS_IS_EXACT; + if (share->table_count_mode & 2) + share->additional_table_flags |= HA_HAS_RECORDS; + +#if MYSQL_VERSION_ID < 50500 + if (pthread_mutex_init(&share->mutex, MY_MUTEX_INIT_FAST)) +#else + if (mysql_mutex_init(spd_key_mutex_share, + &share->mutex, MY_MUTEX_INIT_FAST)) +#endif + { + *error_num = HA_ERR_OUT_OF_MEM; + goto error_init_mutex; + } + +#if MYSQL_VERSION_ID < 50500 + if (pthread_mutex_init(&share->sts_mutex, MY_MUTEX_INIT_FAST)) +#else + if (mysql_mutex_init(spd_key_mutex_share_sts, + &share->sts_mutex, MY_MUTEX_INIT_FAST)) +#endif + { + *error_num = HA_ERR_OUT_OF_MEM; + goto error_init_sts_mutex; + } + +#if MYSQL_VERSION_ID < 50500 + if (pthread_mutex_init(&share->crd_mutex, MY_MUTEX_INIT_FAST)) +#else + if (mysql_mutex_init(spd_key_mutex_share_crd, + &share->crd_mutex, MY_MUTEX_INIT_FAST)) +#endif + { + *error_num = HA_ERR_OUT_OF_MEM; + goto error_init_crd_mutex; + } + +#ifdef SPIDER_HAS_HASH_VALUE_TYPE + if (!(share->lgtm_tblhnd_share = + spider_get_lgtm_tblhnd_share(tmp_name, length, hash_value, FALSE, TRUE, + error_num))) +#else + if (!(share->lgtm_tblhnd_share = + spider_get_lgtm_tblhnd_share(tmp_name, length, FALSE, TRUE, error_num))) +#endif + { + goto error_get_lgtm_tblhnd_share; + } + + if (!(share->wide_share = + spider_get_wide_share(share, table_share, error_num))) + goto error_get_wide_share; + + for (roop_count = 0; roop_count < SPIDER_DBTON_SIZE; roop_count++) + { + if (spider_bit_is_set(share->dbton_bitmap, roop_count)) + { + if (!(share->dbton_share[roop_count] = + spider_dbton[roop_count].create_db_share(share))) + { + *error_num = HA_ERR_OUT_OF_MEM; + goto error_init_dbton; + } + if ((*error_num = share->dbton_share[roop_count]->init())) + { + goto error_init_dbton; + } +#ifdef HA_HAS_CHECKSUM_EXTENDED + if ( + spider_dbton[roop_count].db_access_type == SPIDER_DB_ACCESS_TYPE_SQL && + !share->dbton_share[roop_count]->checksum_support() + ) { + checksum_support = FALSE; + } +#endif + } + } +#ifdef HA_HAS_CHECKSUM_EXTENDED + if (checksum_support) + { + share->additional_table_flags |= + HA_HAS_OLD_CHECKSUM | + HA_HAS_NEW_CHECKSUM; + } +#endif + DBUG_RETURN(share); + +/* + roop_count = SPIDER_DBTON_SIZE - 1; +*/ +error_init_dbton: + for (; roop_count >= 0; roop_count--) + { + if (share->dbton_share[roop_count]) + { + delete share->dbton_share[roop_count]; + share->dbton_share[roop_count] = NULL; + } + } + spider_free_wide_share(share->wide_share); +error_get_wide_share: +error_get_lgtm_tblhnd_share: + pthread_mutex_destroy(&share->crd_mutex); +error_init_crd_mutex: + pthread_mutex_destroy(&share->sts_mutex); +error_init_sts_mutex: + pthread_mutex_destroy(&share->mutex); +error_init_mutex: +error_create_conn_keys: +error_parse_connect_string: +error_init_hint_string: + spider_free_share_alloc(share); + spider_free(spider_current_trx, share, MYF(0)); +error_alloc_share: + DBUG_RETURN(NULL); +} + +SPIDER_SHARE *spider_get_share( + const char *table_name, + TABLE *table, + THD *thd, + ha_spider *spider, + int *error_num +) { + SPIDER_SHARE *share; + TABLE_SHARE *table_share = table->s; + SPIDER_RESULT_LIST *result_list = &spider->result_list; + uint length, tmp_conn_link_idx = 0, buf_sz; + char *tmp_name, *tmp_cid; +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + char *tmp_hs_r_name, *tmp_hs_w_name; +#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS + uint32 *tmp_hs_r_ret_fields, *tmp_hs_w_ret_fields; +#endif +#endif + int roop_count; + double sts_interval; + int sts_mode; +#ifdef WITH_PARTITION_STORAGE_ENGINE + int sts_sync; + int auto_increment_mode; +#endif + double crd_interval; + int crd_mode; +#ifdef WITH_PARTITION_STORAGE_ENGINE + int crd_sync; +#endif + char first_byte; + int semi_table_lock_conn; + int search_link_idx; + uint sql_command = thd_sql_command(thd); + SPIDER_Open_tables_backup open_tables_backup; + MEM_ROOT mem_root; + TABLE *table_tables = NULL; + bool init_mem_root = FALSE; + bool same_server_link; + int load_sts_at_startup; + int load_crd_at_startup; + user_var_entry *loop_check; + char *loop_check_buf; + TABLE_SHARE *top_share; + LEX_CSTRING lex_str; + DBUG_ENTER("spider_get_share"); + top_share = spider->wide_handler->top_share; + length = (uint) strlen(table_name); +#ifdef SPIDER_HAS_HASH_VALUE_TYPE + my_hash_value_type hash_value = my_calc_hash(&spider_open_tables, + (uchar*) table_name, length); +#endif + if (top_share) + { + lex_str.length = top_share->path.length + SPIDER_SQL_LOP_CHK_PRM_PRF_LEN; + buf_sz = spider_unique_id.length > SPIDER_SQL_LOP_CHK_PRM_PRF_LEN ? + top_share->path.length + spider_unique_id.length + 2 : + lex_str.length + 2; + loop_check_buf = (char *) my_alloca(buf_sz); + if (unlikely(!loop_check_buf)) + { + *error_num = HA_ERR_OUT_OF_MEM; + DBUG_RETURN(NULL); + } + lex_str.str = loop_check_buf + buf_sz - lex_str.length - 2; + memcpy((void *) lex_str.str, + SPIDER_SQL_LOP_CHK_PRM_PRF_STR, SPIDER_SQL_LOP_CHK_PRM_PRF_LEN); + memcpy((void *) (lex_str.str + SPIDER_SQL_LOP_CHK_PRM_PRF_LEN), + top_share->path.str, top_share->path.length); + ((char *) lex_str.str)[lex_str.length] = '\0'; + DBUG_PRINT("info",("spider loop check param name=%s", lex_str.str)); + loop_check = get_variable(&thd->user_vars, &lex_str, FALSE); + if (loop_check && loop_check->type == STRING_RESULT) + { + lex_str.length = top_share->path.length + spider_unique_id.length + 1; + lex_str.str = loop_check_buf + buf_sz - top_share->path.length - + spider_unique_id.length - 2; + memcpy((void *) lex_str.str, spider_unique_id.str, + spider_unique_id.length); + ((char *) lex_str.str)[lex_str.length - 1] = '-'; + ((char *) lex_str.str)[lex_str.length] = '\0'; + DBUG_PRINT("info",("spider loop check key=%s", lex_str.str)); + DBUG_PRINT("info",("spider loop check param value=%s", + loop_check->value)); + if (unlikely(strstr(loop_check->value, lex_str.str))) + { + *error_num = ER_SPIDER_INFINITE_LOOP_NUM; + my_printf_error(*error_num, ER_SPIDER_INFINITE_LOOP_STR, MYF(0), + top_share->db.str, top_share->table_name.str); + my_afree(loop_check_buf); + DBUG_RETURN(NULL); + } + } + my_afree(loop_check_buf); + } + pthread_mutex_lock(&spider_tbl_mutex); +#ifdef SPIDER_HAS_HASH_VALUE_TYPE + if (!(share = (SPIDER_SHARE*) my_hash_search_using_hash_value( + &spider_open_tables, hash_value, (uchar*) table_name, length))) +#else + if (!(share = (SPIDER_SHARE*) my_hash_search(&spider_open_tables, + (uchar*) table_name, length))) +#endif + { + if (!(share = spider_create_share( + table_name, table_share, +#ifdef WITH_PARTITION_STORAGE_ENGINE + table->part_info, +#endif +#ifdef SPIDER_HAS_HASH_VALUE_TYPE + hash_value, +#endif + error_num + ))) { + goto error_alloc_share; + } + + uint old_elements = spider_open_tables.array.max_element; +#ifdef HASH_UPDATE_WITH_HASH_VALUE + if (my_hash_insert_with_hash_value(&spider_open_tables, hash_value, + (uchar*) share)) +#else + if (my_hash_insert(&spider_open_tables, (uchar*) share)) +#endif + { + *error_num = HA_ERR_OUT_OF_MEM; + goto error_hash_insert; + } + if (spider_open_tables.array.max_element > old_elements) + { + spider_alloc_calc_mem(spider_current_trx, + spider_open_tables, + (spider_open_tables.array.max_element - old_elements) * + spider_open_tables.array.size_of_element); + } + + spider->share = share; + spider->conn_link_idx = &tmp_conn_link_idx; + + share->use_count++; + pthread_mutex_unlock(&spider_tbl_mutex); + + if (!share->link_status_init) + { + pthread_mutex_lock(&share->mutex); + for (roop_count = 0; + roop_count < (int) spider_param_udf_table_mon_mutex_count(); + roop_count++ + ) { + if (spider_bit_is_set(share->table_mon_mutex_bitmap, roop_count)) + pthread_mutex_lock(&spider_udf_table_mon_mutexes[roop_count]); + } + if (!share->link_status_init) + { + /* + The link statuses need to be refreshed from the spider_tables table + if the operation: + - Is not a DROP TABLE on a permanent table; or + - Is an ALTER TABLE. + + Note that SHOW CREATE TABLE is not excluded, because the commands + that follow it require up-to-date link statuses. + */ + if ((table_share->tmp_table == NO_TMP_TABLE && + sql_command != SQLCOM_DROP_TABLE) || + /* for alter change link status */ + sql_command == SQLCOM_ALTER_TABLE) + { + SPD_INIT_ALLOC_ROOT(&mem_root, 4096, 0, MYF(MY_WME)); + init_mem_root = TRUE; + + if ( + !(table_tables = spider_open_sys_table( + thd, SPIDER_SYS_TABLES_TABLE_NAME_STR, + SPIDER_SYS_TABLES_TABLE_NAME_LEN, FALSE, &open_tables_backup, + FALSE, error_num)) + ) { + for (roop_count = 0; + roop_count < (int) spider_param_udf_table_mon_mutex_count(); + roop_count++ + ) { + if (spider_bit_is_set(share->table_mon_mutex_bitmap, roop_count)) + pthread_mutex_unlock(&spider_udf_table_mon_mutexes[roop_count]); + } + pthread_mutex_unlock(&share->mutex); + share->init_error = TRUE; + share->init_error_time = (time_t) time((time_t*) 0); + share->init = TRUE; + spider_free_share(share); + goto error_open_sys_table; + } + *error_num = spider_get_link_statuses(table_tables, share, + &mem_root); + if (*error_num) + { + if ( + *error_num != HA_ERR_KEY_NOT_FOUND && + *error_num != HA_ERR_END_OF_FILE + ) { + for (roop_count = 0; + roop_count < (int) spider_param_udf_table_mon_mutex_count(); + roop_count++ + ) { + if (spider_bit_is_set(share->table_mon_mutex_bitmap, roop_count)) + pthread_mutex_unlock(&spider_udf_table_mon_mutexes[roop_count]); + } + pthread_mutex_unlock(&share->mutex); + share->init_error = TRUE; + share->init_error_time = (time_t) time((time_t*) 0); + share->init = TRUE; + spider_free_share(share); + spider_close_sys_table(thd, table_tables, + &open_tables_backup, FALSE); + table_tables = NULL; + goto error_open_sys_table; + } + } else { + memcpy(share->alter_table.tmp_link_statuses, share->link_statuses, + sizeof(long) * share->all_link_count); + share->link_status_init = TRUE; + } + spider_close_sys_table(thd, table_tables, + &open_tables_backup, FALSE); + table_tables = NULL; + } + share->have_recovery_link = spider_conn_check_recovery_link(share); + if (init_mem_root) + { + free_root(&mem_root, MYF(0)); + init_mem_root = FALSE; + } + } + for (roop_count = 0; + roop_count < (int) spider_param_udf_table_mon_mutex_count(); + roop_count++ + ) { + if (spider_bit_is_set(share->table_mon_mutex_bitmap, roop_count)) + pthread_mutex_unlock(&spider_udf_table_mon_mutexes[roop_count]); + } + pthread_mutex_unlock(&share->mutex); + } + + semi_table_lock_conn = spider_param_semi_table_lock_connection(thd, + share->semi_table_lock_conn); + if (semi_table_lock_conn) + first_byte = '0' + + spider_param_semi_table_lock(thd, share->semi_table_lock); + else + first_byte = '0'; + + if (!(spider->wide_handler->trx = spider_get_trx(thd, TRUE, error_num))) + { + share->init_error = TRUE; + share->init_error_time = (time_t) time((time_t*) 0); + share->init = TRUE; + spider_free_share(share); + goto error_but_no_delete; + } + spider->set_error_mode(); + +#ifndef WITHOUT_SPIDER_BG_SEARCH + if (!share->sts_spider_init) + { + pthread_mutex_lock(&share->mutex); + if (!share->sts_spider_init) + { + if ((*error_num = spider_create_spider_object_for_share( + spider->wide_handler->trx, share, &share->sts_spider))) + { + pthread_mutex_unlock(&share->mutex); + share->init_error = TRUE; + share->init_error_time = (time_t) time((time_t*) 0); + share->init = TRUE; + spider_free_share(share); + goto error_sts_spider_init; + } +#ifdef HASH_UPDATE_WITH_HASH_VALUE + share->sts_thread = &spider_table_sts_threads[ + hash_value % spider_param_table_sts_thread_count()]; +#else + share->sts_thread = &spider_table_sts_threads[ + my_calc_hash(&spider_open_tables, (uchar*) table_name, length) % + spider_param_table_sts_thread_count()]; +#endif + share->sts_spider_init = TRUE; + } + pthread_mutex_unlock(&share->mutex); + } + + if (!share->crd_spider_init) + { + pthread_mutex_lock(&share->mutex); + if (!share->crd_spider_init) + { + if ((*error_num = spider_create_spider_object_for_share( + spider->wide_handler->trx, share, &share->crd_spider))) + { + pthread_mutex_unlock(&share->mutex); + share->init_error = TRUE; + share->init_error_time = (time_t) time((time_t*) 0); + share->init = TRUE; + spider_free_share(share); + goto error_crd_spider_init; + } +#ifdef HASH_UPDATE_WITH_HASH_VALUE + share->crd_thread = &spider_table_crd_threads[ + hash_value % spider_param_table_crd_thread_count()]; +#else + share->crd_thread = &spider_table_crd_threads[ + my_calc_hash(&spider_open_tables, (uchar*) table_name, length) % + spider_param_table_crd_thread_count()]; +#endif + share->crd_spider_init = TRUE; + } + pthread_mutex_unlock(&share->mutex); + } +#endif + +#ifndef WITHOUT_SPIDER_BG_SEARCH + if ( + sql_command != SQLCOM_DROP_TABLE && + sql_command != SQLCOM_ALTER_TABLE && + sql_command != SQLCOM_SHOW_CREATE && + (*error_num = spider_create_mon_threads(spider->wide_handler->trx, + share)) + ) { + share->init_error = TRUE; + share->init_error_time = (time_t) time((time_t*) 0); + share->init = TRUE; + spider_free_share(share); + goto error_but_no_delete; + } +#endif + + if (!(spider->conn_keys = (char **) + spider_bulk_alloc_mem(spider_current_trx, 47, + __func__, __FILE__, __LINE__, MYF(MY_WME | MY_ZEROFILL), + &spider->conn_keys, sizeof(char *) * share->link_count, + &tmp_name, sizeof(char) * share->conn_keys_charlen, + &spider->conns, sizeof(SPIDER_CONN *) * share->link_count, + &spider->conn_link_idx, sizeof(uint) * share->link_count, + &spider->conn_can_fo, sizeof(uchar) * share->link_bitmap_size, +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + &spider->hs_r_conn_keys, sizeof(char *) * share->link_count, + &tmp_hs_r_name, sizeof(char) * share->hs_read_conn_keys_charlen, + &spider->hs_r_conns, sizeof(SPIDER_CONN *) * share->link_count, + &spider->hs_r_conn_ages, sizeof(ulonglong) * share->link_count, + &spider->hs_w_conn_keys, sizeof(char *) * share->link_count, + &tmp_hs_w_name, sizeof(char) * share->hs_write_conn_keys_charlen, + &spider->hs_w_conns, sizeof(SPIDER_CONN *) * share->link_count, + &spider->hs_w_conn_ages, sizeof(ulonglong) * share->link_count, +#endif + &spider->sql_kind, sizeof(uint) * share->link_count, + &spider->connection_ids, sizeof(ulonglong) * share->link_count, + &spider->conn_kind, sizeof(uint) * share->link_count, + &spider->db_request_id, sizeof(ulonglong) * share->link_count, + &spider->db_request_phase, sizeof(uchar) * share->link_bitmap_size, + &spider->m_handler_opened, sizeof(uchar) * share->link_bitmap_size, + &spider->m_handler_id, sizeof(uint) * share->link_count, + &spider->m_handler_cid, sizeof(char *) * share->link_count, +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + &spider->r_handler_opened, sizeof(uchar) * share->link_bitmap_size, + &spider->r_handler_id, sizeof(uint) * share->link_count, + &spider->r_handler_index, sizeof(uint) * share->link_count, + &spider->w_handler_opened, sizeof(uchar) * share->link_bitmap_size, + &spider->w_handler_id, sizeof(uint) * share->link_count, + &spider->w_handler_index, sizeof(uint) * share->link_count, +#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS + &spider->do_hs_direct_update, sizeof(uchar) * share->link_bitmap_size, + &spider->hs_r_ret_fields, sizeof(uint32 *) * share->link_count, + &spider->hs_w_ret_fields, sizeof(uint32 *) * share->link_count, + &spider->hs_r_ret_fields_num, sizeof(size_t) * share->link_count, + &spider->hs_w_ret_fields_num, sizeof(size_t) * share->link_count, + &tmp_hs_r_ret_fields, + sizeof(uint32) * share->link_count * table_share->fields, + &tmp_hs_w_ret_fields, + sizeof(uint32) * share->link_count * table_share->fields, + &spider->tmp_column_bitmap, sizeof(uchar) * share->bitmap_size, +#endif +#endif + &tmp_cid, sizeof(char) * (SPIDER_SQL_HANDLER_CID_LEN + 1) * + share->link_count, + &spider->need_mons, sizeof(int) * share->link_count, + &spider->quick_targets, sizeof(void *) * share->link_count, + &result_list->upd_tmp_tbls, sizeof(TABLE *) * share->link_count, + &result_list->upd_tmp_tbl_prms, + sizeof(TMP_TABLE_PARAM) * share->link_count, + &result_list->tmp_table_join_first, + sizeof(uchar) * share->link_bitmap_size, + &result_list->tmp_table_created, + sizeof(uchar) * share->link_bitmap_size, +#ifdef HA_CAN_BULK_ACCESS +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + &result_list->hs_r_bulk_open_index, + sizeof(uchar) * share->link_bitmap_size, + &result_list->hs_w_bulk_open_index, + sizeof(uchar) * share->link_bitmap_size, +#endif +#endif + &result_list->sql_kind_backup, sizeof(uint) * share->link_count, + &result_list->casual_read, sizeof(int) * share->link_count, + &spider->dbton_handler, + sizeof(spider_db_handler *) * SPIDER_DBTON_SIZE, + NullS)) + ) { + share->init_error = TRUE; + share->init_error_time = (time_t) time((time_t*) 0); + share->init = TRUE; + spider_free_share(share); + goto error_but_no_delete; + } + memcpy(tmp_name, share->conn_keys[0], share->conn_keys_charlen); +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + memcpy(tmp_hs_r_name, share->hs_read_conn_keys[0], + share->hs_read_conn_keys_charlen); + memcpy(tmp_hs_w_name, share->hs_write_conn_keys[0], + share->hs_write_conn_keys_charlen); +#endif + + spider->conn_keys_first_ptr = tmp_name; + for (roop_count = 0; roop_count < (int) share->link_count; roop_count++) + { + spider->conn_keys[roop_count] = tmp_name; + *tmp_name = first_byte; + tmp_name += share->conn_keys_lengths[roop_count] + 1; +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + spider->hs_r_conn_keys[roop_count] = tmp_hs_r_name; + tmp_hs_r_name += share->hs_read_conn_keys_lengths[roop_count] + 1; + spider->hs_w_conn_keys[roop_count] = tmp_hs_w_name; + tmp_hs_w_name += share->hs_write_conn_keys_lengths[roop_count] + 1; +#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS + spider->hs_r_ret_fields[roop_count] = tmp_hs_r_ret_fields; + tmp_hs_r_ret_fields += table_share->fields; + spider->hs_w_ret_fields[roop_count] = tmp_hs_w_ret_fields; + tmp_hs_w_ret_fields += table_share->fields; +#endif +#endif + spider->m_handler_cid[roop_count] = tmp_cid; + tmp_cid += SPIDER_SQL_HANDLER_CID_LEN + 1; + result_list->upd_tmp_tbl_prms[roop_count].init(); + result_list->upd_tmp_tbl_prms[roop_count].field_count = 1; + spider->conn_kind[roop_count] = SPIDER_CONN_KIND_MYSQL; + } + spider_trx_set_link_idx_for_all(spider); + + for (roop_count = 0; roop_count < (int) share->use_dbton_count; + roop_count++) + { + uint dbton_id = share->use_dbton_ids[roop_count]; + if (!(spider->dbton_handler[dbton_id] = + spider_dbton[dbton_id].create_db_handler(spider, + share->dbton_share[dbton_id]))) + { + *error_num = HA_ERR_OUT_OF_MEM; + break; + } + if ((*error_num = spider->dbton_handler[dbton_id]->init())) + { + break; + } + } + if (roop_count < (int) share->use_dbton_count) + { + for (; roop_count >= 0; roop_count--) + { + uint dbton_id = share->use_dbton_ids[roop_count]; + if (spider->dbton_handler[dbton_id]) + { + delete spider->dbton_handler[dbton_id]; + spider->dbton_handler[dbton_id] = NULL; + } + } + share->init_error = TRUE; + share->init_error_time = (time_t) time((time_t*) 0); + share->init = TRUE; + goto error_after_alloc_conn_keys; + } + + if ( + sql_command != SQLCOM_DROP_TABLE && + sql_command != SQLCOM_ALTER_TABLE && + sql_command != SQLCOM_SHOW_CREATE + ) { + for ( + roop_count = spider_conn_link_idx_next(share->link_statuses, + spider->conn_link_idx, -1, share->link_count, + SPIDER_LINK_STATUS_RECOVERY); + roop_count < (int) share->link_count; + roop_count = spider_conn_link_idx_next(share->link_statuses, + spider->conn_link_idx, roop_count, share->link_count, + SPIDER_LINK_STATUS_RECOVERY) + ) { + if ( + !(spider->conns[roop_count] = + spider_get_conn(share, roop_count, spider->conn_keys[roop_count], + spider->wide_handler->trx, spider, FALSE, TRUE, + SPIDER_CONN_KIND_MYSQL, + error_num)) + ) { + if ( + share->monitoring_kind[roop_count] && + spider->need_mons[roop_count] + ) { + *error_num = spider_ping_table_mon_from_table( + spider->wide_handler->trx, + spider->wide_handler->trx->thd, + share, + roop_count, + (uint32) share->monitoring_sid[roop_count], + share->table_name, + share->table_name_length, + spider->conn_link_idx[roop_count], + NULL, + 0, + share->monitoring_kind[roop_count], + share->monitoring_limit[roop_count], + share->monitoring_flag[roop_count], + FALSE + ); + } + share->init_error = TRUE; + share->init_error_time = (time_t) time((time_t*) 0); + share->init = TRUE; + goto error_after_alloc_dbton_handler; + } + spider->conns[roop_count]->error_mode &= spider->error_mode; + } + } + search_link_idx = spider_conn_first_link_idx(thd, + share->link_statuses, share->access_balances, spider->conn_link_idx, + share->link_count, SPIDER_LINK_STATUS_OK); + if (search_link_idx == -1) + { + char *db = (char *) my_alloca( + table_share->db.length + 1 + table_share->table_name.length + 1); + if (!db) + { + *error_num = HA_ERR_OUT_OF_MEM; + share->init_error = TRUE; + share->init_error_time = (time_t) time((time_t*) 0); + share->init = TRUE; + goto error_after_alloc_dbton_handler; + } + char *table_name = db + table_share->db.length + 1; + memcpy(db, table_share->db.str, table_share->db.length); + db[table_share->db.length] = '\0'; + memcpy(table_name, table_share->table_name.str, + table_share->table_name.length); + table_name[table_share->table_name.length] = '\0'; + my_printf_error(ER_SPIDER_ALL_LINKS_FAILED_NUM, + ER_SPIDER_ALL_LINKS_FAILED_STR, MYF(0), db, table_name); + my_afree(db); + *error_num = ER_SPIDER_ALL_LINKS_FAILED_NUM; + share->init_error = TRUE; + share->init_error_time = (time_t) time((time_t*) 0); + share->init = TRUE; + goto error_after_alloc_dbton_handler; + } else if (search_link_idx == -2) + { + *error_num = HA_ERR_OUT_OF_MEM; + share->init_error = TRUE; + share->init_error_time = (time_t) time((time_t*) 0); + share->init = TRUE; + goto error_after_alloc_dbton_handler; + } + spider->search_link_idx = search_link_idx; + + same_server_link = spider_param_same_server_link(thd); + load_sts_at_startup = + spider_param_load_sts_at_startup(share->load_sts_at_startup); + load_crd_at_startup = + spider_param_load_crd_at_startup(share->load_crd_at_startup); + if ( + sql_command != SQLCOM_DROP_TABLE && + sql_command != SQLCOM_ALTER_TABLE && + sql_command != SQLCOM_SHOW_CREATE && + !spider->error_mode && + ( + !same_server_link || + load_sts_at_startup || + load_crd_at_startup + ) + ) { + SPIDER_INIT_ERROR_TABLE *spider_init_error_table; + sts_interval = spider_param_sts_interval(thd, share->sts_interval); + sts_mode = spider_param_sts_mode(thd, share->sts_mode); +#ifdef WITH_PARTITION_STORAGE_ENGINE + sts_sync = spider_param_sts_sync(thd, share->sts_sync); + auto_increment_mode = spider_param_auto_increment_mode(thd, + share->auto_increment_mode); + if (auto_increment_mode == 1) + sts_sync = 0; +#endif + crd_interval = spider_param_crd_interval(thd, share->crd_interval); + crd_mode = spider_param_crd_mode(thd, share->crd_mode); + if (crd_mode == 3) + crd_mode = 1; +#ifdef WITH_PARTITION_STORAGE_ENGINE + crd_sync = spider_param_crd_sync(thd, share->crd_sync); +#endif + time_t tmp_time = (time_t) time((time_t*) 0); + pthread_mutex_lock(&share->sts_mutex); + pthread_mutex_lock(&share->crd_mutex); + if ((spider_init_error_table = + spider_get_init_error_table(spider->wide_handler->trx, share, FALSE))) + { + DBUG_PRINT("info",("spider diff1=%f", + difftime(tmp_time, spider_init_error_table->init_error_time))); + if (difftime(tmp_time, + spider_init_error_table->init_error_time) < + spider_param_table_init_error_interval()) + { + *error_num = spider_init_error_table->init_error; + if (spider_init_error_table->init_error_with_message) + my_message(spider_init_error_table->init_error, + spider_init_error_table->init_error_msg, MYF(0)); + share->init_error = TRUE; + share->init = TRUE; + pthread_mutex_unlock(&share->crd_mutex); + pthread_mutex_unlock(&share->sts_mutex); + goto error_after_alloc_dbton_handler; + } + } + + if ( + ( + !same_server_link || + load_sts_at_startup + ) && + (*error_num = spider_get_sts(share, spider->search_link_idx, tmp_time, + spider, sts_interval, sts_mode, +#ifdef WITH_PARTITION_STORAGE_ENGINE + sts_sync, +#endif + 1, HA_STATUS_VARIABLE | HA_STATUS_CONST | HA_STATUS_AUTO)) + ) { + if (*error_num != ER_SPIDER_SYS_TABLE_VERSION_NUM) + { + thd->clear_error(); + } else { + pthread_mutex_unlock(&share->crd_mutex); + pthread_mutex_unlock(&share->sts_mutex); + share->init_error = TRUE; + share->init_error_time = (time_t) time((time_t*) 0); + share->init = TRUE; + goto error_after_alloc_dbton_handler; + } + } + if ( + ( + !same_server_link || + load_crd_at_startup + ) && + (*error_num = spider_get_crd(share, spider->search_link_idx, tmp_time, + spider, table, crd_interval, crd_mode, +#ifdef WITH_PARTITION_STORAGE_ENGINE + crd_sync, +#endif + 1)) + ) { + if (*error_num != ER_SPIDER_SYS_TABLE_VERSION_NUM) + { + thd->clear_error(); + } else { + pthread_mutex_unlock(&share->crd_mutex); + pthread_mutex_unlock(&share->sts_mutex); + share->init_error = TRUE; + share->init_error_time = (time_t) time((time_t*) 0); + share->init = TRUE; + goto error_after_alloc_dbton_handler; + } + } + pthread_mutex_unlock(&share->crd_mutex); + pthread_mutex_unlock(&share->sts_mutex); + } + + share->init = TRUE; + } else { + share->use_count++; + pthread_mutex_unlock(&spider_tbl_mutex); + + int sleep_cnt = 0; + while (!share->init) + { + // avoid for dead loop + if (sleep_cnt++ > 1000) + { + fprintf(stderr, " [WARN SPIDER RESULT] " + "Wait share->init too long, table_name %s %s %ld\n", + share->table_name, share->tgt_hosts[0], share->tgt_ports[0]); + *error_num = ER_SPIDER_TABLE_OPEN_TIMEOUT_NUM; + my_printf_error(ER_SPIDER_TABLE_OPEN_TIMEOUT_NUM, + ER_SPIDER_TABLE_OPEN_TIMEOUT_STR, MYF(0), + table_share->db.str, table_share->table_name.str); + spider_free_share(share); + goto error_but_no_delete; + } + my_sleep(10000); // wait 10 ms + } + + if (!share->link_status_init) + { + pthread_mutex_lock(&share->mutex); + for (roop_count = 0; + roop_count < (int) spider_param_udf_table_mon_mutex_count(); + roop_count++ + ) { + if (spider_bit_is_set(share->table_mon_mutex_bitmap, roop_count)) + pthread_mutex_lock(&spider_udf_table_mon_mutexes[roop_count]); + } + if (!share->link_status_init) + { + DBUG_ASSERT(!table_tables); + /* + The link statuses need to be refreshed from the spider_tables table + if the operation: + - Is not a DROP TABLE on a permanent table; or + - Is an ALTER TABLE. + + Note that SHOW CREATE TABLE is not excluded, because the commands + that follow it require up-to-date link statuses. + */ + if ((table_share->tmp_table == NO_TMP_TABLE && + sql_command != SQLCOM_DROP_TABLE) || + /* for alter change link status */ + sql_command == SQLCOM_ALTER_TABLE) + { + SPD_INIT_ALLOC_ROOT(&mem_root, 4096, 0, MYF(MY_WME)); + init_mem_root = TRUE; + + if ( + !(table_tables = spider_open_sys_table( + thd, SPIDER_SYS_TABLES_TABLE_NAME_STR, + SPIDER_SYS_TABLES_TABLE_NAME_LEN, FALSE, &open_tables_backup, + FALSE, error_num)) + ) { + for (roop_count = 0; + roop_count < (int) spider_param_udf_table_mon_mutex_count(); + roop_count++ + ) { + if (spider_bit_is_set(share->table_mon_mutex_bitmap, roop_count)) + pthread_mutex_unlock(&spider_udf_table_mon_mutexes[roop_count]); + } + pthread_mutex_unlock(&share->mutex); + spider_free_share(share); + goto error_open_sys_table; + } + *error_num = spider_get_link_statuses(table_tables, share, + &mem_root); + if (*error_num) + { + if ( + *error_num != HA_ERR_KEY_NOT_FOUND && + *error_num != HA_ERR_END_OF_FILE + ) { + for (roop_count = 0; + roop_count < (int) spider_param_udf_table_mon_mutex_count(); + roop_count++ + ) { + if (spider_bit_is_set(share->table_mon_mutex_bitmap, roop_count)) + pthread_mutex_unlock(&spider_udf_table_mon_mutexes[roop_count]); + } + pthread_mutex_unlock(&share->mutex); + spider_free_share(share); + spider_close_sys_table(thd, table_tables, + &open_tables_backup, FALSE); + table_tables = NULL; + goto error_open_sys_table; + } + } else { + memcpy(share->alter_table.tmp_link_statuses, share->link_statuses, + sizeof(long) * share->all_link_count); + share->link_status_init = TRUE; + } + spider_close_sys_table(thd, table_tables, + &open_tables_backup, FALSE); + table_tables = NULL; + } + share->have_recovery_link = spider_conn_check_recovery_link(share); + if (init_mem_root) + { + free_root(&mem_root, MYF(0)); + init_mem_root = FALSE; + } + } + for (roop_count = 0; + roop_count < (int) spider_param_udf_table_mon_mutex_count(); + roop_count++ + ) { + if (spider_bit_is_set(share->table_mon_mutex_bitmap, roop_count)) + pthread_mutex_unlock(&spider_udf_table_mon_mutexes[roop_count]); + } + pthread_mutex_unlock(&share->mutex); + } + + semi_table_lock_conn = spider_param_semi_table_lock_connection(thd, + share->semi_table_lock_conn); + if (semi_table_lock_conn) + first_byte = '0' + + spider_param_semi_table_lock(thd, share->semi_table_lock); + else + first_byte = '0'; + + spider->share = share; + if (!(spider->wide_handler->trx = spider_get_trx(thd, TRUE, error_num))) + { + spider_free_share(share); + goto error_but_no_delete; + } + spider->set_error_mode(); + +#ifndef WITHOUT_SPIDER_BG_SEARCH + if (!share->sts_spider_init) + { + pthread_mutex_lock(&share->mutex); + if (!share->sts_spider_init) + { + if ((*error_num = spider_create_spider_object_for_share( + spider->wide_handler->trx, share, &share->sts_spider))) + { + pthread_mutex_unlock(&share->mutex); + spider_free_share(share); + goto error_sts_spider_init; + } +#ifdef HASH_UPDATE_WITH_HASH_VALUE + share->sts_thread = &spider_table_sts_threads[ + hash_value % spider_param_table_sts_thread_count()]; +#else + share->sts_thread = &spider_table_sts_threads[ + my_calc_hash(&spider_open_tables, (uchar*) table_name, length) % + spider_param_table_sts_thread_count()]; +#endif + share->sts_spider_init = TRUE; + } + pthread_mutex_unlock(&share->mutex); + } + + if (!share->crd_spider_init) + { + pthread_mutex_lock(&share->mutex); + if (!share->crd_spider_init) + { + if ((*error_num = spider_create_spider_object_for_share( + spider->wide_handler->trx, share, &share->crd_spider))) + { + pthread_mutex_unlock(&share->mutex); + spider_free_share(share); + goto error_crd_spider_init; + } +#ifdef HASH_UPDATE_WITH_HASH_VALUE + share->crd_thread = &spider_table_crd_threads[ + hash_value % spider_param_table_crd_thread_count()]; +#else + share->crd_thread = &spider_table_crd_threads[ + my_calc_hash(&spider_open_tables, (uchar*) table_name, length) % + spider_param_table_crd_thread_count()]; +#endif + share->crd_spider_init = TRUE; + } + pthread_mutex_unlock(&share->mutex); + } +#endif + +#ifndef WITHOUT_SPIDER_BG_SEARCH + if ( + sql_command != SQLCOM_DROP_TABLE && + sql_command != SQLCOM_ALTER_TABLE && + sql_command != SQLCOM_SHOW_CREATE && + (*error_num = spider_create_mon_threads(spider->wide_handler->trx, + share)) + ) { + spider_free_share(share); + goto error_but_no_delete; + } +#endif + + if (!(spider->conn_keys = (char **) + spider_bulk_alloc_mem(spider_current_trx, 49, + __func__, __FILE__, __LINE__, MYF(MY_WME | MY_ZEROFILL), + &spider->conn_keys, sizeof(char *) * share->link_count, + &tmp_name, sizeof(char) * share->conn_keys_charlen, + &spider->conns, sizeof(SPIDER_CONN *) * share->link_count, + &spider->conn_link_idx, sizeof(uint) * share->link_count, + &spider->conn_can_fo, sizeof(uchar) * share->link_bitmap_size, +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + &spider->hs_r_conn_keys, sizeof(char *) * share->link_count, + &tmp_hs_r_name, sizeof(char) * share->hs_read_conn_keys_charlen, + &spider->hs_r_conns, sizeof(SPIDER_CONN *) * share->link_count, + &spider->hs_r_conn_ages, sizeof(ulonglong) * share->link_count, + &spider->hs_w_conn_keys, sizeof(char *) * share->link_count, + &tmp_hs_w_name, sizeof(char) * share->hs_write_conn_keys_charlen, + &spider->hs_w_conns, sizeof(SPIDER_CONN *) * share->link_count, + &spider->hs_w_conn_ages, sizeof(ulonglong) * share->link_count, +#endif + &spider->sql_kind, sizeof(uint) * share->link_count, + &spider->connection_ids, sizeof(ulonglong) * share->link_count, + &spider->conn_kind, sizeof(uint) * share->link_count, + &spider->db_request_id, sizeof(ulonglong) * share->link_count, + &spider->db_request_phase, sizeof(uchar) * share->link_bitmap_size, + &spider->m_handler_opened, sizeof(uchar) * share->link_bitmap_size, + &spider->m_handler_id, sizeof(uint) * share->link_count, + &spider->m_handler_cid, sizeof(char *) * share->link_count, +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + &spider->r_handler_opened, sizeof(uchar) * share->link_bitmap_size, + &spider->r_handler_id, sizeof(uint) * share->link_count, + &spider->r_handler_index, sizeof(uint) * share->link_count, + &spider->w_handler_opened, sizeof(uchar) * share->link_bitmap_size, + &spider->w_handler_id, sizeof(uint) * share->link_count, + &spider->w_handler_index, sizeof(uint) * share->link_count, +#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS + &spider->do_hs_direct_update, sizeof(uchar) * share->link_bitmap_size, + &spider->hs_r_ret_fields, sizeof(uint32 *) * share->link_count, + &spider->hs_w_ret_fields, sizeof(uint32 *) * share->link_count, + &spider->hs_r_ret_fields_num, sizeof(size_t) * share->link_count, + &spider->hs_w_ret_fields_num, sizeof(size_t) * share->link_count, + &tmp_hs_r_ret_fields, + sizeof(uint32) * share->link_count * table_share->fields, + &tmp_hs_w_ret_fields, + sizeof(uint32) * share->link_count * table_share->fields, + &spider->tmp_column_bitmap, sizeof(uchar) * share->bitmap_size, +#endif +#endif + &tmp_cid, sizeof(char) * (SPIDER_SQL_HANDLER_CID_LEN + 1) * + share->link_count, + &spider->need_mons, sizeof(int) * share->link_count, + &spider->quick_targets, sizeof(void *) * share->link_count, + &result_list->upd_tmp_tbls, sizeof(TABLE *) * share->link_count, + &result_list->upd_tmp_tbl_prms, + sizeof(TMP_TABLE_PARAM) * share->link_count, + &result_list->tmp_table_join_first, + sizeof(uchar) * share->link_bitmap_size, + &result_list->tmp_table_created, + sizeof(uchar) * share->link_bitmap_size, +#ifdef HA_CAN_BULK_ACCESS +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + &result_list->hs_r_bulk_open_index, + sizeof(uchar) * share->link_bitmap_size, + &result_list->hs_w_bulk_open_index, + sizeof(uchar) * share->link_bitmap_size, +#endif +#endif + &result_list->sql_kind_backup, sizeof(uint) * share->link_count, + &result_list->casual_read, sizeof(int) * share->link_count, + &spider->dbton_handler, + sizeof(spider_db_handler *) * SPIDER_DBTON_SIZE, + NullS)) + ) { + spider_free_share(share); + goto error_but_no_delete; + } + memcpy(tmp_name, share->conn_keys[0], share->conn_keys_charlen); +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + memcpy(tmp_hs_r_name, share->hs_read_conn_keys[0], + share->hs_read_conn_keys_charlen); + memcpy(tmp_hs_w_name, share->hs_write_conn_keys[0], + share->hs_write_conn_keys_charlen); +#endif + + spider->conn_keys_first_ptr = tmp_name; + for (roop_count = 0; roop_count < (int) share->link_count; roop_count++) + { + spider->conn_keys[roop_count] = tmp_name; + *tmp_name = first_byte; + tmp_name += share->conn_keys_lengths[roop_count] + 1; +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + spider->hs_r_conn_keys[roop_count] = tmp_hs_r_name; + tmp_hs_r_name += share->hs_read_conn_keys_lengths[roop_count] + 1; + spider->hs_w_conn_keys[roop_count] = tmp_hs_w_name; + tmp_hs_w_name += share->hs_write_conn_keys_lengths[roop_count] + 1; +#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS + spider->hs_r_ret_fields[roop_count] = tmp_hs_r_ret_fields; + tmp_hs_r_ret_fields += table_share->fields; + spider->hs_w_ret_fields[roop_count] = tmp_hs_w_ret_fields; + tmp_hs_w_ret_fields += table_share->fields; +#endif +#endif + spider->m_handler_cid[roop_count] = tmp_cid; + tmp_cid += SPIDER_SQL_HANDLER_CID_LEN + 1; + result_list->upd_tmp_tbl_prms[roop_count].init(); + result_list->upd_tmp_tbl_prms[roop_count].field_count = 1; + spider->conn_kind[roop_count] = SPIDER_CONN_KIND_MYSQL; + } + spider_trx_set_link_idx_for_all(spider); + + for (roop_count = 0; roop_count < (int) share->use_dbton_count; + roop_count++) + { + uint dbton_id = share->use_dbton_ids[roop_count]; + if (!(spider->dbton_handler[dbton_id] = + spider_dbton[dbton_id].create_db_handler(spider, + share->dbton_share[dbton_id]))) + { + *error_num = HA_ERR_OUT_OF_MEM; + break; + } + if ((*error_num = spider->dbton_handler[dbton_id]->init())) + { + break; + } + } + if (roop_count < (int) share->use_dbton_count) + { + for (; roop_count >= 0; roop_count--) + { + uint dbton_id = share->use_dbton_ids[roop_count]; + if (spider->dbton_handler[dbton_id]) + { + delete spider->dbton_handler[dbton_id]; + spider->dbton_handler[dbton_id] = NULL; + } + } + goto error_after_alloc_conn_keys; + } + + if ( + sql_command != SQLCOM_DROP_TABLE && + sql_command != SQLCOM_ALTER_TABLE && + sql_command != SQLCOM_SHOW_CREATE + ) { + for ( + roop_count = spider_conn_link_idx_next(share->link_statuses, + spider->conn_link_idx, -1, share->link_count, + SPIDER_LINK_STATUS_RECOVERY); + roop_count < (int) share->link_count; + roop_count = spider_conn_link_idx_next(share->link_statuses, + spider->conn_link_idx, roop_count, share->link_count, + SPIDER_LINK_STATUS_RECOVERY) + ) { + if ( + !(spider->conns[roop_count] = + spider_get_conn(share, roop_count, spider->conn_keys[roop_count], + spider->wide_handler->trx, spider, FALSE, TRUE, + SPIDER_CONN_KIND_MYSQL, + error_num)) + ) { + if ( + share->monitoring_kind[roop_count] && + spider->need_mons[roop_count] + ) { + *error_num = spider_ping_table_mon_from_table( + spider->wide_handler->trx, + spider->wide_handler->trx->thd, + share, + roop_count, + (uint32) share->monitoring_sid[roop_count], + share->table_name, + share->table_name_length, + spider->conn_link_idx[roop_count], + NULL, + 0, + share->monitoring_kind[roop_count], + share->monitoring_limit[roop_count], + share->monitoring_flag[roop_count], + FALSE + ); + } + goto error_after_alloc_dbton_handler; + } + spider->conns[roop_count]->error_mode &= spider->error_mode; + } + } + search_link_idx = spider_conn_first_link_idx(thd, + share->link_statuses, share->access_balances, spider->conn_link_idx, + share->link_count, SPIDER_LINK_STATUS_OK); + if (search_link_idx == -1) + { + char *db = (char *) my_alloca( + table_share->db.length + 1 + table_share->table_name.length + 1); + if (!db) + { + *error_num = HA_ERR_OUT_OF_MEM; + goto error_after_alloc_dbton_handler; + } + char *table_name = db + table_share->db.length + 1; + memcpy(db, table_share->db.str, table_share->db.length); + db[table_share->db.length] = '\0'; + memcpy(table_name, table_share->table_name.str, + table_share->table_name.length); + table_name[table_share->table_name.length] = '\0'; + my_printf_error(ER_SPIDER_ALL_LINKS_FAILED_NUM, + ER_SPIDER_ALL_LINKS_FAILED_STR, MYF(0), db, table_name); + my_afree(db); + *error_num = ER_SPIDER_ALL_LINKS_FAILED_NUM; + goto error_after_alloc_dbton_handler; + } else if (search_link_idx == -2) + { + *error_num = HA_ERR_OUT_OF_MEM; + goto error_after_alloc_dbton_handler; + } + spider->search_link_idx = search_link_idx; + + if (share->init_error) + { + pthread_mutex_lock(&share->sts_mutex); + pthread_mutex_lock(&share->crd_mutex); + if (share->init_error) + { + same_server_link = spider_param_same_server_link(thd); + load_sts_at_startup = + spider_param_load_sts_at_startup(share->load_sts_at_startup); + load_crd_at_startup = + spider_param_load_crd_at_startup(share->load_crd_at_startup); + if ( + sql_command != SQLCOM_DROP_TABLE && + sql_command != SQLCOM_ALTER_TABLE && + sql_command != SQLCOM_SHOW_CREATE && + !spider->error_mode && + ( + !same_server_link || + load_sts_at_startup || + load_crd_at_startup + ) + ) { + SPIDER_INIT_ERROR_TABLE *spider_init_error_table; + sts_interval = spider_param_sts_interval(thd, share->sts_interval); + sts_mode = spider_param_sts_mode(thd, share->sts_mode); +#ifdef WITH_PARTITION_STORAGE_ENGINE + sts_sync = spider_param_sts_sync(thd, share->sts_sync); + auto_increment_mode = spider_param_auto_increment_mode(thd, + share->auto_increment_mode); + if (auto_increment_mode == 1) + sts_sync = 0; +#endif + crd_interval = spider_param_crd_interval(thd, share->crd_interval); + crd_mode = spider_param_crd_mode(thd, share->crd_mode); + if (crd_mode == 3) + crd_mode = 1; +#ifdef WITH_PARTITION_STORAGE_ENGINE + crd_sync = spider_param_crd_sync(thd, share->crd_sync); +#endif + time_t tmp_time = (time_t) time((time_t*) 0); + if ((spider_init_error_table = + spider_get_init_error_table(spider->wide_handler->trx, share, + FALSE))) + { + DBUG_PRINT("info",("spider diff2=%f", + difftime(tmp_time, spider_init_error_table->init_error_time))); + if (difftime(tmp_time, + spider_init_error_table->init_error_time) < + spider_param_table_init_error_interval()) + { + *error_num = spider_init_error_table->init_error; + if (spider_init_error_table->init_error_with_message) + my_message(spider_init_error_table->init_error, + spider_init_error_table->init_error_msg, MYF(0)); + pthread_mutex_unlock(&share->crd_mutex); + pthread_mutex_unlock(&share->sts_mutex); + goto error_after_alloc_dbton_handler; + } + } + + if ( + ( + !same_server_link || + load_sts_at_startup + ) && + (*error_num = spider_get_sts(share, spider->search_link_idx, + tmp_time, spider, sts_interval, sts_mode, +#ifdef WITH_PARTITION_STORAGE_ENGINE + sts_sync, +#endif + 1, HA_STATUS_VARIABLE | HA_STATUS_CONST | HA_STATUS_AUTO)) + ) { + if (*error_num != ER_SPIDER_SYS_TABLE_VERSION_NUM) + { + thd->clear_error(); + } else { + pthread_mutex_unlock(&share->crd_mutex); + pthread_mutex_unlock(&share->sts_mutex); + goto error_after_alloc_dbton_handler; + } + } + if ( + ( + !same_server_link || + load_crd_at_startup + ) && + (*error_num = spider_get_crd(share, spider->search_link_idx, + tmp_time, spider, table, crd_interval, crd_mode, +#ifdef WITH_PARTITION_STORAGE_ENGINE + crd_sync, +#endif + 1)) + ) { + if (*error_num != ER_SPIDER_SYS_TABLE_VERSION_NUM) + { + thd->clear_error(); + } else { + pthread_mutex_unlock(&share->crd_mutex); + pthread_mutex_unlock(&share->sts_mutex); + goto error_after_alloc_dbton_handler; + } + } + } + share->init_error = FALSE; + } + pthread_mutex_unlock(&share->crd_mutex); + pthread_mutex_unlock(&share->sts_mutex); + } + } + + DBUG_PRINT("info",("spider share=%p", share)); + DBUG_RETURN(share); + +error_after_alloc_dbton_handler: + for (roop_count = 0; roop_count < (int) share->use_dbton_count; ++roop_count) + { + uint dbton_id = share->use_dbton_ids[roop_count]; + if (spider->dbton_handler[dbton_id]) + { + delete spider->dbton_handler[dbton_id]; + spider->dbton_handler[dbton_id] = NULL; + } + } +error_after_alloc_conn_keys: + spider_free(spider_current_trx, spider->conn_keys, MYF(0)); + spider->conn_keys = NULL; + spider_free_share(share); + goto error_but_no_delete; + +error_hash_insert: + spider_free_share_resource_only(share); +error_alloc_share: + pthread_mutex_unlock(&spider_tbl_mutex); +error_open_sys_table: +#ifndef WITHOUT_SPIDER_BG_SEARCH +error_crd_spider_init: +error_sts_spider_init: +#endif + if (init_mem_root) + { + free_root(&mem_root, MYF(0)); + init_mem_root = FALSE; + } +error_but_no_delete: + DBUG_RETURN(NULL); +} + +void spider_free_share_resource_only( + SPIDER_SHARE *share +) { + DBUG_ENTER("spider_free_share_resource_only"); + spider_free_share_alloc(share); + pthread_mutex_destroy(&share->crd_mutex); + pthread_mutex_destroy(&share->sts_mutex); + pthread_mutex_destroy(&share->mutex); + spider_free(spider_current_trx, share, MYF(0)); + DBUG_VOID_RETURN; +} + +int spider_free_share( + SPIDER_SHARE *share +) { + DBUG_ENTER("spider_free_share"); + pthread_mutex_lock(&spider_tbl_mutex); + bool do_delete_thd = false; + THD *thd = current_thd; + if (!--share->use_count) + { +#ifndef WITHOUT_SPIDER_BG_SEARCH + spider_free_sts_thread(share); + spider_free_crd_thread(share); + spider_free_mon_threads(share); + if (share->sts_spider_init) + { + spider_table_remove_share_from_sts_thread(share); + spider_free_spider_object_for_share(&share->sts_spider); + } + if (share->crd_spider_init) + { + spider_table_remove_share_from_crd_thread(share); + spider_free_spider_object_for_share(&share->crd_spider); + } +#endif + if ( + share->sts_init && + spider_param_store_last_sts(share->store_last_sts) + ) { + if (!thd) + { + /* Create a thread for Spider system table update */ + thd = spider_create_thd(); + if (!thd) + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + do_delete_thd = TRUE; + } + spider_sys_insert_or_update_table_sts( + thd, + share->lgtm_tblhnd_share->table_name, + share->lgtm_tblhnd_share->table_name_length, + &share->stat, + FALSE + ); + } + if ( + share->crd_init && + spider_param_store_last_crd(share->store_last_crd) + ) { + if (!thd) + { + /* Create a thread for Spider system table update */ + thd = spider_create_thd(); + if (!thd) + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + do_delete_thd = TRUE; + } + spider_sys_insert_or_update_table_crd( + thd, + share->lgtm_tblhnd_share->table_name, + share->lgtm_tblhnd_share->table_name_length, + share->cardinality, + share->table_share->fields, + FALSE + ); + } + spider_free_share_alloc(share); +#ifdef HASH_UPDATE_WITH_HASH_VALUE + my_hash_delete_with_hash_value(&spider_open_tables, + share->table_name_hash_value, (uchar*) share); +#else + my_hash_delete(&spider_open_tables, (uchar*) share); +#endif + pthread_mutex_destroy(&share->crd_mutex); + pthread_mutex_destroy(&share->sts_mutex); + pthread_mutex_destroy(&share->mutex); + free_root(&share->mem_root, MYF(0)); + spider_free(spider_current_trx, share, MYF(0)); + } + if (do_delete_thd) + spider_destroy_thd(thd); + pthread_mutex_unlock(&spider_tbl_mutex); + DBUG_RETURN(0); +} + +void spider_update_link_status_for_share( + const char *table_name, + uint table_name_length, + int link_idx, + long link_status +) { + SPIDER_SHARE *share; + DBUG_ENTER("spider_update_link_status_for_share"); + +#ifdef SPIDER_HAS_HASH_VALUE_TYPE + my_hash_value_type hash_value = my_calc_hash(&spider_open_tables, + (uchar*) table_name, table_name_length); +#endif + pthread_mutex_lock(&spider_tbl_mutex); +#ifdef SPIDER_HAS_HASH_VALUE_TYPE + if ((share = (SPIDER_SHARE*) my_hash_search_using_hash_value( + &spider_open_tables, hash_value, (uchar*) table_name, + table_name_length))) +#else + if ((share = (SPIDER_SHARE*) my_hash_search(&spider_open_tables, + (uchar*) table_name, table_name_length))) +#endif + { + DBUG_PRINT("info", ("spider share->link_status_init=%s", + share->link_status_init ? "TRUE" : "FALSE")); + if (share->link_status_init) + { + DBUG_PRINT("info", ("spider share->link_statuses[%d]=%ld", + link_idx, link_status)); + share->link_statuses[link_idx] = link_status; + } + } + pthread_mutex_unlock(&spider_tbl_mutex); + DBUG_VOID_RETURN; +} + +#ifdef SPIDER_HAS_HASH_VALUE_TYPE +SPIDER_LGTM_TBLHND_SHARE *spider_get_lgtm_tblhnd_share( + const char *table_name, + uint table_name_length, + my_hash_value_type hash_value, + bool locked, + bool need_to_create, + int *error_num +) +#else +SPIDER_LGTM_TBLHND_SHARE *spider_get_lgtm_tblhnd_share( + const char *table_name, + uint table_name_length, + bool locked, + bool need_to_create, + int *error_num +) +#endif +{ + SPIDER_LGTM_TBLHND_SHARE *lgtm_tblhnd_share; + char *tmp_name; + DBUG_ENTER("spider_get_lgtm_tblhnd_share"); + + if (!locked) + pthread_mutex_lock(&spider_lgtm_tblhnd_share_mutex); +#ifdef SPIDER_HAS_HASH_VALUE_TYPE + if (!(lgtm_tblhnd_share = (SPIDER_LGTM_TBLHND_SHARE*) + my_hash_search_using_hash_value( + &spider_lgtm_tblhnd_share_hash, hash_value, + (uchar*) table_name, table_name_length))) +#else + if (!(lgtm_tblhnd_share = (SPIDER_LGTM_TBLHND_SHARE*) my_hash_search( + &spider_lgtm_tblhnd_share_hash, + (uchar*) table_name, table_name_length))) +#endif + { + DBUG_PRINT("info",("spider create new lgtm tblhnd share")); + if (!(lgtm_tblhnd_share = (SPIDER_LGTM_TBLHND_SHARE *) + spider_bulk_malloc(spider_current_trx, 244, MYF(MY_WME | MY_ZEROFILL), + &lgtm_tblhnd_share, (uint) (sizeof(*lgtm_tblhnd_share)), + &tmp_name, (uint) (table_name_length + 1), + NullS)) + ) { + *error_num = HA_ERR_OUT_OF_MEM; + goto error_alloc_share; + } + + lgtm_tblhnd_share->table_name_length = table_name_length; + lgtm_tblhnd_share->table_name = tmp_name; + memcpy(lgtm_tblhnd_share->table_name, table_name, + lgtm_tblhnd_share->table_name_length); +#ifdef SPIDER_HAS_HASH_VALUE_TYPE + lgtm_tblhnd_share->table_path_hash_value = hash_value; +#endif + +#if MYSQL_VERSION_ID < 50500 + if (pthread_mutex_init(&lgtm_tblhnd_share->auto_increment_mutex, + MY_MUTEX_INIT_FAST)) +#else + if (mysql_mutex_init(spd_key_mutex_share_auto_increment, + &lgtm_tblhnd_share->auto_increment_mutex, MY_MUTEX_INIT_FAST)) +#endif + { + *error_num = HA_ERR_OUT_OF_MEM; + goto error_init_auto_increment_mutex; + } + + uint old_elements = spider_lgtm_tblhnd_share_hash.array.max_element; +#ifdef HASH_UPDATE_WITH_HASH_VALUE + if (my_hash_insert_with_hash_value(&spider_lgtm_tblhnd_share_hash, + hash_value, (uchar*) lgtm_tblhnd_share)) +#else + if (my_hash_insert(&spider_lgtm_tblhnd_share_hash, + (uchar*) lgtm_tblhnd_share)) +#endif + { + *error_num = HA_ERR_OUT_OF_MEM; + goto error_hash_insert; + } + if (spider_lgtm_tblhnd_share_hash.array.max_element > old_elements) + { + spider_alloc_calc_mem(spider_current_trx, + spider_lgtm_tblhnd_share_hash, + (spider_lgtm_tblhnd_share_hash.array.max_element - old_elements) * + spider_lgtm_tblhnd_share_hash.array.size_of_element); + } + } + if (!locked) + pthread_mutex_unlock(&spider_lgtm_tblhnd_share_mutex); + + DBUG_PRINT("info",("spider lgtm_tblhnd_share=%p", lgtm_tblhnd_share)); + DBUG_RETURN(lgtm_tblhnd_share); + +error_hash_insert: + pthread_mutex_destroy(&lgtm_tblhnd_share->auto_increment_mutex); +error_init_auto_increment_mutex: + spider_free(spider_current_trx, lgtm_tblhnd_share, MYF(0)); +error_alloc_share: + if (!locked) + pthread_mutex_unlock(&spider_lgtm_tblhnd_share_mutex); + DBUG_RETURN(NULL); +} + +void spider_free_lgtm_tblhnd_share_alloc( + SPIDER_LGTM_TBLHND_SHARE *lgtm_tblhnd_share, + bool locked +) { + DBUG_ENTER("spider_free_lgtm_tblhnd_share"); + if (!locked) + pthread_mutex_lock(&spider_lgtm_tblhnd_share_mutex); +#ifdef HASH_UPDATE_WITH_HASH_VALUE + my_hash_delete_with_hash_value(&spider_lgtm_tblhnd_share_hash, + lgtm_tblhnd_share->table_path_hash_value, (uchar*) lgtm_tblhnd_share); +#else + my_hash_delete(&spider_lgtm_tblhnd_share_hash, (uchar*) lgtm_tblhnd_share); +#endif + pthread_mutex_destroy(&lgtm_tblhnd_share->auto_increment_mutex); + spider_free(spider_current_trx, lgtm_tblhnd_share, MYF(0)); + if (!locked) + pthread_mutex_unlock(&spider_lgtm_tblhnd_share_mutex); + DBUG_VOID_RETURN; +} + +SPIDER_WIDE_SHARE *spider_get_wide_share( + SPIDER_SHARE *share, + TABLE_SHARE *table_share, + int *error_num +) { + SPIDER_WIDE_SHARE *wide_share; + char *tmp_name; + longlong *tmp_cardinality; + DBUG_ENTER("spider_get_wide_share"); + + pthread_mutex_lock(&spider_wide_share_mutex); +#ifdef SPIDER_HAS_HASH_VALUE_TYPE + if (!(wide_share = (SPIDER_WIDE_SHARE*) + my_hash_search_using_hash_value( + &spider_open_wide_share, share->table_path_hash_value, + (uchar*) table_share->path.str, table_share->path.length))) +#else + if (!(wide_share = (SPIDER_WIDE_SHARE*) my_hash_search( + &spider_open_wide_share, + (uchar*) table_share->path.str, table_share->path.length))) +#endif + { + DBUG_PRINT("info",("spider create new wide share")); + if (!(wide_share = (SPIDER_WIDE_SHARE *) + spider_bulk_malloc(spider_current_trx, 51, MYF(MY_WME | MY_ZEROFILL), + &wide_share, sizeof(SPIDER_WIDE_SHARE), + &tmp_name, (uint) (table_share->path.length + 1), + &tmp_cardinality, + (uint) (sizeof(*tmp_cardinality) * table_share->fields), + NullS)) + ) { + *error_num = HA_ERR_OUT_OF_MEM; + goto error_alloc_share; + } + + wide_share->use_count = 0; + wide_share->table_name_length = table_share->path.length; + wide_share->table_name = tmp_name; + memcpy(wide_share->table_name, table_share->path.str, + wide_share->table_name_length); +#ifdef SPIDER_HAS_HASH_VALUE_TYPE + wide_share->table_path_hash_value = share->table_path_hash_value; +#endif + wide_share->cardinality = tmp_cardinality; + + wide_share->crd_get_time = wide_share->sts_get_time = + share->crd_get_time; + +#if MYSQL_VERSION_ID < 50500 + if (pthread_mutex_init(&wide_share->sts_mutex, MY_MUTEX_INIT_FAST)) +#else + if (mysql_mutex_init(spd_key_mutex_wide_share_sts, + &wide_share->sts_mutex, MY_MUTEX_INIT_FAST)) +#endif + { + *error_num = HA_ERR_OUT_OF_MEM; + goto error_init_sts_mutex; + } + +#if MYSQL_VERSION_ID < 50500 + if (pthread_mutex_init(&wide_share->crd_mutex, MY_MUTEX_INIT_FAST)) +#else + if (mysql_mutex_init(spd_key_mutex_wide_share_crd, + &wide_share->crd_mutex, MY_MUTEX_INIT_FAST)) +#endif + { + *error_num = HA_ERR_OUT_OF_MEM; + goto error_init_crd_mutex; + } + +#if MYSQL_VERSION_ID < 50500 + if (pthread_mutex_init(&wide_share->pt_handler_mutex, + MY_MUTEX_INIT_FAST)) +#else + if (mysql_mutex_init(spd_key_mutex_pt_handler, + &wide_share->pt_handler_mutex, MY_MUTEX_INIT_FAST)) +#endif + { + *error_num = HA_ERR_OUT_OF_MEM; + goto error_init_pt_handler_mutex; + } + + if( + my_hash_init(PSI_INSTRUMENT_ME, &wide_share->pt_handler_hash, spd_charset_utf8mb3_bin, + 32, 0, 0, (my_hash_get_key) spider_pt_handler_share_get_key, 0, 0) + ) { + *error_num = HA_ERR_OUT_OF_MEM; + goto error_init_pt_handler_hash; + } + + thr_lock_init(&wide_share->lock); + + spider_alloc_calc_mem_init(wide_share->pt_handler_hash, 142); + spider_alloc_calc_mem(spider_current_trx, + wide_share->pt_handler_hash, + wide_share->pt_handler_hash.array.max_element * + wide_share->pt_handler_hash.array.size_of_element); + + uint old_elements = spider_open_wide_share.array.max_element; +#ifdef HASH_UPDATE_WITH_HASH_VALUE + if (my_hash_insert_with_hash_value(&spider_open_wide_share, + share->table_path_hash_value, + (uchar*) wide_share)) +#else + if (my_hash_insert(&spider_open_wide_share, (uchar*) wide_share)) +#endif + { + *error_num = HA_ERR_OUT_OF_MEM; + goto error_hash_insert; + } + if (spider_open_wide_share.array.max_element > old_elements) + { + spider_alloc_calc_mem(spider_current_trx, + spider_open_wide_share, + (spider_open_wide_share.array.max_element - old_elements) * + spider_open_wide_share.array.size_of_element); + } + } + wide_share->use_count++; + pthread_mutex_unlock(&spider_wide_share_mutex); + + DBUG_PRINT("info",("spider wide_share=%p", wide_share)); + DBUG_RETURN(wide_share); + +error_hash_insert: + spider_free_mem_calc(spider_current_trx, + wide_share->pt_handler_hash_id, + wide_share->pt_handler_hash.array.max_element * + wide_share->pt_handler_hash.array.size_of_element); + my_hash_free(&wide_share->pt_handler_hash); +error_init_pt_handler_hash: + pthread_mutex_destroy(&wide_share->pt_handler_mutex); +error_init_pt_handler_mutex: + pthread_mutex_destroy(&wide_share->crd_mutex); +error_init_crd_mutex: + pthread_mutex_destroy(&wide_share->sts_mutex); +error_init_sts_mutex: + spider_free(spider_current_trx, wide_share, MYF(0)); +error_alloc_share: + pthread_mutex_unlock(&spider_wide_share_mutex); + DBUG_RETURN(NULL); +} + +int spider_free_wide_share( + SPIDER_WIDE_SHARE *wide_share +) { + DBUG_ENTER("spider_free_wide_share"); + pthread_mutex_lock(&spider_wide_share_mutex); + if (!--wide_share->use_count) + { + thr_lock_delete(&wide_share->lock); +#ifdef HASH_UPDATE_WITH_HASH_VALUE + my_hash_delete_with_hash_value(&spider_open_wide_share, + wide_share->table_path_hash_value, (uchar*) wide_share); +#else + my_hash_delete(&spider_open_wide_share, (uchar*) wide_share); +#endif + spider_free_mem_calc(spider_current_trx, + wide_share->pt_handler_hash_id, + wide_share->pt_handler_hash.array.max_element * + wide_share->pt_handler_hash.array.size_of_element); + my_hash_free(&wide_share->pt_handler_hash); + pthread_mutex_destroy(&wide_share->pt_handler_mutex); + pthread_mutex_destroy(&wide_share->crd_mutex); + pthread_mutex_destroy(&wide_share->sts_mutex); + spider_free(spider_current_trx, wide_share, MYF(0)); + } + pthread_mutex_unlock(&spider_wide_share_mutex); + DBUG_RETURN(0); +} + +void spider_copy_sts_to_wide_share( + SPIDER_WIDE_SHARE *wide_share, + SPIDER_SHARE *share +) { + DBUG_ENTER("spider_copy_sts_to_pt_share"); + wide_share->stat = share->stat; + DBUG_VOID_RETURN; +} + +void spider_copy_sts_to_share( + SPIDER_SHARE *share, + SPIDER_WIDE_SHARE *wide_share +) { + DBUG_ENTER("spider_copy_sts_to_share"); + share->stat = wide_share->stat; + DBUG_VOID_RETURN; +} + +void spider_copy_crd_to_wide_share( + SPIDER_WIDE_SHARE *wide_share, + SPIDER_SHARE *share, + int fields +) { + DBUG_ENTER("spider_copy_crd_to_wide_share"); + memcpy(wide_share->cardinality, share->cardinality, + sizeof(longlong) * fields); + DBUG_VOID_RETURN; +} + +void spider_copy_crd_to_share( + SPIDER_SHARE *share, + SPIDER_WIDE_SHARE *wide_share, + int fields +) { + DBUG_ENTER("spider_copy_crd_to_share"); + memcpy(share->cardinality, wide_share->cardinality, + sizeof(longlong) * fields); + DBUG_VOID_RETURN; +} + +int spider_open_all_tables( + SPIDER_TRX *trx, + bool lock +) { + THD *thd = trx->thd; + TABLE *table_tables; + int error_num, *need_mon, mon_val; + SPIDER_SHARE tmp_share; + char *db_name, *table_name; + uint db_name_length, table_name_length; + char *tmp_connect_info[SPIDER_TMP_SHARE_CHAR_PTR_COUNT]; + uint tmp_connect_info_length[SPIDER_TMP_SHARE_UINT_COUNT]; + long tmp_long[SPIDER_TMP_SHARE_LONG_COUNT]; + longlong tmp_longlong[SPIDER_TMP_SHARE_LONGLONG_COUNT]; + SPIDER_CONN *conn, **conns; + ha_spider *spider; + SPIDER_SHARE *share; + char **connect_info; + uint *connect_info_length; + long *long_info; + longlong *longlong_info; + MEM_ROOT mem_root; + SPIDER_Open_tables_backup open_tables_backup; + DBUG_ENTER("spider_open_all_tables"); + if ( + !(table_tables = spider_open_sys_table( + thd, SPIDER_SYS_TABLES_TABLE_NAME_STR, + SPIDER_SYS_TABLES_TABLE_NAME_LEN, TRUE, &open_tables_backup, TRUE, + &error_num)) + ) + DBUG_RETURN(error_num); + if ( + (error_num = spider_sys_index_first(table_tables, 1)) + ) { + if (error_num != HA_ERR_KEY_NOT_FOUND && error_num != HA_ERR_END_OF_FILE) + { + table_tables->file->print_error(error_num, MYF(0)); + spider_close_sys_table(thd, table_tables, + &open_tables_backup, TRUE); + DBUG_RETURN(error_num); + } else { + spider_close_sys_table(thd, table_tables, + &open_tables_backup, TRUE); + DBUG_RETURN(0); + } + } + + SPD_INIT_ALLOC_ROOT(&mem_root, 4096, 0, MYF(MY_WME)); + memset((void*)&tmp_share, 0, sizeof(SPIDER_SHARE)); + memset(&tmp_connect_info, 0, + sizeof(char *) * SPIDER_TMP_SHARE_CHAR_PTR_COUNT); + memset(tmp_connect_info_length, 0, + sizeof(uint) * SPIDER_TMP_SHARE_UINT_COUNT); + memset(tmp_long, 0, sizeof(long) * SPIDER_TMP_SHARE_LONG_COUNT); + memset(tmp_longlong, 0, sizeof(longlong) * SPIDER_TMP_SHARE_LONGLONG_COUNT); + spider_set_tmp_share_pointer(&tmp_share, (char **) &tmp_connect_info, + tmp_connect_info_length, tmp_long, tmp_longlong); + tmp_share.link_statuses[0] = -1; + + do { + if ( + (error_num = spider_get_sys_tables( + table_tables, &db_name, &table_name, &mem_root)) || + (error_num = spider_get_sys_tables_connect_info( + table_tables, &tmp_share, 0, &mem_root)) || + (error_num = spider_set_connect_info_default( + &tmp_share, +#ifdef WITH_PARTITION_STORAGE_ENGINE + NULL, + NULL, +#endif + NULL + )) + ) { + spider_sys_index_end(table_tables); + spider_close_sys_table(thd, table_tables, + &open_tables_backup, TRUE); + spider_free_tmp_share_alloc(&tmp_share); + free_root(&mem_root, MYF(0)); + DBUG_RETURN(error_num); + } + db_name_length = strlen(db_name); + table_name_length = strlen(table_name); + + if ( + (error_num = spider_set_connect_info_default_db_table( + &tmp_share, + db_name, + db_name_length, + table_name, + table_name_length + )) || + (error_num = spider_create_conn_keys(&tmp_share)) || +/* + (error_num = spider_db_create_table_names_str(&tmp_share)) || +*/ + (error_num = spider_create_tmp_dbton_share(&tmp_share)) + ) { + spider_sys_index_end(table_tables); + spider_close_sys_table(thd, table_tables, + &open_tables_backup, TRUE); + spider_free_tmp_share_alloc(&tmp_share); + free_root(&mem_root, MYF(0)); + DBUG_RETURN(error_num); + } + + /* create conn */ + if ( + !(conn = spider_get_conn( + &tmp_share, 0, tmp_share.conn_keys[0], trx, NULL, FALSE, FALSE, + SPIDER_CONN_KIND_MYSQL, &error_num)) + ) { + spider_sys_index_end(table_tables); + spider_close_sys_table(thd, table_tables, + &open_tables_backup, TRUE); + spider_free_tmp_dbton_share(&tmp_share); + spider_free_tmp_share_alloc(&tmp_share); + free_root(&mem_root, MYF(0)); + DBUG_RETURN(error_num); + } + conn->error_mode &= spider_param_error_read_mode(thd, 0); + conn->error_mode &= spider_param_error_write_mode(thd, 0); + pthread_mutex_assert_not_owner(&conn->mta_conn_mutex); + pthread_mutex_lock(&conn->mta_conn_mutex); + SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos); + conn->need_mon = &mon_val; + DBUG_ASSERT(!conn->mta_conn_mutex_lock_already); + DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later); + conn->mta_conn_mutex_lock_already = TRUE; + conn->mta_conn_mutex_unlock_later = TRUE; + if ((error_num = spider_db_before_query(conn, &mon_val))) + { + DBUG_ASSERT(conn->mta_conn_mutex_lock_already); + DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); + conn->mta_conn_mutex_lock_already = FALSE; + conn->mta_conn_mutex_unlock_later = FALSE; + SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); + pthread_mutex_unlock(&conn->mta_conn_mutex); + spider_sys_index_end(table_tables); + spider_close_sys_table(thd, table_tables, + &open_tables_backup, TRUE); + spider_free_tmp_dbton_share(&tmp_share); + spider_free_tmp_share_alloc(&tmp_share); + free_root(&mem_root, MYF(0)); + DBUG_RETURN(error_num); + } + DBUG_ASSERT(conn->mta_conn_mutex_lock_already); + DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); + conn->mta_conn_mutex_lock_already = FALSE; + conn->mta_conn_mutex_unlock_later = FALSE; + SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); + pthread_mutex_unlock(&conn->mta_conn_mutex); + + if (lock && spider_param_use_snapshot_with_flush_tables(thd) == 2) + { + if (!(spider = new ha_spider())) + { + spider_sys_index_end(table_tables); + spider_close_sys_table(thd, table_tables, + &open_tables_backup, TRUE); + spider_free_tmp_dbton_share(&tmp_share); + spider_free_tmp_share_alloc(&tmp_share); + free_root(&mem_root, MYF(0)); + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + } + spider->wide_handler->lock_type = TL_READ_NO_INSERT; + + if (!(share = (SPIDER_SHARE *) + spider_bulk_malloc(spider_current_trx, 52, MYF(MY_WME | MY_ZEROFILL), + &share, (uint) (sizeof(*share)), + &connect_info, + (uint) (sizeof(char *) * SPIDER_TMP_SHARE_CHAR_PTR_COUNT), + &connect_info_length, + (uint) (sizeof(uint) * SPIDER_TMP_SHARE_UINT_COUNT), + &long_info, (uint) (sizeof(long) * SPIDER_TMP_SHARE_LONG_COUNT), + &longlong_info, + (uint) (sizeof(longlong) * SPIDER_TMP_SHARE_LONGLONG_COUNT), + &conns, (uint) (sizeof(SPIDER_CONN *)), + &need_mon, (uint) (sizeof(int)), + &spider->conn_link_idx, (uint) (sizeof(uint)), + &spider->conn_can_fo, (uint) (sizeof(uchar)), + NullS)) + ) { + delete spider; + spider_sys_index_end(table_tables); + spider_close_sys_table(thd, table_tables, + &open_tables_backup, TRUE); + spider_free_tmp_dbton_share(&tmp_share); + spider_free_tmp_share_alloc(&tmp_share); + free_root(&mem_root, MYF(0)); + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + } + memcpy((void*)share, &tmp_share, sizeof(*share)); + spider_set_tmp_share_pointer(share, connect_info, + connect_info_length, long_info, longlong_info); + memcpy(connect_info, &tmp_connect_info, sizeof(char *) * + SPIDER_TMP_SHARE_CHAR_PTR_COUNT); + memcpy(connect_info_length, &tmp_connect_info_length, sizeof(uint) * + SPIDER_TMP_SHARE_UINT_COUNT); + memcpy(long_info, &tmp_long, sizeof(long) * SPIDER_TMP_SHARE_LONG_COUNT); + memcpy(longlong_info, &tmp_longlong, sizeof(longlong) * + SPIDER_TMP_SHARE_LONGLONG_COUNT); + spider->share = share; + spider->wide_handler->trx = trx; + spider->conns = conns; + spider->need_mons = need_mon; + spider->conn_link_idx[0] = 0; + spider->conn_can_fo[0] = 0; + if ((error_num = spider_create_tmp_dbton_handler(spider))) + { + spider_free(trx, share, MYF(0)); + delete spider; + spider_sys_index_end(table_tables); + spider_close_sys_table(thd, table_tables, + &open_tables_backup, TRUE); + spider_free_tmp_dbton_share(&tmp_share); + spider_free_tmp_share_alloc(&tmp_share); + free_root(&mem_root, MYF(0)); + DBUG_RETURN(error_num); + } + + /* create another conn */ + if ( + (!(conn = spider_get_conn( + &tmp_share, 0, tmp_share.conn_keys[0], trx, spider, TRUE, FALSE, + SPIDER_CONN_KIND_MYSQL, &error_num))) + ) { + spider_free_tmp_dbton_handler(spider); + spider_free(trx, share, MYF(0)); + delete spider; + spider_sys_index_end(table_tables); + spider_close_sys_table(thd, table_tables, + &open_tables_backup, TRUE); + spider_free_tmp_dbton_share(&tmp_share); + spider_free_tmp_share_alloc(&tmp_share); + free_root(&mem_root, MYF(0)); + DBUG_RETURN(error_num); + } + conn->error_mode &= spider_param_error_read_mode(thd, 0); + conn->error_mode &= spider_param_error_write_mode(thd, 0); + + spider->next = NULL; + if (conn->another_ha_last) + { + ((ha_spider*) conn->another_ha_last)->next = spider; + } else { + conn->another_ha_first = (void*) spider; + } + conn->another_ha_last = (void*) spider; + + int appended = 0; + if ((error_num = spider->dbton_handler[conn->dbton_id]-> + append_lock_tables_list(conn, 0, &appended))) + { + spider_free_tmp_dbton_handler(spider); + spider_free(trx, share, MYF(0)); + delete spider; + spider_sys_index_end(table_tables); + spider_close_sys_table(thd, table_tables, + &open_tables_backup, TRUE); + spider_free_tmp_dbton_share(&tmp_share); + spider_free_tmp_share_alloc(&tmp_share); + free_root(&mem_root, MYF(0)); + DBUG_RETURN(error_num); + } + } else { + spider_free_tmp_dbton_share(&tmp_share); + spider_free_tmp_share_alloc(&tmp_share); + } + error_num = spider_sys_index_next(table_tables); + } while (error_num == 0); + free_root(&mem_root, MYF(0)); + + spider_sys_index_end(table_tables); + spider_close_sys_table(thd, table_tables, + &open_tables_backup, TRUE); + DBUG_RETURN(0); +} + +bool spider_flush_logs( + handlerton *hton +) { + int error_num; + THD* thd = current_thd; + SPIDER_TRX *trx; + DBUG_ENTER("spider_flush_logs"); + + if (!(trx = spider_get_trx(thd, TRUE, &error_num))) + { + my_errno = error_num; + DBUG_RETURN(TRUE); + } + if ( + spider_param_use_flash_logs(trx->thd) && + ( + !trx->trx_consistent_snapshot || + !spider_param_use_all_conns_snapshot(trx->thd) || + !spider_param_use_snapshot_with_flush_tables(trx->thd) + ) + ) { + if ( + (error_num = spider_open_all_tables(trx, FALSE)) || + (error_num = spider_trx_all_flush_logs(trx)) + ) { + my_errno = error_num; + DBUG_RETURN(TRUE); + } + } + + DBUG_RETURN(FALSE); +} + +handler* spider_create_handler( + handlerton *hton, + TABLE_SHARE *table, + MEM_ROOT *mem_root +) { + DBUG_ENTER("spider_create_handler"); +#ifndef WITHOUT_SPIDER_BG_SEARCH + SPIDER_THREAD *thread = &spider_table_sts_threads[0]; + if (unlikely(thread->init_command)) + { + THD *thd = current_thd; + pthread_cond_t *cond = thd->mysys_var->current_cond; + pthread_mutex_t *mutex = thd->mysys_var->current_mutex; + /* wait for finishing init_command */ + pthread_mutex_lock(&thread->mutex); + if (unlikely(thread->init_command)) + { + thd->mysys_var->current_cond = &thread->sync_cond; + thd->mysys_var->current_mutex = &thread->mutex; + pthread_cond_wait(&thread->sync_cond, &thread->mutex); + } + pthread_mutex_unlock(&thread->mutex); + thd->mysys_var->current_cond = cond; + thd->mysys_var->current_mutex = mutex; + if (thd->killed) + { + DBUG_RETURN(NULL); + } + } +#endif + DBUG_RETURN(new (mem_root) ha_spider(hton, table)); +} + +int spider_close_connection( + handlerton* hton, + THD* thd +) { + int roop_count = 0; + SPIDER_CONN *conn; + SPIDER_TRX *trx; + DBUG_ENTER("spider_close_connection"); + if (!(trx = (SPIDER_TRX*) thd_get_ha_data(thd, spider_hton_ptr))) + DBUG_RETURN(0); /* transaction is not started */ + + trx->tmp_spider->conns = &conn; + while ((conn = (SPIDER_CONN*) my_hash_element(&trx->trx_conn_hash, + roop_count))) + { + SPIDER_BACKUP_DASTATUS; + DBUG_PRINT("info",("spider conn->table_lock=%d", conn->table_lock)); + if (conn->table_lock > 0) + { + if (!conn->trx_start) + conn->disable_reconnect = FALSE; + if (conn->table_lock != 2) + { + spider_db_unlock_tables(trx->tmp_spider, 0); + } + conn->table_lock = 0; + } + roop_count++; + SPIDER_CONN_RESTORE_DASTATUS; + } + + spider_rollback(spider_hton_ptr, thd, TRUE); + spider_free_trx(trx, TRUE, false); + + DBUG_RETURN(0); +} + +void spider_drop_database( + handlerton *hton, + char* path +) { + DBUG_ENTER("spider_drop_database"); + DBUG_VOID_RETURN; +} + +bool spider_show_status( + handlerton *hton, + THD *thd, + stat_print_fn *stat_print, + enum ha_stat_type stat_type +) { + DBUG_ENTER("spider_show_status"); + switch (stat_type) { + case HA_ENGINE_STATUS: + default: + DBUG_RETURN(FALSE); + } +} + +int spider_db_done( + void *p +) { + int roop_count; + bool do_delete_thd; + THD *thd = current_thd, *tmp_thd; + SPIDER_CONN *conn; + SPIDER_INIT_ERROR_TABLE *spider_init_error_table; + SPIDER_TABLE_MON_LIST *table_mon_list; + SPIDER_LGTM_TBLHND_SHARE *lgtm_tblhnd_share; + DBUG_ENTER("spider_db_done"); + + /* Begin Spider plugin deinit */ + if (thd) + do_delete_thd = FALSE; + else + { + /* Create a thread for Spider plugin deinit */ + thd = spider_create_thd(); + if (!thd) + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + do_delete_thd = TRUE; + } + + for (roop_count = SPIDER_DBTON_SIZE - 1; roop_count >= 0; roop_count--) + { + if (spider_dbton[roop_count].deinit) + { + spider_dbton[roop_count].deinit(); + } + } + +#ifndef WITHOUT_SPIDER_BG_SEARCH + for (roop_count = spider_param_table_crd_thread_count() - 1; + roop_count >= 0; roop_count--) + { + spider_free_crd_threads(&spider_table_crd_threads[roop_count]); + } + for (roop_count = spider_param_table_sts_thread_count() - 1; + roop_count >= 0; roop_count--) + { + spider_free_sts_threads(&spider_table_sts_threads[roop_count]); + } + spider_free(NULL, spider_table_sts_threads, MYF(0)); +#endif + + for (roop_count = spider_param_udf_table_mon_mutex_count() - 1; + roop_count >= 0; roop_count--) + { + while ((table_mon_list = (SPIDER_TABLE_MON_LIST *) my_hash_element( + &spider_udf_table_mon_list_hash[roop_count], 0))) + { +#ifdef HASH_UPDATE_WITH_HASH_VALUE + my_hash_delete_with_hash_value( + &spider_udf_table_mon_list_hash[roop_count], + table_mon_list->key_hash_value, (uchar*) table_mon_list); +#else + my_hash_delete(&spider_udf_table_mon_list_hash[roop_count], + (uchar*) table_mon_list); +#endif + spider_ping_table_free_mon_list(table_mon_list); + } + spider_free_mem_calc(spider_current_trx, + spider_udf_table_mon_list_hash_id, + spider_udf_table_mon_list_hash[roop_count].array.max_element * + spider_udf_table_mon_list_hash[roop_count].array.size_of_element); + my_hash_free(&spider_udf_table_mon_list_hash[roop_count]); + } + for (roop_count = spider_param_udf_table_mon_mutex_count() - 1; + roop_count >= 0; roop_count--) + pthread_cond_destroy(&spider_udf_table_mon_conds[roop_count]); + for (roop_count = spider_param_udf_table_mon_mutex_count() - 1; + roop_count >= 0; roop_count--) + pthread_mutex_destroy(&spider_udf_table_mon_mutexes[roop_count]); + spider_free(NULL, spider_udf_table_mon_mutexes, MYF(0)); + + pthread_mutex_lock(&spider_allocated_thds_mutex); + while ((tmp_thd = (THD *) my_hash_element(&spider_allocated_thds, 0))) + { + SPIDER_TRX *trx = (SPIDER_TRX *) + thd_get_ha_data(tmp_thd, spider_hton_ptr); + if (trx) + { + DBUG_ASSERT(tmp_thd == trx->thd); + spider_free_trx(trx, FALSE); + thd_set_ha_data(tmp_thd, spider_hton_ptr, NULL); + } + else + my_hash_delete(&spider_allocated_thds, (uchar *) tmp_thd); + } + pthread_mutex_unlock(&spider_allocated_thds_mutex); + +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + pthread_mutex_lock(&spider_hs_w_conn_mutex); + while ((conn = (SPIDER_CONN*) my_hash_element(&spider_hs_w_conn_hash, 0))) + { +#ifdef HASH_UPDATE_WITH_HASH_VALUE + my_hash_delete_with_hash_value(&spider_hs_w_conn_hash, + conn->conn_key_hash_value, (uchar*) conn); +#else + my_hash_delete(&spider_hs_w_conn_hash, (uchar*) conn); +#endif + spider_free_conn(conn); + } + pthread_mutex_unlock(&spider_hs_w_conn_mutex); + pthread_mutex_lock(&spider_hs_r_conn_mutex); + while ((conn = (SPIDER_CONN*) my_hash_element(&spider_hs_r_conn_hash, 0))) + { +#ifdef HASH_UPDATE_WITH_HASH_VALUE + my_hash_delete_with_hash_value(&spider_hs_r_conn_hash, + conn->conn_key_hash_value, (uchar*) conn); +#else + my_hash_delete(&spider_hs_r_conn_hash, (uchar*) conn); +#endif + spider_free_conn(conn); + } + pthread_mutex_unlock(&spider_hs_r_conn_mutex); +#endif + pthread_mutex_lock(&spider_conn_mutex); + while ((conn = (SPIDER_CONN*) my_hash_element(&spider_open_connections, 0))) + { +#ifdef HASH_UPDATE_WITH_HASH_VALUE + my_hash_delete_with_hash_value(&spider_open_connections, + conn->conn_key_hash_value, (uchar*) conn); +#else + my_hash_delete(&spider_open_connections, (uchar*) conn); +#endif + spider_free_conn(conn); + } + pthread_mutex_unlock(&spider_conn_mutex); + pthread_mutex_lock(&spider_lgtm_tblhnd_share_mutex); + while ((lgtm_tblhnd_share = (SPIDER_LGTM_TBLHND_SHARE*) my_hash_element( + &spider_lgtm_tblhnd_share_hash, 0))) + { + spider_free_lgtm_tblhnd_share_alloc(lgtm_tblhnd_share, TRUE); + } + pthread_mutex_unlock(&spider_lgtm_tblhnd_share_mutex); + 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); + delete_dynamic(&spider_mon_table_cache); + spider_free_mem_calc(spider_current_trx, + spider_allocated_thds_id, + spider_allocated_thds.array.max_element * + spider_allocated_thds.array.size_of_element); + my_hash_free(&spider_allocated_thds); +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + spider_free_mem_calc(spider_current_trx, + spider_hs_w_conn_hash_id, + spider_hs_w_conn_hash.array.max_element * + spider_hs_w_conn_hash.array.size_of_element); + my_hash_free(&spider_hs_w_conn_hash); + spider_free_mem_calc(spider_current_trx, + spider_hs_r_conn_hash_id, + spider_hs_r_conn_hash.array.max_element * + spider_hs_r_conn_hash.array.size_of_element); + my_hash_free(&spider_hs_r_conn_hash); +#endif + spider_free_mem_calc(spider_current_trx, + spider_open_connections_id, + spider_open_connections.array.max_element * + spider_open_connections.array.size_of_element); + my_hash_free(&spider_open_connections); + my_hash_free(&spider_ipport_conns); + spider_free_mem_calc(spider_current_trx, + spider_lgtm_tblhnd_share_hash_id, + spider_lgtm_tblhnd_share_hash.array.max_element * + spider_lgtm_tblhnd_share_hash.array.size_of_element); + my_hash_free(&spider_lgtm_tblhnd_share_hash); +#ifdef WITH_PARTITION_STORAGE_ENGINE + spider_free_mem_calc(spider_current_trx, + spider_open_wide_share_id, + spider_open_wide_share.array.max_element * + spider_open_wide_share.array.size_of_element); + my_hash_free(&spider_open_wide_share); +#endif + pthread_mutex_lock(&spider_init_error_tbl_mutex); + while ((spider_init_error_table = (SPIDER_INIT_ERROR_TABLE*) + my_hash_element(&spider_init_error_tables, 0))) + { +#ifdef HASH_UPDATE_WITH_HASH_VALUE + my_hash_delete_with_hash_value(&spider_init_error_tables, + spider_init_error_table->table_name_hash_value, + (uchar*) spider_init_error_table); +#else + my_hash_delete(&spider_init_error_tables, + (uchar*) spider_init_error_table); +#endif + spider_free(NULL, spider_init_error_table, MYF(0)); + } + pthread_mutex_unlock(&spider_init_error_tbl_mutex); + spider_free_mem_calc(spider_current_trx, + spider_init_error_tables_id, + spider_init_error_tables.array.max_element * + spider_init_error_tables.array.size_of_element); + my_hash_free(&spider_init_error_tables); + spider_free_mem_calc(spider_current_trx, + spider_open_tables_id, + spider_open_tables.array.max_element * + spider_open_tables.array.size_of_element); + my_hash_free(&spider_open_tables); + pthread_mutex_destroy(&spider_mem_calc_mutex); + pthread_mutex_destroy(&spider_mon_table_cache_mutex); + pthread_mutex_destroy(&spider_allocated_thds_mutex); + pthread_mutex_destroy(&spider_open_conn_mutex); +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + pthread_mutex_destroy(&spider_hs_w_conn_mutex); + pthread_mutex_destroy(&spider_hs_r_conn_mutex); +#endif + pthread_mutex_destroy(&spider_conn_mutex); + pthread_mutex_destroy(&spider_lgtm_tblhnd_share_mutex); +#ifdef WITH_PARTITION_STORAGE_ENGINE + pthread_mutex_destroy(&spider_wide_share_mutex); +#endif + pthread_mutex_destroy(&spider_init_error_tbl_mutex); + pthread_mutex_destroy(&spider_conn_id_mutex); + pthread_mutex_destroy(&spider_ipport_conn_mutex); + pthread_mutex_destroy(&spider_thread_id_mutex); + pthread_mutex_destroy(&spider_tbl_mutex); +#ifndef WITHOUT_SPIDER_BG_SEARCH + pthread_attr_destroy(&spider_pt_attr); +#endif + + for (roop_count = 0; roop_count < SPIDER_MEM_CALC_LIST_NUM; roop_count++) + { + if (spider_alloc_func_name[roop_count]) + DBUG_PRINT("info",("spider %d %s %s %lu %llu %lld %llu %llu %s", + roop_count, + spider_alloc_func_name[roop_count], + spider_alloc_file_name[roop_count], + spider_alloc_line_no[roop_count], + spider_total_alloc_mem[roop_count], + spider_current_alloc_mem[roop_count], + spider_alloc_mem_count[roop_count], + spider_free_mem_count[roop_count], + spider_current_alloc_mem[roop_count] ? "NG" : "OK" + )); + } + + /* End Spider plugin deinit */ + if (do_delete_thd) + spider_destroy_thd(thd); + +/* +DBUG_ASSERT(0); +*/ + DBUG_RETURN(0); +} + +int spider_panic( + handlerton *hton, + ha_panic_function type +) { + DBUG_ENTER("spider_panic"); + DBUG_RETURN(0); +} + +int spider_db_init( + void *p +) { + int error_num = HA_ERR_OUT_OF_MEM, roop_count; + uint dbton_id = 0; + uchar addr[6]; + handlerton *spider_hton = (handlerton *)p; + DBUG_ENTER("spider_db_init"); + spider_hton_ptr = spider_hton; + + spider_hton->flags = HTON_NO_FLAGS; +#ifdef HTON_CAN_READ_CONNECT_STRING_IN_PARTITION + spider_hton->flags |= HTON_CAN_READ_CONNECT_STRING_IN_PARTITION; +#endif + /* spider_hton->db_type = DB_TYPE_SPIDER; */ + /* + spider_hton->savepoint_offset; + spider_hton->savepoint_set = spider_savepoint_set; + spider_hton->savepoint_rollback = spider_savepoint_rollback; + spider_hton->savepoint_release = spider_savepoint_release; + spider_hton->create_cursor_read_view = spider_create_cursor_read_view; + spider_hton->set_cursor_read_view = spider_set_cursor_read_view; + spider_hton->close_cursor_read_view = spider_close_cursor_read_view; + */ + spider_hton->panic = spider_panic; + spider_hton->close_connection = spider_close_connection; + spider_hton->start_consistent_snapshot = spider_start_consistent_snapshot; + spider_hton->flush_logs = spider_flush_logs; + spider_hton->commit = spider_commit; + spider_hton->rollback = spider_rollback; +#ifdef SPIDER_HAS_DISCOVER_TABLE_STRUCTURE + spider_hton->discover_table_structure = spider_discover_table_structure; +#endif + if (spider_param_support_xa()) + { + spider_hton->prepare = spider_xa_prepare; + spider_hton->recover = spider_xa_recover; + spider_hton->commit_by_xid = spider_xa_commit_by_xid; + spider_hton->rollback_by_xid = spider_xa_rollback_by_xid; + } + spider_hton->create = spider_create_handler; + spider_hton->drop_database = spider_drop_database; + spider_hton->show_status = spider_show_status; +#ifdef SPIDER_HAS_GROUP_BY_HANDLER + spider_hton->create_group_by = spider_create_group_by_handler; +#endif + + if (my_gethwaddr((uchar *) addr)) + { + my_printf_error(ER_SPIDER_CANT_NUM, ER_SPIDER_CANT_STR1, MYF(0), + "get hardware address with error ", errno); + } + spider_unique_id.str = spider_unique_id_buf; + spider_unique_id.length = my_sprintf(spider_unique_id_buf, + (spider_unique_id_buf, "-%02x%02x%02x%02x%02x%02x-%lx-", + addr[0], addr[1], addr[2], addr[3], addr[4], addr[5], (ulong) getpid())); + + memset(&spider_alloc_func_name, 0, sizeof(spider_alloc_func_name)); + memset(&spider_alloc_file_name, 0, sizeof(spider_alloc_file_name)); + memset(&spider_alloc_line_no, 0, sizeof(spider_alloc_line_no)); + memset(&spider_total_alloc_mem, 0, sizeof(spider_total_alloc_mem)); + memset(&spider_current_alloc_mem, 0, sizeof(spider_current_alloc_mem)); + memset(&spider_alloc_mem_count, 0, sizeof(spider_alloc_mem_count)); + memset(&spider_free_mem_count, 0, sizeof(spider_free_mem_count)); + +#ifndef SPIDER_HAS_NEXT_THREAD_ID + spd_db_att_thread_id = &thread_id; +#endif +#ifdef SPIDER_XID_USES_xid_cache_iterate +#else +#ifdef XID_CACHE_IS_SPLITTED + spd_db_att_xid_cache_split_num = &opt_xid_cache_split_num; + spd_db_att_LOCK_xid_cache = LOCK_xid_cache; + spd_db_att_xid_cache = xid_cache; +#else + spd_db_att_LOCK_xid_cache = &LOCK_xid_cache; + spd_db_att_xid_cache = &xid_cache; +#endif +#endif + spd_charset_utf8mb3_bin = &my_charset_utf8mb3_bin; + spd_defaults_extra_file = &my_defaults_extra_file; + spd_defaults_file = &my_defaults_file; + spd_mysqld_unix_port = (const char **) &mysqld_unix_port; + spd_mysqld_port = &mysqld_port; + spd_abort_loop = &abort_loop; + spd_tz_system = my_tz_SYSTEM; + spd_mysqld_server_started = &mysqld_server_started; + spd_LOCK_server_started = &LOCK_server_started; + spd_COND_server_started = &COND_server_started; + +#ifdef HAVE_PSI_INTERFACE + init_spider_psi_keys(); +#endif + +#ifndef WITHOUT_SPIDER_BG_SEARCH + if (pthread_attr_init(&spider_pt_attr)) + goto error_pt_attr_init; +/* + if (pthread_attr_setdetachstate(&spider_pt_attr, PTHREAD_CREATE_DETACHED)) + goto error_pt_attr_setstate; +*/ +#endif + +#if MYSQL_VERSION_ID < 50500 + if (pthread_mutex_init(&spider_tbl_mutex, MY_MUTEX_INIT_FAST)) +#else + if (mysql_mutex_init(spd_key_mutex_tbl, + &spider_tbl_mutex, MY_MUTEX_INIT_FAST)) +#endif + goto error_tbl_mutex_init; +#if MYSQL_VERSION_ID < 50500 + if (pthread_mutex_init(&spider_thread_id_mutex, MY_MUTEX_INIT_FAST)) +#else + if (mysql_mutex_init(spd_key_thread_id, + &spider_thread_id_mutex, MY_MUTEX_INIT_FAST)) +#endif + goto error_thread_id_mutex_init; +#if MYSQL_VERSION_ID < 50500 + if (pthread_mutex_init(&spider_conn_id_mutex, MY_MUTEX_INIT_FAST)) +#else + if (mysql_mutex_init(spd_key_conn_id, + &spider_conn_id_mutex, MY_MUTEX_INIT_FAST)) +#endif + goto error_conn_id_mutex_init; +#if MYSQL_VERSION_ID < 50500 + if (pthread_mutex_init(&spider_ipport_conn_mutex, MY_MUTEX_INIT_FAST)) +#else + if (mysql_mutex_init(spd_key_mutex_ipport_count, + &spider_ipport_conn_mutex, MY_MUTEX_INIT_FAST)) +#endif + goto error_ipport_count_mutex_init; + +#if MYSQL_VERSION_ID < 50500 + if (pthread_mutex_init(&spider_init_error_tbl_mutex, MY_MUTEX_INIT_FAST)) +#else + if (mysql_mutex_init(spd_key_mutex_init_error_tbl, + &spider_init_error_tbl_mutex, MY_MUTEX_INIT_FAST)) +#endif + goto error_init_error_tbl_mutex_init; + +#ifdef WITH_PARTITION_STORAGE_ENGINE +#if MYSQL_VERSION_ID < 50500 + if (pthread_mutex_init(&spider_wide_share_mutex, MY_MUTEX_INIT_FAST)) +#else + if (mysql_mutex_init(spd_key_mutex_wide_share, + &spider_wide_share_mutex, MY_MUTEX_INIT_FAST)) +#endif + goto error_wide_share_mutex_init; + +#endif +#if MYSQL_VERSION_ID < 50500 + if (pthread_mutex_init(&spider_lgtm_tblhnd_share_mutex, MY_MUTEX_INIT_FAST)) +#else + if (mysql_mutex_init(spd_key_mutex_lgtm_tblhnd_share, + &spider_lgtm_tblhnd_share_mutex, MY_MUTEX_INIT_FAST)) +#endif + goto error_lgtm_tblhnd_share_mutex_init; + +#if MYSQL_VERSION_ID < 50500 + if (pthread_mutex_init(&spider_conn_mutex, MY_MUTEX_INIT_FAST)) +#else + if (mysql_mutex_init(spd_key_mutex_conn, + &spider_conn_mutex, MY_MUTEX_INIT_FAST)) +#endif + goto error_conn_mutex_init; + +#if MYSQL_VERSION_ID < 50500 + if (pthread_mutex_init(&spider_open_conn_mutex, MY_MUTEX_INIT_FAST)) +#else + if (mysql_mutex_init(spd_key_mutex_open_conn, + &spider_open_conn_mutex, MY_MUTEX_INIT_FAST)) +#endif + goto error_open_conn_mutex_init; + +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) +#if MYSQL_VERSION_ID < 50500 + if (pthread_mutex_init(&spider_hs_r_conn_mutex, MY_MUTEX_INIT_FAST)) +#else + if (mysql_mutex_init(spd_key_mutex_hs_r_conn, + &spider_hs_r_conn_mutex, MY_MUTEX_INIT_FAST)) +#endif + goto error_hs_r_conn_mutex_init; + +#if MYSQL_VERSION_ID < 50500 + if (pthread_mutex_init(&spider_hs_w_conn_mutex, MY_MUTEX_INIT_FAST)) +#else + if (mysql_mutex_init(spd_key_mutex_hs_w_conn, + &spider_hs_w_conn_mutex, MY_MUTEX_INIT_FAST)) +#endif + goto error_hs_w_conn_mutex_init; + +#endif +#if MYSQL_VERSION_ID < 50500 + if (pthread_mutex_init(&spider_allocated_thds_mutex, MY_MUTEX_INIT_FAST)) +#else + if (mysql_mutex_init(spd_key_mutex_allocated_thds, + &spider_allocated_thds_mutex, MY_MUTEX_INIT_FAST)) +#endif + goto error_allocated_thds_mutex_init; + +#if MYSQL_VERSION_ID < 50500 + if (pthread_mutex_init(&spider_mon_table_cache_mutex, MY_MUTEX_INIT_FAST)) +#else + if (mysql_mutex_init(spd_key_mutex_mon_table_cache, + &spider_mon_table_cache_mutex, MY_MUTEX_INIT_FAST)) +#endif + goto error_mon_table_cache_mutex_init; + +#if MYSQL_VERSION_ID < 50500 + if (pthread_mutex_init(&spider_mem_calc_mutex, MY_MUTEX_INIT_FAST)) +#else + if (mysql_mutex_init(spd_key_mutex_mem_calc, + &spider_mem_calc_mutex, MY_MUTEX_INIT_FAST)) +#endif + goto error_mem_calc_mutex_init; + + if (my_hash_init(PSI_INSTRUMENT_ME, &spider_open_tables, spd_charset_utf8mb3_bin, 32, 0, 0, + (my_hash_get_key) spider_tbl_get_key, 0, 0)) + goto error_open_tables_hash_init; + + spider_alloc_calc_mem_init(spider_open_tables, 143); + spider_alloc_calc_mem(NULL, + spider_open_tables, + spider_open_tables.array.max_element * + spider_open_tables.array.size_of_element); + if (my_hash_init(PSI_INSTRUMENT_ME, &spider_init_error_tables, spd_charset_utf8mb3_bin, 32, 0, 0, + (my_hash_get_key) spider_tbl_get_key, 0, 0)) + goto error_init_error_tables_hash_init; + + spider_alloc_calc_mem_init(spider_init_error_tables, 144); + spider_alloc_calc_mem(NULL, + spider_init_error_tables, + spider_init_error_tables.array.max_element * + spider_init_error_tables.array.size_of_element); +#ifdef WITH_PARTITION_STORAGE_ENGINE + if( + my_hash_init(PSI_INSTRUMENT_ME, &spider_open_wide_share, spd_charset_utf8mb3_bin, 32, 0, 0, + (my_hash_get_key) spider_wide_share_get_key, 0, 0) + ) + goto error_open_wide_share_hash_init; + + spider_alloc_calc_mem_init(spider_open_wide_share, 145); + spider_alloc_calc_mem(NULL, + spider_open_wide_share, + spider_open_wide_share.array.max_element * + spider_open_wide_share.array.size_of_element); +#endif + if (my_hash_init(PSI_INSTRUMENT_ME, &spider_lgtm_tblhnd_share_hash, + spd_charset_utf8mb3_bin, 32, 0, 0, + (my_hash_get_key) spider_lgtm_tblhnd_share_hash_get_key, 0, 0)) + goto error_lgtm_tblhnd_share_hash_init; + + spider_alloc_calc_mem_init(spider_lgtm_tblhnd_share_hash, 245); + spider_alloc_calc_mem(NULL, + spider_lgtm_tblhnd_share_hash, + spider_lgtm_tblhnd_share_hash.array.max_element * + spider_lgtm_tblhnd_share_hash.array.size_of_element); + if (my_hash_init(PSI_INSTRUMENT_ME, &spider_open_connections, spd_charset_utf8mb3_bin, 32, 0, 0, + (my_hash_get_key) spider_conn_get_key, 0, 0)) + goto error_open_connections_hash_init; + + if (my_hash_init(PSI_INSTRUMENT_ME, &spider_ipport_conns, spd_charset_utf8mb3_bin, 32, 0, 0, + (my_hash_get_key) spider_ipport_conn_get_key, + spider_free_ipport_conn, 0)) + goto error_ipport_conn__hash_init; + + spider_alloc_calc_mem_init(spider_open_connections, 146); + spider_alloc_calc_mem(NULL, + spider_open_connections, + spider_open_connections.array.max_element * + spider_open_connections.array.size_of_element); +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + if (my_hash_init(PSI_INSTRUMENT_ME, &spider_hs_r_conn_hash, spd_charset_utf8mb3_bin, 32, 0, 0, + (my_hash_get_key) spider_conn_get_key, 0, 0)) + goto error_hs_r_conn_hash_init; + + spider_alloc_calc_mem_init(spider_hs_r_conn_hash, 147); + spider_alloc_calc_mem(NULL, + spider_hs_r_conn_hash, + spider_hs_r_conn_hash.array.max_element * + spider_hs_r_conn_hash.array.size_of_element); + if (my_hash_init(PSI_INSTRUMENT_ME, &spider_hs_w_conn_hash, spd_charset_utf8mb3_bin, 32, 0, 0, + (my_hash_get_key) spider_conn_get_key, 0, 0)) + goto error_hs_w_conn_hash_init; + + spider_alloc_calc_mem_init(spider_hs_w_conn_hash, 148); + spider_alloc_calc_mem(NULL, + spider_hs_w_conn_hash, + spider_hs_w_conn_hash.array.max_element * + spider_hs_w_conn_hash.array.size_of_element); +#endif + if (my_hash_init(PSI_INSTRUMENT_ME, &spider_allocated_thds, spd_charset_utf8mb3_bin, 32, 0, 0, + (my_hash_get_key) spider_allocated_thds_get_key, 0, 0)) + goto error_allocated_thds_hash_init; + + spider_alloc_calc_mem_init(spider_allocated_thds, 149); + spider_alloc_calc_mem(NULL, + spider_allocated_thds, + spider_allocated_thds.array.max_element * + spider_allocated_thds.array.size_of_element); + + if (SPD_INIT_DYNAMIC_ARRAY2(&spider_mon_table_cache, sizeof(SPIDER_MON_KEY), + NULL, 64, 64, MYF(MY_WME))) + goto error_mon_table_cache_array_init; + + spider_alloc_calc_mem_init(spider_mon_table_cache, 165); + spider_alloc_calc_mem(NULL, + spider_mon_table_cache, + spider_mon_table_cache.max_element * + spider_mon_table_cache.size_of_element); + + if (!(spider_udf_table_mon_mutexes = (pthread_mutex_t *) + spider_bulk_malloc(NULL, 53, MYF(MY_WME | MY_ZEROFILL), + &spider_udf_table_mon_mutexes, (uint) (sizeof(pthread_mutex_t) * + spider_param_udf_table_mon_mutex_count()), + &spider_udf_table_mon_conds, (uint) (sizeof(pthread_cond_t) * + spider_param_udf_table_mon_mutex_count()), + &spider_udf_table_mon_list_hash, (uint) (sizeof(HASH) * + spider_param_udf_table_mon_mutex_count()), + NullS)) + ) + goto error_alloc_mon_mutxes; + + for (roop_count = 0; + roop_count < (int) spider_param_udf_table_mon_mutex_count(); + roop_count++) + { +#if MYSQL_VERSION_ID < 50500 + if (pthread_mutex_init(&spider_udf_table_mon_mutexes[roop_count], + MY_MUTEX_INIT_FAST)) +#else + if (mysql_mutex_init(spd_key_mutex_udf_table_mon, + &spider_udf_table_mon_mutexes[roop_count], MY_MUTEX_INIT_FAST)) +#endif + goto error_init_udf_table_mon_mutex; + } + for (roop_count = 0; + roop_count < (int) spider_param_udf_table_mon_mutex_count(); + roop_count++) + { +#if MYSQL_VERSION_ID < 50500 + if (pthread_cond_init(&spider_udf_table_mon_conds[roop_count], NULL)) +#else + if (mysql_cond_init(spd_key_cond_udf_table_mon, + &spider_udf_table_mon_conds[roop_count], NULL)) +#endif + goto error_init_udf_table_mon_cond; + } + for (roop_count = 0; + roop_count < (int) spider_param_udf_table_mon_mutex_count(); + roop_count++) + { + if (my_hash_init(PSI_INSTRUMENT_ME, &spider_udf_table_mon_list_hash[roop_count], + spd_charset_utf8mb3_bin, 32, 0, 0, + (my_hash_get_key) spider_udf_tbl_mon_list_key, 0, 0)) + goto error_init_udf_table_mon_list_hash; + + spider_alloc_calc_mem_init(spider_udf_table_mon_list_hash, 150); + spider_alloc_calc_mem(NULL, + spider_udf_table_mon_list_hash, + spider_udf_table_mon_list_hash[roop_count].array.max_element * + spider_udf_table_mon_list_hash[roop_count].array.size_of_element); + } + +#ifndef WITHOUT_SPIDER_BG_SEARCH + if (!(spider_table_sts_threads = (SPIDER_THREAD *) + spider_bulk_malloc(NULL, 256, MYF(MY_WME | MY_ZEROFILL), + &spider_table_sts_threads, (uint) (sizeof(SPIDER_THREAD) * + spider_param_table_sts_thread_count()), + &spider_table_crd_threads, (uint) (sizeof(SPIDER_THREAD) * + spider_param_table_crd_thread_count()), + NullS)) + ) + goto error_alloc_mon_mutxes; + spider_table_sts_threads[0].init_command = TRUE; + + for (roop_count = 0; + roop_count < (int) spider_param_table_sts_thread_count(); + roop_count++) + { + if ((error_num = spider_create_sts_threads(&spider_table_sts_threads[roop_count]))) + { + goto error_init_table_sts_threads; + } + } + for (roop_count = 0; + roop_count < (int) spider_param_table_crd_thread_count(); + roop_count++) + { + if ((error_num = spider_create_crd_threads(&spider_table_crd_threads[roop_count]))) + { + goto error_init_table_crd_threads; + } + } +#endif + + spider_dbton_mysql.dbton_id = dbton_id; + spider_dbton_mysql.db_util->dbton_id = dbton_id; + spider_dbton[dbton_id] = spider_dbton_mysql; + ++dbton_id; + spider_dbton_mariadb.dbton_id = dbton_id; + spider_dbton_mariadb.db_util->dbton_id = dbton_id; + spider_dbton[dbton_id] = spider_dbton_mariadb; + ++dbton_id; +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + spider_dbton_handlersocket.dbton_id = dbton_id; + spider_dbton_handlersocket.db_util->dbton_id = dbton_id; + spider_dbton[dbton_id] = spider_dbton_handlersocket; + ++dbton_id; +#endif +#ifdef HAVE_ORACLE_OCI + spider_dbton_oracle.dbton_id = dbton_id; + spider_dbton_oracle.db_util->dbton_id = dbton_id; + spider_dbton[dbton_id] = spider_dbton_oracle; + ++dbton_id; +#endif + for (roop_count = 0; roop_count < SPIDER_DBTON_SIZE; roop_count++) + { + if (spider_dbton[roop_count].init) + { + if ((error_num = spider_dbton[roop_count].init())) + { + goto error_init_dbton; + } + } + } + DBUG_RETURN(0); + +#ifndef WITHOUT_SPIDER_BG_SEARCH +error_init_dbton: + for (roop_count--; roop_count >= 0; roop_count--) + { + if (spider_dbton[roop_count].deinit) + { + spider_dbton[roop_count].deinit(); + } + } + roop_count = spider_param_table_crd_thread_count() - 1; +error_init_table_crd_threads: + for (; roop_count >= 0; roop_count--) + { + spider_free_crd_threads(&spider_table_crd_threads[roop_count]); + } + roop_count = spider_param_table_sts_thread_count() - 1; +error_init_table_sts_threads: + for (; roop_count >= 0; roop_count--) + { + spider_free_sts_threads(&spider_table_sts_threads[roop_count]); + } + spider_free(NULL, spider_table_sts_threads, MYF(0)); + roop_count = spider_param_udf_table_mon_mutex_count() - 1; +#endif +error_init_udf_table_mon_list_hash: + for (; roop_count >= 0; roop_count--) + { + spider_free_mem_calc(NULL, + spider_udf_table_mon_list_hash_id, + spider_udf_table_mon_list_hash[roop_count].array.max_element * + spider_udf_table_mon_list_hash[roop_count].array.size_of_element); + my_hash_free(&spider_udf_table_mon_list_hash[roop_count]); + } + roop_count = spider_param_udf_table_mon_mutex_count() - 1; +error_init_udf_table_mon_cond: + for (; roop_count >= 0; roop_count--) + pthread_cond_destroy(&spider_udf_table_mon_conds[roop_count]); + roop_count = spider_param_udf_table_mon_mutex_count() - 1; +error_init_udf_table_mon_mutex: + for (; roop_count >= 0; roop_count--) + pthread_mutex_destroy(&spider_udf_table_mon_mutexes[roop_count]); + spider_free(NULL, spider_udf_table_mon_mutexes, MYF(0)); +error_alloc_mon_mutxes: + spider_free_mem_calc(NULL, + spider_mon_table_cache_id, + spider_mon_table_cache.max_element * + spider_mon_table_cache.size_of_element); + delete_dynamic(&spider_mon_table_cache); +error_mon_table_cache_array_init: + spider_free_mem_calc(NULL, + spider_allocated_thds_id, + spider_allocated_thds.array.max_element * + spider_allocated_thds.array.size_of_element); + my_hash_free(&spider_allocated_thds); +error_allocated_thds_hash_init: + my_hash_free(&spider_ipport_conns); +error_ipport_conn__hash_init: +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + spider_free_mem_calc(NULL, + spider_hs_w_conn_hash_id, + spider_hs_w_conn_hash.array.max_element * + spider_hs_w_conn_hash.array.size_of_element); + my_hash_free(&spider_hs_w_conn_hash); +error_hs_w_conn_hash_init: + spider_free_mem_calc(NULL, + spider_hs_r_conn_hash_id, + spider_hs_r_conn_hash.array.max_element * + spider_hs_r_conn_hash.array.size_of_element); + my_hash_free(&spider_hs_r_conn_hash); +error_hs_r_conn_hash_init: +#endif + spider_free_mem_calc(NULL, + spider_open_connections_id, + spider_open_connections.array.max_element * + spider_open_connections.array.size_of_element); + my_hash_free(&spider_open_connections); +error_open_connections_hash_init: + spider_free_mem_calc(NULL, + spider_lgtm_tblhnd_share_hash_id, + spider_lgtm_tblhnd_share_hash.array.max_element * + spider_lgtm_tblhnd_share_hash.array.size_of_element); + my_hash_free(&spider_lgtm_tblhnd_share_hash); +error_lgtm_tblhnd_share_hash_init: +#ifdef WITH_PARTITION_STORAGE_ENGINE + spider_free_mem_calc(NULL, + spider_open_wide_share_id, + spider_open_wide_share.array.max_element * + spider_open_wide_share.array.size_of_element); + my_hash_free(&spider_open_wide_share); +error_open_wide_share_hash_init: +#endif + spider_free_mem_calc(NULL, + spider_init_error_tables_id, + spider_init_error_tables.array.max_element * + spider_init_error_tables.array.size_of_element); + my_hash_free(&spider_init_error_tables); +error_init_error_tables_hash_init: + spider_free_mem_calc(NULL, + spider_open_tables_id, + spider_open_tables.array.max_element * + spider_open_tables.array.size_of_element); + my_hash_free(&spider_open_tables); +error_open_tables_hash_init: + pthread_mutex_destroy(&spider_mem_calc_mutex); +error_mem_calc_mutex_init: + pthread_mutex_destroy(&spider_mon_table_cache_mutex); +error_mon_table_cache_mutex_init: + pthread_mutex_destroy(&spider_allocated_thds_mutex); +error_allocated_thds_mutex_init: +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + pthread_mutex_destroy(&spider_hs_w_conn_mutex); +error_hs_w_conn_mutex_init: + pthread_mutex_destroy(&spider_hs_r_conn_mutex); +error_hs_r_conn_mutex_init: +#endif + pthread_mutex_destroy(&spider_open_conn_mutex); +error_open_conn_mutex_init: + pthread_mutex_destroy(&spider_conn_mutex); +error_conn_mutex_init: + pthread_mutex_destroy(&spider_lgtm_tblhnd_share_mutex); +error_lgtm_tblhnd_share_mutex_init: +#ifdef WITH_PARTITION_STORAGE_ENGINE + pthread_mutex_destroy(&spider_wide_share_mutex); +error_wide_share_mutex_init: +#endif + pthread_mutex_destroy(&spider_init_error_tbl_mutex); +error_init_error_tbl_mutex_init: + pthread_mutex_destroy(&spider_ipport_conn_mutex); +error_ipport_count_mutex_init: + pthread_mutex_destroy(&spider_conn_id_mutex); +error_conn_id_mutex_init: + pthread_mutex_destroy(&spider_thread_id_mutex); +error_thread_id_mutex_init: + pthread_mutex_destroy(&spider_tbl_mutex); +error_tbl_mutex_init: +#ifndef WITHOUT_SPIDER_BG_SEARCH +/* +error_pt_attr_setstate: +*/ + pthread_attr_destroy(&spider_pt_attr); +error_pt_attr_init: +#endif + DBUG_RETURN(error_num); +} + +char *spider_create_string( + const char *str, + uint length +) { + char *res; + DBUG_ENTER("spider_create_string"); + if (!(res = (char*) spider_malloc(spider_current_trx, 13, length + 1, + MYF(MY_WME)))) + DBUG_RETURN(NULL); + memcpy(res, str, length); + res[length] = '\0'; + DBUG_RETURN(res); +} + +char *spider_create_table_name_string( + const char *table_name, + const char *part_name, + const char *sub_name +) { + char *res, *tmp; + uint length = strlen(table_name); + DBUG_ENTER("spider_create_table_name_string"); + if (part_name) + { + length += sizeof("#P#") - 1 + strlen(part_name); + if (sub_name) + length += sizeof("#SP#") - 1 + strlen(sub_name); + } + if (!(res = (char*) spider_malloc(spider_current_trx, 14, length + 1, + MYF(MY_WME)))) + DBUG_RETURN(NULL); + tmp = strmov(res, table_name); + if (part_name) + { + tmp = strmov(tmp, "#P#"); + tmp = strmov(tmp, part_name); + if (sub_name) + { + tmp = strmov(tmp, "#SP#"); + tmp = strmov(tmp, sub_name); + } + } + DBUG_RETURN(res); +} + +#ifdef WITH_PARTITION_STORAGE_ENGINE +void spider_get_partition_info( + const char *table_name, + uint table_name_length, + const TABLE_SHARE *table_share, + partition_info *part_info, + partition_element **part_elem, + partition_element **sub_elem +) { + char tmp_name[FN_REFLEN + 1]; + partition_element *tmp_part_elem = NULL, *tmp_sub_elem = NULL; + bool tmp_flg = FALSE, tmp_find_flg = FALSE; + DBUG_ENTER("spider_get_partition_info"); + *part_elem = NULL; + *sub_elem = NULL; + if (!part_info) + DBUG_VOID_RETURN; + + if (!memcmp(table_name + table_name_length - 5, "#TMP#", 5)) + tmp_flg = TRUE; + + DBUG_PRINT("info",("spider table_name=%s", table_name)); + List_iterator<partition_element> part_it(part_info->partitions); + while ((*part_elem = part_it++)) + { + if ((*part_elem)->subpartitions.elements) + { + List_iterator<partition_element> sub_it((*part_elem)->subpartitions); + while ((*sub_elem = sub_it++)) + { + if (SPIDER_create_subpartition_name( + tmp_name, FN_REFLEN + 1, table_share->path.str, + (*part_elem)->partition_name, (*sub_elem)->partition_name, + NORMAL_PART_NAME)) + { + DBUG_VOID_RETURN; + } + DBUG_PRINT("info",("spider tmp_name=%s", tmp_name)); + if (!memcmp(table_name, tmp_name, table_name_length + 1)) + DBUG_VOID_RETURN; + if ( + tmp_flg && + *(tmp_name + table_name_length - 5) == '\0' && + !memcmp(table_name, tmp_name, table_name_length - 5) + ) { + tmp_part_elem = *part_elem; + tmp_sub_elem = *sub_elem; + tmp_flg = FALSE; + tmp_find_flg = TRUE; + } + } + } else { + if (SPIDER_create_partition_name( + tmp_name, FN_REFLEN + 1, table_share->path.str, + (*part_elem)->partition_name, NORMAL_PART_NAME, TRUE)) + { + DBUG_VOID_RETURN; + } + DBUG_PRINT("info",("spider tmp_name=%s", tmp_name)); + if (!memcmp(table_name, tmp_name, table_name_length + 1)) + DBUG_VOID_RETURN; + if ( + tmp_flg && + *(tmp_name + table_name_length - 5) == '\0' && + !memcmp(table_name, tmp_name, table_name_length - 5) + ) { + tmp_part_elem = *part_elem; + tmp_flg = FALSE; + tmp_find_flg = TRUE; + } + } + } + if (tmp_find_flg) + { + *part_elem = tmp_part_elem; + *sub_elem = tmp_sub_elem; + DBUG_PRINT("info",("spider tmp find")); + DBUG_VOID_RETURN; + } + *part_elem = NULL; + *sub_elem = NULL; + DBUG_PRINT("info",("spider no hit")); + DBUG_VOID_RETURN; +} +#endif + +int spider_get_sts( + SPIDER_SHARE *share, + int link_idx, + time_t tmp_time, + ha_spider *spider, + double sts_interval, + int sts_mode, +#ifdef WITH_PARTITION_STORAGE_ENGINE + int sts_sync, +#endif + int sts_sync_level, + uint flag +) { +#ifdef WITH_PARTITION_STORAGE_ENGINE + int get_type; +#endif + int error_num = 0; + bool need_to_get = TRUE; + DBUG_ENTER("spider_get_sts"); + +#ifdef WITH_PARTITION_STORAGE_ENGINE + if ( + sts_sync == 0 + ) { + /* get */ + get_type = 1; + } else if ( + !share->wide_share->sts_init + ) { + pthread_mutex_lock(&share->wide_share->sts_mutex); + if (!share->wide_share->sts_init) + { + /* get after mutex_lock */ + get_type = 2; + } else { + pthread_mutex_unlock(&share->wide_share->sts_mutex); + /* copy */ + get_type = 0; + } + } else if ( + difftime(share->sts_get_time, share->wide_share->sts_get_time) < + sts_interval + ) { + /* copy */ + get_type = 0; + } else if ( + !pthread_mutex_trylock(&share->wide_share->sts_mutex) + ) { + /* get after mutex_trylock */ + get_type = 3; + } else { + /* copy */ + get_type = 0; + } +#endif + if ( + !share->sts_init && + spider_param_load_sts_at_startup(share->load_sts_at_startup) && + (!share->init || share->init_error) + ) { + error_num = spider_sys_get_table_sts( + current_thd, + share->lgtm_tblhnd_share->table_name, + share->lgtm_tblhnd_share->table_name_length, + &share->stat, + FALSE + ); + if ( + !error_num || + (error_num != HA_ERR_KEY_NOT_FOUND && error_num != HA_ERR_END_OF_FILE) + ) + need_to_get = FALSE; + } + + if (need_to_get) + { +#ifdef WITH_PARTITION_STORAGE_ENGINE + if (get_type == 0) + spider_copy_sts_to_share(share, share->wide_share); + else { +#endif + error_num = spider_db_show_table_status(spider, link_idx, sts_mode, flag); +#ifdef WITH_PARTITION_STORAGE_ENGINE + } +#endif + } +#ifdef WITH_PARTITION_STORAGE_ENGINE + if (get_type >= 2) + pthread_mutex_unlock(&share->wide_share->sts_mutex); +#endif + if (error_num) + { +#ifdef WITH_PARTITION_STORAGE_ENGINE + SPIDER_PARTITION_HANDLER_SHARE *partition_handler_share = + spider->partition_handler_share; + if ( + !share->wide_share->sts_init && + sts_sync >= sts_sync_level && + get_type > 1 && + partition_handler_share && + partition_handler_share->handlers && + partition_handler_share->handlers[0] == spider + ) { + int roop_count; + ha_spider *tmp_spider; + SPIDER_SHARE *tmp_share; + double tmp_sts_interval; + int tmp_sts_mode; + int tmp_sts_sync; + THD *thd = spider->wide_handler->trx->thd; + for (roop_count = 1; + roop_count < (int) partition_handler_share->no_parts; + roop_count++) + { + tmp_spider = + (ha_spider *) partition_handler_share->handlers[roop_count]; + tmp_share = tmp_spider->share; + tmp_sts_interval = spider_param_sts_interval(thd, share->sts_interval); + tmp_sts_mode = spider_param_sts_mode(thd, share->sts_mode); + tmp_sts_sync = spider_param_sts_sync(thd, share->sts_sync); + spider_get_sts(tmp_share, tmp_spider->search_link_idx, + tmp_time, tmp_spider, tmp_sts_interval, tmp_sts_mode, tmp_sts_sync, + 1, flag); + if (share->wide_share->sts_init) + { + error_num = 0; + thd->clear_error(); + get_type = 0; + spider_copy_sts_to_share(share, share->wide_share); + break; + } + } + } + if (error_num) +#endif + DBUG_RETURN(error_num); + } +#ifdef WITH_PARTITION_STORAGE_ENGINE + if (sts_sync >= sts_sync_level && get_type > 0) + { + spider_copy_sts_to_wide_share(share->wide_share, share); + share->wide_share->sts_get_time = tmp_time; + share->wide_share->sts_init = TRUE; + } +#endif + share->sts_get_time = tmp_time; + share->sts_init = TRUE; + DBUG_RETURN(0); +} + +int spider_get_crd( + SPIDER_SHARE *share, + int link_idx, + time_t tmp_time, + ha_spider *spider, + TABLE *table, + double crd_interval, + int crd_mode, +#ifdef WITH_PARTITION_STORAGE_ENGINE + int crd_sync, +#endif + int crd_sync_level +) { +#ifdef WITH_PARTITION_STORAGE_ENGINE + int get_type; +#endif + int error_num = 0; + bool need_to_get = TRUE; + DBUG_ENTER("spider_get_crd"); + +#ifdef WITH_PARTITION_STORAGE_ENGINE + if ( + crd_sync == 0 + ) { + /* get */ + get_type = 1; + } else if ( + !share->wide_share->crd_init + ) { + pthread_mutex_lock(&share->wide_share->crd_mutex); + if (!share->wide_share->crd_init) + { + /* get after mutex_lock */ + get_type = 2; + } else { + pthread_mutex_unlock(&share->wide_share->crd_mutex); + /* copy */ + get_type = 0; + } + } else if ( + difftime(share->crd_get_time, share->wide_share->crd_get_time) < + crd_interval + ) { + /* copy */ + get_type = 0; + } else if ( + !pthread_mutex_trylock(&share->wide_share->crd_mutex) + ) { + /* get after mutex_trylock */ + get_type = 3; + } else { + /* copy */ + get_type = 0; + } +#endif + if ( + !share->crd_init && + spider_param_load_sts_at_startup(share->load_crd_at_startup) + ) { + error_num = spider_sys_get_table_crd( + current_thd, + share->lgtm_tblhnd_share->table_name, + share->lgtm_tblhnd_share->table_name_length, + share->cardinality, + table->s->fields, + FALSE + ); + if ( + !error_num || + (error_num != HA_ERR_KEY_NOT_FOUND && error_num != HA_ERR_END_OF_FILE) + ) + need_to_get = FALSE; + } + + if (need_to_get) + { +#ifdef WITH_PARTITION_STORAGE_ENGINE + if (get_type == 0) + spider_copy_crd_to_share(share, share->wide_share, + table->s->fields); + else { +#endif + error_num = spider_db_show_index(spider, link_idx, table, crd_mode); +#ifdef WITH_PARTITION_STORAGE_ENGINE + } +#endif + } +#ifdef WITH_PARTITION_STORAGE_ENGINE + if (get_type >= 2) + pthread_mutex_unlock(&share->wide_share->crd_mutex); +#endif + if (error_num) + { +#ifdef WITH_PARTITION_STORAGE_ENGINE + SPIDER_PARTITION_HANDLER_SHARE *partition_handler_share = + spider->partition_handler_share; + if ( + !share->wide_share->crd_init && + crd_sync >= crd_sync_level && + get_type > 1 && + partition_handler_share && + partition_handler_share->handlers && + partition_handler_share->handlers[0] == spider + ) { + int roop_count; + ha_spider *tmp_spider; + SPIDER_SHARE *tmp_share; + double tmp_crd_interval; + int tmp_crd_mode; + int tmp_crd_sync; + THD *thd = spider->wide_handler->trx->thd; + for (roop_count = 1; + roop_count < (int) partition_handler_share->no_parts; + roop_count++) + { + tmp_spider = + (ha_spider *) partition_handler_share->handlers[roop_count]; + tmp_share = tmp_spider->share; + tmp_crd_interval = spider_param_crd_interval(thd, share->crd_interval); + tmp_crd_mode = spider_param_crd_mode(thd, share->crd_mode); + tmp_crd_sync = spider_param_crd_sync(thd, share->crd_sync); + spider_get_crd(tmp_share, tmp_spider->search_link_idx, + tmp_time, tmp_spider, table, tmp_crd_interval, tmp_crd_mode, + tmp_crd_sync, 1); + if (share->wide_share->crd_init) + { + error_num = 0; + thd->clear_error(); + get_type = 0; + spider_copy_crd_to_share(share, share->wide_share, + table->s->fields); + break; + } + } + } + if (error_num) +#endif + DBUG_RETURN(error_num); + } +#ifdef WITH_PARTITION_STORAGE_ENGINE + if (crd_sync >= crd_sync_level && get_type > 0) + { + spider_copy_crd_to_wide_share(share->wide_share, share, + table->s->fields); + share->wide_share->crd_get_time = tmp_time; + share->wide_share->crd_init = TRUE; + } +#endif + share->crd_get_time = tmp_time; + share->crd_init = TRUE; + DBUG_RETURN(0); +} + +void spider_set_result_list_param( + ha_spider *spider +) { + SPIDER_RESULT_LIST *result_list = &spider->result_list; + SPIDER_SHARE *share = spider->share; + THD *thd = spider->wide_handler->trx->thd; + DBUG_ENTER("spider_set_result_list_param"); + result_list->internal_offset = + spider_param_internal_offset(thd, share->internal_offset); + result_list->internal_limit = +#ifdef INFO_KIND_FORCE_LIMIT_BEGIN + spider->wide_handler->info_limit < 9223372036854775807LL ? + spider->wide_handler->info_limit : +#endif + spider_param_internal_limit(thd, share->internal_limit); + result_list->split_read = spider_split_read_param(spider); + if (spider->support_multi_split_read_sql()) + { + result_list->multi_split_read = + spider_param_multi_split_read(thd, share->multi_split_read); + } else { + result_list->multi_split_read = 1; + } + result_list->max_order = + spider_param_max_order(thd, share->max_order); + result_list->quick_mode = + spider_param_quick_mode(thd, share->quick_mode); + result_list->quick_page_size = + spider_param_quick_page_size(thd, share->quick_page_size); + result_list->quick_page_byte = + spider_param_quick_page_byte(thd, share->quick_page_byte); + result_list->low_mem_read = + spider_param_low_mem_read(thd, share->low_mem_read); + DBUG_VOID_RETURN; +} + +SPIDER_INIT_ERROR_TABLE *spider_get_init_error_table( + SPIDER_TRX *trx, + SPIDER_SHARE *share, + bool create +) { + SPIDER_INIT_ERROR_TABLE *spider_init_error_table; + char *tmp_name; + DBUG_ENTER("spider_get_init_error_table"); + pthread_mutex_lock(&spider_init_error_tbl_mutex); +#ifdef SPIDER_HAS_HASH_VALUE_TYPE + if (!(spider_init_error_table = (SPIDER_INIT_ERROR_TABLE *) + my_hash_search_using_hash_value( + &spider_init_error_tables, share->table_name_hash_value, + (uchar*) share->table_name, share->table_name_length))) +#else + if (!(spider_init_error_table = (SPIDER_INIT_ERROR_TABLE *) my_hash_search( + &spider_init_error_tables, + (uchar*) share->table_name, share->table_name_length))) +#endif + { + if (!create) + { + pthread_mutex_unlock(&spider_init_error_tbl_mutex); + DBUG_RETURN(NULL); + } + if (!(spider_init_error_table = (SPIDER_INIT_ERROR_TABLE *) + spider_bulk_malloc(spider_current_trx, 54, MYF(MY_WME | MY_ZEROFILL), + &spider_init_error_table, (uint) (sizeof(*spider_init_error_table)), + &tmp_name, (uint) (share->table_name_length + 1), + NullS)) + ) { + pthread_mutex_unlock(&spider_init_error_tbl_mutex); + DBUG_RETURN(NULL); + } + memcpy(tmp_name, share->table_name, share->table_name_length); + spider_init_error_table->table_name = tmp_name; + spider_init_error_table->table_name_length = share->table_name_length; +#ifdef SPIDER_HAS_HASH_VALUE_TYPE + spider_init_error_table->table_name_hash_value = + share->table_name_hash_value; +#endif + uint old_elements = spider_init_error_tables.array.max_element; +#ifdef HASH_UPDATE_WITH_HASH_VALUE + if (my_hash_insert_with_hash_value(&spider_init_error_tables, + share->table_name_hash_value, (uchar*) spider_init_error_table)) +#else + if (my_hash_insert(&spider_init_error_tables, + (uchar*) spider_init_error_table)) +#endif + { + spider_free(trx, spider_init_error_table, MYF(0)); + pthread_mutex_unlock(&spider_init_error_tbl_mutex); + DBUG_RETURN(NULL); + } + if (spider_init_error_tables.array.max_element > old_elements) + { + spider_alloc_calc_mem(spider_current_trx, + spider_init_error_tables, + (spider_init_error_tables.array.max_element - old_elements) * + spider_init_error_tables.array.size_of_element); + } + } + pthread_mutex_unlock(&spider_init_error_tbl_mutex); + DBUG_RETURN(spider_init_error_table); +} + +void spider_delete_init_error_table( + const char *name +) { + SPIDER_INIT_ERROR_TABLE *spider_init_error_table; + uint length = strlen(name); +#ifdef SPIDER_HAS_HASH_VALUE_TYPE + my_hash_value_type hash_value = my_calc_hash(&spider_open_tables, + (uchar*) name, length); +#endif + DBUG_ENTER("spider_delete_init_error_table"); + pthread_mutex_lock(&spider_init_error_tbl_mutex); +#ifdef SPIDER_HAS_HASH_VALUE_TYPE + if ((spider_init_error_table = (SPIDER_INIT_ERROR_TABLE *) + my_hash_search_using_hash_value(&spider_init_error_tables, hash_value, + (uchar*) name, length))) +#else + if ((spider_init_error_table = (SPIDER_INIT_ERROR_TABLE *) my_hash_search( + &spider_init_error_tables, (uchar*) name, length))) +#endif + { +#ifdef HASH_UPDATE_WITH_HASH_VALUE + my_hash_delete_with_hash_value(&spider_init_error_tables, + spider_init_error_table->table_name_hash_value, + (uchar*) spider_init_error_table); +#else + my_hash_delete(&spider_init_error_tables, + (uchar*) spider_init_error_table); +#endif + spider_free(spider_current_trx, spider_init_error_table, MYF(0)); + } + pthread_mutex_unlock(&spider_init_error_tbl_mutex); + DBUG_VOID_RETURN; +} + +bool spider_check_pk_update( + TABLE *table +) { + int roop_count; + TABLE_SHARE *table_share = table->s; + KEY *key_info; + KEY_PART_INFO *key_part; + DBUG_ENTER("spider_check_pk_update"); + if (table_share->primary_key == MAX_KEY) + DBUG_RETURN(FALSE); + + key_info = &table_share->key_info[table_share->primary_key]; + key_part = key_info->key_part; + for (roop_count = 0; + roop_count < (int) spider_user_defined_key_parts(key_info); roop_count++) + { + if (bitmap_is_set(table->write_set, + key_part[roop_count].field->field_index)) + DBUG_RETURN(TRUE); + } + DBUG_RETURN(FALSE); +} + +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) +#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS +bool spider_check_hs_pk_update( + ha_spider *spider, + key_range *key +) { + uint roop_count, field_index, set_count = 0; + TABLE *table = spider->get_table(); + TABLE_SHARE *table_share = table->s; + SPIDER_SHARE *share = spider->share; + KEY *key_info; + KEY_PART_INFO *key_part; + char buf[MAX_FIELD_WIDTH], buf2[MAX_FIELD_WIDTH]; + spider_string tmp_str(buf, MAX_FIELD_WIDTH, &my_charset_bin), + tmp_str2(buf2, MAX_FIELD_WIDTH, &my_charset_bin); + String *str, *str2; + DBUG_ENTER("spider_check_hs_pk_update"); + tmp_str.init_calc_mem(137); + + if (table_share->primary_key == MAX_KEY) + DBUG_RETURN(FALSE); + memset(spider->tmp_column_bitmap, 0, sizeof(uchar) * share->bitmap_size); + key_info = &table->key_info[table_share->primary_key]; + key_part = key_info->key_part; + for (roop_count = 0; roop_count < spider_user_defined_key_parts(key_info); + roop_count++) + { + field_index = key_part[roop_count].field->field_index; + if (bitmap_is_set(table->write_set, field_index)) + { + DBUG_PRINT("info", ("spider set key_part=%u field_index=%u", + roop_count, field_index)); + spider_set_bit(spider->tmp_column_bitmap, field_index); + set_count++; + } + } + DBUG_PRINT("info", ("spider set_count=%u", set_count)); + + Field *field; + uint store_length, length, var_len; + const uchar *ptr; + bool key_eq; + key_part_map tgt_key_part_map = key->keypart_map; + key_info = &table->key_info[spider->active_index]; + for ( + key_part = key_info->key_part, + length = 0; + tgt_key_part_map; + length += store_length, + tgt_key_part_map >>= 1, + key_part++ + ) { + store_length = key_part->store_length; + field = key_part->field; + field_index = field->field_index; + if (spider_bit_is_set(spider->tmp_column_bitmap, field_index)) + { + ptr = key->key + length; + key_eq = (tgt_key_part_map > 1); + if (key_part->null_bit && *ptr++) + { + if (key->flag != HA_READ_KEY_EXACT || !field->is_null()) + { + DBUG_PRINT("info", ("spider flag=%u is_null=%s", + key->flag, field->is_null() ? "TRUE" : "FALSE")); + DBUG_RETURN(TRUE); + } + } else { + if ( + field->type() == MYSQL_TYPE_BLOB || + field->real_type() == MYSQL_TYPE_VARCHAR || + field->type() == MYSQL_TYPE_GEOMETRY + ) { + var_len = uint2korr(ptr); + tmp_str.set_quick((char *) ptr + HA_KEY_BLOB_LENGTH, var_len, + &my_charset_bin); + str = tmp_str.get_str(); + } else { + str = field->val_str(tmp_str.get_str(), ptr); + tmp_str.mem_calc(); + } + str2 = field->val_str(tmp_str2.get_str()); + tmp_str2.mem_calc(); + if ( + str->length() != str2->length() || + memcmp(str->ptr(), str2->ptr(), str->length()) + ) { + DBUG_PRINT("info", ("spider length=%u %u", + str->length(), str2->length())); + DBUG_PRINT("info", ("spider length=%s %s", + str->c_ptr_safe(), str2->c_ptr_safe())); + DBUG_RETURN(TRUE); + } + } + set_count--; + } + } + DBUG_PRINT("info", ("spider set_count=%u", set_count)); + if (set_count) + { + DBUG_RETURN(TRUE); + } + DBUG_RETURN(FALSE); +} +#endif +#endif + +void spider_set_tmp_share_pointer( + SPIDER_SHARE *tmp_share, + char **tmp_connect_info, + uint *tmp_connect_info_length, + long *tmp_long, + longlong *tmp_longlong +) { + DBUG_ENTER("spider_set_tmp_share_pointer"); + tmp_share->link_count = 1; + tmp_share->all_link_count = 1; + tmp_share->server_names = &tmp_connect_info[0]; + tmp_share->tgt_table_names = &tmp_connect_info[1]; + tmp_share->tgt_dbs = &tmp_connect_info[2]; + tmp_share->tgt_hosts = &tmp_connect_info[3]; + tmp_share->tgt_usernames = &tmp_connect_info[4]; + tmp_share->tgt_passwords = &tmp_connect_info[5]; + tmp_share->tgt_sockets = &tmp_connect_info[6]; + tmp_share->tgt_wrappers = &tmp_connect_info[7]; + tmp_share->tgt_ssl_cas = &tmp_connect_info[8]; + tmp_share->tgt_ssl_capaths = &tmp_connect_info[9]; + tmp_share->tgt_ssl_certs = &tmp_connect_info[10]; + tmp_share->tgt_ssl_ciphers = &tmp_connect_info[11]; + tmp_share->tgt_ssl_keys = &tmp_connect_info[12]; + tmp_share->tgt_default_files = &tmp_connect_info[13]; + tmp_share->tgt_default_groups = &tmp_connect_info[14]; + tmp_share->tgt_dsns = &tmp_connect_info[15]; + tmp_share->tgt_pk_names = &tmp_connect_info[16]; + tmp_share->tgt_sequence_names = &tmp_connect_info[17]; + tmp_share->static_link_ids = &tmp_connect_info[18]; +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + tmp_share->hs_read_socks = &tmp_connect_info[19]; + tmp_share->hs_write_socks = &tmp_connect_info[20]; +#endif + tmp_share->tgt_ports = &tmp_long[0]; + tmp_share->tgt_ssl_vscs = &tmp_long[1]; + tmp_share->link_statuses = &tmp_long[2]; + tmp_share->monitoring_binlog_pos_at_failing = &tmp_long[3]; + tmp_share->monitoring_flag = &tmp_long[4]; + tmp_share->monitoring_kind = &tmp_long[5]; +#ifndef WITHOUT_SPIDER_BG_SEARCH + tmp_share->monitoring_bg_flag = &tmp_long[6]; + tmp_share->monitoring_bg_kind = &tmp_long[7]; +#endif +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + tmp_share->use_hs_reads = &tmp_long[8]; + tmp_share->use_hs_writes = &tmp_long[9]; + tmp_share->hs_read_ports = &tmp_long[10]; + tmp_share->hs_write_ports = &tmp_long[11]; + tmp_share->hs_write_to_reads = &tmp_long[12]; +#endif + tmp_share->use_handlers = &tmp_long[13]; + tmp_share->connect_timeouts = &tmp_long[14]; + tmp_long[13] = -1; + tmp_share->net_read_timeouts = &tmp_long[15]; + tmp_long[14] = -1; + tmp_share->net_write_timeouts = &tmp_long[16]; + tmp_long[15] = -1; + tmp_share->access_balances = &tmp_long[17]; + tmp_share->bka_table_name_types = &tmp_long[18]; + tmp_share->strict_group_bys = &tmp_long[19]; + tmp_share->monitoring_limit = &tmp_longlong[0]; + tmp_share->monitoring_sid = &tmp_longlong[1]; +#ifndef WITHOUT_SPIDER_BG_SEARCH + tmp_share->monitoring_bg_interval = &tmp_longlong[2]; +#endif + tmp_share->server_names_lengths = &tmp_connect_info_length[0]; + tmp_share->tgt_table_names_lengths = &tmp_connect_info_length[1]; + tmp_share->tgt_dbs_lengths = &tmp_connect_info_length[2]; + tmp_share->tgt_hosts_lengths = &tmp_connect_info_length[3]; + tmp_share->tgt_usernames_lengths = &tmp_connect_info_length[4]; + tmp_share->tgt_passwords_lengths = &tmp_connect_info_length[5]; + tmp_share->tgt_sockets_lengths = &tmp_connect_info_length[6]; + tmp_share->tgt_wrappers_lengths = &tmp_connect_info_length[7]; + tmp_share->tgt_ssl_cas_lengths = &tmp_connect_info_length[8]; + tmp_share->tgt_ssl_capaths_lengths = &tmp_connect_info_length[9]; + tmp_share->tgt_ssl_certs_lengths = &tmp_connect_info_length[10]; + tmp_share->tgt_ssl_ciphers_lengths = &tmp_connect_info_length[11]; + tmp_share->tgt_ssl_keys_lengths = &tmp_connect_info_length[12]; + tmp_share->tgt_default_files_lengths = &tmp_connect_info_length[13]; + tmp_share->tgt_default_groups_lengths = &tmp_connect_info_length[14]; + tmp_share->tgt_dsns_lengths = &tmp_connect_info_length[15]; + tmp_share->tgt_pk_names_lengths = &tmp_connect_info_length[16]; + tmp_share->tgt_sequence_names_lengths = &tmp_connect_info_length[17]; + tmp_share->static_link_ids_lengths = &tmp_connect_info_length[18]; +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + tmp_share->hs_read_socks_lengths = &tmp_connect_info_length[19]; + tmp_share->hs_write_socks_lengths = &tmp_connect_info_length[20]; +#endif + tmp_share->server_names_length = 1; + tmp_share->tgt_table_names_length = 1; + tmp_share->tgt_dbs_length = 1; + tmp_share->tgt_hosts_length = 1; + tmp_share->tgt_usernames_length = 1; + tmp_share->tgt_passwords_length = 1; + tmp_share->tgt_sockets_length = 1; + tmp_share->tgt_wrappers_length = 1; + tmp_share->tgt_ssl_cas_length = 1; + tmp_share->tgt_ssl_capaths_length = 1; + tmp_share->tgt_ssl_certs_length = 1; + tmp_share->tgt_ssl_ciphers_length = 1; + tmp_share->tgt_ssl_keys_length = 1; + tmp_share->tgt_default_files_length = 1; + tmp_share->tgt_default_groups_length = 1; + tmp_share->tgt_dsns_length = 1; + tmp_share->tgt_pk_names_length = 1; + tmp_share->tgt_sequence_names_length = 1; + tmp_share->static_link_ids_length = 1; + tmp_share->tgt_ports_length = 1; + tmp_share->tgt_ssl_vscs_length = 1; + tmp_share->link_statuses_length = 1; + tmp_share->monitoring_binlog_pos_at_failing_length = 1; + tmp_share->monitoring_flag_length = 1; + tmp_share->monitoring_kind_length = 1; +#ifndef WITHOUT_SPIDER_BG_SEARCH + tmp_share->monitoring_bg_flag_length = 1; + tmp_share->monitoring_bg_kind_length = 1; +#endif + tmp_share->monitoring_limit_length = 1; + tmp_share->monitoring_sid_length = 1; +#ifndef WITHOUT_SPIDER_BG_SEARCH + tmp_share->monitoring_bg_interval_length = 1; +#endif +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + tmp_share->hs_read_socks_length = 1; + tmp_share->hs_write_socks_length = 1; + tmp_share->use_hs_reads_length = 1; + tmp_share->use_hs_writes_length = 1; + tmp_share->hs_read_ports_length = 1; + tmp_share->hs_write_ports_length = 1; + tmp_share->hs_write_to_reads_length = 1; +#endif + tmp_share->use_handlers_length = 1; + tmp_share->connect_timeouts_length = 1; + tmp_share->net_read_timeouts_length = 1; + tmp_share->net_write_timeouts_length = 1; + tmp_share->access_balances_length = 1; + tmp_share->bka_table_name_types_length = 1; + tmp_share->strict_group_bys_length = 1; + +#ifndef WITHOUT_SPIDER_BG_SEARCH + tmp_share->monitoring_bg_flag[0] = -1; + tmp_share->monitoring_bg_kind[0] = -1; +#endif + tmp_share->monitoring_binlog_pos_at_failing[0] = -1; + tmp_share->monitoring_flag[0] = -1; + tmp_share->monitoring_kind[0] = -1; +#ifndef WITHOUT_SPIDER_BG_SEARCH + tmp_share->monitoring_bg_interval[0] = -1; +#endif + tmp_share->monitoring_limit[0] = -1; + tmp_share->monitoring_sid[0] = -1; + tmp_share->bka_engine = NULL; + tmp_share->use_dbton_count = 0; +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + tmp_share->use_hs_dbton_count = 0; +#endif + DBUG_VOID_RETURN; +} + +int spider_create_tmp_dbton_share( + SPIDER_SHARE *tmp_share +) { + int error_num; + uint dbton_id = tmp_share->use_dbton_ids[0]; + DBUG_ENTER("spider_create_tmp_dbton_share"); + if (!(tmp_share->dbton_share[dbton_id] = + spider_dbton[dbton_id].create_db_share(tmp_share))) + { + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + } + if ((error_num = tmp_share->dbton_share[dbton_id]->init())) + { + delete tmp_share->dbton_share[dbton_id]; + tmp_share->dbton_share[dbton_id] = NULL; + DBUG_RETURN(error_num); + } + DBUG_RETURN(0); +} + +void spider_free_tmp_dbton_share( + SPIDER_SHARE *tmp_share +) { + uint dbton_id = tmp_share->use_dbton_ids[0]; + DBUG_ENTER("spider_free_tmp_dbton_share"); + if (tmp_share->dbton_share[dbton_id]) + { + delete tmp_share->dbton_share[dbton_id]; + tmp_share->dbton_share[dbton_id] = NULL; + } + DBUG_VOID_RETURN; +} + +int spider_create_tmp_dbton_handler( + ha_spider *tmp_spider +) { + int error_num; + SPIDER_SHARE *tmp_share = tmp_spider->share; + uint dbton_id = tmp_share->use_dbton_ids[0]; + DBUG_ENTER("spider_create_tmp_dbton_handler"); + if (!(tmp_spider->dbton_handler[dbton_id] = + spider_dbton[dbton_id].create_db_handler(tmp_spider, + tmp_share->dbton_share[dbton_id]))) + { + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + } + if ((error_num = tmp_spider->dbton_handler[dbton_id]->init())) + { + delete tmp_spider->dbton_handler[dbton_id]; + tmp_spider->dbton_handler[dbton_id] = NULL; + DBUG_RETURN(error_num); + } + DBUG_RETURN(0); +} + +void spider_free_tmp_dbton_handler( + ha_spider *tmp_spider +) { + SPIDER_SHARE *tmp_share = tmp_spider->share; + uint dbton_id = tmp_share->use_dbton_ids[0]; + DBUG_ENTER("spider_create_tmp_dbton_handler"); + if (tmp_spider->dbton_handler[dbton_id]) + { + delete tmp_spider->dbton_handler[dbton_id]; + tmp_spider->dbton_handler[dbton_id] = NULL; + } + DBUG_VOID_RETURN; +} + +TABLE_LIST *spider_get_parent_table_list( + ha_spider *spider +) { + TABLE *table = spider->get_table(); + DBUG_ENTER("spider_get_parent_table_list"); + DBUG_RETURN(table->pos_in_table_list); +} + +List<Index_hint> *spider_get_index_hints( + ha_spider *spider + ) { + TABLE_LIST *table_list = spider_get_parent_table_list(spider); + DBUG_ENTER("spider_get_index_hint"); + if (table_list) + { + DBUG_RETURN(table_list->index_hints); + } + DBUG_RETURN(NULL); +} + + +st_select_lex *spider_get_select_lex( + ha_spider *spider +) { + TABLE_LIST *table_list = spider_get_parent_table_list(spider); + DBUG_ENTER("spider_get_select_lex"); + if (table_list) + { + DBUG_RETURN(table_list->select_lex); + } + DBUG_RETURN(NULL); +} + +void spider_get_select_limit_from_select_lex( + st_select_lex *select_lex, + longlong *select_limit, + longlong *offset_limit +) { + DBUG_ENTER("spider_get_select_limit_from_select_lex"); + *select_limit = 9223372036854775807LL; + *offset_limit = 0; + if (select_lex && select_lex->explicit_limit) + { + *select_limit = select_lex->select_limit ? + select_lex->select_limit->val_int() : 0; + *offset_limit = select_lex->offset_limit ? + select_lex->offset_limit->val_int() : 0; + } + DBUG_VOID_RETURN; +} + +void spider_get_select_limit( + ha_spider *spider, + st_select_lex **select_lex, + longlong *select_limit, + longlong *offset_limit +) { + DBUG_ENTER("spider_get_select_limit"); + *select_lex = spider_get_select_lex(spider); + spider_get_select_limit_from_select_lex( + *select_lex, select_limit, offset_limit); + DBUG_VOID_RETURN; +} + +longlong spider_split_read_param( + ha_spider *spider +) { + SPIDER_SHARE *share = spider->share; + SPIDER_RESULT_LIST *result_list = &spider->result_list; + THD *thd = spider->wide_handler->trx->thd; + st_select_lex *select_lex; + longlong select_limit; + longlong offset_limit; + double semi_split_read; + longlong split_read; + DBUG_ENTER("spider_split_read_param"); + result_list->set_split_read_count = 1; +#ifdef INFO_KIND_FORCE_LIMIT_BEGIN + if (spider->wide_handler->info_limit < 9223372036854775807LL) + { + DBUG_PRINT("info",("spider info_limit=%lld", + spider->wide_handler->info_limit)); + longlong info_limit = spider->wide_handler->info_limit; + result_list->split_read_base = info_limit; + result_list->semi_split_read = 0; + result_list->first_read = info_limit; + result_list->second_read = info_limit; + result_list->semi_split_read_base = 0; + result_list->set_split_read = FALSE; + DBUG_RETURN(info_limit); + } +#endif + if (spider->sql_kinds & SPIDER_SQL_KIND_HANDLER) + { + DBUG_RETURN(result_list->semi_split_read_base); + } + spider_get_select_limit(spider, &select_lex, &select_limit, &offset_limit); + DBUG_PRINT("info",("spider result_list->set_split_read=%s", result_list->set_split_read ? "TRUE" : "FALSE")); + if (!result_list->set_split_read) + { + int bulk_update_mode = spider_param_bulk_update_mode(thd, + share->bulk_update_mode); + DBUG_PRINT("info",("spider sql_command=%u", + spider->wide_handler->sql_command)); + DBUG_PRINT("info",("spider bulk_update_mode=%d", bulk_update_mode)); + DBUG_PRINT("info",("spider support_bulk_update_sql=%s", + spider->support_bulk_update_sql() ? "TRUE" : "FALSE")); +#ifdef SPIDER_HAS_GROUP_BY_HANDLER + bool inserting = + ( +#ifdef HS_HAS_SQLCOM + spider->wide_handler->sql_command == SQLCOM_HS_INSERT || +#endif + spider->wide_handler->sql_command == SQLCOM_INSERT || + spider->wide_handler->sql_command == SQLCOM_INSERT_SELECT + ); +#endif + bool updating = + ( +#ifdef HS_HAS_SQLCOM + spider->wide_handler->sql_command == SQLCOM_HS_UPDATE || +#endif + spider->wide_handler->sql_command == SQLCOM_UPDATE || + spider->wide_handler->sql_command == SQLCOM_UPDATE_MULTI + ); + bool deleting = + ( +#ifdef HS_HAS_SQLCOM + spider->wide_handler->sql_command == SQLCOM_HS_DELETE || +#endif + spider->wide_handler->sql_command == SQLCOM_DELETE || + spider->wide_handler->sql_command == SQLCOM_DELETE_MULTI + ); + bool replacing = + ( + spider->wide_handler->sql_command == SQLCOM_REPLACE || + spider->wide_handler->sql_command == SQLCOM_REPLACE_SELECT + ); + DBUG_PRINT("info",("spider updating=%s", updating ? "TRUE" : "FALSE")); + DBUG_PRINT("info",("spider deleting=%s", deleting ? "TRUE" : "FALSE")); + DBUG_PRINT("info",("spider replacing=%s", replacing ? "TRUE" : "FALSE")); + TABLE *table = spider->get_table(); + if ( +#ifdef SPIDER_HAS_GROUP_BY_HANDLER + ( + inserting && + spider->use_fields + ) || +#endif + replacing || + ( + ( + updating || + deleting + ) && + ( + bulk_update_mode != 2 || + !spider->support_bulk_update_sql() || + ( + updating && + table->triggers && +#ifdef HA_CAN_FORCE_BULK_UPDATE + !(table->file->ha_table_flags() & HA_CAN_FORCE_BULK_UPDATE) && +#endif + table->triggers->has_triggers(TRG_EVENT_UPDATE, TRG_ACTION_AFTER) + ) || + ( + deleting && + table->triggers && +#ifdef HA_CAN_FORCE_BULK_DELETE + !(table->file->ha_table_flags() & HA_CAN_FORCE_BULK_DELETE) && +#endif + table->triggers->has_triggers(TRG_EVENT_DELETE, TRG_ACTION_AFTER) + ) + ) + ) + ) { + /* This case must select by one shot */ + DBUG_PRINT("info",("spider cancel split read")); + result_list->split_read_base = 9223372036854775807LL; + result_list->semi_split_read = 0; + result_list->semi_split_read_limit = 9223372036854775807LL; + result_list->first_read = 9223372036854775807LL; + result_list->second_read = 9223372036854775807LL; + result_list->semi_split_read_base = 0; + result_list->set_split_read = TRUE; + DBUG_RETURN(9223372036854775807LL); + } +#ifdef SPIDER_HAS_EXPLAIN_QUERY + Explain_query *explain = thd->lex->explain; + bool filesort = FALSE; + if (explain) + { + DBUG_PRINT("info",("spider explain=%p", explain)); + Explain_select *explain_select = NULL; + if (select_lex) + { + DBUG_PRINT("info",("spider select_lex=%p", select_lex)); + DBUG_PRINT("info",("spider select_number=%u", + select_lex->select_number)); + explain_select = + explain->get_select(select_lex->select_number); + } + if (explain_select) + { + DBUG_PRINT("info",("spider explain_select=%p", explain_select)); + if (explain_select->using_filesort) + { + DBUG_PRINT("info",("spider using filesort")); + filesort = TRUE; + } + } + } +#endif + result_list->split_read_base = + spider_param_split_read(thd, share->split_read); +#ifdef SPIDER_HAS_EXPLAIN_QUERY + if (filesort) + { + result_list->semi_split_read = 0; + result_list->semi_split_read_limit = 9223372036854775807LL; + } else { +#endif + result_list->semi_split_read = + spider_param_semi_split_read(thd, share->semi_split_read); + result_list->semi_split_read_limit = + spider_param_semi_split_read_limit(thd, share->semi_split_read_limit); +#ifdef SPIDER_HAS_EXPLAIN_QUERY + } +#endif + result_list->first_read = + spider_param_first_read(thd, share->first_read); + result_list->second_read = + spider_param_second_read(thd, share->second_read); + result_list->semi_split_read_base = 0; + result_list->set_split_read = TRUE; + } + DBUG_PRINT("info",("spider result_list->semi_split_read=%f", result_list->semi_split_read)); + DBUG_PRINT("info",("spider select_lex->explicit_limit=%d", select_lex ? select_lex->explicit_limit : 0)); + DBUG_PRINT("info",("spider OPTION_FOUND_ROWS=%s", select_lex && (select_lex->options & OPTION_FOUND_ROWS) ? "TRUE" : "FALSE")); + DBUG_PRINT("info",("spider select_lex->group_list.elements=%u", select_lex ? select_lex->group_list.elements : 0)); + DBUG_PRINT("info",("spider select_lex->with_sum_func=%s", select_lex && select_lex->with_sum_func ? "TRUE" : "FALSE")); + if ( + result_list->semi_split_read > 0 && + select_lex && select_lex->explicit_limit && + !(select_lex->options & OPTION_FOUND_ROWS) && + !select_lex->group_list.elements && + !select_lex->with_sum_func + ) { + semi_split_read = result_list->semi_split_read * + (select_limit + offset_limit); + DBUG_PRINT("info",("spider semi_split_read=%f", semi_split_read)); + if (semi_split_read >= result_list->semi_split_read_limit) + { + result_list->semi_split_read_base = result_list->semi_split_read_limit; + DBUG_RETURN(result_list->semi_split_read_limit); + } else { + split_read = (longlong) semi_split_read; + if (split_read < 0) + { + result_list->semi_split_read_base = result_list->semi_split_read_limit; + DBUG_RETURN(result_list->semi_split_read_limit); + } else if (split_read == 0) + { + result_list->semi_split_read_base = 1; + DBUG_RETURN(1); + } else { + result_list->semi_split_read_base = split_read; + DBUG_RETURN(split_read); + } + } + } else if (result_list->first_read > 0) + DBUG_RETURN(result_list->first_read); + DBUG_RETURN(result_list->split_read_base); +} + +longlong spider_bg_split_read_param( + ha_spider *spider +) { + SPIDER_RESULT_LIST *result_list = &spider->result_list; + DBUG_ENTER("spider_bg_split_read_param"); + if (result_list->semi_split_read_base) + DBUG_RETURN(result_list->semi_split_read_base); + DBUG_RETURN(result_list->split_read_base); +} + +void spider_first_split_read_param( + ha_spider *spider +) { + SPIDER_RESULT_LIST *result_list = &spider->result_list; + DBUG_ENTER("spider_first_split_read_param"); + if (result_list->semi_split_read_base) + result_list->split_read = result_list->semi_split_read_base; + else if (result_list->second_read > 0) + result_list->split_read = result_list->first_read; + else + result_list->split_read = result_list->split_read_base; + result_list->set_split_read_count = 1; + DBUG_VOID_RETURN; +} + +void spider_next_split_read_param( + ha_spider *spider +) { + SPIDER_RESULT_LIST *result_list = &spider->result_list; + DBUG_ENTER("spider_next_split_read_param"); + if (result_list->semi_split_read_base) + result_list->split_read = result_list->semi_split_read_base; + else if ( + result_list->set_split_read_count == 1 && + result_list->second_read > 0 + ) + result_list->split_read = result_list->second_read; + else + result_list->split_read = result_list->split_read_base; + result_list->set_split_read_count++; + DBUG_VOID_RETURN; +} + +bool spider_check_direct_order_limit( + ha_spider *spider +) { + THD *thd = spider->wide_handler->trx->thd; + SPIDER_SHARE *share = spider->share; + st_select_lex *select_lex; + longlong select_limit; + longlong offset_limit; + DBUG_ENTER("spider_check_direct_order_limit"); + if (spider_check_index_merge(spider->get_table(), + spider_get_select_lex(spider))) + { + DBUG_PRINT("info",("spider set use_index_merge")); + spider->use_index_merge = TRUE; + } + DBUG_PRINT("info",("spider SQLCOM_HA_READ=%s", + (spider->wide_handler->sql_command == SQLCOM_HA_READ) ? "TRUE" : "FALSE")); + DBUG_PRINT("info",("spider sql_kinds with SPIDER_SQL_KIND_HANDLER=%s", + (spider->sql_kinds & SPIDER_SQL_KIND_HANDLER) ? "TRUE" : "FALSE")); + DBUG_PRINT("info",("spider use_index_merge=%s", + spider->use_index_merge ? "TRUE" : "FALSE")); + DBUG_PRINT("info",("spider is_clone=%s", + spider->is_clone ? "TRUE" : "FALSE")); +#ifdef HA_CAN_BULK_ACCESS + DBUG_PRINT("info",("spider is_bulk_access_clone=%s", + spider->is_bulk_access_clone ? "TRUE" : "FALSE")); +#endif + if ( + spider->wide_handler->sql_command != SQLCOM_HA_READ && + !spider->use_index_merge && +#ifdef HA_CAN_BULK_ACCESS + (!spider->is_clone || spider->is_bulk_access_clone) +#else + !spider->is_clone +#endif + ) { + spider_get_select_limit(spider, &select_lex, &select_limit, &offset_limit); + bool first_check = TRUE; + DBUG_PRINT("info",("spider select_lex=%p", select_lex)); +#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000 + DBUG_PRINT("info",("spider leaf_tables.elements=%u", + select_lex ? select_lex->leaf_tables.elements : 0)); +#endif + + if (select_lex && (select_lex->options & SELECT_DISTINCT)) + { + DBUG_PRINT("info",("spider with distinct")); + spider->result_list.direct_distinct = TRUE; + } +#ifdef HANDLER_HAS_DIRECT_AGGREGATE + spider->result_list.direct_aggregate = TRUE; +#endif + DBUG_PRINT("info",("spider select_limit=%lld", select_limit)); + DBUG_PRINT("info",("spider offset_limit=%lld", offset_limit)); + if ( +#if MYSQL_VERSION_ID < 50500 + !thd->variables.engine_condition_pushdown || +#else +#ifdef SPIDER_ENGINE_CONDITION_PUSHDOWN_IS_ALWAYS_ON +#else + !(thd->variables.optimizer_switch & + OPTIMIZER_SWITCH_ENGINE_CONDITION_PUSHDOWN) || +#endif +#endif +#ifdef SPIDER_NEED_CHECK_CONDITION_AT_CHECKING_DIRECT_ORDER_LIMIT + !spider->condition || +#endif + !select_lex || +#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000 + select_lex->leaf_tables.elements != 1 || +#endif + select_lex->table_list.elements != 1 + ) { + DBUG_PRINT("info",("spider first_check is FALSE")); + first_check = FALSE; + spider->result_list.direct_distinct = FALSE; +#ifdef HANDLER_HAS_DIRECT_AGGREGATE + spider->result_list.direct_aggregate = FALSE; +#endif + } else if (spider_db_append_condition(spider, NULL, 0, TRUE)) + { + DBUG_PRINT("info",("spider FALSE by condition")); + first_check = FALSE; + spider->result_list.direct_distinct = FALSE; +#ifdef HANDLER_HAS_DIRECT_AGGREGATE + spider->result_list.direct_aggregate = FALSE; +#endif + } else if (spider->sql_kinds & SPIDER_SQL_KIND_HANDLER) + { + DBUG_PRINT("info",("spider sql_kinds with SPIDER_SQL_KIND_HANDLER")); + spider->result_list.direct_distinct = FALSE; +#ifdef HANDLER_HAS_DIRECT_AGGREGATE + spider->result_list.direct_aggregate = FALSE; + } else if ( + !select_lex->group_list.elements && + !select_lex->with_sum_func + ) { + DBUG_PRINT("info",("spider this SQL is not aggregate SQL")); + spider->result_list.direct_aggregate = FALSE; + } else { + ORDER *group; + for (group = (ORDER *) select_lex->group_list.first; group; + group = group->next) + { + if (spider->print_item_type((*group->item), NULL, NULL, 0)) + { + DBUG_PRINT("info",("spider aggregate FALSE by group")); + spider->result_list.direct_aggregate = FALSE; + break; + } + } + JOIN *join = select_lex->join; + Item_sum **item_sum_ptr; + for (item_sum_ptr = join->sum_funcs; *item_sum_ptr; ++item_sum_ptr) + { + if (spider->print_item_type(*item_sum_ptr, NULL, NULL, 0)) + { + DBUG_PRINT("info",("spider aggregate FALSE by not supported")); + spider->result_list.direct_aggregate = FALSE; + break; + } + } + if (!spider_all_part_in_order((ORDER *) select_lex->group_list.first, + spider->get_table())) + { + DBUG_PRINT("info",("spider FALSE by group condition")); + first_check = FALSE; + spider->result_list.direct_distinct = FALSE; + } +#endif + } + + longlong direct_order_limit = spider_param_direct_order_limit(thd, + share->direct_order_limit); + DBUG_PRINT("info",("spider direct_order_limit=%lld", direct_order_limit)); + if (direct_order_limit) + { + DBUG_PRINT("info",("spider first_check=%s", + first_check ? "TRUE" : "FALSE")); + DBUG_PRINT("info",("spider (select_lex->options & OPTION_FOUND_ROWS)=%s", + select_lex && (select_lex->options & OPTION_FOUND_ROWS) ? "TRUE" : "FALSE")); +#ifdef HANDLER_HAS_DIRECT_AGGREGATE + DBUG_PRINT("info",("spider direct_aggregate=%s", + spider->result_list.direct_aggregate ? "TRUE" : "FALSE")); +#endif + DBUG_PRINT("info",("spider select_lex->group_list.elements=%u", + select_lex ? select_lex->group_list.elements : 0)); + DBUG_PRINT("info",("spider select_lex->with_sum_func=%s", + select_lex && select_lex->with_sum_func ? "TRUE" : "FALSE")); + DBUG_PRINT("info",("spider select_lex->having=%s", + select_lex && select_lex->having ? "TRUE" : "FALSE")); + DBUG_PRINT("info",("spider select_lex->order_list.elements=%u", + select_lex ? select_lex->order_list.elements : 0)); + if ( + !first_check || + !select_lex->explicit_limit || + (select_lex->options & OPTION_FOUND_ROWS) || + ( +#ifdef HANDLER_HAS_DIRECT_AGGREGATE + !spider->result_list.direct_aggregate && +#endif + ( + select_lex->group_list.elements || + select_lex->with_sum_func + ) + ) || + select_lex->having || + !select_lex->order_list.elements || + select_limit > direct_order_limit - offset_limit + ) { + DBUG_PRINT("info",("spider FALSE by select_lex")); + DBUG_RETURN(FALSE); + } + ORDER *order; + for (order = (ORDER *) select_lex->order_list.first; order; + order = order->next) + { + if (spider->print_item_type((*order->item), NULL, NULL, 0)) + { + DBUG_PRINT("info",("spider FALSE by order")); + DBUG_RETURN(FALSE); + } + } + DBUG_PRINT("info",("spider TRUE")); + spider->result_list.internal_limit = select_limit + offset_limit; + spider->result_list.split_read = select_limit + offset_limit; + spider->wide_handler->trx->direct_order_limit_count++; + DBUG_RETURN(TRUE); + } + } + DBUG_PRINT("info",("spider FALSE by parameter")); + DBUG_RETURN(FALSE); +} + +#ifdef HANDLER_HAS_DIRECT_AGGREGATE +bool spider_all_part_in_order( + ORDER *order, + TABLE *table +) { + TABLE_LIST *parent; + partition_info *part_info; + Field **part_fields; + ORDER *ptr; + Item *item; + Item_field *item_field; + DBUG_ENTER("spider_all_part_in_order"); + while (TRUE) + { + DBUG_PRINT("info", ("spider table_name = %s", table->s->db.str)); + DBUG_PRINT("info",("spider part_info=%p", table->part_info)); + if ((part_info = table->part_info)) + { + for (part_fields = part_info->full_part_field_array; + *part_fields; ++part_fields) + { + DBUG_PRINT("info", ("spider part_field = %s", + SPIDER_field_name_str(*part_fields))); + for (ptr = order; ptr; ptr = ptr->next) + { + item = *ptr->item; + if (item->type() != Item::FIELD_ITEM) + { + continue; + } + item_field = (Item_field *) item; + Field *field = item_field->field; + if (!field) + { + continue; + } + DBUG_PRINT("info", ("spider field_name = %s.%s", + field->table->s->db.str, SPIDER_field_name_str(field))); + if (*part_fields == spider_field_exchange(table->file, field)) + { + break; + } + } + if (!ptr) + { + DBUG_RETURN(FALSE); + } + } + } + if (!(parent = table->pos_in_table_list->parent_l)) + { + break; + } + table = parent->table; + } + DBUG_RETURN(TRUE); +} + +Field *spider_field_exchange( + handler *handler, + Field *field +) { + DBUG_ENTER("spider_field_exchange"); +#ifdef HA_CAN_BULK_ACCESS + if (handler->is_bulk_access_clone) + { + handler = handler->pt_clone_source_handler; + } +#endif + DBUG_PRINT("info",("spider in field=%p", field)); + DBUG_PRINT("info",("spider in field->table=%p", field->table)); + DBUG_PRINT("info",("spider table=%p", handler->get_table())); + if (field->table != handler->get_table()) + DBUG_RETURN(NULL); + DBUG_PRINT("info",("spider out field=%p", field)); + DBUG_RETURN(field); +} +#endif + +int spider_set_direct_limit_offset( + ha_spider *spider +) { +#ifndef SPIDER_ENGINE_CONDITION_PUSHDOWN_IS_ALWAYS_ON + THD *thd = spider->wide_handler->trx->thd; +#endif + st_select_lex *select_lex; + longlong select_limit; + longlong offset_limit; + TABLE_LIST *table_list; + DBUG_ENTER("spider_set_direct_limit_offset"); + + if (spider->result_list.direct_limit_offset) + DBUG_RETURN(TRUE); + + if ( + spider->partition_handler_share && + !spider->pt_handler_share_owner + ) { + if (spider->partition_handler_share->owner-> + result_list.direct_limit_offset == TRUE) + { + spider->result_list.direct_limit_offset = TRUE; + DBUG_RETURN(TRUE); + } else { + DBUG_RETURN(FALSE); + } + } + + if ( + spider->wide_handler->sql_command != SQLCOM_SELECT || +#ifdef HANDLER_HAS_DIRECT_AGGREGATE + spider->result_list.direct_aggregate || +#endif + spider->result_list.direct_order_limit || + spider->prev_index_rnd_init != SPD_RND // must be RND_INIT and not be INDEX_INIT + ) + DBUG_RETURN(FALSE); + + spider_get_select_limit(spider, &select_lex, &select_limit, &offset_limit); + + // limit and offset is non-zero + if (!(select_limit && offset_limit)) + DBUG_RETURN(FALSE); + + // more than one table + if ( + !select_lex || + select_lex->table_list.elements != 1 + ) + DBUG_RETURN(FALSE); + + table_list = (TABLE_LIST *) select_lex->table_list.first; + if (table_list->table->file->partition_ht() != spider_hton_ptr) + { + DBUG_PRINT("info",("spider ht1=%u ht2=%u", + table_list->table->file->partition_ht()->slot, + spider_hton_ptr->slot + )); + DBUG_RETURN(FALSE); + } + + // contain where + if ( +#if MYSQL_VERSION_ID < 50500 + !thd->variables.engine_condition_pushdown || +#else +#ifdef SPIDER_ENGINE_CONDITION_PUSHDOWN_IS_ALWAYS_ON +#else + !(thd->variables.optimizer_switch & + OPTIMIZER_SWITCH_ENGINE_CONDITION_PUSHDOWN) || +#endif +#endif + // conditions is null may be no where condition in rand_init + spider->wide_handler->condition + ) + DBUG_RETURN(FALSE); + + // ignore condition like 1=1 +#ifdef SPIDER_has_Item_with_subquery + if (select_lex->where && select_lex->where->with_subquery()) +#else + if (select_lex->where && select_lex->where->with_subselect) +#endif + DBUG_RETURN(FALSE); + + if ( + select_lex->group_list.elements || + select_lex->with_sum_func || + select_lex->having || + select_lex->order_list.elements + ) + DBUG_RETURN(FALSE); + + // must not be derived table + if (SPIDER_get_linkage(select_lex) == DERIVED_TABLE_TYPE) + DBUG_RETURN(FALSE); + + spider->direct_select_offset = offset_limit; + spider->direct_current_offset = offset_limit; + spider->direct_select_limit = select_limit; + spider->result_list.direct_limit_offset = TRUE; + DBUG_RETURN(TRUE); +} + + +bool spider_check_index_merge( + TABLE *table, + st_select_lex *select_lex +) { + uint roop_count; + JOIN *join; + DBUG_ENTER("spider_check_index_merge"); + if (!select_lex) + { + DBUG_PRINT("info",("spider select_lex is null")); + DBUG_RETURN(FALSE); + } + join = select_lex->join; + if (!join) + { + DBUG_PRINT("info",("spider join is null")); + DBUG_RETURN(FALSE); + } + if (!join->join_tab) + { + DBUG_PRINT("info",("spider join->join_tab is null")); + DBUG_RETURN(FALSE); + } + for (roop_count = 0; roop_count < spider_join_table_count(join); ++roop_count) + { + JOIN_TAB *join_tab = &join->join_tab[roop_count]; + if (join_tab->table == table) + { + DBUG_PRINT("info",("spider join_tab->type=%u", join_tab->type)); + if ( +#ifdef SPIDER_HAS_JT_HASH_INDEX_MERGE + join_tab->type == JT_HASH_INDEX_MERGE || +#endif + join_tab->type == JT_INDEX_MERGE + ) { + DBUG_RETURN(TRUE); + } +/* + DBUG_PRINT("info",("spider join_tab->quick->get_type()=%u", + join_tab->quick ? join_tab->quick->get_type() : 0)); + if ( + join_tab->quick && + join_tab->quick->get_type() == QUICK_SELECT_I::QS_TYPE_INDEX_MERGE + ) { + DBUG_RETURN(TRUE); + } +*/ + DBUG_PRINT("info",("spider join_tab->select->quick->get_type()=%u", + join_tab->select && join_tab->select->quick ? join_tab->select->quick->get_type() : 0)); + if ( + join_tab->select && + join_tab->select->quick && + join_tab->select->quick->get_type() == QUICK_SELECT_I::QS_TYPE_INDEX_MERGE + ) { + DBUG_RETURN(TRUE); + } + break; + } + } + DBUG_RETURN(FALSE); +} + +int spider_compare_for_sort( + SPIDER_SORT *a, + SPIDER_SORT *b +) { + DBUG_ENTER("spider_compare_for_sort"); + if (a->sort > b->sort) + DBUG_RETURN(-1); + if (a->sort < b->sort) + DBUG_RETURN(1); + DBUG_RETURN(0); +} + +ulong spider_calc_for_sort( + uint count, + ... +) { + ulong sort = 0; + va_list args; + va_start(args, count); + DBUG_ENTER("spider_calc_for_sort"); + while (count--) + { + char *start = va_arg(args, char *), *str; + uint wild_pos = 0; + + if ((str = start)) + { + wild_pos = 128; + for (; *str; str++) + { + if (*str == spider_wild_prefix && str[1]) + str++; + else if (*str == spider_wild_many || *str == spider_wild_one) + { + wild_pos = (uint) (str - start) + 1; + if (wild_pos > 127) + wild_pos = 127; + break; + } + } + } + sort = (sort << 8) + wild_pos; + } + va_end(args); + DBUG_RETURN(sort); +} + +double spider_rand( + uint32 rand_source +) { +#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000 + struct my_rnd_struct rand; +#else + struct rand_struct rand; +#endif + DBUG_ENTER("spider_rand"); + /* generate same as rand function for applications */ +#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000 + my_rnd_init(&rand, (uint32) (rand_source * 65537L + 55555555L), + (uint32) (rand_source * 268435457L)); +#else + randominit(&rand, (uint32) (rand_source * 65537L + 55555555L), + (uint32) (rand_source * 268435457L)); +#endif + DBUG_RETURN(my_rnd(&rand)); +} + +#ifdef SPIDER_HAS_DISCOVER_TABLE_STRUCTURE +int spider_discover_table_structure_internal( + SPIDER_TRX *trx, + SPIDER_SHARE *spider_share, + spider_string *str +) { + int error_num = 0, roop_count; + DBUG_ENTER("spider_discover_table_structure_internal"); + for (roop_count = 0; roop_count < SPIDER_DBTON_SIZE; roop_count++) + { + if (spider_bit_is_set(spider_share->dbton_bitmap, roop_count)) + { + if ((error_num = spider_share->dbton_share[roop_count]-> + discover_table_structure(trx, spider_share, str))) + { + continue; + } + break; + } + } + DBUG_RETURN(error_num); +} + +int spider_discover_table_structure( + handlerton *hton, + THD* thd, + TABLE_SHARE *share, + HA_CREATE_INFO *info +) { + int error_num = HA_ERR_WRONG_COMMAND, dummy; + SPIDER_SHARE *spider_share; + const char *table_name = share->path.str; + uint table_name_length = (uint) strlen(table_name); + SPIDER_TRX *trx; +#ifdef WITH_PARTITION_STORAGE_ENGINE + partition_info *part_info = thd->work_part_info; +#endif + SPIDER_Open_tables_backup open_tables_backup; + TABLE *table_tables; +#ifdef WITH_PARTITION_STORAGE_ENGINE + uint str_len; +#endif + char buf[MAX_FIELD_WIDTH]; + spider_string str(buf, sizeof(buf), system_charset_info); + DBUG_ENTER("spider_discover_table_structure"); + str.init_calc_mem(229); + str.length(0); + if (str.reserve( + SPIDER_SQL_CREATE_TABLE_LEN + share->db.length + + SPIDER_SQL_DOT_LEN + share->table_name.length + + /* SPIDER_SQL_LCL_NAME_QUOTE_LEN */ 4 + SPIDER_SQL_OPEN_PAREN_LEN + )) { + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + } + str.q_append(SPIDER_SQL_CREATE_TABLE_STR, SPIDER_SQL_CREATE_TABLE_LEN); + str.q_append(SPIDER_SQL_LCL_NAME_QUOTE_STR, SPIDER_SQL_LCL_NAME_QUOTE_LEN); + str.q_append(share->db.str, share->db.length); + str.q_append(SPIDER_SQL_LCL_NAME_QUOTE_STR, SPIDER_SQL_LCL_NAME_QUOTE_LEN); + str.q_append(SPIDER_SQL_DOT_STR, SPIDER_SQL_DOT_LEN); + str.q_append(SPIDER_SQL_LCL_NAME_QUOTE_STR, SPIDER_SQL_LCL_NAME_QUOTE_LEN); + str.q_append(share->table_name.str, share->table_name.length); + str.q_append(SPIDER_SQL_LCL_NAME_QUOTE_STR, SPIDER_SQL_LCL_NAME_QUOTE_LEN); + str.q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN); +#ifdef WITH_PARTITION_STORAGE_ENGINE + str_len = str.length(); +#endif +#ifdef SPIDER_HAS_HASH_VALUE_TYPE + my_hash_value_type hash_value = my_calc_hash(&spider_open_tables, + (uchar*) table_name, table_name_length); +#endif + if (!(trx = spider_get_trx(thd, TRUE, &error_num))) + { + DBUG_PRINT("info",("spider spider_get_trx error")); + my_error(error_num, MYF(0)); + DBUG_RETURN(error_num); + } + share->table_charset = info->default_table_charset; + share->comment = info->comment; +#ifdef WITH_PARTITION_STORAGE_ENGINE + if (!part_info) + { +#endif + if (!(spider_share = spider_create_share(table_name, share, +#ifdef WITH_PARTITION_STORAGE_ENGINE + NULL, +#endif +#ifdef SPIDER_HAS_HASH_VALUE_TYPE + hash_value, +#endif + &error_num + ))) { + DBUG_RETURN(error_num); + } + + error_num = spider_discover_table_structure_internal(trx, spider_share, &str); + + if (!error_num) + { + if ( + (table_tables = spider_open_sys_table( + thd, SPIDER_SYS_TABLES_TABLE_NAME_STR, + SPIDER_SYS_TABLES_TABLE_NAME_LEN, TRUE, &open_tables_backup, FALSE, + &error_num)) + ) { +#ifdef SPIDER_SUPPORT_CREATE_OR_REPLACE_TABLE + if (thd->lex->create_info.or_replace()) + { + error_num = spider_delete_tables(table_tables, + spider_share->table_name, &dummy); + } + if (!error_num) + { +#endif + error_num = spider_insert_tables(table_tables, spider_share); +#ifdef SPIDER_SUPPORT_CREATE_OR_REPLACE_TABLE + } +#endif + spider_close_sys_table(thd, table_tables, + &open_tables_backup, FALSE); + } + } + + spider_free_share_resource_only(spider_share); +#ifdef WITH_PARTITION_STORAGE_ENGINE + } else { + char tmp_name[FN_REFLEN + 1]; + List_iterator<partition_element> part_it(part_info->partitions); + List_iterator<partition_element> part_it2(part_info->partitions); + partition_element *part_elem, *sub_elem; + while ((part_elem = part_it++)) + { + if ((part_elem)->subpartitions.elements) + { + List_iterator<partition_element> sub_it((part_elem)->subpartitions); + while ((sub_elem = sub_it++)) + { + str.length(str_len); + if ((error_num = SPIDER_create_subpartition_name( + tmp_name, FN_REFLEN + 1, table_name, + (part_elem)->partition_name, (sub_elem)->partition_name, + NORMAL_PART_NAME))) + { + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + } + DBUG_PRINT("info",("spider tmp_name=%s", tmp_name)); + if (!(spider_share = spider_create_share(tmp_name, share, + part_info, +#ifdef SPIDER_HAS_HASH_VALUE_TYPE + hash_value, +#endif + &error_num + ))) { + DBUG_RETURN(error_num); + } + + error_num = spider_discover_table_structure_internal( + trx, spider_share, &str); + + spider_free_share_resource_only(spider_share); + if (!error_num) + break; + } + if (!error_num) + break; + } else { + str.length(str_len); + if ((error_num = SPIDER_create_partition_name( + tmp_name, FN_REFLEN + 1, table_name, + (part_elem)->partition_name, NORMAL_PART_NAME, TRUE))) + { + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + } + DBUG_PRINT("info",("spider tmp_name=%s", tmp_name)); + if (!(spider_share = spider_create_share(tmp_name, share, + part_info, +#ifdef SPIDER_HAS_HASH_VALUE_TYPE + hash_value, +#endif + &error_num + ))) { + DBUG_RETURN(error_num); + } + + error_num = spider_discover_table_structure_internal( + trx, spider_share, &str); + + spider_free_share_resource_only(spider_share); + if (!error_num) + break; + } + } + if (!error_num) + { + if ( + !(table_tables = spider_open_sys_table( + thd, SPIDER_SYS_TABLES_TABLE_NAME_STR, + SPIDER_SYS_TABLES_TABLE_NAME_LEN, TRUE, &open_tables_backup, FALSE, + &error_num)) + ) { + DBUG_RETURN(error_num); + } + while ((part_elem = part_it2++)) + { + if ((part_elem)->subpartitions.elements) + { + List_iterator<partition_element> sub_it((part_elem)->subpartitions); + while ((sub_elem = sub_it++)) + { + if ((error_num = SPIDER_create_subpartition_name( + tmp_name, FN_REFLEN + 1, table_name, + (part_elem)->partition_name, (sub_elem)->partition_name, + NORMAL_PART_NAME))) + { + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + } + DBUG_PRINT("info",("spider tmp_name=%s", tmp_name)); + if (!(spider_share = spider_create_share(tmp_name, share, + part_info, +#ifdef SPIDER_HAS_HASH_VALUE_TYPE + hash_value, +#endif + &error_num + ))) { + DBUG_RETURN(error_num); + } + +#ifdef SPIDER_SUPPORT_CREATE_OR_REPLACE_TABLE + if (thd->lex->create_info.or_replace()) + { + error_num = spider_delete_tables(table_tables, + spider_share->table_name, &dummy); + } + if (!error_num) + { +#endif + error_num = spider_insert_tables(table_tables, spider_share); +#ifdef SPIDER_SUPPORT_CREATE_OR_REPLACE_TABLE + } +#endif + + spider_free_share_resource_only(spider_share); + if (error_num) + break; + } + if (error_num) + break; + } else { + if ((error_num = SPIDER_create_partition_name( + tmp_name, FN_REFLEN + 1, table_name, + (part_elem)->partition_name, NORMAL_PART_NAME, TRUE))) + { + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + } + DBUG_PRINT("info",("spider tmp_name=%s", tmp_name)); + if (!(spider_share = spider_create_share(tmp_name, share, + part_info, +#ifdef SPIDER_HAS_HASH_VALUE_TYPE + hash_value, +#endif + &error_num + ))) { + DBUG_RETURN(error_num); + } + +#ifdef SPIDER_SUPPORT_CREATE_OR_REPLACE_TABLE + if (thd->lex->create_info.or_replace()) + { + error_num = spider_delete_tables(table_tables, + spider_share->table_name, &dummy); + } + if (!error_num) + { +#endif + error_num = spider_insert_tables(table_tables, spider_share); +#ifdef SPIDER_SUPPORT_CREATE_OR_REPLACE_TABLE + } +#endif + + spider_free_share_resource_only(spider_share); + if (error_num) + break; + } + } + spider_close_sys_table(thd, table_tables, + &open_tables_backup, FALSE); + } + } +#endif + + if (!error_num) + thd->clear_error(); + else + DBUG_RETURN(error_num); + + str.length(str.length() - SPIDER_SQL_COMMA_LEN); + CHARSET_INFO *table_charset; + if (share->table_charset) + { + table_charset = share->table_charset; + } else { + table_charset = system_charset_info; + } + uint csnamelen = strlen(table_charset->csname); + uint collatelen = strlen(table_charset->name); + if (str.reserve(SPIDER_SQL_CLOSE_PAREN_LEN + SPIDER_SQL_DEFAULT_CHARSET_LEN + + csnamelen + SPIDER_SQL_COLLATE_LEN + collatelen + + SPIDER_SQL_CONNECTION_LEN + SPIDER_SQL_VALUE_QUOTE_LEN + + (share->comment.length * 2) + )) { + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + } + str.q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN); + str.q_append(SPIDER_SQL_DEFAULT_CHARSET_STR, SPIDER_SQL_DEFAULT_CHARSET_LEN); + str.q_append(table_charset->csname, csnamelen); + str.q_append(SPIDER_SQL_COLLATE_STR, SPIDER_SQL_COLLATE_LEN); + str.q_append(table_charset->name, collatelen); + str.q_append(SPIDER_SQL_COMMENT_STR, SPIDER_SQL_COMMENT_LEN); + str.q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN); + str.append_escape_string(share->comment.str, share->comment.length); + if (str.reserve(SPIDER_SQL_CONNECTION_LEN + + (SPIDER_SQL_VALUE_QUOTE_LEN * 2) + + (share->connect_string.length * 2))) + { + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + } + str.q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN); + str.q_append(SPIDER_SQL_CONNECTION_STR, SPIDER_SQL_CONNECTION_LEN); + str.q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN); + str.append_escape_string(share->connect_string.str, + share->connect_string.length); + if (str.reserve(SPIDER_SQL_VALUE_QUOTE_LEN)) + { + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + } + str.q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN); +#ifdef WITH_PARTITION_STORAGE_ENGINE + DBUG_PRINT("info",("spider part_info=%p", part_info)); + if (part_info) + { + uint part_syntax_len; + char *part_syntax; + List_iterator<partition_element> part_it(part_info->partitions); + partition_element *part_elem, *sub_elem; + while ((part_elem = part_it++)) + { + part_elem->engine_type = hton; + if ((part_elem)->subpartitions.elements) + { + List_iterator<partition_element> sub_it((part_elem)->subpartitions); + while ((sub_elem = sub_it++)) + { + sub_elem->engine_type = hton; + } + } + } + if (part_info->fix_parser_data(thd)) + { + DBUG_RETURN(ER_SPIDER_UNKNOWN_NUM); + } + if (!(part_syntax = SPIDER_generate_partition_syntax(thd, part_info, + &part_syntax_len, FALSE, TRUE, info, NULL, NULL))) + { + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + } + if (str.reserve(part_syntax_len)) + { + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + } + str.q_append(part_syntax, part_syntax_len); + SPIDER_free_part_syntax(part_syntax, MYF(0)); + } +#endif + DBUG_PRINT("info",("spider str=%s", str.c_ptr_safe())); + + error_num = share->init_from_sql_statement_string(thd, TRUE, str.ptr(), + str.length()); + DBUG_RETURN(error_num); +} +#endif + +#ifndef WITHOUT_SPIDER_BG_SEARCH +int spider_create_spider_object_for_share( + SPIDER_TRX *trx, + SPIDER_SHARE *share, + ha_spider **spider +) { + int error_num, roop_count, *need_mons; + SPIDER_CONN **conns; + uint *conn_link_idx; + uchar *conn_can_fo; + char **conn_keys; +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + char **hs_r_conn_keys; + char **hs_w_conn_keys; +#endif + spider_db_handler **dbton_hdl; + SPIDER_WIDE_HANDLER *wide_handler; + DBUG_ENTER("spider_create_spider_object_for_share"); + DBUG_PRINT("info",("spider trx=%p", trx)); + DBUG_PRINT("info",("spider share=%p", share)); + DBUG_PRINT("info",("spider spider_ptr=%p", spider)); + DBUG_PRINT("info",("spider spider=%p", (*spider))); + + if (*spider) + { + /* already exists */ + DBUG_RETURN(0); + } + (*spider) = new (&share->mem_root) ha_spider(); + if (!(*spider)) + { + error_num = HA_ERR_OUT_OF_MEM; + goto error_spider_alloc; + } + DBUG_PRINT("info",("spider spider=%p", (*spider))); +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + if (!(need_mons = (int *) + spider_bulk_malloc(spider_current_trx, 255, MYF(MY_WME | MY_ZEROFILL), + &need_mons, (uint) (sizeof(int) * share->link_count), + &conns, (uint) (sizeof(SPIDER_CONN *) * share->link_count), + &conn_link_idx, (uint) (sizeof(uint) * share->link_count), + &conn_can_fo, (uint) (sizeof(uchar) * share->link_bitmap_size), + &conn_keys, (uint) (sizeof(char *) * share->link_count), + &hs_r_conn_keys, (uint) (sizeof(char *) * share->link_count), + &hs_w_conn_keys, (uint) (sizeof(char *) * share->link_count), + &dbton_hdl, (uint) (sizeof(spider_db_handler *) * SPIDER_DBTON_SIZE), + &wide_handler, (uint) sizeof(SPIDER_WIDE_HANDLER), + NullS)) + ) +#else + if (!(need_mons = (int *) + spider_bulk_malloc(spider_current_trx, 255, MYF(MY_WME | MY_ZEROFILL), + &need_mons, (uint) (sizeof(int) * share->link_count), + &conns, (uint) (sizeof(SPIDER_CONN *) * share->link_count), + &conn_link_idx, (uint) (sizeof(uint) * share->link_count), + &conn_can_fo, (uint) (sizeof(uchar) * share->link_bitmap_size), + &conn_keys, (uint) (sizeof(char *) * share->link_count), + &dbton_hdl, (uint) (sizeof(spider_db_handler *) * SPIDER_DBTON_SIZE), + &wide_handler, (uint) sizeof(SPIDER_WIDE_HANDLER), + NullS)) + ) +#endif + { + error_num = HA_ERR_OUT_OF_MEM; + goto error_need_mons_alloc; + } + DBUG_PRINT("info",("spider need_mons=%p", need_mons)); + (*spider)->wide_handler = wide_handler; + wide_handler->trx = trx; + (*spider)->change_table_ptr(&share->table, share->table_share); + (*spider)->share = share; + (*spider)->conns = conns; + (*spider)->conn_link_idx = conn_link_idx; + (*spider)->conn_can_fo = conn_can_fo; + (*spider)->need_mons = need_mons; + (*spider)->conn_keys_first_ptr = share->conn_keys[0]; + (*spider)->conn_keys = conn_keys; +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + (*spider)->hs_r_conn_keys = hs_r_conn_keys; + (*spider)->hs_w_conn_keys = hs_w_conn_keys; +#endif + (*spider)->dbton_handler = dbton_hdl; + (*spider)->search_link_idx = -1; + for (roop_count = 0; roop_count < SPIDER_DBTON_SIZE; roop_count++) + { + if ( + spider_bit_is_set(share->dbton_bitmap, roop_count) && + spider_dbton[roop_count].create_db_handler + ) { + if (!(dbton_hdl[roop_count] = spider_dbton[roop_count].create_db_handler( + *spider, share->dbton_share[roop_count]))) + { + error_num = HA_ERR_OUT_OF_MEM; + goto error_init_db_handler; + } + if ((error_num = dbton_hdl[roop_count]->init())) + goto error_init_db_handler; + } + } + DBUG_PRINT("info",("spider share=%p", (*spider)->share)); + DBUG_PRINT("info",("spider need_mons=%p", (*spider)->need_mons)); + DBUG_RETURN(0); + +error_init_db_handler: + for (; roop_count >= 0; --roop_count) + { + if ( + spider_bit_is_set(share->dbton_bitmap, roop_count) && + dbton_hdl[roop_count] + ) { + delete dbton_hdl[roop_count]; + dbton_hdl[roop_count] = NULL; + } + } + spider_free(spider_current_trx, (*spider)->need_mons, MYF(0)); +error_need_mons_alloc: + delete (*spider); + (*spider) = NULL; +error_spider_alloc: + DBUG_RETURN(error_num); +} + +void spider_free_spider_object_for_share( + ha_spider **spider +) { + int roop_count; + SPIDER_SHARE *share = (*spider)->share; + spider_db_handler **dbton_hdl = (*spider)->dbton_handler; + DBUG_ENTER("spider_free_spider_object_for_share"); + DBUG_PRINT("info",("spider share=%p", share)); + DBUG_PRINT("info",("spider spider_ptr=%p", spider)); + DBUG_PRINT("info",("spider spider=%p", (*spider))); + for (roop_count = SPIDER_DBTON_SIZE - 1; roop_count >= 0; --roop_count) + { + if ( + spider_bit_is_set(share->dbton_bitmap, roop_count) && + dbton_hdl[roop_count] + ) { + delete dbton_hdl[roop_count]; + dbton_hdl[roop_count] = NULL; + } + } + spider_free(spider_current_trx, (*spider)->need_mons, MYF(0)); + delete (*spider); + (*spider) = NULL; + DBUG_VOID_RETURN; +} + +int spider_create_sts_threads( + SPIDER_THREAD *spider_thread +) { + int error_num; + DBUG_ENTER("spider_create_sts_threads"); +#if MYSQL_VERSION_ID < 50500 + if (pthread_mutex_init(&spider_thread->mutex, + MY_MUTEX_INIT_FAST)) +#else + if (mysql_mutex_init(spd_key_mutex_bg_stss, + &spider_thread->mutex, MY_MUTEX_INIT_FAST)) +#endif + { + error_num = HA_ERR_OUT_OF_MEM; + goto error_mutex_init; + } +#if MYSQL_VERSION_ID < 50500 + if (pthread_cond_init(&spider_thread->cond, NULL)) +#else + if (mysql_cond_init(spd_key_cond_bg_stss, + &spider_thread->cond, NULL)) +#endif + { + error_num = HA_ERR_OUT_OF_MEM; + goto error_cond_init; + } +#if MYSQL_VERSION_ID < 50500 + if (pthread_cond_init(&spider_thread->sync_cond, NULL)) +#else + if (mysql_cond_init(spd_key_cond_bg_sts_syncs, + &spider_thread->sync_cond, NULL)) +#endif + { + error_num = HA_ERR_OUT_OF_MEM; + goto error_sync_cond_init; + } +#if MYSQL_VERSION_ID < 50500 + if (pthread_create(&spider_thread->thread, &spider_pt_attr, + spider_table_bg_sts_action, (void *) spider_thread) + ) +#else + if (mysql_thread_create(spd_key_thd_bg_stss, &spider_thread->thread, + &spider_pt_attr, spider_table_bg_sts_action, (void *) spider_thread) + ) +#endif + { + error_num = HA_ERR_OUT_OF_MEM; + goto error_thread_create; + } + DBUG_RETURN(0); + +error_thread_create: + pthread_cond_destroy(&spider_thread->sync_cond); +error_sync_cond_init: + pthread_cond_destroy(&spider_thread->cond); +error_cond_init: + pthread_mutex_destroy(&spider_thread->mutex); +error_mutex_init: + DBUG_RETURN(error_num); +} + +void spider_free_sts_threads( + SPIDER_THREAD *spider_thread +) { + bool thread_killed; + DBUG_ENTER("spider_free_sts_threads"); + pthread_mutex_lock(&spider_thread->mutex); + thread_killed = spider_thread->killed; + spider_thread->killed = TRUE; + if (!thread_killed) + { + if (spider_thread->thd_wait) + { + pthread_cond_signal(&spider_thread->cond); + } + pthread_cond_wait(&spider_thread->sync_cond, &spider_thread->mutex); + } + pthread_mutex_unlock(&spider_thread->mutex); + pthread_join(spider_thread->thread, NULL); + pthread_cond_destroy(&spider_thread->sync_cond); + pthread_cond_destroy(&spider_thread->cond); + pthread_mutex_destroy(&spider_thread->mutex); + spider_thread->thd_wait = FALSE; + spider_thread->killed = FALSE; + DBUG_VOID_RETURN; +} + +int spider_create_crd_threads( + SPIDER_THREAD *spider_thread +) { + int error_num; + DBUG_ENTER("spider_create_crd_threads"); +#if MYSQL_VERSION_ID < 50500 + if (pthread_mutex_init(&spider_thread->mutex, + MY_MUTEX_INIT_FAST)) +#else + if (mysql_mutex_init(spd_key_mutex_bg_crds, + &spider_thread->mutex, MY_MUTEX_INIT_FAST)) +#endif + { + error_num = HA_ERR_OUT_OF_MEM; + goto error_mutex_init; + } +#if MYSQL_VERSION_ID < 50500 + if (pthread_cond_init(&spider_thread->cond, NULL)) +#else + if (mysql_cond_init(spd_key_cond_bg_crds, + &spider_thread->cond, NULL)) +#endif + { + error_num = HA_ERR_OUT_OF_MEM; + goto error_cond_init; + } +#if MYSQL_VERSION_ID < 50500 + if (pthread_cond_init(&spider_thread->sync_cond, NULL)) +#else + if (mysql_cond_init(spd_key_cond_bg_crd_syncs, + &spider_thread->sync_cond, NULL)) +#endif + { + error_num = HA_ERR_OUT_OF_MEM; + goto error_sync_cond_init; + } +#if MYSQL_VERSION_ID < 50500 + if (pthread_create(&spider_thread->thread, &spider_pt_attr, + spider_table_bg_crd_action, (void *) spider_thread) + ) +#else + if (mysql_thread_create(spd_key_thd_bg_crds, &spider_thread->thread, + &spider_pt_attr, spider_table_bg_crd_action, (void *) spider_thread) + ) +#endif + { + error_num = HA_ERR_OUT_OF_MEM; + goto error_thread_create; + } + DBUG_RETURN(0); + +error_thread_create: + pthread_cond_destroy(&spider_thread->sync_cond); +error_sync_cond_init: + pthread_cond_destroy(&spider_thread->cond); +error_cond_init: + pthread_mutex_destroy(&spider_thread->mutex); +error_mutex_init: + DBUG_RETURN(error_num); +} + +void spider_free_crd_threads( + SPIDER_THREAD *spider_thread +) { + bool thread_killed; + DBUG_ENTER("spider_free_crd_threads"); + pthread_mutex_lock(&spider_thread->mutex); + thread_killed = spider_thread->killed; + spider_thread->killed = TRUE; + if (!thread_killed) + { + if (spider_thread->thd_wait) + { + pthread_cond_signal(&spider_thread->cond); + } + pthread_cond_wait(&spider_thread->sync_cond, &spider_thread->mutex); + } + pthread_mutex_unlock(&spider_thread->mutex); + pthread_join(spider_thread->thread, NULL); + pthread_cond_destroy(&spider_thread->sync_cond); + pthread_cond_destroy(&spider_thread->cond); + pthread_mutex_destroy(&spider_thread->mutex); + spider_thread->thd_wait = FALSE; + spider_thread->killed = FALSE; + DBUG_VOID_RETURN; +} + +void *spider_table_bg_sts_action( + void *arg +) { + SPIDER_THREAD *thread = (SPIDER_THREAD *) arg; + SPIDER_SHARE *share; + SPIDER_TRX *trx; + int error_num; + ha_spider *spider; + SPIDER_CONN **conns; + THD *thd; + my_thread_init(); + DBUG_ENTER("spider_table_bg_sts_action"); + /* init start */ + pthread_mutex_lock(&thread->mutex); + if (!(thd = spider_create_sys_thd(thread))) + { + thread->thd_wait = FALSE; + thread->killed = FALSE; + pthread_mutex_unlock(&thread->mutex); + my_thread_end(); + DBUG_RETURN(NULL); + } + SPIDER_set_next_thread_id(thd); +#ifdef HAVE_PSI_INTERFACE + mysql_thread_set_psi_id(thd->thread_id); +#endif + thd_proc_info(thd, "Spider table background statistics action handler"); + if (!(trx = spider_get_trx(NULL, FALSE, &error_num))) + { + spider_destroy_sys_thd(thd); + thread->thd_wait = FALSE; + thread->killed = FALSE; + pthread_mutex_unlock(&thread->mutex); +#if !defined(MYSQL_DYNAMIC_PLUGIN) || !defined(_WIN32) + set_current_thd(nullptr); +#endif + my_thread_end(); + DBUG_RETURN(NULL); + } + trx->thd = thd; + /* init end */ + + if (thread->init_command) + { + uint i = 0; + tmp_disable_binlog(thd); + thd->security_ctx->skip_grants(); + thd->client_capabilities |= CLIENT_MULTI_RESULTS; + if (!(*spd_mysqld_server_started) && !thd->killed) + { + pthread_mutex_lock(spd_LOCK_server_started); + thd->mysys_var->current_cond = spd_COND_server_started; + thd->mysys_var->current_mutex = spd_LOCK_server_started; + if (!(*spd_mysqld_server_started) && !thd->killed) + { + do + { + struct timespec abstime; + set_timespec_nsec(abstime, 1000); + error_num = pthread_cond_timedwait(spd_COND_server_started, + spd_LOCK_server_started, &abstime); + } while ( + (error_num == ETIMEDOUT || error_num == ETIME) && + !(*spd_mysqld_server_started) && !thd->killed && !thread->killed + ); + } + pthread_mutex_unlock(spd_LOCK_server_started); + thd->mysys_var->current_cond = &thread->cond; + thd->mysys_var->current_mutex = &thread->mutex; + } + while (spider_init_queries[i].length && !thd->killed && !thread->killed) + { + dispatch_command(COM_QUERY, thd, spider_init_queries[i].str, + (uint) spider_init_queries[i].length, FALSE, FALSE); + if (unlikely(thd->is_error())) + { + fprintf(stderr, "[ERROR] %s\n", spider_stmt_da_message(thd)); + thd->clear_error(); + break; + } + ++i; + } + thd->mysys_var->current_cond = &thread->cond; + thd->mysys_var->current_mutex = &thread->mutex; + thd->client_capabilities -= CLIENT_MULTI_RESULTS; + reenable_binlog(thd); + thread->init_command = FALSE; + pthread_cond_broadcast(&thread->sync_cond); + } + if (thd->killed) + { + thread->killed = TRUE; + } + if (thd->killed) + { + thread->killed = TRUE; + } + + while (TRUE) + { + DBUG_PRINT("info",("spider bg sts loop start")); + if (thread->killed) + { + DBUG_PRINT("info",("spider bg sts kill start")); + trx->thd = NULL; + spider_free_trx(trx, TRUE); + spider_destroy_sys_thd(thd); + pthread_cond_signal(&thread->sync_cond); + pthread_mutex_unlock(&thread->mutex); +#if !defined(MYSQL_DYNAMIC_PLUGIN) || !defined(_WIN32) + set_current_thd(nullptr); +#endif + my_thread_end(); + DBUG_RETURN(NULL); + } + if (!thread->queue_first) + { + DBUG_PRINT("info",("spider bg sts has no job")); + thread->thd_wait = TRUE; + pthread_cond_wait(&thread->cond, &thread->mutex); + thread->thd_wait = FALSE; + if (thd->killed) + thread->killed = TRUE; + continue; + } + share = (SPIDER_SHARE *) thread->queue_first; + share->sts_working = TRUE; + pthread_mutex_unlock(&thread->mutex); + + spider = share->sts_spider; + conns = spider->conns; + if (spider->search_link_idx < 0) + { + spider->wide_handler->trx = trx; + spider_trx_set_link_idx_for_all(spider); + spider->search_link_idx = spider_conn_first_link_idx(thd, + share->link_statuses, share->access_balances, spider->conn_link_idx, + share->link_count, SPIDER_LINK_STATUS_OK); + } + if (spider->search_link_idx >= 0) + { + DBUG_PRINT("info", + ("spider difftime=%f", + difftime(share->bg_sts_try_time, share->sts_get_time))); + DBUG_PRINT("info", + ("spider bg_sts_interval=%f", share->bg_sts_interval)); + if (difftime(share->bg_sts_try_time, share->sts_get_time) >= + share->bg_sts_interval) + { + if (!conns[spider->search_link_idx]) + { + spider_get_conn(share, spider->search_link_idx, + share->conn_keys[spider->search_link_idx], + trx, spider, FALSE, FALSE, SPIDER_CONN_KIND_MYSQL, + &error_num); + if (conns[spider->search_link_idx]) + { + conns[spider->search_link_idx]->error_mode = 0; + } else { + spider->search_link_idx = -1; + } + } + DBUG_PRINT("info", + ("spider search_link_idx=%d", spider->search_link_idx)); + if (spider->search_link_idx >= 0 && conns[spider->search_link_idx]) + { +#ifdef WITH_PARTITION_STORAGE_ENGINE + if (spider_get_sts(share, spider->search_link_idx, + share->bg_sts_try_time, spider, + share->bg_sts_interval, share->bg_sts_mode, + share->bg_sts_sync, + 2, HA_STATUS_CONST | HA_STATUS_VARIABLE)) +#else + if (spider_get_sts(share, spider->search_link_idx, + share->bg_sts_try_time, spider, + share->bg_sts_interval, share->bg_sts_mode, + 2, HA_STATUS_CONST | HA_STATUS_VARIABLE)) +#endif + { + spider->search_link_idx = -1; + } + } + } + } + memset(spider->need_mons, 0, sizeof(int) * share->link_count); + pthread_mutex_lock(&thread->mutex); + if (thread->queue_first == thread->queue_last) + { + thread->queue_first = NULL; + thread->queue_last = NULL; + } else { + thread->queue_first = share->sts_next; + share->sts_next->sts_prev = NULL; + share->sts_next = NULL; + } + share->sts_working = FALSE; + share->sts_wait = FALSE; + if (thread->first_free_wait) + { + pthread_cond_signal(&thread->sync_cond); + pthread_cond_wait(&thread->cond, &thread->mutex); + if (thd->killed) + thread->killed = TRUE; + } + } +} + +void *spider_table_bg_crd_action( + void *arg +) { + SPIDER_THREAD *thread = (SPIDER_THREAD *) arg; + SPIDER_SHARE *share; + SPIDER_TRX *trx; + int error_num; + ha_spider *spider; + TABLE *table; + SPIDER_CONN **conns; + THD *thd; + my_thread_init(); + DBUG_ENTER("spider_table_bg_crd_action"); + /* init start */ + pthread_mutex_lock(&thread->mutex); + if (!(thd = spider_create_sys_thd(thread))) + { + thread->thd_wait = FALSE; + thread->killed = FALSE; + pthread_mutex_unlock(&thread->mutex); + my_thread_end(); + DBUG_RETURN(NULL); + } + SPIDER_set_next_thread_id(thd); +#ifdef HAVE_PSI_INTERFACE + mysql_thread_set_psi_id(thd->thread_id); +#endif + thd_proc_info(thd, "Spider table background cardinality action handler"); + if (!(trx = spider_get_trx(NULL, FALSE, &error_num))) + { + spider_destroy_sys_thd(thd); + thread->thd_wait = FALSE; + thread->killed = FALSE; + pthread_mutex_unlock(&thread->mutex); +#if !defined(MYSQL_DYNAMIC_PLUGIN) || !defined(_WIN32) + set_current_thd(nullptr); +#endif + my_thread_end(); + DBUG_RETURN(NULL); + } + trx->thd = thd; + /* init end */ + + while (TRUE) + { + DBUG_PRINT("info",("spider bg crd loop start")); + if (thread->killed) + { + DBUG_PRINT("info",("spider bg crd kill start")); + trx->thd = NULL; + spider_free_trx(trx, TRUE); + spider_destroy_sys_thd(thd); + pthread_cond_signal(&thread->sync_cond); + pthread_mutex_unlock(&thread->mutex); +#if !defined(MYSQL_DYNAMIC_PLUGIN) || !defined(_WIN32) + set_current_thd(nullptr); +#endif + my_thread_end(); + DBUG_RETURN(NULL); + } + if (!thread->queue_first) + { + DBUG_PRINT("info",("spider bg crd has no job")); + thread->thd_wait = TRUE; + pthread_cond_wait(&thread->cond, &thread->mutex); + thread->thd_wait = FALSE; + if (thd->killed) + thread->killed = TRUE; + continue; + } + share = (SPIDER_SHARE *) thread->queue_first; + share->crd_working = TRUE; + pthread_mutex_unlock(&thread->mutex); + + table = &share->table; + spider = share->crd_spider; + conns = spider->conns; + if (spider->search_link_idx < 0) + { + spider->wide_handler->trx = trx; + spider_trx_set_link_idx_for_all(spider); + spider->search_link_idx = spider_conn_first_link_idx(thd, + share->link_statuses, share->access_balances, spider->conn_link_idx, + share->link_count, SPIDER_LINK_STATUS_OK); + } + if (spider->search_link_idx >= 0) + { + DBUG_PRINT("info", + ("spider difftime=%f", + difftime(share->bg_crd_try_time, share->crd_get_time))); + DBUG_PRINT("info", + ("spider bg_crd_interval=%f", share->bg_crd_interval)); + if (difftime(share->bg_crd_try_time, share->crd_get_time) >= + share->bg_crd_interval) + { + if (!conns[spider->search_link_idx]) + { + spider_get_conn(share, spider->search_link_idx, + share->conn_keys[spider->search_link_idx], + trx, spider, FALSE, FALSE, SPIDER_CONN_KIND_MYSQL, + &error_num); + if (conns[spider->search_link_idx]) + { + conns[spider->search_link_idx]->error_mode = 0; + } else { + spider->search_link_idx = -1; + } + } + DBUG_PRINT("info", + ("spider search_link_idx=%d", spider->search_link_idx)); + if (spider->search_link_idx >= 0 && conns[spider->search_link_idx]) + { +#ifdef WITH_PARTITION_STORAGE_ENGINE + if (spider_get_crd(share, spider->search_link_idx, + share->bg_crd_try_time, spider, table, + share->bg_crd_interval, share->bg_crd_mode, + share->bg_crd_sync, + 2)) +#else + if (spider_get_crd(share, spider->search_link_idx, + share->bg_crd_try_time, spider, table, + share->bg_crd_interval, share->bg_crd_mode, + 2)) +#endif + { + spider->search_link_idx = -1; + } + } + } + } + memset(spider->need_mons, 0, sizeof(int) * share->link_count); + pthread_mutex_lock(&thread->mutex); + if (thread->queue_first == thread->queue_last) + { + thread->queue_first = NULL; + thread->queue_last = NULL; + } else { + thread->queue_first = share->crd_next; + share->crd_next->crd_prev = NULL; + share->crd_next = NULL; + } + share->crd_working = FALSE; + share->crd_wait = FALSE; + if (thread->first_free_wait) + { + pthread_cond_signal(&thread->sync_cond); + pthread_cond_wait(&thread->cond, &thread->mutex); + if (thd->killed) + thread->killed = TRUE; + } + } +} + +void spider_table_add_share_to_sts_thread( + SPIDER_SHARE *share +) { + SPIDER_THREAD *spider_thread = share->sts_thread; + DBUG_ENTER("spider_table_add_share_to_sts_thread"); + if ( + !share->sts_wait && + !pthread_mutex_trylock(&spider_thread->mutex) + ) { + if (!share->sts_wait) + { + if (spider_thread->queue_last) + { + DBUG_PRINT("info",("spider add to last")); + share->sts_prev = spider_thread->queue_last; + spider_thread->queue_last->sts_next = share; + } else { + spider_thread->queue_first = share; + } + spider_thread->queue_last = share; + share->sts_wait = TRUE; + + if (spider_thread->thd_wait) + { + pthread_cond_signal(&spider_thread->cond); + } + } + pthread_mutex_unlock(&spider_thread->mutex); + } + DBUG_VOID_RETURN; +} + +void spider_table_add_share_to_crd_thread( + SPIDER_SHARE *share +) { + SPIDER_THREAD *spider_thread = share->crd_thread; + DBUG_ENTER("spider_table_add_share_to_crd_thread"); + if ( + !share->crd_wait && + !pthread_mutex_trylock(&spider_thread->mutex) + ) { + if (!share->crd_wait) + { + if (spider_thread->queue_last) + { + DBUG_PRINT("info",("spider add to last")); + share->crd_prev = spider_thread->queue_last; + spider_thread->queue_last->crd_next = share; + } else { + spider_thread->queue_first = share; + } + spider_thread->queue_last = share; + share->crd_wait = TRUE; + + if (spider_thread->thd_wait) + { + pthread_cond_signal(&spider_thread->cond); + } + } + pthread_mutex_unlock(&spider_thread->mutex); + } + DBUG_VOID_RETURN; +} + +void spider_table_remove_share_from_sts_thread( + SPIDER_SHARE *share +) { + SPIDER_THREAD *spider_thread = share->sts_thread; + DBUG_ENTER("spider_table_remove_share_from_sts_thread"); + if (share->sts_wait) + { + pthread_mutex_lock(&spider_thread->mutex); + if (share->sts_wait) + { + if (share->sts_working) + { + DBUG_PRINT("info",("spider waiting bg sts start")); + spider_thread->first_free_wait = TRUE; + pthread_cond_wait(&spider_thread->sync_cond, &spider_thread->mutex); + spider_thread->first_free_wait = FALSE; + pthread_cond_signal(&spider_thread->cond); + DBUG_PRINT("info",("spider waiting bg sts end")); + } + + if (share->sts_prev) + { + if (share->sts_next) + { + DBUG_PRINT("info",("spider remove middle one")); + share->sts_prev->sts_next = share->sts_next; + share->sts_next->sts_prev = share->sts_prev; + } else { + DBUG_PRINT("info",("spider remove last one")); + share->sts_prev->sts_next = NULL; + spider_thread->queue_last = share->sts_prev; + } + } else if (share->sts_next) { + DBUG_PRINT("info",("spider remove first one")); + share->sts_next->sts_prev = NULL; + spider_thread->queue_first = share->sts_next; + } else { + DBUG_PRINT("info",("spider empty")); + spider_thread->queue_first = NULL; + spider_thread->queue_last = NULL; + } + } + pthread_mutex_unlock(&spider_thread->mutex); + } + DBUG_VOID_RETURN; +} + +void spider_table_remove_share_from_crd_thread( + SPIDER_SHARE *share +) { + SPIDER_THREAD *spider_thread = share->crd_thread; + DBUG_ENTER("spider_table_remove_share_from_crd_thread"); + if (share->crd_wait) + { + pthread_mutex_lock(&spider_thread->mutex); + if (share->crd_wait) + { + if (share->crd_working) + { + DBUG_PRINT("info",("spider waiting bg crd start")); + spider_thread->first_free_wait = TRUE; + pthread_cond_wait(&spider_thread->sync_cond, &spider_thread->mutex); + spider_thread->first_free_wait = FALSE; + pthread_cond_signal(&spider_thread->cond); + DBUG_PRINT("info",("spider waiting bg crd end")); + } + + if (share->crd_prev) + { + if (share->crd_next) + { + DBUG_PRINT("info",("spider remove middle one")); + share->crd_prev->crd_next = share->crd_next; + share->crd_next->crd_prev = share->crd_prev; + } else { + DBUG_PRINT("info",("spider remove last one")); + share->crd_prev->crd_next = NULL; + spider_thread->queue_last = share->crd_prev; + } + } else if (share->crd_next) { + DBUG_PRINT("info",("spider remove first one")); + share->crd_next->crd_prev = NULL; + spider_thread->queue_first = share->crd_next; + } else { + DBUG_PRINT("info",("spider empty")); + spider_thread->queue_first = NULL; + spider_thread->queue_last = NULL; + } + } + pthread_mutex_unlock(&spider_thread->mutex); + } + DBUG_VOID_RETURN; +} +#endif + +uchar *spider_duplicate_char( + uchar *dst, + uchar esc, + uchar *src, + uint src_lgt +) { + uchar *ed = src + src_lgt; + DBUG_ENTER("spider_duplicate_char"); + while (src < ed) + { + *dst = *src; + if (*src == esc) + { + ++dst; + *dst = esc; + } + ++dst; + ++src; + } + DBUG_RETURN(dst); +} |