diff options
Diffstat (limited to 'storage/spider/spd_sys_table.cc')
| -rw-r--r-- | storage/spider/spd_sys_table.cc | 3776 |
1 files changed, 3776 insertions, 0 deletions
diff --git a/storage/spider/spd_sys_table.cc b/storage/spider/spd_sys_table.cc new file mode 100644 index 00000000..a0cf104d --- /dev/null +++ b/storage/spider/spd_sys_table.cc @@ -0,0 +1,3776 @@ +/* Copyright (C) 2008-2018 Kentoku Shiba + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; version 2 of the License. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 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" +#include "sql_priv.h" +#include "probes_mysql.h" +#include "sql_class.h" +#include "key.h" +#include "sql_base.h" +#include "tztime.h" +#include "sql_select.h" +#include "spd_err.h" +#include "spd_param.h" +#include "spd_db_include.h" +#include "spd_include.h" +#include "spd_sys_table.h" +#include "spd_malloc.h" + +extern handlerton *spider_hton_ptr; +extern Time_zone *spd_tz_system; + +#define SPIDER_XA_FORMAT_ID_POS 0 +#define SPIDER_XA_GTRID_LENGTH_POS 1 +#define SPIDER_XA_BQUAL_LENGTH_POS 2 +#define SPIDER_XA_DATA_POS 3 +#define SPIDER_XA_STATUS_POS 4 + +#define SPIDER_XA_MEMBER_FORMAT_ID_POS 0 +#define SPIDER_XA_MEMBER_GTRID_LENGTH_POS 1 +#define SPIDER_XA_MEMBER_BQUAL_LENGTH_POS 2 +#define SPIDER_XA_MEMBER_DATA_POS 3 +#define SPIDER_XA_MEMBER_SCHEME_POS 4 +#define SPIDER_XA_MEMBER_HOST_POS 5 +#define SPIDER_XA_MEMBER_PORT_POS 6 +#define SPIDER_XA_MEMBER_SOCKET_POS 7 +#define SPIDER_XA_MEMBER_USERNAME_POS 8 +#define SPIDER_XA_MEMBER_PASSWORD_POS 9 +#define SPIDER_XA_MEMBER_SSL_CA_POS 10 +#define SPIDER_XA_MEMBER_SSL_CAPATH_POS 11 +#define SPIDER_XA_MEMBER_SSL_CERT_POS 12 +#define SPIDER_XA_MEMBER_SSL_CIPHER_POS 13 +#define SPIDER_XA_MEMBER_SSL_KEY_POS 14 +#define SPIDER_XA_MEMBER_SSL_VERIFY_SERVER_CERT_POS 15 +#define SPIDER_XA_MEMBER_DEFAULT_FILE_POS 16 +#define SPIDER_XA_MEMBER_DEFAULT_GROUP_POS 17 +#define SPIDER_XA_MEMBER_DSN_POS 18 +#define SPIDER_XA_MEMBER_FILEDSN_POS 19 +#define SPIDER_XA_MEMBER_DRIVER_POS 20 +#define SPIDER_XA_FAILED_LOG_THREAD_ID_POS 21 +#define SPIDER_XA_FAILED_LOG_STATUS_POS 22 +#define SPIDER_XA_FAILED_LOG_FAILED_TIME_POS 23 + +#define SPIDER_TABLES_DB_NAME_POS 0 +#define SPIDER_TABLES_TABLE_NAME_POS 1 +#define SPIDER_TABLES_LINK_ID_POS 2 +#define SPIDER_TABLES_PRIORITY_POS 3 +#define SPIDER_TABLES_SERVER_POS 4 +#define SPIDER_TABLES_SCHEME_POS 5 +#define SPIDER_TABLES_HOST_POS 6 +#define SPIDER_TABLES_PORT_POS 7 +#define SPIDER_TABLES_SOCKET_POS 8 +#define SPIDER_TABLES_USERNAME_POS 9 +#define SPIDER_TABLES_PASSWORD_POS 10 +#define SPIDER_TABLES_SSL_CA_POS 11 +#define SPIDER_TABLES_SSL_CAPATH_POS 12 +#define SPIDER_TABLES_SSL_CERT_POS 13 +#define SPIDER_TABLES_SSL_CIPHER_POS 14 +#define SPIDER_TABLES_SSL_KEY_POS 15 +#define SPIDER_TABLES_SSL_VERIFY_SERVER_CERT_POS 16 +#define SPIDER_TABLES_MONITORING_BINLOG_POS_AT_FAILING_POS 17 +#define SPIDER_TABLES_DEFAULT_FILE_POS 18 +#define SPIDER_TABLES_DEFAULT_GROUP_POS 19 +#define SPIDER_TABLES_DSN_POS 20 +#define SPIDER_TABLES_FILEDSN_POS 21 +#define SPIDER_TABLES_DRIVER_POS 22 +#define SPIDER_TABLES_TGT_DB_NAME_POS 23 +#define SPIDER_TABLES_TGT_TABLE_NAME_POS 24 +#define SPIDER_TABLES_LINK_STATUS_POS 25 +#define SPIDER_TABLES_BLOCK_STATUS_POS 26 +#define SPIDER_TABLES_STATIC_LINK_ID_POS 27 + +#define SPIDER_LINK_MON_SERVERS_DB_NAME_POS 0 +#define SPIDER_LINK_MON_SERVERS_TABLE_NAME_POS 1 +#define SPIDER_LINK_MON_SERVERS_LINK_ID_POS 2 +#define SPIDER_LINK_MON_SERVERS_SID_POS 3 +#define SPIDER_LINK_MON_SERVERS_SERVER_POS 4 +#define SPIDER_LINK_MON_SERVERS_SCHEME_POS 5 +#define SPIDER_LINK_MON_SERVERS_HOST_POS 6 +#define SPIDER_LINK_MON_SERVERS_PORT_POS 7 +#define SPIDER_LINK_MON_SERVERS_SOCKET_POS 8 +#define SPIDER_LINK_MON_SERVERS_USERNAME_POS 9 +#define SPIDER_LINK_MON_SERVERS_PASSWORD_POS 10 +#define SPIDER_LINK_MON_SERVERS_SSL_CA_POS 11 +#define SPIDER_LINK_MON_SERVERS_SSL_CAPATH_POS 12 +#define SPIDER_LINK_MON_SERVERS_SSL_CERT_POS 13 +#define SPIDER_LINK_MON_SERVERS_SSL_CIPHER_POS 14 +#define SPIDER_LINK_MON_SERVERS_SSL_KEY_POS 15 +#define SPIDER_LINK_MON_SERVERS_SSL_VERIFY_SERVER_CERT_POS 16 +#define SPIDER_LINK_MON_SERVERS_DEFAULT_FILE_POS 17 +#define SPIDER_LINK_MON_SERVERS_DEFAULT_GROUP_POS 18 +#define SPIDER_LINK_MON_SERVERS_DSN_POS 19 +#define SPIDER_LINK_MON_SERVERS_FILEDSN_POS 20 +#define SPIDER_LINK_MON_SERVERS_DRIVER_POS 21 + +#define SPIDER_LINK_FAILED_LOG_DB_NAME_POS 0 +#define SPIDER_LINK_FAILED_LOG_TABLE_NAME_POS 1 +#define SPIDER_LINK_FAILED_LOG_LINK_ID_POS 2 +#define SPIDER_LINK_FAILED_LOG_FAILED_TIME_POS 3 + +#define SPIDER_TABLE_POSITION_FOR_RECOVERY_DB_NAME_POS 0 +#define SPIDER_TABLE_POSITION_FOR_RECOVERY_TABLE_NAME_POS 1 +#define SPIDER_TABLE_POSITION_FOR_RECOVERY_FAILED_LINK_ID_POS 2 +#define SPIDER_TABLE_POSITION_FOR_RECOVERY_SOURCE_LINK_ID_POS 3 +#define SPIDER_TABLE_POSITION_FOR_RECOVERY_FILE_POS 4 +#define SPIDER_TABLE_POSITION_FOR_RECOVERY_POSITION_POS 5 +#define SPIDER_TABLE_POSITION_FOR_RECOVERY_GTID_POS 6 + +#define SPIDER_TABLE_STS_DB_NAME_POS 0 +#define SPIDER_TABLE_STS_TABLE_NAME_POS 1 +#define SPIDER_TABLE_STS_DATA_FILE_LENGTH_POS 2 +#define SPIDER_TABLE_STS_MAX_DATA_FILE_LENGTH_POS 3 +#define SPIDER_TABLE_STS_INDEX_FILE_LENGTH_POS 4 +#define SPIDER_TABLE_STS_RECORDS_POS 5 +#define SPIDER_TABLE_STS_MEAN_REC_LENGTH_POS 6 +#define SPIDER_TABLE_STS_CHECK_TIME_POS 7 +#define SPIDER_TABLE_STS_CREATE_TIME_POS 8 +#define SPIDER_TABLE_STS_UPDATE_TIME_POS 9 +#define SPIDER_TABLE_STS_CHECKSUM_POS 10 + +#define SPIDER_TABLE_CRD_DB_NAME_POS 0 +#define SPIDER_TABLE_CRD_TABLE_NAME_POS 1 +#define SPIDER_TABLE_CRD_KEY_SEQ_POS 2 +#define SPIDER_TABLE_CRD_CARDINALITY_POS 3 + +/** + Insert a Spider system table row. + + @param table The spider system table. + @param do_handle_error TRUE if an error message should be printed + before returning. + + @return Error code returned by the write. +*/ + +inline int spider_write_sys_table_row(TABLE *table, bool do_handle_error = TRUE) +{ + int error_num; + THD *thd = table->in_use; + + tmp_disable_binlog(thd); /* Do not replicate the low-level changes. */ + error_num = table->file->ha_write_row(table->record[0]); + reenable_binlog(thd); + + if (error_num && do_handle_error) + table->file->print_error(error_num, MYF(0)); + + return error_num; +} + +/** + Update a Spider system table row. + + @param table The spider system table. + @param do_handle_error TRUE if an error message should be printed + before returning. + + @return Error code returned by the update. +*/ + +inline int spider_update_sys_table_row(TABLE *table, bool do_handle_error = TRUE) +{ + int error_num; + THD *thd = table->in_use; + + tmp_disable_binlog(thd); /* Do not replicate the low-level changes. */ + error_num = table->file->ha_update_row(table->record[1], table->record[0]); + reenable_binlog(thd); + + if (error_num && do_handle_error) + { + if (error_num == HA_ERR_RECORD_IS_THE_SAME) + error_num = 0; + else + table->file->print_error(error_num, MYF(0)); + } + + return error_num; +} + +/** + Delete a Spider system table row. + + @param table The spider system table. + @param record_number Location of the record: 0 or 1. + @param do_handle_error TRUE if an error message should be printed + before returning. + + @return Error code returned by the delete. +*/ + +inline int spider_delete_sys_table_row(TABLE *table, int record_number = 0, + bool do_handle_error = TRUE) +{ + int error_num; + THD *thd = table->in_use; + + tmp_disable_binlog(thd); /* Do not replicate the low-level changes. */ + error_num = table->file->ha_delete_row(table->record[record_number]); + reenable_binlog(thd); + + if (error_num && do_handle_error) + table->file->print_error(error_num, MYF(0)); + + return error_num; +} + +TABLE *spider_open_sys_table( + THD *thd, + const char *table_name, + int table_name_length, + bool write, + SPIDER_Open_tables_backup *open_tables_backup, + bool need_lock, + int *error_num +) { + TABLE *table; + TABLE_LIST tables; + DBUG_ENTER("spider_open_sys_table"); + + +#ifdef SPIDER_use_LEX_CSTRING_for_database_tablename_alias + LEX_CSTRING db_name = + { + "mysql", + sizeof("mysql") - 1 + }; + LEX_CSTRING tbl_name = + { + table_name, + (size_t) table_name_length + }; + tables.init_one_table(&db_name, &tbl_name, 0, (write ? TL_WRITE : TL_READ)); +#else + tables.init_one_table( + "mysql", sizeof("mysql") - 1, table_name, table_name_length, table_name, + (write ? TL_WRITE : TL_READ)); +#endif + if (!(table = spider_sys_open_table(thd, &tables, open_tables_backup))) + { + my_printf_error(ER_SPIDER_CANT_OPEN_SYS_TABLE_NUM, + ER_SPIDER_CANT_OPEN_SYS_TABLE_STR, MYF(0), + "mysql", table_name); + *error_num = ER_SPIDER_CANT_OPEN_SYS_TABLE_NUM; + DBUG_RETURN(NULL); + } + switch (table_name_length) + { + case 9: + if (!memcmp(table_name, SPIDER_SYS_XA_TABLE_NAME_STR, + SPIDER_SYS_XA_TABLE_NAME_LEN)) + { + DBUG_PRINT("info",("spider checking for SYS_XA")); + if (table->s->fields != SPIDER_SYS_XA_COL_CNT) + { + spider_close_sys_table(thd, table, open_tables_backup, need_lock); + table = NULL; + my_printf_error(ER_SPIDER_SYS_TABLE_VERSION_NUM, + ER_SPIDER_SYS_TABLE_VERSION_STR, MYF(0), + SPIDER_SYS_XA_TABLE_NAME_STR); + *error_num = ER_SPIDER_SYS_TABLE_VERSION_NUM; + goto error_col_num_chk; + } + break; + } + DBUG_ASSERT(0); + break; + case 13: + if (!memcmp(table_name, SPIDER_SYS_TABLES_TABLE_NAME_STR, + SPIDER_SYS_TABLES_TABLE_NAME_LEN)) + { + DBUG_PRINT("info",("spider checking for SYS_TABLES")); + if (table->s->fields != SPIDER_SYS_TABLES_COL_CNT) + { + spider_close_sys_table(thd, table, open_tables_backup, need_lock); + table = NULL; + my_printf_error(ER_SPIDER_SYS_TABLE_VERSION_NUM, + ER_SPIDER_SYS_TABLE_VERSION_STR, MYF(0), + SPIDER_SYS_TABLES_TABLE_NAME_STR); + *error_num = ER_SPIDER_SYS_TABLE_VERSION_NUM; + goto error_col_num_chk; + } + break; + } + DBUG_ASSERT(0); + break; + case 16: + if (!memcmp(table_name, SPIDER_SYS_XA_MEMBER_TABLE_NAME_STR, + SPIDER_SYS_XA_MEMBER_TABLE_NAME_LEN)) + { + DBUG_PRINT("info",("spider checking for SYS_XA_MEMBER")); + if (table->s->fields != SPIDER_SYS_XA_MEMBER_COL_CNT) + { + spider_close_sys_table(thd, table, open_tables_backup, need_lock); + table = NULL; + my_printf_error(ER_SPIDER_SYS_TABLE_VERSION_NUM, + ER_SPIDER_SYS_TABLE_VERSION_STR, MYF(0), + SPIDER_SYS_XA_MEMBER_TABLE_NAME_STR); + *error_num = ER_SPIDER_SYS_TABLE_VERSION_NUM; + goto error_col_num_chk; + } + break; + } + if (!memcmp(table_name, SPIDER_SYS_TABLE_STS_TABLE_NAME_STR, + SPIDER_SYS_TABLE_STS_TABLE_NAME_LEN)) + { + DBUG_PRINT("info",("spider checking for SYS_TABLE_STS")); + if (table->s->fields != SPIDER_SYS_TABLE_STS_COL_CNT) + { + spider_close_sys_table(thd, table, open_tables_backup, need_lock); + table = NULL; + my_printf_error(ER_SPIDER_SYS_TABLE_VERSION_NUM, + ER_SPIDER_SYS_TABLE_VERSION_STR, MYF(0), + SPIDER_SYS_TABLE_STS_TABLE_NAME_STR); + *error_num = ER_SPIDER_SYS_TABLE_VERSION_NUM; + goto error_col_num_chk; + } + break; + } + if (!memcmp(table_name, SPIDER_SYS_TABLE_CRD_TABLE_NAME_STR, + SPIDER_SYS_TABLE_CRD_TABLE_NAME_LEN)) + { + DBUG_PRINT("info",("spider checking for SYS_TABLE_CRD")); + if (table->s->fields != SPIDER_SYS_TABLE_CRD_COL_CNT) + { + spider_close_sys_table(thd, table, open_tables_backup, need_lock); + table = NULL; + my_printf_error(ER_SPIDER_SYS_TABLE_VERSION_NUM, + ER_SPIDER_SYS_TABLE_VERSION_STR, MYF(0), + SPIDER_SYS_TABLE_CRD_TABLE_NAME_STR); + *error_num = ER_SPIDER_SYS_TABLE_VERSION_NUM; + goto error_col_num_chk; + } + break; + } + DBUG_ASSERT(0); + break; + case 20: + if (!memcmp(table_name, SPIDER_SYS_XA_FAILED_TABLE_NAME_STR, + SPIDER_SYS_XA_FAILED_TABLE_NAME_LEN)) + { + DBUG_PRINT("info",("spider checking for SYS_XA_FAILED")); + if (table->s->fields != SPIDER_SYS_XA_FAILED_TABLE_COL_CNT) + { + spider_close_sys_table(thd, table, open_tables_backup, need_lock); + table = NULL; + my_printf_error(ER_SPIDER_SYS_TABLE_VERSION_NUM, + ER_SPIDER_SYS_TABLE_VERSION_STR, MYF(0), + SPIDER_SYS_XA_FAILED_TABLE_NAME_STR); + *error_num = ER_SPIDER_SYS_TABLE_VERSION_NUM; + goto error_col_num_chk; + } + break; + } + DBUG_ASSERT(0); + break; + case 21: + if (!memcmp(table_name, SPIDER_SYS_RW_TBLS_TABLE_NAME_STR, + SPIDER_SYS_RW_TBLS_TABLE_NAME_LEN)) + { + DBUG_PRINT("info",("spider checking for SYS_RW_TBLS")); + if (table->s->fields != SPIDER_SYS_RW_TBLS_COL_CNT) + { + spider_close_sys_table(thd, table, open_tables_backup, need_lock); + table = NULL; + my_printf_error(ER_SPIDER_SYS_TABLE_VERSION_NUM, + ER_SPIDER_SYS_TABLE_VERSION_STR, MYF(0), + SPIDER_SYS_RW_TBLS_TABLE_NAME_STR); + *error_num = ER_SPIDER_SYS_TABLE_VERSION_NUM; + goto error_col_num_chk; + } + } + DBUG_ASSERT(0); + break; + case 22: + if (!memcmp(table_name, SPIDER_SYS_LINK_FAILED_TABLE_NAME_STR, + SPIDER_SYS_LINK_FAILED_TABLE_NAME_LEN)) + { + DBUG_PRINT("info",("spider checking for SYS_LINK_FAILED")); + if (table->s->fields != SPIDER_SYS_LINK_FAILED_TABLE_COL_CNT) + { + spider_close_sys_table(thd, table, open_tables_backup, need_lock); + table = NULL; + my_printf_error(ER_SPIDER_SYS_TABLE_VERSION_NUM, + ER_SPIDER_SYS_TABLE_VERSION_STR, MYF(0), + SPIDER_SYS_LINK_FAILED_TABLE_NAME_STR); + *error_num = ER_SPIDER_SYS_TABLE_VERSION_NUM; + goto error_col_num_chk; + } + break; + } + DBUG_ASSERT(0); + break; + case 23: + if (!memcmp(table_name, SPIDER_SYS_LINK_MON_TABLE_NAME_STR, + SPIDER_SYS_LINK_MON_TABLE_NAME_LEN)) + { + DBUG_PRINT("info",("spider checking for SYS_LINK_MON")); + if (table->s->fields != SPIDER_SYS_LINK_MON_TABLE_COL_CNT) + { + spider_close_sys_table(thd, table, open_tables_backup, need_lock); + table = NULL; + my_printf_error(ER_SPIDER_SYS_TABLE_VERSION_NUM, + ER_SPIDER_SYS_TABLE_VERSION_STR, MYF(0), + SPIDER_SYS_LINK_MON_TABLE_NAME_STR); + *error_num = ER_SPIDER_SYS_TABLE_VERSION_NUM; + goto error_col_num_chk; + } + break; + } + if (!memcmp(table_name, SPIDER_SYS_RWN_TBLS_TABLE_NAME_STR, + SPIDER_SYS_RWN_TBLS_TABLE_NAME_LEN)) + { + DBUG_PRINT("info",("spider checking for SYS_RWN_TBLS")); + if (table->s->fields != SPIDER_SYS_RWN_TBLS_COL_CNT) + { + spider_close_sys_table(thd, table, open_tables_backup, need_lock); + table = NULL; + my_printf_error(ER_SPIDER_SYS_TABLE_VERSION_NUM, + ER_SPIDER_SYS_TABLE_VERSION_STR, MYF(0), + SPIDER_SYS_RWN_TBLS_TABLE_NAME_STR); + *error_num = ER_SPIDER_SYS_TABLE_VERSION_NUM; + goto error_col_num_chk; + } + break; + } + DBUG_ASSERT(0); + break; + case 27: + if (!memcmp(table_name, SPIDER_SYS_RW_TBL_TBLS_TABLE_NAME_STR, + SPIDER_SYS_RW_TBL_TBLS_TABLE_NAME_LEN)) + { + DBUG_PRINT("info",("spider checking for SYS_RW_TBL_TBLS")); + if (table->s->fields != SPIDER_SYS_RW_TBL_TBLS_COL_CNT) + { + spider_close_sys_table(thd, table, open_tables_backup, need_lock); + table = NULL; + my_printf_error(ER_SPIDER_SYS_TABLE_VERSION_NUM, + ER_SPIDER_SYS_TABLE_VERSION_STR, MYF(0), + SPIDER_SYS_RW_TBL_TBLS_TABLE_NAME_STR); + *error_num = ER_SPIDER_SYS_TABLE_VERSION_NUM; + goto error_col_num_chk; + } + break; + } + DBUG_ASSERT(0); + break; + case 31: + if (!memcmp(table_name, SPIDER_SYS_RW_TBL_PTTS_TABLE_NAME_STR, + SPIDER_SYS_RW_TBL_PTTS_TABLE_NAME_LEN)) + { + DBUG_PRINT("info",("spider checking for SYS_RW_TBL_PTTS")); + if (table->s->fields != SPIDER_SYS_RW_TBL_PTTS_COL_CNT) + { + spider_close_sys_table(thd, table, open_tables_backup, need_lock); + table = NULL; + my_printf_error(ER_SPIDER_SYS_TABLE_VERSION_NUM, + ER_SPIDER_SYS_TABLE_VERSION_STR, MYF(0), + SPIDER_SYS_RW_TBL_PTTS_TABLE_NAME_STR); + *error_num = ER_SPIDER_SYS_TABLE_VERSION_NUM; + goto error_col_num_chk; + } + break; + } + DBUG_ASSERT(0); + break; + case 34: + if (!memcmp(table_name, SPIDER_SYS_POS_FOR_RECOVERY_TABLE_NAME_STR, + SPIDER_SYS_POS_FOR_RECOVERY_TABLE_NAME_LEN)) + { + DBUG_PRINT("info",("spider checking for SYS_POS_FOR_RECOVERY")); + if (table->s->fields != SPIDER_SYS_POS_FOR_RECOVERY_TABLE_COL_CNT) + { + spider_close_sys_table(thd, table, open_tables_backup, need_lock); + table = NULL; + my_printf_error(ER_SPIDER_SYS_TABLE_VERSION_NUM, + ER_SPIDER_SYS_TABLE_VERSION_STR, MYF(0), + SPIDER_SYS_POS_FOR_RECOVERY_TABLE_NAME_STR); + *error_num = ER_SPIDER_SYS_TABLE_VERSION_NUM; + goto error_col_num_chk; + } + break; + } + if (!memcmp(table_name, SPIDER_SYS_RW_TBL_SPTTS_TABLE_NAME_STR, + SPIDER_SYS_RW_TBL_SPTTS_TABLE_NAME_LEN)) + { + DBUG_PRINT("info",("spider checking for SYS_RW_TBL_SPTTS")); + if (table->s->fields != SPIDER_SYS_RW_TBL_SPTTS_COL_CNT) + { + spider_close_sys_table(thd, table, open_tables_backup, need_lock); + table = NULL; + my_printf_error(ER_SPIDER_SYS_TABLE_VERSION_NUM, + ER_SPIDER_SYS_TABLE_VERSION_STR, MYF(0), + SPIDER_SYS_RW_TBL_SPTTS_TABLE_NAME_STR); + *error_num = ER_SPIDER_SYS_TABLE_VERSION_NUM; + goto error_col_num_chk; + } + break; + } + DBUG_ASSERT(0); + break; + default: + DBUG_ASSERT(0); + break; + } + DBUG_RETURN(table); +error_col_num_chk: + DBUG_RETURN(NULL); +} + +void spider_close_sys_table( + THD *thd, + TABLE *table, + SPIDER_Open_tables_backup *open_tables_backup, + bool need_lock +) { + DBUG_ENTER("spider_close_sys_table"); + spider_sys_close_table(thd, open_tables_backup); + DBUG_VOID_RETURN; +} + +bool spider_sys_open_and_lock_tables( + THD *thd, + TABLE_LIST **tables, + SPIDER_Open_tables_backup *open_tables_backup +) { + uint counter; + uint flags = MYSQL_OPEN_IGNORE_GLOBAL_READ_LOCK | + MYSQL_LOCK_IGNORE_GLOBAL_READ_ONLY | MYSQL_OPEN_IGNORE_FLUSH | + MYSQL_LOCK_IGNORE_TIMEOUT | MYSQL_LOCK_LOG_TABLE; + ulonglong utime_after_lock_backup = thd->utime_after_lock; + DBUG_ENTER("spider_sys_open_and_lock_tables"); + SPIDER_reset_n_backup_open_tables_state(thd, open_tables_backup, TRUE); + if (open_tables(thd, tables, &counter, flags)) + { + SPIDER_restore_backup_open_tables_state(thd, open_tables_backup); + thd->utime_after_lock = utime_after_lock_backup; + DBUG_RETURN(TRUE); + } + if (lock_tables(thd, *tables, counter, flags)) + { + SPIDER_sys_close_thread_tables(thd); + SPIDER_restore_backup_open_tables_state(thd, open_tables_backup); + thd->utime_after_lock = utime_after_lock_backup; + DBUG_RETURN(TRUE); + } + thd->utime_after_lock = utime_after_lock_backup; + DBUG_RETURN(FALSE); +} + +TABLE *spider_sys_open_table( + THD *thd, + TABLE_LIST *tables, + SPIDER_Open_tables_backup *open_tables_backup +) { + TABLE *table; + ulonglong utime_after_lock_backup = thd->utime_after_lock; + DBUG_ENTER("spider_sys_open_table"); + if (open_tables_backup) + { + SPIDER_reset_n_backup_open_tables_state(thd, open_tables_backup, NULL); + } + if ((table = open_ltable(thd, tables, tables->lock_type, + MYSQL_OPEN_IGNORE_GLOBAL_READ_LOCK | MYSQL_LOCK_IGNORE_GLOBAL_READ_ONLY | + MYSQL_OPEN_IGNORE_FLUSH | MYSQL_LOCK_IGNORE_TIMEOUT | MYSQL_LOCK_LOG_TABLE + ))) { + table->use_all_columns(); + table->s->no_replicate = 1; + } else if (open_tables_backup) + { + SPIDER_restore_backup_open_tables_state(thd, open_tables_backup); + } + thd->utime_after_lock = utime_after_lock_backup; + DBUG_RETURN(table); +} + +void spider_sys_close_table( + THD *thd, + SPIDER_Open_tables_backup *open_tables_backup +) { + DBUG_ENTER("spider_sys_close_table"); + if (open_tables_backup) + { + SPIDER_sys_close_thread_tables(thd); + SPIDER_restore_backup_open_tables_state(thd, open_tables_backup); + } + DBUG_VOID_RETURN; +} + +int spider_sys_index_init( + TABLE *table, + uint idx, + bool sorted +) { + DBUG_ENTER("spider_sys_index_init"); + DBUG_RETURN(table->file->ha_index_init(idx, sorted)); +} + +int spider_sys_index_end( + TABLE *table +) { + DBUG_ENTER("spider_sys_index_end"); + DBUG_RETURN(table->file->ha_index_end()); +} + +int spider_sys_rnd_init( + TABLE *table, + bool scan +) { + DBUG_ENTER("spider_sys_rnd_init"); + DBUG_RETURN(table->file->ha_rnd_init(scan)); +} + +int spider_sys_rnd_end( + TABLE *table +) { + DBUG_ENTER("spider_sys_rnd_end"); + DBUG_RETURN(table->file->ha_rnd_end()); +} + +int spider_check_sys_table( + TABLE *table, + char *table_key +) { + DBUG_ENTER("spider_check_sys_table"); + + key_copy( + (uchar *) table_key, + table->record[0], + table->key_info, + table->key_info->key_length); + + DBUG_RETURN(table->file->ha_index_read_idx_map( + table->record[0], 0, (uchar *) table_key, + HA_WHOLE_KEY, HA_READ_KEY_EXACT)); +} + +int spider_check_sys_table_with_find_flag( + TABLE *table, + char *table_key, + enum ha_rkey_function find_flag +) { + DBUG_ENTER("spider_check_sys_table"); + + key_copy( + (uchar *) table_key, + table->record[0], + table->key_info, + table->key_info->key_length); + + DBUG_RETURN(table->file->ha_index_read_idx_map( + table->record[0], 0, (uchar *) table_key, + HA_WHOLE_KEY, find_flag)); +} + +int spider_check_sys_table_for_update_all_columns( + TABLE *table, + char *table_key +) { + DBUG_ENTER("spider_check_sys_table_for_update_all_columns"); + + key_copy( + (uchar *) table_key, + table->record[0], + table->key_info, + table->key_info->key_length); + + DBUG_RETURN(table->file->ha_index_read_idx_map( + table->record[1], 0, (uchar *) table_key, + HA_WHOLE_KEY, HA_READ_KEY_EXACT)); +} + +int spider_get_sys_table_by_idx( + TABLE *table, + char *table_key, + const int idx, + const int col_count +) { + int error_num; + uint key_length; + KEY *key_info = table->key_info + idx; + DBUG_ENTER("spider_get_sys_table_by_idx"); + if ((error_num = spider_sys_index_init(table, idx, FALSE))) + DBUG_RETURN(error_num); + + if ((int) spider_user_defined_key_parts(key_info) == col_count) + { + key_length = key_info->key_length; + } else { + int roop_count; + key_length = 0; + for (roop_count = 0; roop_count < col_count; ++roop_count) + { + key_length += key_info->key_part[roop_count].store_length; + } + } + + key_copy( + (uchar *) table_key, + table->record[0], + key_info, + key_length); + + if ( + (error_num = table->file->ha_index_read_map( + table->record[0], (uchar *) table_key, + make_prev_keypart_map(col_count), HA_READ_KEY_EXACT)) + ) { + spider_sys_index_end(table); + DBUG_RETURN(error_num); + } + DBUG_RETURN(0); +} + +int spider_sys_index_next_same( + TABLE *table, + char *table_key +) { + DBUG_ENTER("spider_sys_index_next_same"); + DBUG_RETURN(table->file->ha_index_next_same( + table->record[0], + (const uchar*) table_key, + table->key_info->key_length)); +} + +int spider_sys_index_first( + TABLE *table, + const int idx +) { + int error_num; + DBUG_ENTER("spider_sys_index_first"); + if ((error_num = spider_sys_index_init(table, idx, FALSE))) + DBUG_RETURN(error_num); + + if ( + (error_num = table->file->ha_index_first(table->record[0])) + ) { + spider_sys_index_end(table); + DBUG_RETURN(error_num); + } + DBUG_RETURN(0); +} + +int spider_sys_index_last( + TABLE *table, + const int idx +) { + int error_num; + DBUG_ENTER("spider_sys_index_last"); + if ((error_num = spider_sys_index_init(table, idx, FALSE))) + DBUG_RETURN(error_num); + + if ( + (error_num = table->file->ha_index_last(table->record[0])) + ) { + spider_sys_index_end(table); + DBUG_RETURN(error_num); + } + DBUG_RETURN(0); +} + +int spider_sys_index_next( + TABLE *table +) { + DBUG_ENTER("spider_sys_index_next"); + DBUG_RETURN(table->file->ha_index_next(table->record[0])); +} + +void spider_store_xa_pk( + TABLE *table, + XID *xid +) { + DBUG_ENTER("spider_store_xa_pk"); + table->field[SPIDER_XA_FORMAT_ID_POS]->store(xid->formatID); + table->field[SPIDER_XA_GTRID_LENGTH_POS]->store(xid->gtrid_length); + table->field[SPIDER_XA_DATA_POS]->store( + xid->data, + (uint) xid->gtrid_length + xid->bqual_length, + system_charset_info); + DBUG_VOID_RETURN; +} + +void spider_store_xa_bqual_length( + TABLE *table, + XID *xid +) { + DBUG_ENTER("spider_store_xa_bqual_length"); + table->field[SPIDER_XA_BQUAL_LENGTH_POS]->store(xid->bqual_length); + DBUG_VOID_RETURN; +} + +void spider_store_xa_status( + TABLE *table, + const char *status +) { + DBUG_ENTER("spider_store_xa_status"); + table->field[SPIDER_XA_STATUS_POS]->store( + status, + (uint) strlen(status), + system_charset_info); + DBUG_VOID_RETURN; +} + +void spider_store_xa_member_pk( + TABLE *table, + XID *xid, + SPIDER_CONN *conn +) { + DBUG_ENTER("spider_store_xa_member_pk"); + table->field[SPIDER_XA_MEMBER_FORMAT_ID_POS]->store(xid->formatID); + table->field[SPIDER_XA_MEMBER_GTRID_LENGTH_POS]->store(xid->gtrid_length); + table->field[SPIDER_XA_MEMBER_DATA_POS]->store( + xid->data, + (uint) xid->gtrid_length + xid->bqual_length, + system_charset_info); + table->field[SPIDER_XA_MEMBER_HOST_POS]->store( + conn->tgt_host, + (uint) conn->tgt_host_length, + system_charset_info); + table->field[SPIDER_XA_MEMBER_PORT_POS]->store( + conn->tgt_port); + table->field[SPIDER_XA_MEMBER_SOCKET_POS]->store( + conn->tgt_socket, + (uint) conn->tgt_socket_length, + system_charset_info); + DBUG_VOID_RETURN; +} + +void spider_store_xa_member_info( + TABLE *table, + XID *xid, + SPIDER_CONN *conn +) { + DBUG_ENTER("spider_store_xa_member_info"); + table->field[SPIDER_XA_MEMBER_BQUAL_LENGTH_POS]->store(xid->bqual_length); + table->field[SPIDER_XA_MEMBER_SCHEME_POS]->store( + conn->tgt_wrapper, + (uint) conn->tgt_wrapper_length, + system_charset_info); + table->field[SPIDER_XA_MEMBER_USERNAME_POS]->store( + conn->tgt_username, + (uint) conn->tgt_username_length, + system_charset_info); + table->field[SPIDER_XA_MEMBER_PASSWORD_POS]->store( + conn->tgt_password, + (uint) conn->tgt_password_length, + system_charset_info); + if (conn->tgt_ssl_ca) + { + table->field[SPIDER_XA_MEMBER_SSL_CA_POS]->set_notnull(); + table->field[SPIDER_XA_MEMBER_SSL_CA_POS]->store( + conn->tgt_ssl_ca, + (uint) conn->tgt_ssl_ca_length, + system_charset_info); + } else { + table->field[SPIDER_XA_MEMBER_SSL_CA_POS]->set_null(); + table->field[SPIDER_XA_MEMBER_SSL_CA_POS]->reset(); + } + if (conn->tgt_ssl_capath) + { + table->field[SPIDER_XA_MEMBER_SSL_CAPATH_POS]->set_notnull(); + table->field[SPIDER_XA_MEMBER_SSL_CAPATH_POS]->store( + conn->tgt_ssl_capath, + (uint) conn->tgt_ssl_capath_length, + system_charset_info); + } else { + table->field[SPIDER_XA_MEMBER_SSL_CAPATH_POS]->set_null(); + table->field[SPIDER_XA_MEMBER_SSL_CAPATH_POS]->reset(); + } + if (conn->tgt_ssl_cert) + { + table->field[SPIDER_XA_MEMBER_SSL_CERT_POS]->set_notnull(); + table->field[SPIDER_XA_MEMBER_SSL_CERT_POS]->store( + conn->tgt_ssl_cert, + (uint) conn->tgt_ssl_cert_length, + system_charset_info); + } else { + table->field[SPIDER_XA_MEMBER_SSL_CERT_POS]->set_null(); + table->field[SPIDER_XA_MEMBER_SSL_CERT_POS]->reset(); + } + if (conn->tgt_ssl_cipher) + { + table->field[SPIDER_XA_MEMBER_SSL_CIPHER_POS]->set_notnull(); + table->field[SPIDER_XA_MEMBER_SSL_CIPHER_POS]->store( + conn->tgt_ssl_cipher, + (uint) conn->tgt_ssl_cipher_length, + system_charset_info); + } else { + table->field[SPIDER_XA_MEMBER_SSL_CIPHER_POS]->set_null(); + table->field[SPIDER_XA_MEMBER_SSL_CIPHER_POS]->reset(); + } + if (conn->tgt_ssl_key) + { + table->field[SPIDER_XA_MEMBER_SSL_KEY_POS]->set_notnull(); + table->field[SPIDER_XA_MEMBER_SSL_KEY_POS]->store( + conn->tgt_ssl_key, + (uint) conn->tgt_ssl_key_length, + system_charset_info); + } else { + table->field[SPIDER_XA_MEMBER_SSL_KEY_POS]->set_null(); + table->field[SPIDER_XA_MEMBER_SSL_KEY_POS]->reset(); + } + if (conn->tgt_ssl_vsc >= 0) + { + table->field[SPIDER_XA_MEMBER_SSL_VERIFY_SERVER_CERT_POS]->set_notnull(); + table->field[SPIDER_XA_MEMBER_SSL_VERIFY_SERVER_CERT_POS]->store( + conn->tgt_ssl_vsc); + } else { + table->field[SPIDER_XA_MEMBER_SSL_VERIFY_SERVER_CERT_POS]->set_null(); + table->field[SPIDER_XA_MEMBER_SSL_VERIFY_SERVER_CERT_POS]->reset(); + } + if (conn->tgt_default_file) + { + table->field[SPIDER_XA_MEMBER_DEFAULT_FILE_POS]->set_notnull(); + table->field[SPIDER_XA_MEMBER_DEFAULT_FILE_POS]->store( + conn->tgt_default_file, + (uint) conn->tgt_default_file_length, + system_charset_info); + } else { + table->field[SPIDER_XA_MEMBER_DEFAULT_FILE_POS]->set_null(); + table->field[SPIDER_XA_MEMBER_DEFAULT_FILE_POS]->reset(); + } + if (conn->tgt_default_group) + { + table->field[SPIDER_XA_MEMBER_DEFAULT_GROUP_POS]->set_notnull(); + table->field[SPIDER_XA_MEMBER_DEFAULT_GROUP_POS]->store( + conn->tgt_default_group, + (uint) conn->tgt_default_group_length, + system_charset_info); + } else { + table->field[SPIDER_XA_MEMBER_DEFAULT_GROUP_POS]->set_null(); + table->field[SPIDER_XA_MEMBER_DEFAULT_GROUP_POS]->reset(); + } + if (conn->tgt_dsn) + { + table->field[SPIDER_XA_MEMBER_DSN_POS]->set_notnull(); + table->field[SPIDER_XA_MEMBER_DSN_POS]->store( + conn->tgt_dsn, + (uint) conn->tgt_dsn_length, + system_charset_info); + } else { + table->field[SPIDER_XA_MEMBER_DSN_POS]->set_null(); + table->field[SPIDER_XA_MEMBER_DSN_POS]->reset(); + } + if (conn->tgt_filedsn) + { + table->field[SPIDER_XA_MEMBER_FILEDSN_POS]->set_notnull(); + table->field[SPIDER_XA_MEMBER_FILEDSN_POS]->store( + conn->tgt_filedsn, + (uint) conn->tgt_filedsn_length, + system_charset_info); + } else { + table->field[SPIDER_XA_MEMBER_FILEDSN_POS]->set_null(); + table->field[SPIDER_XA_MEMBER_FILEDSN_POS]->reset(); + } + if (conn->tgt_driver) + { + table->field[SPIDER_XA_MEMBER_DRIVER_POS]->set_notnull(); + table->field[SPIDER_XA_MEMBER_DRIVER_POS]->store( + conn->tgt_driver, + (uint) conn->tgt_driver_length, + system_charset_info); + } else { + table->field[SPIDER_XA_MEMBER_DRIVER_POS]->set_null(); + table->field[SPIDER_XA_MEMBER_DRIVER_POS]->reset(); + } + DBUG_VOID_RETURN; +} + +void spider_store_tables_name( + TABLE *table, + const char *name, + const uint name_length +) { + const char *ptr_db, *ptr_table; + my_ptrdiff_t ptr_diff_db, ptr_diff_table; + DBUG_ENTER("spider_store_tables_name"); + if (name[0] == FN_CURLIB && name[1] == FN_LIBCHAR) + { + ptr_db = strchr(name, FN_LIBCHAR); + ptr_db++; + ptr_diff_db = PTR_BYTE_DIFF(ptr_db, 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)); + } else { + DBUG_PRINT("info",("spider temporary table")); + ptr_db = ""; + ptr_diff_db = 1; + ptr_table = ""; + ptr_diff_table = 1; + } + table->field[SPIDER_TABLES_DB_NAME_POS]->store( + ptr_db, + (uint)(ptr_diff_table - 1), + system_charset_info); + DBUG_PRINT("info",("spider field[%u]->null_bit = %d", + SPIDER_TABLES_DB_NAME_POS, + table->field[SPIDER_TABLES_DB_NAME_POS]->null_bit)); + table->field[SPIDER_TABLES_TABLE_NAME_POS]->store( + ptr_table, + (uint) ((my_ptrdiff_t) name_length - ptr_diff_db - ptr_diff_table), + system_charset_info); + DBUG_PRINT("info",("spider field[%u]->null_bit = %d", + SPIDER_TABLES_TABLE_NAME_POS, + table->field[SPIDER_TABLES_TABLE_NAME_POS]->null_bit)); + DBUG_VOID_RETURN; +} + +void spider_store_db_and_table_name( + TABLE *table, + const char *db_name, + const uint db_name_length, + const char *table_name, + const uint table_name_length +) { + DBUG_ENTER("spider_store_db_and_table_name"); + table->field[SPIDER_TABLES_DB_NAME_POS]->store( + db_name, + db_name_length, + system_charset_info); + DBUG_PRINT("info",("spider field[%u]->null_bit = %d", + SPIDER_TABLES_DB_NAME_POS, + table->field[SPIDER_TABLES_DB_NAME_POS]->null_bit)); + table->field[SPIDER_TABLES_TABLE_NAME_POS]->store( + table_name, + table_name_length, + system_charset_info); + DBUG_PRINT("info",("spider field[%u]->null_bit = %d", + SPIDER_TABLES_TABLE_NAME_POS, + table->field[SPIDER_TABLES_TABLE_NAME_POS]->null_bit)); + DBUG_VOID_RETURN; +} + +void spider_store_tables_link_idx( + TABLE *table, + int link_idx +) { + DBUG_ENTER("spider_store_tables_link_idx"); + table->field[SPIDER_TABLES_LINK_ID_POS]->set_notnull(); + table->field[SPIDER_TABLES_LINK_ID_POS]->store(link_idx); + DBUG_VOID_RETURN; +} + +void spider_store_tables_link_idx_str( + TABLE *table, + const char *link_idx, + const uint link_idx_length +) { + DBUG_ENTER("spider_store_tables_link_idx_str"); + table->field[SPIDER_TABLES_LINK_ID_POS]->store( + link_idx, + link_idx_length, + system_charset_info); + DBUG_PRINT("info",("spider field[%u]->null_bit = %d", + SPIDER_TABLES_LINK_ID_POS, + table->field[SPIDER_TABLES_LINK_ID_POS]->null_bit)); + DBUG_VOID_RETURN; +} + +void spider_store_tables_static_link_id( + TABLE *table, + const char *static_link_id, + const uint static_link_id_length +) { + DBUG_ENTER("spider_store_tables_static_link_id"); + if (static_link_id) + { + table->field[SPIDER_TABLES_STATIC_LINK_ID_POS]->set_notnull(); + table->field[SPIDER_TABLES_STATIC_LINK_ID_POS]->store( + static_link_id, + static_link_id_length, + system_charset_info); + } else { + table->field[SPIDER_TABLES_STATIC_LINK_ID_POS]->set_null(); + table->field[SPIDER_TABLES_STATIC_LINK_ID_POS]->reset(); + } + DBUG_VOID_RETURN; +} + +void spider_store_tables_priority( + TABLE *table, + longlong priority +) { + DBUG_ENTER("spider_store_tables_priority"); + DBUG_PRINT("info",("spider priority = %lld", priority)); + table->field[SPIDER_TABLES_PRIORITY_POS]->store(priority, FALSE); + DBUG_VOID_RETURN; +} + +void spider_store_tables_connect_info( + TABLE *table, + SPIDER_ALTER_TABLE *alter_table, + int link_idx +) { + DBUG_ENTER("spider_store_tables_connect_info"); + if (alter_table->tmp_server_names[link_idx]) + { + table->field[SPIDER_TABLES_SERVER_POS]->set_notnull(); + table->field[SPIDER_TABLES_SERVER_POS]->store( + alter_table->tmp_server_names[link_idx], + (uint) alter_table->tmp_server_names_lengths[link_idx], + system_charset_info); + } else { + table->field[SPIDER_TABLES_SERVER_POS]->set_null(); + table->field[SPIDER_TABLES_SERVER_POS]->reset(); + } + if (alter_table->tmp_tgt_wrappers[link_idx]) + { + table->field[SPIDER_TABLES_SCHEME_POS]->set_notnull(); + table->field[SPIDER_TABLES_SCHEME_POS]->store( + alter_table->tmp_tgt_wrappers[link_idx], + (uint) alter_table->tmp_tgt_wrappers_lengths[link_idx], + system_charset_info); + } else { + table->field[SPIDER_TABLES_SCHEME_POS]->set_null(); + table->field[SPIDER_TABLES_SCHEME_POS]->reset(); + } + if (alter_table->tmp_tgt_hosts[link_idx]) + { + table->field[SPIDER_TABLES_HOST_POS]->set_notnull(); + table->field[SPIDER_TABLES_HOST_POS]->store( + alter_table->tmp_tgt_hosts[link_idx], + (uint) alter_table->tmp_tgt_hosts_lengths[link_idx], + system_charset_info); + } else { + table->field[SPIDER_TABLES_HOST_POS]->set_null(); + table->field[SPIDER_TABLES_HOST_POS]->reset(); + } + if (alter_table->tmp_tgt_ports[link_idx] >= 0) + { + table->field[SPIDER_TABLES_PORT_POS]->set_notnull(); + table->field[SPIDER_TABLES_PORT_POS]->store( + alter_table->tmp_tgt_ports[link_idx]); + } else { + table->field[SPIDER_TABLES_PORT_POS]->set_null(); + table->field[SPIDER_TABLES_PORT_POS]->reset(); + } + if (alter_table->tmp_tgt_sockets[link_idx]) + { + table->field[SPIDER_TABLES_SOCKET_POS]->set_notnull(); + table->field[SPIDER_TABLES_SOCKET_POS]->store( + alter_table->tmp_tgt_sockets[link_idx], + (uint) alter_table->tmp_tgt_sockets_lengths[link_idx], + system_charset_info); + } else { + table->field[SPIDER_TABLES_SOCKET_POS]->set_null(); + table->field[SPIDER_TABLES_SOCKET_POS]->reset(); + } + if (alter_table->tmp_tgt_usernames[link_idx]) + { + table->field[SPIDER_TABLES_USERNAME_POS]->set_notnull(); + table->field[SPIDER_TABLES_USERNAME_POS]->store( + alter_table->tmp_tgt_usernames[link_idx], + (uint) alter_table->tmp_tgt_usernames_lengths[link_idx], + system_charset_info); + } else { + table->field[SPIDER_TABLES_USERNAME_POS]->set_null(); + table->field[SPIDER_TABLES_USERNAME_POS]->reset(); + } + if (alter_table->tmp_tgt_passwords[link_idx]) + { + table->field[SPIDER_TABLES_PASSWORD_POS]->set_notnull(); + table->field[SPIDER_TABLES_PASSWORD_POS]->store( + alter_table->tmp_tgt_passwords[link_idx], + (uint) alter_table->tmp_tgt_passwords_lengths[link_idx], + system_charset_info); + } else { + table->field[SPIDER_TABLES_PASSWORD_POS]->set_null(); + table->field[SPIDER_TABLES_PASSWORD_POS]->reset(); + } + if (alter_table->tmp_tgt_ssl_cas[link_idx]) + { + table->field[SPIDER_TABLES_SSL_CA_POS]->set_notnull(); + table->field[SPIDER_TABLES_SSL_CA_POS]->store( + alter_table->tmp_tgt_ssl_cas[link_idx], + (uint) alter_table->tmp_tgt_ssl_cas_lengths[link_idx], + system_charset_info); + } else { + table->field[SPIDER_TABLES_SSL_CA_POS]->set_null(); + table->field[SPIDER_TABLES_SSL_CA_POS]->reset(); + } + if (alter_table->tmp_tgt_ssl_capaths[link_idx]) + { + table->field[SPIDER_TABLES_SSL_CAPATH_POS]->set_notnull(); + table->field[SPIDER_TABLES_SSL_CAPATH_POS]->store( + alter_table->tmp_tgt_ssl_capaths[link_idx], + (uint) alter_table->tmp_tgt_ssl_capaths_lengths[link_idx], + system_charset_info); + } else { + table->field[SPIDER_TABLES_SSL_CAPATH_POS]->set_null(); + table->field[SPIDER_TABLES_SSL_CAPATH_POS]->reset(); + } + if (alter_table->tmp_tgt_ssl_certs[link_idx]) + { + table->field[SPIDER_TABLES_SSL_CERT_POS]->set_notnull(); + table->field[SPIDER_TABLES_SSL_CERT_POS]->store( + alter_table->tmp_tgt_ssl_certs[link_idx], + (uint) alter_table->tmp_tgt_ssl_certs_lengths[link_idx], + system_charset_info); + } else { + table->field[SPIDER_TABLES_SSL_CERT_POS]->set_null(); + table->field[SPIDER_TABLES_SSL_CERT_POS]->reset(); + } + if (alter_table->tmp_tgt_ssl_ciphers[link_idx]) + { + table->field[SPIDER_TABLES_SSL_CIPHER_POS]->set_notnull(); + table->field[SPIDER_TABLES_SSL_CIPHER_POS]->store( + alter_table->tmp_tgt_ssl_ciphers[link_idx], + (uint) alter_table->tmp_tgt_ssl_ciphers_lengths[link_idx], + system_charset_info); + } else { + table->field[SPIDER_TABLES_SSL_CIPHER_POS]->set_null(); + table->field[SPIDER_TABLES_SSL_CIPHER_POS]->reset(); + } + if (alter_table->tmp_tgt_ssl_keys[link_idx]) + { + table->field[SPIDER_TABLES_SSL_KEY_POS]->set_notnull(); + table->field[SPIDER_TABLES_SSL_KEY_POS]->store( + alter_table->tmp_tgt_ssl_keys[link_idx], + (uint) alter_table->tmp_tgt_ssl_keys_lengths[link_idx], + system_charset_info); + } else { + table->field[SPIDER_TABLES_SSL_KEY_POS]->set_null(); + table->field[SPIDER_TABLES_SSL_KEY_POS]->reset(); + } + if (alter_table->tmp_tgt_ssl_vscs[link_idx] >= 0) + { + table->field[SPIDER_TABLES_SSL_VERIFY_SERVER_CERT_POS]->set_notnull(); + table->field[SPIDER_TABLES_SSL_VERIFY_SERVER_CERT_POS]->store( + alter_table->tmp_tgt_ssl_vscs[link_idx]); + } else { + table->field[SPIDER_TABLES_SSL_VERIFY_SERVER_CERT_POS]->set_null(); + table->field[SPIDER_TABLES_SSL_VERIFY_SERVER_CERT_POS]->reset(); + } + table->field[SPIDER_TABLES_MONITORING_BINLOG_POS_AT_FAILING_POS]-> + set_notnull(); + if (alter_table->tmp_monitoring_binlog_pos_at_failing[link_idx] >= 0) + { + table->field[SPIDER_TABLES_MONITORING_BINLOG_POS_AT_FAILING_POS]->store( + alter_table->tmp_monitoring_binlog_pos_at_failing[link_idx]); + } else { + table->field[SPIDER_TABLES_MONITORING_BINLOG_POS_AT_FAILING_POS]->store(0); + } + if (alter_table->tmp_tgt_default_files[link_idx]) + { + table->field[SPIDER_TABLES_DEFAULT_FILE_POS]->set_notnull(); + table->field[SPIDER_TABLES_DEFAULT_FILE_POS]->store( + alter_table->tmp_tgt_default_files[link_idx], + (uint) alter_table->tmp_tgt_default_files_lengths[link_idx], + system_charset_info); + } else { + table->field[SPIDER_TABLES_DEFAULT_FILE_POS]->set_null(); + table->field[SPIDER_TABLES_DEFAULT_FILE_POS]->reset(); + } + if (alter_table->tmp_tgt_default_groups[link_idx]) + { + table->field[SPIDER_TABLES_DEFAULT_GROUP_POS]->set_notnull(); + table->field[SPIDER_TABLES_DEFAULT_GROUP_POS]->store( + alter_table->tmp_tgt_default_groups[link_idx], + (uint) alter_table->tmp_tgt_default_groups_lengths[link_idx], + system_charset_info); + } else { + table->field[SPIDER_TABLES_DEFAULT_GROUP_POS]->set_null(); + table->field[SPIDER_TABLES_DEFAULT_GROUP_POS]->reset(); + } + if (alter_table->tmp_tgt_dsns[link_idx]) + { + table->field[SPIDER_TABLES_DSN_POS]->set_notnull(); + table->field[SPIDER_TABLES_DSN_POS]->store( + alter_table->tmp_tgt_dsns[link_idx], + (uint) alter_table->tmp_tgt_dsns_lengths[link_idx], + system_charset_info); + } else { + table->field[SPIDER_TABLES_DSN_POS]->set_null(); + table->field[SPIDER_TABLES_DSN_POS]->reset(); + } + if (alter_table->tmp_tgt_filedsns[link_idx]) + { + table->field[SPIDER_TABLES_FILEDSN_POS]->set_notnull(); + table->field[SPIDER_TABLES_FILEDSN_POS]->store( + alter_table->tmp_tgt_filedsns[link_idx], + (uint) alter_table->tmp_tgt_filedsns_lengths[link_idx], + system_charset_info); + } else { + table->field[SPIDER_TABLES_FILEDSN_POS]->set_null(); + table->field[SPIDER_TABLES_FILEDSN_POS]->reset(); + } + if (alter_table->tmp_tgt_drivers[link_idx]) + { + table->field[SPIDER_TABLES_DRIVER_POS]->set_notnull(); + table->field[SPIDER_TABLES_DRIVER_POS]->store( + alter_table->tmp_tgt_drivers[link_idx], + (uint) alter_table->tmp_tgt_drivers_lengths[link_idx], + system_charset_info); + } else { + table->field[SPIDER_TABLES_DRIVER_POS]->set_null(); + table->field[SPIDER_TABLES_DRIVER_POS]->reset(); + } + if (alter_table->tmp_tgt_dbs[link_idx]) + { + table->field[SPIDER_TABLES_TGT_DB_NAME_POS]->set_notnull(); + table->field[SPIDER_TABLES_TGT_DB_NAME_POS]->store( + alter_table->tmp_tgt_dbs[link_idx], + (uint) alter_table->tmp_tgt_dbs_lengths[link_idx], + system_charset_info); + } else { + table->field[SPIDER_TABLES_TGT_DB_NAME_POS]->set_null(); + table->field[SPIDER_TABLES_TGT_DB_NAME_POS]->reset(); + } + if (alter_table->tmp_tgt_table_names[link_idx]) + { + table->field[SPIDER_TABLES_TGT_TABLE_NAME_POS]->set_notnull(); + table->field[SPIDER_TABLES_TGT_TABLE_NAME_POS]->store( + alter_table->tmp_tgt_table_names[link_idx], + (uint) alter_table->tmp_tgt_table_names_lengths[link_idx], + system_charset_info); + } else { + table->field[SPIDER_TABLES_TGT_TABLE_NAME_POS]->set_null(); + table->field[SPIDER_TABLES_TGT_TABLE_NAME_POS]->reset(); + } + table->field[SPIDER_TABLES_BLOCK_STATUS_POS]->store((longlong) 0, FALSE); + if (alter_table->tmp_static_link_ids[link_idx]) + { + DBUG_PRINT("info",("spider static_link_id[%d] = %s", + link_idx, alter_table->tmp_static_link_ids[link_idx])); + table->field[SPIDER_TABLES_STATIC_LINK_ID_POS]->set_notnull(); + table->field[SPIDER_TABLES_STATIC_LINK_ID_POS]->store( + alter_table->tmp_static_link_ids[link_idx], + (uint) alter_table->tmp_static_link_ids_lengths[link_idx], + system_charset_info); + } else { + DBUG_PRINT("info",("spider static_link_id[%d] = NULL", link_idx)); + table->field[SPIDER_TABLES_STATIC_LINK_ID_POS]->set_null(); + table->field[SPIDER_TABLES_STATIC_LINK_ID_POS]->reset(); + } + DBUG_VOID_RETURN; +} + +void spider_store_tables_link_status( + TABLE *table, + long link_status +) { + DBUG_ENTER("spider_store_tables_link_status"); + DBUG_PRINT("info",("spider link_status = %ld", link_status)); + if (link_status > SPIDER_LINK_STATUS_NO_CHANGE) + table->field[SPIDER_TABLES_LINK_STATUS_POS]->store(link_status, FALSE); + DBUG_VOID_RETURN; +} + +void spider_store_binlog_pos_failed_link_idx( + TABLE *table, + int failed_link_idx +) { + DBUG_ENTER("spider_store_binlog_pos_failed_link_idx"); + table->field[SPIDER_TABLE_POSITION_FOR_RECOVERY_FAILED_LINK_ID_POS]-> + set_notnull(); + table->field[SPIDER_TABLE_POSITION_FOR_RECOVERY_FAILED_LINK_ID_POS]-> + store(failed_link_idx); + DBUG_VOID_RETURN; +} + +void spider_store_binlog_pos_source_link_idx( + TABLE *table, + int source_link_idx +) { + DBUG_ENTER("spider_store_binlog_pos_source_link_idx"); + table->field[SPIDER_TABLE_POSITION_FOR_RECOVERY_SOURCE_LINK_ID_POS]-> + set_notnull(); + table->field[SPIDER_TABLE_POSITION_FOR_RECOVERY_SOURCE_LINK_ID_POS]-> + store(source_link_idx); + DBUG_VOID_RETURN; +} + +void spider_store_binlog_pos_binlog_file( + TABLE *table, + const char *file_name, + int file_name_length, + const char *position, + int position_length, + CHARSET_INFO *binlog_pos_cs +) { + DBUG_ENTER("spider_store_binlog_pos_binlog_file"); + if (!file_name) + { + DBUG_PRINT("info",("spider file_name is NULL")); + table->field[SPIDER_TABLE_POSITION_FOR_RECOVERY_FILE_POS]->set_null(); + table->field[SPIDER_TABLE_POSITION_FOR_RECOVERY_FILE_POS]->reset(); + } else { + DBUG_PRINT("info",("spider file_name = %s", file_name)); + table->field[SPIDER_TABLE_POSITION_FOR_RECOVERY_FILE_POS]->set_notnull(); + table->field[SPIDER_TABLE_POSITION_FOR_RECOVERY_FILE_POS]->store( + file_name, file_name_length, binlog_pos_cs); + } + if (!position) + { + DBUG_PRINT("info",("spider position is NULL")); + table->field[SPIDER_TABLE_POSITION_FOR_RECOVERY_POSITION_POS]->set_null(); + table->field[SPIDER_TABLE_POSITION_FOR_RECOVERY_POSITION_POS]->reset(); + } else { + DBUG_PRINT("info",("spider position = %s", position)); + table->field[SPIDER_TABLE_POSITION_FOR_RECOVERY_POSITION_POS]-> + set_notnull(); + table->field[SPIDER_TABLE_POSITION_FOR_RECOVERY_POSITION_POS]->store( + position, position_length, binlog_pos_cs); + } + DBUG_VOID_RETURN; +} + +void spider_store_binlog_pos_gtid( + TABLE *table, + const char *gtid, + int gtid_length, + CHARSET_INFO *binlog_pos_cs +) { + DBUG_ENTER("spider_store_binlog_pos_gtid"); + if (!gtid) + { + DBUG_PRINT("info",("spider gtid is NULL")); + table->field[SPIDER_TABLE_POSITION_FOR_RECOVERY_GTID_POS]->set_null(); + table->field[SPIDER_TABLE_POSITION_FOR_RECOVERY_GTID_POS]->reset(); + } else { + DBUG_PRINT("info",("spider gtid = %s", gtid)); + table->field[SPIDER_TABLE_POSITION_FOR_RECOVERY_GTID_POS]->set_notnull(); + table->field[SPIDER_TABLE_POSITION_FOR_RECOVERY_GTID_POS]->store( + gtid, gtid_length, binlog_pos_cs); + } + DBUG_VOID_RETURN; +} + +void spider_store_table_sts_info( + TABLE *table, + ha_statistics *stat +) { + MYSQL_TIME mysql_time; + DBUG_ENTER("spider_store_table_sts_info"); + table->field[SPIDER_TABLE_STS_DATA_FILE_LENGTH_POS]->store( + (longlong) stat->data_file_length, TRUE); + table->field[SPIDER_TABLE_STS_MAX_DATA_FILE_LENGTH_POS]->store( + (longlong) stat->max_data_file_length, TRUE); + table->field[SPIDER_TABLE_STS_INDEX_FILE_LENGTH_POS]->store( + (longlong) stat->index_file_length, TRUE); + table->field[SPIDER_TABLE_STS_RECORDS_POS]->store( + (longlong) stat->records, TRUE); + table->field[SPIDER_TABLE_STS_MEAN_REC_LENGTH_POS]->store( + (longlong) stat->mean_rec_length, TRUE); + spd_tz_system->gmt_sec_to_TIME(&mysql_time, (my_time_t) stat->check_time); + table->field[SPIDER_TABLE_STS_CHECK_TIME_POS]->store_time(&mysql_time); + spd_tz_system->gmt_sec_to_TIME(&mysql_time, (my_time_t) stat->create_time); + table->field[SPIDER_TABLE_STS_CREATE_TIME_POS]->store_time(&mysql_time); + spd_tz_system->gmt_sec_to_TIME(&mysql_time, (my_time_t) stat->update_time); + table->field[SPIDER_TABLE_STS_UPDATE_TIME_POS]->store_time(&mysql_time); + if (stat->checksum_null) + { + table->field[SPIDER_TABLE_STS_CHECKSUM_POS]->set_null(); + table->field[SPIDER_TABLE_STS_CHECKSUM_POS]->reset(); + } else { + table->field[SPIDER_TABLE_STS_CHECKSUM_POS]->set_notnull(); + table->field[SPIDER_TABLE_STS_CHECKSUM_POS]->store( + (longlong) stat->checksum, TRUE); + } + DBUG_VOID_RETURN; +} + +void spider_store_table_crd_info( + TABLE *table, + uint *seq, + longlong *cardinality +) { + DBUG_ENTER("spider_store_table_crd_info"); + table->field[SPIDER_TABLE_CRD_KEY_SEQ_POS]->store((longlong) *seq, TRUE); + table->field[SPIDER_TABLE_CRD_CARDINALITY_POS]->store( + (longlong) *cardinality, FALSE); + DBUG_VOID_RETURN; +} + +int spider_insert_xa( + TABLE *table, + XID *xid, + const char *status +) { + int error_num; + char table_key[MAX_KEY_LENGTH]; + DBUG_ENTER("spider_insert_xa"); + table->use_all_columns(); + empty_record(table); + spider_store_xa_pk(table, xid); + + if ((error_num = spider_check_sys_table(table, table_key))) + { + if (error_num != HA_ERR_KEY_NOT_FOUND && error_num != HA_ERR_END_OF_FILE) + { + table->file->print_error(error_num, MYF(0)); + DBUG_RETURN(error_num); + } + table->use_all_columns(); + spider_store_xa_bqual_length(table, xid); + spider_store_xa_status(table, status); + if ((error_num = spider_write_sys_table_row(table))) + { + DBUG_RETURN(error_num); + } + } else { + my_message(ER_SPIDER_XA_EXISTS_NUM, ER_SPIDER_XA_EXISTS_STR, MYF(0)); + DBUG_RETURN(ER_SPIDER_XA_EXISTS_NUM); + } + + DBUG_RETURN(0); +} + +int spider_insert_xa_member( + TABLE *table, + XID *xid, + SPIDER_CONN *conn +) { + int error_num; + char table_key[MAX_KEY_LENGTH]; + DBUG_ENTER("spider_insert_xa_member"); + table->use_all_columns(); + empty_record(table); + spider_store_xa_member_pk(table, xid, conn); + + if ((error_num = spider_check_sys_table(table, table_key))) + { + if (error_num != HA_ERR_KEY_NOT_FOUND && error_num != HA_ERR_END_OF_FILE) + { + table->file->print_error(error_num, MYF(0)); + DBUG_RETURN(error_num); + } + table->use_all_columns(); + spider_store_xa_member_info(table, xid, conn); + if ((error_num = spider_write_sys_table_row(table))) + { + DBUG_RETURN(error_num); + } + } else { + my_message(ER_SPIDER_XA_MEMBER_EXISTS_NUM, ER_SPIDER_XA_MEMBER_EXISTS_STR, + MYF(0)); + DBUG_RETURN(ER_SPIDER_XA_MEMBER_EXISTS_NUM); + } + + DBUG_RETURN(0); +} + +int spider_insert_tables( + TABLE *table, + SPIDER_SHARE *share +) { + int error_num, roop_count; + DBUG_ENTER("spider_insert_tables"); + table->use_all_columns(); + empty_record(table); + + spider_store_tables_name(table, share->table_name, share->table_name_length); + spider_store_tables_priority(table, share->priority); + for (roop_count = 0; roop_count < (int) share->all_link_count; roop_count++) + { + spider_store_tables_link_idx(table, roop_count); + spider_store_tables_connect_info(table, &share->alter_table, roop_count); + spider_store_tables_link_status(table, + share->alter_table.tmp_link_statuses[roop_count] > + SPIDER_LINK_STATUS_NO_CHANGE ? + share->alter_table.tmp_link_statuses[roop_count] : + SPIDER_LINK_STATUS_OK); + if ((error_num = spider_write_sys_table_row(table))) + { + DBUG_RETURN(error_num); + } + } + + DBUG_RETURN(0); +} + +int spider_insert_sys_table( + TABLE *table +) { + int error_num; + DBUG_ENTER("spider_insert_sys_table"); + error_num = spider_write_sys_table_row(table); + DBUG_RETURN(error_num); +} + +int spider_insert_or_update_table_sts( + TABLE *table, + const char *name, + uint name_length, + ha_statistics *stat +) { + int error_num; + char table_key[MAX_KEY_LENGTH]; + DBUG_ENTER("spider_insert_or_update_table_sts"); + table->use_all_columns(); + spider_store_tables_name(table, name, name_length); + spider_store_table_sts_info( + table, + stat + ); + + if ((error_num = spider_check_sys_table_for_update_all_columns(table, table_key))) + { + if (error_num != HA_ERR_KEY_NOT_FOUND && error_num != HA_ERR_END_OF_FILE) + { + table->file->print_error(error_num, MYF(0)); + DBUG_RETURN(error_num); + } + if ((error_num = spider_write_sys_table_row(table))) + { + DBUG_RETURN(error_num); + } + } else { + if ((error_num = spider_update_sys_table_row(table, FALSE))) + { + table->file->print_error(error_num, MYF(0)); + DBUG_RETURN(error_num); + } + } + + DBUG_RETURN(0); +} + +int spider_insert_or_update_table_crd( + TABLE *table, + const char *name, + uint name_length, + longlong *cardinality, + uint number_of_keys +) { + int error_num; + uint roop_count; + char table_key[MAX_KEY_LENGTH]; + DBUG_ENTER("spider_insert_or_update_table_crd"); + table->use_all_columns(); + spider_store_tables_name(table, name, name_length); + + for (roop_count = 0; roop_count < number_of_keys; ++roop_count) + { + spider_store_table_crd_info(table, &roop_count, &cardinality[roop_count]); + if ((error_num = spider_check_sys_table_for_update_all_columns(table, table_key))) + { + if (error_num != HA_ERR_KEY_NOT_FOUND && error_num != HA_ERR_END_OF_FILE) + { + table->file->print_error(error_num, MYF(0)); + DBUG_RETURN(error_num); + } + if ((error_num = spider_write_sys_table_row(table))) + { + DBUG_RETURN(error_num); + } + } else { + if ((error_num = spider_update_sys_table_row(table, FALSE))) + { + table->file->print_error(error_num, MYF(0)); + DBUG_RETURN(error_num); + } + } + } + DBUG_RETURN(0); +} + +int spider_log_tables_link_failed( + TABLE *table, + char *name, + uint name_length, + int link_idx +) { + int error_num; + DBUG_ENTER("spider_log_tables_link_failed"); + table->use_all_columns(); + spider_store_tables_name(table, name, name_length); + spider_store_tables_link_idx(table, link_idx); + if ((error_num = spider_write_sys_table_row(table))) + { + DBUG_RETURN(error_num); + } + DBUG_RETURN(0); +} + +int spider_log_xa_failed( + THD *thd, + TABLE *table, + XID *xid, + SPIDER_CONN *conn, + const char *status +) { + int error_num; + DBUG_ENTER("spider_log_xa_failed"); + table->use_all_columns(); + spider_store_xa_member_pk(table, xid, conn); + spider_store_xa_member_info(table, xid, conn); + if (thd) + { + table->field[SPIDER_XA_FAILED_LOG_THREAD_ID_POS]->set_notnull(); + table->field[SPIDER_XA_FAILED_LOG_THREAD_ID_POS]->store( + thd->thread_id, TRUE); + } else { + table->field[SPIDER_XA_FAILED_LOG_THREAD_ID_POS]->set_null(); + table->field[SPIDER_XA_FAILED_LOG_THREAD_ID_POS]->reset(); + } + table->field[SPIDER_XA_FAILED_LOG_STATUS_POS]->store( + status, + (uint) strlen(status), + system_charset_info); + + if ((error_num = spider_write_sys_table_row(table))) + { + DBUG_RETURN(error_num); + } + DBUG_RETURN(0); +} + +int spider_update_xa( + TABLE *table, + XID *xid, + const char *status +) { + int error_num; + char table_key[MAX_KEY_LENGTH]; + DBUG_ENTER("spider_update_xa"); + table->use_all_columns(); + spider_store_xa_pk(table, xid); + + if ((error_num = spider_check_sys_table(table, table_key))) + { + if (error_num != HA_ERR_KEY_NOT_FOUND && error_num != HA_ERR_END_OF_FILE) + { + table->file->print_error(error_num, MYF(0)); + DBUG_RETURN(error_num); + } + my_message(ER_SPIDER_XA_NOT_EXISTS_NUM, ER_SPIDER_XA_NOT_EXISTS_STR, + MYF(0)); + DBUG_RETURN(ER_SPIDER_XA_NOT_EXISTS_NUM); + } else { + store_record(table, record[1]); + table->use_all_columns(); + spider_store_xa_status(table, status); + if ((error_num = spider_update_sys_table_row(table))) + { + DBUG_RETURN(error_num); + } + } + + DBUG_RETURN(0); +} + +int spider_update_tables_name( + TABLE *table, + const char *from, + const char *to, + int *old_link_count +) { + int error_num, roop_count = 0; + char table_key[MAX_KEY_LENGTH]; + DBUG_ENTER("spider_update_tables_name"); + table->use_all_columns(); + while (TRUE) + { + spider_store_tables_name(table, from, strlen(from)); + spider_store_tables_link_idx(table, roop_count); + if ((error_num = spider_check_sys_table(table, table_key))) + { + if ( + roop_count && + (error_num == HA_ERR_KEY_NOT_FOUND || error_num == HA_ERR_END_OF_FILE) + ) + break; + table->file->print_error(error_num, MYF(0)); + DBUG_RETURN(error_num); + } else { + store_record(table, record[1]); + table->use_all_columns(); + spider_store_tables_name(table, to, strlen(to)); + if ((error_num = spider_update_sys_table_row(table))) + { + DBUG_RETURN(error_num); + } + } + roop_count++; + } + + *old_link_count = roop_count; + DBUG_RETURN(0); +} + +int spider_update_tables_priority( + TABLE *table, + SPIDER_ALTER_TABLE *alter_table, + const char *name, + int *old_link_count +) { + int error_num, roop_count; + char table_key[MAX_KEY_LENGTH]; + DBUG_ENTER("spider_update_tables_priority"); + table->use_all_columns(); + for (roop_count = 0; roop_count < (int) alter_table->all_link_count; + roop_count++) + { + spider_store_tables_name(table, alter_table->table_name, + alter_table->table_name_length); + spider_store_tables_link_idx(table, roop_count); + if ((error_num = spider_check_sys_table(table, table_key))) + { + if ( + roop_count && + (error_num == HA_ERR_KEY_NOT_FOUND || error_num == HA_ERR_END_OF_FILE) + ) { + *old_link_count = roop_count; + + /* insert for adding link */ + spider_store_tables_name(table, name, strlen(name)); + spider_store_tables_priority(table, alter_table->tmp_priority); + do { + spider_store_tables_link_idx(table, roop_count); + spider_store_tables_connect_info(table, alter_table, roop_count); + spider_store_tables_link_status(table, + alter_table->tmp_link_statuses[roop_count] != + SPIDER_LINK_STATUS_NO_CHANGE ? + alter_table->tmp_link_statuses[roop_count] : + SPIDER_LINK_STATUS_OK); + if ((error_num = spider_write_sys_table_row(table))) + { + DBUG_RETURN(error_num); + } + roop_count++; + } while (roop_count < (int) alter_table->all_link_count); + DBUG_RETURN(0); + } else { + table->file->print_error(error_num, MYF(0)); + DBUG_RETURN(error_num); + } + } else { + store_record(table, record[1]); + table->use_all_columns(); + spider_store_tables_name(table, name, strlen(name)); + spider_store_tables_priority(table, alter_table->tmp_priority); + spider_store_tables_connect_info(table, alter_table, roop_count); + spider_store_tables_link_status(table, + alter_table->tmp_link_statuses[roop_count]); + if ((error_num = spider_update_sys_table_row(table))) + { + DBUG_RETURN(error_num); + } + } + } + while (TRUE) + { + /* delete for subtracting link */ + spider_store_tables_link_idx(table, roop_count); + if ((error_num = spider_check_sys_table(table, table_key))) + { + if ( + roop_count && + (error_num == HA_ERR_KEY_NOT_FOUND || error_num == HA_ERR_END_OF_FILE) + ) + break; + else { + table->file->print_error(error_num, MYF(0)); + DBUG_RETURN(error_num); + } + if ((error_num = spider_delete_sys_table_row(table))) + { + DBUG_RETURN(error_num); + } + } + roop_count++; + } + + *old_link_count = roop_count; + DBUG_RETURN(0); +} + +int spider_update_tables_link_status( + TABLE *table, + char *name, + uint name_length, + int link_idx, + long link_status +) { + int error_num; + char table_key[MAX_KEY_LENGTH]; + DBUG_ENTER("spider_update_tables_link_status"); + table->use_all_columns(); + spider_store_tables_name(table, name, name_length); + spider_store_tables_link_idx(table, link_idx); + if ((error_num = spider_check_sys_table(table, table_key))) + { + if ( + (error_num == HA_ERR_KEY_NOT_FOUND || error_num == HA_ERR_END_OF_FILE) + ) + DBUG_RETURN(0); + else { + table->file->print_error(error_num, MYF(0)); + DBUG_RETURN(error_num); + } + } else { + store_record(table, record[1]); + table->use_all_columns(); + spider_store_tables_link_status(table, link_status); + if ((error_num = spider_update_sys_table_row(table))) + { + DBUG_RETURN(error_num); + } + } + + DBUG_RETURN(0); +} + +int spider_update_sys_table( + TABLE *table +) { + int error_num; + DBUG_ENTER("spider_update_sys_table"); + error_num = spider_update_sys_table_row(table); + DBUG_RETURN(error_num); +} + +int spider_delete_xa( + TABLE *table, + XID *xid +) { + int error_num; + char table_key[MAX_KEY_LENGTH]; + DBUG_ENTER("spider_delete_xa"); + table->use_all_columns(); + spider_store_xa_pk(table, xid); + + if ((error_num = spider_check_sys_table(table, table_key))) + { + if (error_num != HA_ERR_KEY_NOT_FOUND && error_num != HA_ERR_END_OF_FILE) + { + table->file->print_error(error_num, MYF(0)); + DBUG_RETURN(error_num); + } + my_message(ER_SPIDER_XA_NOT_EXISTS_NUM, ER_SPIDER_XA_NOT_EXISTS_STR, + MYF(0)); + DBUG_RETURN(ER_SPIDER_XA_NOT_EXISTS_NUM); + } else { + if ((error_num = spider_delete_sys_table_row(table))) + { + DBUG_RETURN(error_num); + } + } + + DBUG_RETURN(0); +} + +int spider_delete_xa_member( + TABLE *table, + XID *xid +) { + int error_num; + char table_key[MAX_KEY_LENGTH]; + DBUG_ENTER("spider_delete_xa_member"); + table->use_all_columns(); + spider_store_xa_pk(table, xid); + + if ((error_num = spider_get_sys_table_by_idx(table, table_key, 0, + SPIDER_SYS_XA_PK_COL_CNT))) + { + if (error_num != HA_ERR_KEY_NOT_FOUND && error_num != HA_ERR_END_OF_FILE) + { + table->file->print_error(error_num, MYF(0)); + DBUG_RETURN(error_num); + } + DBUG_RETURN(0); + } else { + do { + if ((error_num = spider_delete_sys_table_row(table, 0, FALSE))) + { + spider_sys_index_end(table); + table->file->print_error(error_num, MYF(0)); + DBUG_RETURN(error_num); + } + error_num = spider_sys_index_next_same(table, table_key); + } while (error_num == 0); + } + if ((error_num = spider_sys_index_end(table))) + { + table->file->print_error(error_num, MYF(0)); + DBUG_RETURN(error_num); + } + + DBUG_RETURN(0); +} + +int spider_delete_tables( + TABLE *table, + const char *name, + int *old_link_count +) { + int error_num, roop_count = 0; + char table_key[MAX_KEY_LENGTH]; + DBUG_ENTER("spider_delete_tables"); + table->use_all_columns(); + spider_store_tables_name(table, name, strlen(name)); + + while (TRUE) + { + spider_store_tables_link_idx(table, roop_count); + if ((error_num = spider_check_sys_table(table, table_key))) + break; + else { + if ((error_num = spider_delete_sys_table_row(table))) + { + DBUG_RETURN(error_num); + } + } + roop_count++; + } + + *old_link_count = roop_count; + DBUG_RETURN(0); +} + +int spider_delete_table_sts( + TABLE *table, + const char *name, + uint name_length +) { + int error_num; + char table_key[MAX_KEY_LENGTH]; + DBUG_ENTER("spider_delete_table_sts"); + table->use_all_columns(); + spider_store_tables_name(table, name, name_length); + + if ((error_num = spider_check_sys_table(table, table_key))) + { + if (error_num != HA_ERR_KEY_NOT_FOUND && error_num != HA_ERR_END_OF_FILE) + { + table->file->print_error(error_num, MYF(0)); + DBUG_RETURN(error_num); + } + /* no record is ok */ + DBUG_RETURN(0); + } else { + if ((error_num = spider_delete_sys_table_row(table))) + { + DBUG_RETURN(error_num); + } + } + + DBUG_RETURN(0); +} + +int spider_delete_table_crd( + TABLE *table, + const char *name, + uint name_length +) { + int error_num; + char table_key[MAX_KEY_LENGTH]; + DBUG_ENTER("spider_delete_table_crd"); + table->use_all_columns(); + spider_store_tables_name(table, name, name_length); + + if ((error_num = spider_get_sys_table_by_idx(table, table_key, 0, + SPIDER_SYS_TABLE_CRD_PK_COL_CNT - 1))) + { + if (error_num != HA_ERR_KEY_NOT_FOUND && error_num != HA_ERR_END_OF_FILE) + { + table->file->print_error(error_num, MYF(0)); + DBUG_RETURN(error_num); + } + /* no record is ok */ + DBUG_RETURN(0); + } else { + do { + if ((error_num = spider_delete_sys_table_row(table))) + { + spider_sys_index_end(table); + DBUG_RETURN(error_num); + } + error_num = spider_sys_index_next_same(table, table_key); + } while (error_num == 0); + } + if ((error_num = spider_sys_index_end(table))) + { + table->file->print_error(error_num, MYF(0)); + DBUG_RETURN(error_num); + } + + DBUG_RETURN(0); +} + +int spider_get_sys_xid( + TABLE *table, + XID *xid, + MEM_ROOT *mem_root +) { + char *ptr; + DBUG_ENTER("spider_get_sys_xid"); + ptr = get_field(mem_root, table->field[SPIDER_XA_FORMAT_ID_POS]); + if (ptr) + { + xid->formatID = atoi(ptr); + } else + xid->formatID = 0; + ptr = get_field(mem_root, table->field[SPIDER_XA_GTRID_LENGTH_POS]); + if (ptr) + { + xid->gtrid_length = atoi(ptr); + } else + xid->gtrid_length = 0; + ptr = get_field(mem_root, table->field[SPIDER_XA_BQUAL_LENGTH_POS]); + if (ptr) + { + xid->bqual_length = atoi(ptr); + } else + xid->bqual_length = 0; + ptr = get_field(mem_root, table->field[SPIDER_XA_DATA_POS]); + if (ptr) + { + strmov(xid->data, ptr); + } + DBUG_RETURN(0); +} + +int spider_get_sys_server_info( + TABLE *table, + SPIDER_SHARE *share, + int link_idx, + MEM_ROOT *mem_root +) { + char *ptr; + DBUG_ENTER("spider_get_sys_server_info"); + if ((ptr = get_field(mem_root, table->field[SPIDER_XA_MEMBER_SCHEME_POS]))) + { + share->tgt_wrappers_lengths[link_idx] = strlen(ptr); + share->tgt_wrappers[link_idx] = spider_create_string(ptr, + share->tgt_wrappers_lengths[link_idx]); + } else { + share->tgt_wrappers_lengths[link_idx] = 0; + share->tgt_wrappers[link_idx] = NULL; + } + if ((ptr = get_field(mem_root, table->field[SPIDER_XA_MEMBER_HOST_POS]))) + { + share->tgt_hosts_lengths[link_idx] = strlen(ptr); + share->tgt_hosts[link_idx] = spider_create_string(ptr, + share->tgt_hosts_lengths[link_idx]); + } else { + share->tgt_hosts_lengths[link_idx] = 0; + share->tgt_hosts[link_idx] = NULL; + } + if ((ptr = get_field(mem_root, table->field[SPIDER_XA_MEMBER_PORT_POS]))) + { + share->tgt_ports[link_idx] = atol(ptr); + } else + share->tgt_ports[link_idx] = MYSQL_PORT; + if ((ptr = get_field(mem_root, table->field[SPIDER_XA_MEMBER_SOCKET_POS]))) + { + share->tgt_sockets_lengths[link_idx] = strlen(ptr); + share->tgt_sockets[link_idx] = spider_create_string(ptr, + share->tgt_sockets_lengths[link_idx]); + } else { + share->tgt_sockets_lengths[link_idx] = 0; + share->tgt_sockets[link_idx] = NULL; + } + if ((ptr = get_field(mem_root, table->field[SPIDER_XA_MEMBER_USERNAME_POS]))) + { + share->tgt_usernames_lengths[link_idx] = strlen(ptr); + share->tgt_usernames[link_idx] = + spider_create_string(ptr, share->tgt_usernames_lengths[link_idx]); + } else { + share->tgt_usernames_lengths[link_idx] = 0; + share->tgt_usernames[link_idx] = NULL; + } + if ((ptr = get_field(mem_root, table->field[SPIDER_XA_MEMBER_PASSWORD_POS]))) + { + share->tgt_passwords_lengths[link_idx] = strlen(ptr); + share->tgt_passwords[link_idx] = + spider_create_string(ptr, share->tgt_passwords_lengths[link_idx]); + } else { + share->tgt_passwords_lengths[link_idx] = 0; + share->tgt_passwords[link_idx] = NULL; + } + if ( + !table->field[SPIDER_XA_MEMBER_SSL_CA_POS]->is_null() && + (ptr = get_field(mem_root, table->field[SPIDER_XA_MEMBER_SSL_CA_POS])) + ) { + share->tgt_ssl_cas_lengths[link_idx] = strlen(ptr); + share->tgt_ssl_cas[link_idx] = + spider_create_string(ptr, share->tgt_ssl_cas_lengths[link_idx]); + } else { + share->tgt_ssl_cas_lengths[link_idx] = 0; + share->tgt_ssl_cas[link_idx] = NULL; + } + if ( + !table->field[SPIDER_XA_MEMBER_SSL_CAPATH_POS]->is_null() && + (ptr = get_field(mem_root, table->field[SPIDER_XA_MEMBER_SSL_CAPATH_POS])) + ) { + share->tgt_ssl_capaths_lengths[link_idx] = strlen(ptr); + share->tgt_ssl_capaths[link_idx] = + spider_create_string(ptr, share->tgt_ssl_capaths_lengths[link_idx]); + } else { + share->tgt_ssl_capaths_lengths[link_idx] = 0; + share->tgt_ssl_capaths[link_idx] = NULL; + } + if ( + !table->field[SPIDER_XA_MEMBER_SSL_CERT_POS]->is_null() && + (ptr = get_field(mem_root, table->field[SPIDER_XA_MEMBER_SSL_CERT_POS])) + ) { + share->tgt_ssl_certs_lengths[link_idx] = strlen(ptr); + share->tgt_ssl_certs[link_idx] = + spider_create_string(ptr, share->tgt_ssl_certs_lengths[link_idx]); + } else { + share->tgt_ssl_certs_lengths[link_idx] = 0; + share->tgt_ssl_certs[link_idx] = NULL; + } + if ( + !table->field[SPIDER_XA_MEMBER_SSL_CIPHER_POS]->is_null() && + (ptr = get_field(mem_root, table->field[SPIDER_XA_MEMBER_SSL_CIPHER_POS])) + ) { + share->tgt_ssl_ciphers_lengths[link_idx] = strlen(ptr); + share->tgt_ssl_ciphers[link_idx] = + spider_create_string(ptr, share->tgt_ssl_ciphers_lengths[link_idx]); + } else { + share->tgt_ssl_ciphers_lengths[link_idx] = 0; + share->tgt_ssl_ciphers[link_idx] = NULL; + } + if ( + !table->field[SPIDER_XA_MEMBER_SSL_KEY_POS]->is_null() && + (ptr = get_field(mem_root, table->field[SPIDER_XA_MEMBER_SSL_KEY_POS])) + ) { + share->tgt_ssl_keys_lengths[link_idx] = strlen(ptr); + share->tgt_ssl_keys[link_idx] = + spider_create_string(ptr, share->tgt_ssl_keys_lengths[link_idx]); + } else { + share->tgt_ssl_keys_lengths[link_idx] = 0; + share->tgt_ssl_keys[link_idx] = NULL; + } + if ( + !table->field[SPIDER_XA_MEMBER_SSL_VERIFY_SERVER_CERT_POS]->is_null() && + (ptr = get_field(mem_root, table-> + field[SPIDER_XA_MEMBER_SSL_VERIFY_SERVER_CERT_POS])) + ) { + share->tgt_ssl_vscs[link_idx] = atol(ptr); + } else + share->tgt_ssl_vscs[link_idx] = 0; + if ( + !table->field[SPIDER_XA_MEMBER_DEFAULT_FILE_POS]->is_null() && + (ptr = get_field(mem_root, table-> + field[SPIDER_XA_MEMBER_DEFAULT_FILE_POS])) + ) { + share->tgt_default_files_lengths[link_idx] = strlen(ptr); + share->tgt_default_files[link_idx] = + spider_create_string(ptr, share->tgt_default_files_lengths[link_idx]); + } else { + share->tgt_default_files_lengths[link_idx] = 0; + share->tgt_default_files[link_idx] = NULL; + } + if ( + !table->field[SPIDER_XA_MEMBER_DEFAULT_GROUP_POS]->is_null() && + (ptr = get_field(mem_root, table-> + field[SPIDER_XA_MEMBER_DEFAULT_GROUP_POS])) + ) { + share->tgt_default_groups_lengths[link_idx] = strlen(ptr); + share->tgt_default_groups[link_idx] = + spider_create_string(ptr, share->tgt_default_groups_lengths[link_idx]); + } else { + share->tgt_default_groups_lengths[link_idx] = 0; + share->tgt_default_groups[link_idx] = NULL; + } + if ( + !table->field[SPIDER_XA_MEMBER_DSN_POS]->is_null() && + (ptr = get_field(mem_root, table->field[SPIDER_XA_MEMBER_DSN_POS])) + ) { + share->tgt_dsns_lengths[link_idx] = strlen(ptr); + share->tgt_dsns[link_idx] = + spider_create_string(ptr, share->tgt_dsns_lengths[link_idx]); + } else { + share->tgt_dsns_lengths[link_idx] = 0; + share->tgt_dsns[link_idx] = NULL; + } + if ( + !table->field[SPIDER_XA_MEMBER_FILEDSN_POS]->is_null() && + (ptr = get_field(mem_root, table->field[SPIDER_XA_MEMBER_FILEDSN_POS])) + ) { + share->tgt_filedsns_lengths[link_idx] = strlen(ptr); + share->tgt_filedsns[link_idx] = + spider_create_string(ptr, share->tgt_filedsns_lengths[link_idx]); + } else { + share->tgt_filedsns_lengths[link_idx] = 0; + share->tgt_filedsns[link_idx] = NULL; + } + if ( + !table->field[SPIDER_XA_MEMBER_DRIVER_POS]->is_null() && + (ptr = get_field(mem_root, table->field[SPIDER_XA_MEMBER_DRIVER_POS])) + ) { + share->tgt_drivers_lengths[link_idx] = strlen(ptr); + share->tgt_drivers[link_idx] = + spider_create_string(ptr, share->tgt_drivers_lengths[link_idx]); + } else { + share->tgt_drivers_lengths[link_idx] = 0; + share->tgt_drivers[link_idx] = NULL; + } + DBUG_RETURN(0); +} + +int spider_check_sys_xa_status( + TABLE *table, + const char *status1, + const char *status2, + const char *status3, + const int check_error_num, + MEM_ROOT *mem_root +) { + char *ptr; + int error_num; + DBUG_ENTER("spider_check_sys_xa_status"); + ptr = get_field(mem_root, table->field[SPIDER_XA_STATUS_POS]); + if (ptr) + { + if ( + strcmp(ptr, status1) && + (status2 == NULL || strcmp(ptr, status2)) && + (status3 == NULL || strcmp(ptr, status3)) + ) + error_num = check_error_num; + else + error_num = 0; + } else + error_num = check_error_num; + DBUG_RETURN(error_num); +} + +int spider_get_sys_tables( + TABLE *table, + char **db_name, + char **table_name, + MEM_ROOT *mem_root +) { + char *ptr; + DBUG_ENTER("spider_get_sys_tables"); + if ((ptr = get_field(mem_root, table->field[SPIDER_TABLES_DB_NAME_POS]))) + { + *db_name = spider_create_string(ptr, strlen(ptr)); + } else { + *db_name = NULL; + } + if ((ptr = get_field(mem_root, table->field[SPIDER_TABLES_TABLE_NAME_POS]))) + { + *table_name = spider_create_string(ptr, strlen(ptr)); + } else { + *table_name = NULL; + } + DBUG_RETURN(0); +} + +int spider_get_sys_tables_connect_info( + TABLE *table, + SPIDER_SHARE *share, + int link_idx, + MEM_ROOT *mem_root +) { + char *ptr; + int error_num = 0; + DBUG_ENTER("spider_get_sys_tables_connect_info"); + DBUG_PRINT("info",("spider link_idx:%d", link_idx)); + if ((ptr = get_field(mem_root, table->field[SPIDER_TABLES_PRIORITY_POS]))) + { + share->priority = my_strtoll10(ptr, (char**) NULL, &error_num); + } else + share->priority = 1000000; + DBUG_PRINT("info",("spider priority:%lld", share->priority)); + if ( + !table->field[SPIDER_TABLES_SERVER_POS]->is_null() && + (ptr = get_field(mem_root, table->field[SPIDER_TABLES_SERVER_POS])) + ) { + share->server_names_lengths[link_idx] = strlen(ptr); + share->server_names[link_idx] = + spider_create_string(ptr, share->server_names_lengths[link_idx]); + DBUG_PRINT("info",("spider server_name:%s", + share->server_names[link_idx])); + } else { + share->server_names_lengths[link_idx] = 0; + share->server_names[link_idx] = NULL; + DBUG_PRINT("info",("spider server_name is NULL")); + } + if ( + !table->field[SPIDER_TABLES_SCHEME_POS]->is_null() && + (ptr = get_field(mem_root, table->field[SPIDER_TABLES_SCHEME_POS])) + ) { + share->tgt_wrappers_lengths[link_idx] = strlen(ptr); + share->tgt_wrappers[link_idx] = + spider_create_string(ptr, share->tgt_wrappers_lengths[link_idx]); + DBUG_PRINT("info",("spider tgt_wrapper:%s", + share->tgt_wrappers[link_idx])); + } else { + share->tgt_wrappers_lengths[link_idx] = 0; + share->tgt_wrappers[link_idx] = NULL; + DBUG_PRINT("info",("spider tgt_wrapper is NULL")); + } + if ( + !table->field[SPIDER_TABLES_HOST_POS]->is_null() && + (ptr = get_field(mem_root, table->field[SPIDER_TABLES_HOST_POS])) + ) { + share->tgt_hosts_lengths[link_idx] = strlen(ptr); + share->tgt_hosts[link_idx] = + spider_create_string(ptr, share->tgt_hosts_lengths[link_idx]); + DBUG_PRINT("info",("spider tgt_host:%s", + share->tgt_hosts[link_idx])); + } else { + share->tgt_hosts_lengths[link_idx] = 0; + share->tgt_hosts[link_idx] = NULL; + DBUG_PRINT("info",("spider tgt_host is NULL")); + } + if ( + !table->field[SPIDER_TABLES_PORT_POS]->is_null() && + (ptr = get_field(mem_root, table->field[SPIDER_TABLES_PORT_POS])) + ) { + share->tgt_ports[link_idx] = atol(ptr); + } else { + share->tgt_ports[link_idx] = -1; + } + DBUG_PRINT("info",("spider port:%ld", share->tgt_ports[link_idx])); + if ( + !table->field[SPIDER_TABLES_SOCKET_POS]->is_null() && + (ptr = get_field(mem_root, table->field[SPIDER_TABLES_SOCKET_POS])) + ) { + share->tgt_sockets_lengths[link_idx] = strlen(ptr); + share->tgt_sockets[link_idx] = + spider_create_string(ptr, share->tgt_sockets_lengths[link_idx]); + } else { + share->tgt_sockets_lengths[link_idx] = 0; + share->tgt_sockets[link_idx] = NULL; + } + if ( + !table->field[SPIDER_TABLES_USERNAME_POS]->is_null() && + (ptr = get_field(mem_root, table->field[SPIDER_TABLES_USERNAME_POS])) + ) { + share->tgt_usernames_lengths[link_idx] = strlen(ptr); + share->tgt_usernames[link_idx] = + spider_create_string(ptr, share->tgt_usernames_lengths[link_idx]); + } else { + share->tgt_usernames_lengths[link_idx] = 0; + share->tgt_usernames[link_idx] = NULL; + } + if ( + !table->field[SPIDER_TABLES_PASSWORD_POS]->is_null() && + (ptr = get_field(mem_root, table->field[SPIDER_TABLES_PASSWORD_POS])) + ) { + share->tgt_passwords_lengths[link_idx] = strlen(ptr); + share->tgt_passwords[link_idx] = + spider_create_string(ptr, share->tgt_passwords_lengths[link_idx]); + } else { + share->tgt_passwords_lengths[link_idx] = 0; + share->tgt_passwords[link_idx] = NULL; + } + if ( + !table->field[SPIDER_TABLES_SSL_CA_POS]->is_null() && + (ptr = get_field(mem_root, table->field[SPIDER_TABLES_SSL_CA_POS])) + ) { + share->tgt_ssl_cas_lengths[link_idx] = strlen(ptr); + share->tgt_ssl_cas[link_idx] = + spider_create_string(ptr, share->tgt_ssl_cas_lengths[link_idx]); + } else { + share->tgt_ssl_cas_lengths[link_idx] = 0; + share->tgt_ssl_cas[link_idx] = NULL; + } + if ( + !table->field[SPIDER_TABLES_SSL_CAPATH_POS]->is_null() && + (ptr = get_field(mem_root, table->field[SPIDER_TABLES_SSL_CAPATH_POS])) + ) { + share->tgt_ssl_capaths_lengths[link_idx] = strlen(ptr); + share->tgt_ssl_capaths[link_idx] = + spider_create_string(ptr, share->tgt_ssl_capaths_lengths[link_idx]); + } else { + share->tgt_ssl_capaths_lengths[link_idx] = 0; + share->tgt_ssl_capaths[link_idx] = NULL; + } + if ( + !table->field[SPIDER_TABLES_SSL_CERT_POS]->is_null() && + (ptr = get_field(mem_root, table->field[SPIDER_TABLES_SSL_CERT_POS])) + ) { + share->tgt_ssl_certs_lengths[link_idx] = strlen(ptr); + share->tgt_ssl_certs[link_idx] = + spider_create_string(ptr, share->tgt_ssl_certs_lengths[link_idx]); + } else { + share->tgt_ssl_certs_lengths[link_idx] = 0; + share->tgt_ssl_certs[link_idx] = NULL; + } + if ( + !table->field[SPIDER_TABLES_SSL_CIPHER_POS]->is_null() && + (ptr = get_field(mem_root, table->field[SPIDER_TABLES_SSL_CIPHER_POS])) + ) { + share->tgt_ssl_ciphers_lengths[link_idx] = strlen(ptr); + share->tgt_ssl_ciphers[link_idx] = + spider_create_string(ptr, share->tgt_ssl_ciphers_lengths[link_idx]); + } else { + share->tgt_ssl_ciphers_lengths[link_idx] = 0; + share->tgt_ssl_ciphers[link_idx] = NULL; + } + if ( + !table->field[SPIDER_TABLES_SSL_KEY_POS]->is_null() && + (ptr = get_field(mem_root, table->field[SPIDER_TABLES_SSL_KEY_POS])) + ) { + share->tgt_ssl_keys_lengths[link_idx] = strlen(ptr); + share->tgt_ssl_keys[link_idx] = + spider_create_string(ptr, share->tgt_ssl_keys_lengths[link_idx]); + } else { + share->tgt_ssl_keys_lengths[link_idx] = 0; + share->tgt_ssl_keys[link_idx] = NULL; + } + if ( + !table->field[SPIDER_TABLES_SSL_VERIFY_SERVER_CERT_POS]->is_null() && + (ptr = get_field(mem_root, + table->field[SPIDER_TABLES_SSL_VERIFY_SERVER_CERT_POS])) + ) { + share->tgt_ssl_vscs[link_idx] = atol(ptr); + } else + share->tgt_ssl_vscs[link_idx] = -1; + if ( + !table->field[SPIDER_TABLES_MONITORING_BINLOG_POS_AT_FAILING_POS]-> + is_null() && + (ptr = get_field(mem_root, table-> + field[SPIDER_TABLES_MONITORING_BINLOG_POS_AT_FAILING_POS])) + ) { + share->monitoring_binlog_pos_at_failing[link_idx] = atol(ptr); + } else + share->monitoring_binlog_pos_at_failing[link_idx] = 0; + if ( + !table->field[SPIDER_TABLES_DEFAULT_FILE_POS]->is_null() && + (ptr = get_field(mem_root, table->field[SPIDER_TABLES_DEFAULT_FILE_POS])) + ) { + share->tgt_default_files_lengths[link_idx] = strlen(ptr); + share->tgt_default_files[link_idx] = + spider_create_string(ptr, share->tgt_default_files_lengths[link_idx]); + } else { + share->tgt_default_files_lengths[link_idx] = 0; + share->tgt_default_files[link_idx] = NULL; + } + if ( + !table->field[SPIDER_TABLES_DEFAULT_GROUP_POS]->is_null() && + (ptr = get_field(mem_root, table->field[SPIDER_TABLES_DEFAULT_GROUP_POS])) + ) { + share->tgt_default_groups_lengths[link_idx] = strlen(ptr); + share->tgt_default_groups[link_idx] = + spider_create_string(ptr, share->tgt_default_groups_lengths[link_idx]); + } else { + share->tgt_default_groups_lengths[link_idx] = 0; + share->tgt_default_groups[link_idx] = NULL; + } + if ( + !table->field[SPIDER_TABLES_DSN_POS]->is_null() && + (ptr = get_field(mem_root, table->field[SPIDER_TABLES_DSN_POS])) + ) { + share->tgt_dsns_lengths[link_idx] = strlen(ptr); + share->tgt_dsns[link_idx] = + spider_create_string(ptr, share->tgt_dsns_lengths[link_idx]); + } else { + share->tgt_dsns_lengths[link_idx] = 0; + share->tgt_dsns[link_idx] = NULL; + } + if ( + !table->field[SPIDER_TABLES_FILEDSN_POS]->is_null() && + (ptr = get_field(mem_root, table->field[SPIDER_TABLES_FILEDSN_POS])) + ) { + share->tgt_filedsns_lengths[link_idx] = strlen(ptr); + share->tgt_filedsns[link_idx] = + spider_create_string(ptr, share->tgt_filedsns_lengths[link_idx]); + } else { + share->tgt_filedsns_lengths[link_idx] = 0; + share->tgt_filedsns[link_idx] = NULL; + } + if ( + !table->field[SPIDER_TABLES_DRIVER_POS]->is_null() && + (ptr = get_field(mem_root, table->field[SPIDER_TABLES_DRIVER_POS])) + ) { + share->tgt_drivers_lengths[link_idx] = strlen(ptr); + share->tgt_drivers[link_idx] = + spider_create_string(ptr, share->tgt_drivers_lengths[link_idx]); + } else { + share->tgt_drivers_lengths[link_idx] = 0; + share->tgt_drivers[link_idx] = NULL; + } + if ( + !table->field[SPIDER_TABLES_TGT_DB_NAME_POS]->is_null() && + (ptr = get_field(mem_root, table->field[SPIDER_TABLES_TGT_DB_NAME_POS])) + ) { + share->tgt_dbs_lengths[link_idx] = strlen(ptr); + share->tgt_dbs[link_idx] = + spider_create_string(ptr, share->tgt_dbs_lengths[link_idx]); + } else { + share->tgt_dbs_lengths[link_idx] = 0; + share->tgt_dbs[link_idx] = NULL; + } + if ( + !table->field[SPIDER_TABLES_TGT_TABLE_NAME_POS]->is_null() && + (ptr = get_field(mem_root, table->field[SPIDER_TABLES_TGT_TABLE_NAME_POS])) + ) { + share->tgt_table_names_lengths[link_idx] = strlen(ptr); + share->tgt_table_names[link_idx] = + spider_create_string(ptr, share->tgt_table_names_lengths[link_idx]); + } else { + share->tgt_table_names_lengths[link_idx] = 0; + share->tgt_table_names[link_idx] = NULL; + } + if ( + !table->field[SPIDER_TABLES_STATIC_LINK_ID_POS]->is_null() && + (ptr = get_field(mem_root, table->field[SPIDER_TABLES_STATIC_LINK_ID_POS])) + ) { + share->static_link_ids_lengths[link_idx] = strlen(ptr); + share->static_link_ids[link_idx] = + spider_create_string(ptr, share->static_link_ids_lengths[link_idx]); + } else { + share->static_link_ids_lengths[link_idx] = 0; + share->static_link_ids[link_idx] = NULL; + } + DBUG_RETURN(error_num); +} + +int spider_get_sys_tables_monitoring_binlog_pos_at_failing( + TABLE *table, + long *monitoring_binlog_pos_at_failing, + MEM_ROOT *mem_root +) { + char *ptr; + int error_num = 0; + DBUG_ENTER("spider_get_sys_tables_monitoring_binlog_pos_at_failing"); + if ((ptr = get_field(mem_root, table-> + field[SPIDER_TABLES_MONITORING_BINLOG_POS_AT_FAILING_POS]))) + *monitoring_binlog_pos_at_failing = (long) my_strtoll10(ptr, (char**) NULL, + &error_num); + else + *monitoring_binlog_pos_at_failing = 1; + DBUG_PRINT("info",("spider monitoring_binlog_pos_at_failing=%ld", + *monitoring_binlog_pos_at_failing)); + DBUG_RETURN(error_num); +} + +int spider_get_sys_tables_link_status( + TABLE *table, + SPIDER_SHARE *share, + int link_idx, + MEM_ROOT *mem_root +) { + char *ptr; + int error_num = 0; + DBUG_ENTER("spider_get_sys_tables_link_status"); + if ((ptr = get_field(mem_root, table->field[SPIDER_TABLES_LINK_STATUS_POS]))) + { + share->link_statuses[link_idx] = + (long) my_strtoll10(ptr, (char**) NULL, &error_num); + } else + share->link_statuses[link_idx] = 1; + DBUG_PRINT("info",("spider link_statuses[%d]=%ld", + link_idx, share->link_statuses[link_idx])); + DBUG_RETURN(error_num); +} + +int spider_get_sys_tables_link_status( + TABLE *table, + long *link_status, + MEM_ROOT *mem_root +) { + char *ptr; + int error_num = 0; + DBUG_ENTER("spider_get_sys_tables_link_status"); + if ((ptr = get_field(mem_root, table->field[SPIDER_TABLES_LINK_STATUS_POS]))) + *link_status = (long) my_strtoll10(ptr, (char**) NULL, &error_num); + else + *link_status = 1; + DBUG_PRINT("info",("spider link_statuses=%ld", *link_status)); + DBUG_RETURN(error_num); +} + +int spider_get_sys_tables_link_idx( + TABLE *table, + int *link_idx, + MEM_ROOT *mem_root +) { + char *ptr; + int error_num = 0; + DBUG_ENTER("spider_get_sys_tables_link_idx"); + if ((ptr = get_field(mem_root, table->field[SPIDER_TABLES_LINK_ID_POS]))) + *link_idx = (int) my_strtoll10(ptr, (char**) NULL, &error_num); + else + *link_idx = 1; + DBUG_PRINT("info",("spider link_idx=%d", *link_idx)); + DBUG_RETURN(error_num); +} + +int spider_get_sys_tables_static_link_id( + TABLE *table, + char **static_link_id, + uint *static_link_id_length, + MEM_ROOT *mem_root +) { + int error_num = 0; + DBUG_ENTER("spider_get_sys_tables_static_link_id"); + *static_link_id = NULL; + if ( + !table->field[SPIDER_TABLES_STATIC_LINK_ID_POS]->is_null() && + (*static_link_id = get_field(mem_root, table-> + field[SPIDER_TABLES_STATIC_LINK_ID_POS])) + ) { + *static_link_id_length = strlen(*static_link_id); + } else { + *static_link_id_length = 0; + } + DBUG_PRINT("info",("spider static_link_id=%s", *static_link_id ? *static_link_id : "NULL")); + DBUG_RETURN(error_num); +} + +void spider_get_sys_table_sts_info( + TABLE *table, + ha_statistics *stat +) { + MYSQL_TIME mysql_time; + uint not_used_uint; + long not_used_long; + DBUG_ENTER("spider_get_sys_table_sts_info"); + stat->data_file_length = (ulonglong) table-> + field[SPIDER_TABLE_STS_DATA_FILE_LENGTH_POS]->val_int(); + stat->max_data_file_length = (ulonglong) table-> + field[SPIDER_TABLE_STS_MAX_DATA_FILE_LENGTH_POS]->val_int(); + stat->index_file_length = (ulonglong) table-> + field[SPIDER_TABLE_STS_INDEX_FILE_LENGTH_POS]->val_int(); + stat->records = (ha_rows) table-> + field[SPIDER_TABLE_STS_RECORDS_POS]->val_int(); + stat->mean_rec_length = (ulong) table-> + field[SPIDER_TABLE_STS_MEAN_REC_LENGTH_POS]->val_int(); + table->field[SPIDER_TABLE_STS_CHECK_TIME_POS]->get_date(&mysql_time, + SPIDER_date_mode_t(0)); + stat->check_time = (time_t) my_system_gmt_sec(&mysql_time, + ¬_used_long, ¬_used_uint); + table->field[SPIDER_TABLE_STS_CREATE_TIME_POS]->get_date(&mysql_time, + SPIDER_date_mode_t(0)); + stat->create_time = (time_t) my_system_gmt_sec(&mysql_time, + ¬_used_long, ¬_used_uint); + table->field[SPIDER_TABLE_STS_UPDATE_TIME_POS]->get_date(&mysql_time, + SPIDER_date_mode_t(0)); + stat->update_time = (time_t) my_system_gmt_sec(&mysql_time, + ¬_used_long, ¬_used_uint); + if (table->field[SPIDER_TABLE_STS_CHECKSUM_POS]->is_null()) + { + stat->checksum_null = TRUE; + stat->checksum = 0; + } else { + stat->checksum_null = FALSE; + stat->checksum = (ha_checksum) table-> + field[SPIDER_TABLE_STS_CHECKSUM_POS]->val_int(); + } + DBUG_VOID_RETURN; +} + +void spider_get_sys_table_crd_info( + TABLE *table, + longlong *cardinality, + uint number_of_keys +) { + uint seq; + DBUG_ENTER("spider_get_sys_table_crd_info"); + seq = (uint) table->field[SPIDER_TABLE_CRD_KEY_SEQ_POS]->val_int(); + if (seq < number_of_keys) + { + cardinality[seq] = (longlong) table-> + field[SPIDER_TABLE_CRD_CARDINALITY_POS]->val_int(); + } + DBUG_VOID_RETURN; +} + +int spider_sys_update_tables_link_status( + THD *thd, + char *name, + uint name_length, + int link_idx, + long link_status, + bool need_lock +) { + int error_num; + TABLE *table_tables = NULL; + SPIDER_Open_tables_backup open_tables_backup; + DBUG_ENTER("spider_sys_update_tables_link_status"); + if ( + !(table_tables = spider_open_sys_table( + thd, SPIDER_SYS_TABLES_TABLE_NAME_STR, + SPIDER_SYS_TABLES_TABLE_NAME_LEN, TRUE, &open_tables_backup, need_lock, + &error_num)) + ) { + goto error; + } + if ((error_num = spider_update_tables_link_status(table_tables, + name, name_length, link_idx, link_status))) + goto error; + spider_close_sys_table(thd, table_tables, + &open_tables_backup, need_lock); + table_tables = NULL; + DBUG_RETURN(0); + +error: + if (table_tables) + spider_close_sys_table(thd, table_tables, + &open_tables_backup, need_lock); + DBUG_RETURN(error_num); +} + +int spider_sys_log_tables_link_failed( + THD *thd, + char *name, + uint name_length, + int link_idx, + bool need_lock +) { + int error_num; + TABLE *table_tables = NULL; + SPIDER_Open_tables_backup open_tables_backup; + DBUG_ENTER("spider_sys_log_tables_link_failed"); + if ( + !(table_tables = spider_open_sys_table( + thd, SPIDER_SYS_LINK_FAILED_TABLE_NAME_STR, + SPIDER_SYS_LINK_FAILED_TABLE_NAME_LEN, TRUE, &open_tables_backup, + need_lock, &error_num)) + ) { + goto error; + } + empty_record(table_tables); + if ((error_num = spider_log_tables_link_failed(table_tables, + name, name_length, link_idx))) + goto error; + spider_close_sys_table(thd, table_tables, + &open_tables_backup, need_lock); + table_tables = NULL; + DBUG_RETURN(0); + +error: + if (table_tables) + spider_close_sys_table(thd, table_tables, + &open_tables_backup, need_lock); + DBUG_RETURN(error_num); +} + +int spider_sys_log_xa_failed( + THD *thd, + XID *xid, + SPIDER_CONN *conn, + const char *status, + bool need_lock +) { + int error_num; + TABLE *table_tables = NULL; + SPIDER_Open_tables_backup open_tables_backup; + DBUG_ENTER("spider_sys_log_xa_failed"); + if ( + !(table_tables = spider_open_sys_table( + thd, SPIDER_SYS_XA_FAILED_TABLE_NAME_STR, + SPIDER_SYS_XA_FAILED_TABLE_NAME_LEN, TRUE, &open_tables_backup, + need_lock, &error_num)) + ) { + goto error; + } + empty_record(table_tables); + if ((error_num = spider_log_xa_failed(thd, table_tables, xid, conn, status))) + goto error; + spider_close_sys_table(thd, table_tables, &open_tables_backup, need_lock); + table_tables = NULL; + DBUG_RETURN(0); + +error: + if (table_tables) + spider_close_sys_table(thd, table_tables, &open_tables_backup, need_lock); + DBUG_RETURN(error_num); +} + +int spider_get_sys_link_mon_key( + TABLE *table, + SPIDER_MON_KEY *mon_key, + MEM_ROOT *mem_root, + int *same +) { + char *db_name, *table_name, *link_id; + uint db_name_length, table_name_length, link_id_length; + DBUG_ENTER("spider_get_sys_link_mon_key"); + if ( + table->field[SPIDER_LINK_MON_SERVERS_DB_NAME_POS]->is_null() || + table->field[SPIDER_LINK_MON_SERVERS_TABLE_NAME_POS]->is_null() || + table->field[SPIDER_LINK_MON_SERVERS_LINK_ID_POS]->is_null() + ) { + my_printf_error(ER_SPIDER_SYS_TABLE_VERSION_NUM, + ER_SPIDER_SYS_TABLE_VERSION_STR, MYF(0), + SPIDER_SYS_LINK_MON_TABLE_NAME_STR); + DBUG_RETURN(ER_SPIDER_SYS_TABLE_VERSION_NUM); + } + + if (!(db_name= + get_field(mem_root, + table->field[SPIDER_LINK_MON_SERVERS_DB_NAME_POS]))) + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + if (!(table_name= + get_field(mem_root, + table->field[SPIDER_LINK_MON_SERVERS_TABLE_NAME_POS]))) + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + if (!(link_id= + get_field(mem_root, + table->field[SPIDER_LINK_MON_SERVERS_LINK_ID_POS]))) + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + + db_name_length = strlen(db_name); + table_name_length = strlen(table_name); + link_id_length = strlen(link_id); + + if ( + db_name_length > SPIDER_SYS_LINK_MON_TABLE_DB_NAME_SIZE || + table_name_length > SPIDER_SYS_LINK_MON_TABLE_TABLE_NAME_SIZE || + link_id_length > SPIDER_SYS_LINK_MON_TABLE_LINK_ID_SIZE + ) { + my_printf_error(ER_SPIDER_SYS_TABLE_VERSION_NUM, + ER_SPIDER_SYS_TABLE_VERSION_STR, MYF(0), + SPIDER_SYS_LINK_MON_TABLE_NAME_STR); + DBUG_RETURN(ER_SPIDER_SYS_TABLE_VERSION_NUM); + } + + if ( + db_name_length == mon_key->db_name_length && + table_name_length == mon_key->table_name_length && + link_id_length == mon_key->link_id_length && + !memcmp(db_name, mon_key->db_name, db_name_length) && + !memcmp(table_name, mon_key->table_name, table_name_length) && + !memcmp(link_id, mon_key->link_id, link_id_length) + ) { + /* same key */ + *same = 1; + DBUG_RETURN(0); + } + + *same = 0; + mon_key->db_name_length = db_name_length; + memcpy(mon_key->db_name, db_name, db_name_length + 1); + mon_key->table_name_length = table_name_length; + memcpy(mon_key->table_name, table_name, table_name_length + 1); + mon_key->link_id_length = link_id_length; + memcpy(mon_key->link_id, link_id, link_id_length + 1); + DBUG_RETURN(0); +} + +int spider_get_sys_link_mon_server_id( + TABLE *table, + uint32 *server_id, + MEM_ROOT *mem_root +) { + char *ptr; + int error_num = 0; + DBUG_ENTER("spider_get_sys_link_mon_server_id"); + if ((ptr = get_field(mem_root, + table->field[SPIDER_LINK_MON_SERVERS_SID_POS]))) + *server_id = (uint32) my_strtoll10(ptr, (char**) NULL, &error_num); + else + *server_id = ~(uint32) 0; + DBUG_RETURN(error_num); +} + +int spider_get_sys_link_mon_connect_info( + TABLE *table, + SPIDER_SHARE *share, + int link_idx, + MEM_ROOT *mem_root +) { + char *ptr; + int error_num = 0; + DBUG_ENTER("spider_get_sys_link_mon_connect_info"); + if ( + !table->field[SPIDER_LINK_MON_SERVERS_SERVER_POS]->is_null() && + (ptr = get_field(mem_root, + table->field[SPIDER_LINK_MON_SERVERS_SERVER_POS])) + ) { + share->server_names_lengths[link_idx] = strlen(ptr); + share->server_names[link_idx] = + spider_create_string(ptr, share->server_names_lengths[link_idx]); + } else { + share->server_names_lengths[link_idx] = 0; + share->server_names[link_idx] = NULL; + } + if ( + !table->field[SPIDER_LINK_MON_SERVERS_SCHEME_POS]->is_null() && + (ptr = get_field(mem_root, + table->field[SPIDER_LINK_MON_SERVERS_SCHEME_POS])) + ) { + share->tgt_wrappers_lengths[link_idx] = strlen(ptr); + share->tgt_wrappers[link_idx] = + spider_create_string(ptr, share->tgt_wrappers_lengths[link_idx]); + } else { + share->tgt_wrappers_lengths[link_idx] = 0; + share->tgt_wrappers[link_idx] = NULL; + } + if ( + !table->field[SPIDER_LINK_MON_SERVERS_HOST_POS]->is_null() && + (ptr = get_field(mem_root, table->field[SPIDER_LINK_MON_SERVERS_HOST_POS])) + ) { + share->tgt_hosts_lengths[link_idx] = strlen(ptr); + share->tgt_hosts[link_idx] = + spider_create_string(ptr, share->tgt_hosts_lengths[link_idx]); + } else { + share->tgt_hosts_lengths[link_idx] = 0; + share->tgt_hosts[link_idx] = NULL; + } + if ( + !table->field[SPIDER_LINK_MON_SERVERS_PORT_POS]->is_null() && + (ptr = get_field(mem_root, table->field[SPIDER_LINK_MON_SERVERS_PORT_POS])) + ) { + share->tgt_ports[link_idx] = atol(ptr); + } else { + share->tgt_ports[link_idx] = -1; + } + if ( + !table->field[SPIDER_LINK_MON_SERVERS_SOCKET_POS]->is_null() && + (ptr = get_field(mem_root, + table->field[SPIDER_LINK_MON_SERVERS_SOCKET_POS])) + ) { + share->tgt_sockets_lengths[link_idx] = strlen(ptr); + share->tgt_sockets[link_idx] = + spider_create_string(ptr, share->tgt_sockets_lengths[link_idx]); + } else { + share->tgt_sockets_lengths[link_idx] = 0; + share->tgt_sockets[link_idx] = NULL; + } + if ( + !table->field[SPIDER_LINK_MON_SERVERS_USERNAME_POS]->is_null() && + (ptr = get_field(mem_root, + table->field[SPIDER_LINK_MON_SERVERS_USERNAME_POS])) + ) { + share->tgt_usernames_lengths[link_idx] = strlen(ptr); + share->tgt_usernames[link_idx] = + spider_create_string(ptr, share->tgt_usernames_lengths[link_idx]); + } else { + share->tgt_usernames_lengths[link_idx] = 0; + share->tgt_usernames[link_idx] = NULL; + } + if ( + !table->field[SPIDER_LINK_MON_SERVERS_PASSWORD_POS]->is_null() && + (ptr = get_field(mem_root, + table->field[SPIDER_LINK_MON_SERVERS_PASSWORD_POS])) + ) { + share->tgt_passwords_lengths[link_idx] = strlen(ptr); + share->tgt_passwords[link_idx] = + spider_create_string(ptr, share->tgt_passwords_lengths[link_idx]); + } else { + share->tgt_passwords_lengths[link_idx] = 0; + share->tgt_passwords[link_idx] = NULL; + } + if ( + !table->field[SPIDER_LINK_MON_SERVERS_SSL_CA_POS]->is_null() && + (ptr = get_field(mem_root, + table->field[SPIDER_LINK_MON_SERVERS_SSL_CA_POS])) + ) { + share->tgt_ssl_cas_lengths[link_idx] = strlen(ptr); + share->tgt_ssl_cas[link_idx] = + spider_create_string(ptr, share->tgt_ssl_cas_lengths[link_idx]); + } else { + share->tgt_ssl_cas_lengths[link_idx] = 0; + share->tgt_ssl_cas[link_idx] = NULL; + } + if ( + !table->field[SPIDER_LINK_MON_SERVERS_SSL_CAPATH_POS]->is_null() && + (ptr = get_field(mem_root, + table->field[SPIDER_LINK_MON_SERVERS_SSL_CAPATH_POS])) + ) { + share->tgt_ssl_capaths_lengths[link_idx] = strlen(ptr); + share->tgt_ssl_capaths[link_idx] = + spider_create_string(ptr, share->tgt_ssl_capaths_lengths[link_idx]); + } else { + share->tgt_ssl_capaths_lengths[link_idx] = 0; + share->tgt_ssl_capaths[link_idx] = NULL; + } + if ( + !table->field[SPIDER_LINK_MON_SERVERS_SSL_CERT_POS]->is_null() && + (ptr = get_field(mem_root, + table->field[SPIDER_LINK_MON_SERVERS_SSL_CERT_POS])) + ) { + share->tgt_ssl_certs_lengths[link_idx] = strlen(ptr); + share->tgt_ssl_certs[link_idx] = + spider_create_string(ptr, share->tgt_ssl_certs_lengths[link_idx]); + } else { + share->tgt_ssl_certs_lengths[link_idx] = 0; + share->tgt_ssl_certs[link_idx] = NULL; + } + if ( + !table->field[SPIDER_LINK_MON_SERVERS_SSL_CIPHER_POS]->is_null() && + (ptr = get_field(mem_root, + table->field[SPIDER_LINK_MON_SERVERS_SSL_CIPHER_POS])) + ) { + share->tgt_ssl_ciphers_lengths[link_idx] = strlen(ptr); + share->tgt_ssl_ciphers[link_idx] = + spider_create_string(ptr, share->tgt_ssl_ciphers_lengths[link_idx]); + } else { + share->tgt_ssl_ciphers_lengths[link_idx] = 0; + share->tgt_ssl_ciphers[link_idx] = NULL; + } + if ( + !table->field[SPIDER_LINK_MON_SERVERS_SSL_KEY_POS]->is_null() && + (ptr = get_field(mem_root, + table->field[SPIDER_LINK_MON_SERVERS_SSL_KEY_POS])) + ) { + share->tgt_ssl_keys_lengths[link_idx] = strlen(ptr); + share->tgt_ssl_keys[link_idx] = + spider_create_string(ptr, share->tgt_ssl_keys_lengths[link_idx]); + } else { + share->tgt_ssl_keys_lengths[link_idx] = 0; + share->tgt_ssl_keys[link_idx] = NULL; + } + if ( + !table->field[SPIDER_LINK_MON_SERVERS_SSL_VERIFY_SERVER_CERT_POS]-> + is_null() && + (ptr = get_field(mem_root, + table->field[SPIDER_LINK_MON_SERVERS_SSL_VERIFY_SERVER_CERT_POS])) + ) { + share->tgt_ssl_vscs[link_idx] = atol(ptr); + } else + share->tgt_ssl_vscs[link_idx] = -1; + if ( + !table->field[SPIDER_LINK_MON_SERVERS_DEFAULT_FILE_POS]->is_null() && + (ptr = get_field(mem_root, + table->field[SPIDER_LINK_MON_SERVERS_DEFAULT_FILE_POS])) + ) { + share->tgt_default_files_lengths[link_idx] = strlen(ptr); + share->tgt_default_files[link_idx] = + spider_create_string(ptr, share->tgt_default_files_lengths[link_idx]); + } else { + share->tgt_default_files_lengths[link_idx] = 0; + share->tgt_default_files[link_idx] = NULL; + } + if ( + !table->field[SPIDER_LINK_MON_SERVERS_DEFAULT_GROUP_POS]->is_null() && + (ptr = get_field(mem_root, + table->field[SPIDER_LINK_MON_SERVERS_DEFAULT_GROUP_POS])) + ) { + share->tgt_default_groups_lengths[link_idx] = strlen(ptr); + share->tgt_default_groups[link_idx] = + spider_create_string(ptr, share->tgt_default_groups_lengths[link_idx]); + } else { + share->tgt_default_groups_lengths[link_idx] = 0; + share->tgt_default_groups[link_idx] = NULL; + } + if ( + !table->field[SPIDER_LINK_MON_SERVERS_DSN_POS]->is_null() && + (ptr = get_field(mem_root, table->field[SPIDER_LINK_MON_SERVERS_DSN_POS])) + ) { + share->tgt_dsns_lengths[link_idx] = strlen(ptr); + share->tgt_dsns[link_idx] = + spider_create_string(ptr, share->tgt_dsns_lengths[link_idx]); + } else { + share->tgt_dsns_lengths[link_idx] = 0; + share->tgt_dsns[link_idx] = NULL; + } + if ( + !table->field[SPIDER_LINK_MON_SERVERS_FILEDSN_POS]->is_null() && + (ptr = get_field(mem_root, table->field[SPIDER_LINK_MON_SERVERS_FILEDSN_POS])) + ) { + share->tgt_filedsns_lengths[link_idx] = strlen(ptr); + share->tgt_filedsns[link_idx] = + spider_create_string(ptr, share->tgt_filedsns_lengths[link_idx]); + } else { + share->tgt_filedsns_lengths[link_idx] = 0; + share->tgt_filedsns[link_idx] = NULL; + } + if ( + !table->field[SPIDER_LINK_MON_SERVERS_DRIVER_POS]->is_null() && + (ptr = get_field(mem_root, table->field[SPIDER_LINK_MON_SERVERS_DRIVER_POS])) + ) { + share->tgt_drivers_lengths[link_idx] = strlen(ptr); + share->tgt_drivers[link_idx] = + spider_create_string(ptr, share->tgt_drivers_lengths[link_idx]); + } else { + share->tgt_drivers_lengths[link_idx] = 0; + share->tgt_drivers[link_idx] = NULL; + } + DBUG_RETURN(error_num); +} + +int spider_get_link_statuses( + TABLE *table, + SPIDER_SHARE *share, + MEM_ROOT *mem_root +) { + int error_num, roop_count; + char table_key[MAX_KEY_LENGTH]; + DBUG_ENTER("spider_get_link_statuses"); + table->use_all_columns(); + spider_store_tables_name(table, share->table_name, + share->table_name_length); + for (roop_count = 0; roop_count < (int) share->link_count; roop_count++) + { + spider_store_tables_link_idx(table, roop_count); + if ((error_num = spider_check_sys_table(table, table_key))) + { + if ( + (error_num == HA_ERR_KEY_NOT_FOUND || error_num == HA_ERR_END_OF_FILE) + ) { +/* + table->file->print_error(error_num, MYF(0)); +*/ + DBUG_RETURN(error_num); + } + } else if ((error_num = + spider_get_sys_tables_link_status(table, share, roop_count, mem_root))) + { + table->file->print_error(error_num, MYF(0)); + DBUG_RETURN(error_num); + } + } + DBUG_RETURN(0); +} + +int spider_sys_insert_or_update_table_sts( + THD *thd, + const char *name, + uint name_length, + ha_statistics *stat, + bool need_lock +) { + int error_num; + TABLE *table_sts = NULL; + SPIDER_Open_tables_backup open_tables_backup; + DBUG_ENTER("spider_sys_insert_or_update_table_sts"); + if ( + !(table_sts = spider_open_sys_table( + thd, SPIDER_SYS_TABLE_STS_TABLE_NAME_STR, + SPIDER_SYS_TABLE_STS_TABLE_NAME_LEN, TRUE, + &open_tables_backup, need_lock, &error_num)) + ) { + goto error; + } + if ((error_num = spider_insert_or_update_table_sts( + table_sts, + name, + name_length, + stat + ))) + goto error; + spider_close_sys_table(thd, table_sts, &open_tables_backup, need_lock); + table_sts = NULL; + DBUG_RETURN(0); + +error: + if (table_sts) + spider_close_sys_table(thd, table_sts, &open_tables_backup, need_lock); + DBUG_RETURN(error_num); +} + +int spider_sys_insert_or_update_table_crd( + THD *thd, + const char *name, + uint name_length, + longlong *cardinality, + uint number_of_keys, + bool need_lock +) { + int error_num; + TABLE *table_crd = NULL; + SPIDER_Open_tables_backup open_tables_backup; + DBUG_ENTER("spider_sys_insert_or_update_table_crd"); + if ( + !(table_crd = spider_open_sys_table( + thd, SPIDER_SYS_TABLE_CRD_TABLE_NAME_STR, + SPIDER_SYS_TABLE_CRD_TABLE_NAME_LEN, TRUE, + &open_tables_backup, need_lock, &error_num)) + ) { + goto error; + } + if ((error_num = spider_insert_or_update_table_crd( + table_crd, + name, + name_length, + cardinality, + number_of_keys + ))) + goto error; + spider_close_sys_table(thd, table_crd, &open_tables_backup, need_lock); + table_crd = NULL; + DBUG_RETURN(0); + +error: + if (table_crd) + spider_close_sys_table(thd, table_crd, &open_tables_backup, need_lock); + DBUG_RETURN(error_num); +} + +int spider_sys_delete_table_sts( + THD *thd, + const char *name, + uint name_length, + bool need_lock +) { + int error_num; + TABLE *table_sts = NULL; + SPIDER_Open_tables_backup open_tables_backup; + DBUG_ENTER("spider_sys_delete_table_sts"); + if ( + !(table_sts = spider_open_sys_table( + thd, SPIDER_SYS_TABLE_STS_TABLE_NAME_STR, + SPIDER_SYS_TABLE_STS_TABLE_NAME_LEN, TRUE, + &open_tables_backup, need_lock, &error_num)) + ) { + goto error; + } + if ((error_num = spider_delete_table_sts( + table_sts, + name, + name_length + ))) + goto error; + spider_close_sys_table(thd, table_sts, &open_tables_backup, need_lock); + table_sts = NULL; + DBUG_RETURN(0); + +error: + if (table_sts) + spider_close_sys_table(thd, table_sts, &open_tables_backup, need_lock); + DBUG_RETURN(error_num); +} + +int spider_sys_delete_table_crd( + THD *thd, + const char *name, + uint name_length, + bool need_lock +) { + int error_num; + TABLE *table_crd = NULL; + SPIDER_Open_tables_backup open_tables_backup; + DBUG_ENTER("spider_sys_delete_table_crd"); + if ( + !(table_crd = spider_open_sys_table( + thd, SPIDER_SYS_TABLE_CRD_TABLE_NAME_STR, + SPIDER_SYS_TABLE_CRD_TABLE_NAME_LEN, TRUE, + &open_tables_backup, need_lock, &error_num)) + ) { + goto error; + } + if ((error_num = spider_delete_table_crd( + table_crd, + name, + name_length + ))) + goto error; + spider_close_sys_table(thd, table_crd, &open_tables_backup, need_lock); + table_crd = NULL; + DBUG_RETURN(0); + +error: + if (table_crd) + spider_close_sys_table(thd, table_crd, &open_tables_backup, need_lock); + DBUG_RETURN(error_num); +} + +int spider_sys_get_table_sts( + THD *thd, + const char *name, + uint name_length, + ha_statistics *stat, + bool need_lock +) { + int error_num; + char table_key[MAX_KEY_LENGTH]; + TABLE *table_sts = NULL; + SPIDER_Open_tables_backup open_tables_backup; + DBUG_ENTER("spider_sys_get_table_sts"); + if ( + !(table_sts = spider_open_sys_table( + thd, SPIDER_SYS_TABLE_STS_TABLE_NAME_STR, + SPIDER_SYS_TABLE_STS_TABLE_NAME_LEN, TRUE, + &open_tables_backup, need_lock, &error_num)) + ) { + goto error; + } + + table_sts->use_all_columns(); + spider_store_tables_name(table_sts, name, name_length); + if ((error_num = spider_check_sys_table(table_sts, table_key))) + { + if (error_num != HA_ERR_KEY_NOT_FOUND && error_num != HA_ERR_END_OF_FILE) + { + table_sts->file->print_error(error_num, MYF(0)); + } + goto error; + } else { + spider_get_sys_table_sts_info( + table_sts, + stat + ); + } + + spider_close_sys_table(thd, table_sts, &open_tables_backup, need_lock); + table_sts = NULL; + DBUG_RETURN(0); + +error: + if (table_sts) + spider_close_sys_table(thd, table_sts, &open_tables_backup, need_lock); + DBUG_RETURN(error_num); +} + +int spider_sys_get_table_crd( + THD *thd, + const char *name, + uint name_length, + longlong *cardinality, + uint number_of_keys, + bool need_lock +) { + int error_num; + char table_key[MAX_KEY_LENGTH]; + bool index_inited = FALSE; + TABLE *table_crd = NULL; + SPIDER_Open_tables_backup open_tables_backup; + DBUG_ENTER("spider_sys_get_table_crd"); + + if ( + !(table_crd = spider_open_sys_table( + thd, SPIDER_SYS_TABLE_CRD_TABLE_NAME_STR, + SPIDER_SYS_TABLE_CRD_TABLE_NAME_LEN, TRUE, + &open_tables_backup, need_lock, &error_num)) + ) { + goto error; + } + + table_crd->use_all_columns(); + spider_store_tables_name(table_crd, name, name_length); + if ((error_num = spider_get_sys_table_by_idx(table_crd, table_key, 0, + SPIDER_SYS_TABLE_CRD_PK_COL_CNT - 1))) + { + if (error_num != HA_ERR_KEY_NOT_FOUND && error_num != HA_ERR_END_OF_FILE) + { + table_crd->file->print_error(error_num, MYF(0)); + } + goto error; + } else { + index_inited = TRUE; + do { + spider_get_sys_table_crd_info( + table_crd, + cardinality, + number_of_keys + ); + error_num = spider_sys_index_next_same(table_crd, table_key); + } while (error_num == 0); + } + index_inited = FALSE; + if ((error_num = spider_sys_index_end(table_crd))) + { + table_crd->file->print_error(error_num, MYF(0)); + goto error; + } + + spider_close_sys_table(thd, table_crd, &open_tables_backup, need_lock); + table_crd = NULL; + DBUG_RETURN(0); + +error: + if (index_inited) + spider_sys_index_end(table_crd); + + if (table_crd) + spider_close_sys_table(thd, table_crd, &open_tables_backup, need_lock); + DBUG_RETURN(error_num); +} + +int spider_sys_replace( + TABLE *table, + bool *modified_non_trans_table +) { + int error_num, key_num; + bool last_uniq_key; + char table_key[MAX_KEY_LENGTH]; + DBUG_ENTER("spider_sys_replace"); + + while ((error_num = spider_write_sys_table_row(table, FALSE))) + { + if ( + table->file->is_fatal_error(error_num, HA_CHECK_DUP) || + (key_num = table->file->get_dup_key(error_num)) < 0 + ) + goto error; + + if (table->file->ha_table_flags() & HA_DUPLICATE_POS) + { + error_num = table->file->ha_rnd_pos(table->record[1], + table->file->dup_ref); + if (error_num) + { + if (error_num == HA_ERR_RECORD_DELETED) + error_num = HA_ERR_KEY_NOT_FOUND; + goto error; + } + } else { + if ((error_num = table->file->extra(HA_EXTRA_FLUSH_CACHE))) + goto error; + + key_copy((uchar*)table_key, table->record[0], + table->key_info + key_num, 0); + error_num = table->file->ha_index_read_idx_map(table->record[1], key_num, + (const uchar*)table_key, HA_WHOLE_KEY, HA_READ_KEY_EXACT); + if (error_num) + { + if (error_num == HA_ERR_RECORD_DELETED) + error_num = HA_ERR_KEY_NOT_FOUND; + goto error; + } + } + + last_uniq_key = TRUE; + while (++key_num < (int) table->s->keys) + if (table->key_info[key_num].flags & HA_NOSAME) + last_uniq_key = FALSE; + + if ( + last_uniq_key && + !table->file->referenced_by_foreign_key() + ) { + if ((error_num = spider_update_sys_table_row(table))) + goto error; + DBUG_RETURN(0); + } else { + if ((error_num = spider_delete_sys_table_row(table, 1, FALSE))) + goto error; + *modified_non_trans_table = TRUE; + } + } + + DBUG_RETURN(0); + +error: + DBUG_RETURN(error_num); +} + +#ifdef SPIDER_use_LEX_CSTRING_for_Field_blob_constructor +TABLE *spider_mk_sys_tmp_table( + THD *thd, + TABLE *table, + TMP_TABLE_PARAM *tmp_tbl_prm, + const LEX_CSTRING *field_name, + CHARSET_INFO *cs +) +#else +TABLE *spider_mk_sys_tmp_table( + THD *thd, + TABLE *table, + TMP_TABLE_PARAM *tmp_tbl_prm, + const char *field_name, + CHARSET_INFO *cs +) +#endif +{ + Field_blob *field; + Item_field *i_field; + List<Item> i_list; + TABLE *tmp_table; + DBUG_ENTER("spider_mk_sys_tmp_table"); + +#ifdef SPIDER_FIELD_FIELDPTR_REQUIRES_THDPTR + if (!(field = new (thd->mem_root) Field_blob( + 4294967295U, FALSE, field_name, cs, TRUE))) + goto error_alloc_field; +#else + if (!(field = new Field_blob( + 4294967295U, FALSE, field_name, cs, TRUE))) + goto error_alloc_field; +#endif + field->init(table); + +#ifdef SPIDER_FIELD_FIELDPTR_REQUIRES_THDPTR + if (!(i_field = new (thd->mem_root) Item_field(thd, (Field *) field))) + goto error_alloc_item_field; +#else + if (!(i_field = new Item_field((Field *) field))) + goto error_alloc_item_field; +#endif + + if (i_list.push_back(i_field)) + goto error_push_item; + + if (!(tmp_table = create_tmp_table(thd, tmp_tbl_prm, + i_list, (ORDER*) NULL, FALSE, FALSE, + (TMP_TABLE_FORCE_MYISAM | TMP_TABLE_ALL_COLUMNS), + HA_POS_ERROR, &SPIDER_empty_string))) + goto error_create_tmp_table; + DBUG_RETURN(tmp_table); + +error_create_tmp_table: +error_push_item: + delete i_field; +error_alloc_item_field: + delete field; +error_alloc_field: + DBUG_RETURN(NULL); +} + +void spider_rm_sys_tmp_table( + THD *thd, + TABLE *tmp_table, + TMP_TABLE_PARAM *tmp_tbl_prm +) { + DBUG_ENTER("spider_rm_sys_tmp_table"); + free_tmp_table(thd, tmp_table); + tmp_tbl_prm->cleanup(); + tmp_tbl_prm->field_count = 1; + DBUG_VOID_RETURN; +} + +#ifdef SPIDER_use_LEX_CSTRING_for_Field_blob_constructor +TABLE *spider_mk_sys_tmp_table_for_result( + THD *thd, + TABLE *table, + TMP_TABLE_PARAM *tmp_tbl_prm, + const LEX_CSTRING *field_name1, + const LEX_CSTRING *field_name2, + const LEX_CSTRING *field_name3, + CHARSET_INFO *cs +) +#else +TABLE *spider_mk_sys_tmp_table_for_result( + THD *thd, + TABLE *table, + TMP_TABLE_PARAM *tmp_tbl_prm, + const char *field_name1, + const char *field_name2, + const char *field_name3, + CHARSET_INFO *cs +) +#endif +{ + Field_blob *field1, *field2, *field3; + Item_field *i_field1, *i_field2, *i_field3; + List<Item> i_list; + TABLE *tmp_table; + DBUG_ENTER("spider_mk_sys_tmp_table_for_result"); + +#ifdef SPIDER_FIELD_FIELDPTR_REQUIRES_THDPTR + if (!(field1 = new (thd->mem_root) Field_blob( + 4294967295U, FALSE, field_name1, cs, TRUE))) + goto error_alloc_field1; +#else + if (!(field1 = new Field_blob( + 4294967295U, FALSE, field_name1, cs, TRUE))) + goto error_alloc_field1; +#endif + field1->init(table); + +#ifdef SPIDER_FIELD_FIELDPTR_REQUIRES_THDPTR + if (!(i_field1 = new (thd->mem_root) Item_field(thd, (Field *) field1))) + goto error_alloc_item_field1; +#else + if (!(i_field1 = new Item_field((Field *) field1))) + goto error_alloc_item_field1; +#endif + + if (i_list.push_back(i_field1)) + goto error_push_item1; + +#ifdef SPIDER_FIELD_FIELDPTR_REQUIRES_THDPTR + if (!(field2 = new (thd->mem_root) Field_blob( + 4294967295U, FALSE, field_name2, cs, TRUE))) + goto error_alloc_field2; +#else + if (!(field2 = new Field_blob( + 4294967295U, FALSE, field_name2, cs, TRUE))) + goto error_alloc_field2; +#endif + field2->init(table); + +#ifdef SPIDER_FIELD_FIELDPTR_REQUIRES_THDPTR + if (!(i_field2 = new (thd->mem_root) Item_field(thd, (Field *) field2))) + goto error_alloc_item_field2; +#else + if (!(i_field2 = new Item_field((Field *) field2))) + goto error_alloc_item_field2; +#endif + + if (i_list.push_back(i_field2)) + goto error_push_item2; + +#ifdef SPIDER_FIELD_FIELDPTR_REQUIRES_THDPTR + if (!(field3 = new (thd->mem_root) Field_blob( + 4294967295U, FALSE, field_name3, cs, TRUE))) + goto error_alloc_field3; +#else + if (!(field3 = new Field_blob( + 4294967295U, FALSE, field_name3, cs, TRUE))) + goto error_alloc_field3; +#endif + field3->init(table); + +#ifdef SPIDER_FIELD_FIELDPTR_REQUIRES_THDPTR + if (!(i_field3 = new (thd->mem_root) Item_field(thd, (Field *) field3))) + goto error_alloc_item_field3; +#else + if (!(i_field3 = new Item_field((Field *) field3))) + goto error_alloc_item_field3; +#endif + + if (i_list.push_back(i_field3)) + goto error_push_item3; + + if (!(tmp_table = create_tmp_table(thd, tmp_tbl_prm, + i_list, (ORDER*) NULL, FALSE, FALSE, + (TMP_TABLE_FORCE_MYISAM | TMP_TABLE_ALL_COLUMNS), + HA_POS_ERROR, &SPIDER_empty_string))) + goto error_create_tmp_table; + DBUG_RETURN(tmp_table); + +error_create_tmp_table: +error_push_item3: + delete i_field3; +error_alloc_item_field3: + delete field3; +error_alloc_field3: +error_push_item2: + delete i_field2; +error_alloc_item_field2: + delete field2; +error_alloc_field2: +error_push_item1: + delete i_field1; +error_alloc_item_field1: + delete field1; +error_alloc_field1: + DBUG_RETURN(NULL); +} + +void spider_rm_sys_tmp_table_for_result( + THD *thd, + TABLE *tmp_table, + TMP_TABLE_PARAM *tmp_tbl_prm +) { + DBUG_ENTER("spider_rm_sys_tmp_table_for_result"); + free_tmp_table(thd, tmp_table); + tmp_tbl_prm->cleanup(); + tmp_tbl_prm->field_count = 3; + DBUG_VOID_RETURN; +} + +TABLE *spider_find_temporary_table( + THD *thd, + TABLE_LIST *table_list +) { + DBUG_ENTER("spider_find_temporary_table"); +#ifdef SPIDER_open_temporary_table + if (!thd->has_temporary_tables()) + { + DBUG_RETURN(NULL); + } + if (thd->open_temporary_table(table_list)) + { + DBUG_RETURN(NULL); + } else { + DBUG_RETURN(table_list->table); + } +#else + DBUG_RETURN(find_temporary_table(A,B)); +#endif +} |