diff options
Diffstat (limited to 'storage')
239 files changed, 704 insertions, 49800 deletions
diff --git a/storage/connect/json.cpp b/storage/connect/json.cpp index a46d6001434..4490f179d24 100644 --- a/storage/connect/json.cpp +++ b/storage/connect/json.cpp @@ -24,10 +24,8 @@ #define ARGS MY_MIN(24,(int)len-i),s+MY_MAX(i-3,0) -#if defined(_WIN32) -#define EL "\r\n" -#else -#define EL "\n" +#define EL "\n" +#if !defined(_WIN32) #undef SE_CATCH // Does not work for Linux #endif diff --git a/storage/connect/tabmul.cpp b/storage/connect/tabmul.cpp index 4fad2b27cd8..d0b7b3163b6 100644 --- a/storage/connect/tabmul.cpp +++ b/storage/connect/tabmul.cpp @@ -199,23 +199,16 @@ bool TDBMUL::InitFileNames(PGLOBAL g) p = filename + strlen(filename) - 1; -#if !defined(_WIN32) - // Data files can be imported from Windows (having CRLF) + + // Data files can have CRLF if (*p == '\n' || *p == '\r') { - // is this enough for Unix ??? p--; // Eliminate ending CR or LF character if (p >= filename) - // is this enough for Unix ??? if (*p == '\n' || *p == '\r') p--; // Eliminate ending CR or LF character - } // endif p - -#else - if (*p == '\n') - p--; // Eliminate ending new-line character -#endif + } // endif p // Trim rightmost blanks for (; p >= filename && *p == ' '; p--) ; diff --git a/storage/innobase/buf/buf0flu.cc b/storage/innobase/buf/buf0flu.cc index 400220235a7..3fa26dab25f 100644 --- a/storage/innobase/buf/buf0flu.cc +++ b/storage/innobase/buf/buf0flu.cc @@ -1708,40 +1708,144 @@ inline void log_t::write_checkpoint(lsn_t end_lsn) noexcept mach_write_to_8(my_assume_aligned<8>(c), next_checkpoint_lsn); mach_write_to_8(my_assume_aligned<8>(c + 8), end_lsn); mach_write_to_4(my_assume_aligned<4>(c + 60), my_crc32c(0, c, 60)); + + lsn_t resizing; + #ifdef HAVE_PMEM if (is_pmem()) + { + resizing= resize_lsn.load(std::memory_order_relaxed); + + if (resizing > 1 && resizing <= next_checkpoint_lsn) + { + memcpy_aligned<64>(resize_buf + CHECKPOINT_1, c, 64); + header_write(resize_buf, resizing, is_encrypted()); + pmem_persist(resize_buf, resize_target); + } pmem_persist(c, 64); + } else #endif { ut_ad(!checkpoint_pending); checkpoint_pending= true; latch.wr_unlock(); + log_write_and_flush_prepare(); + resizing= resize_lsn.load(std::memory_order_relaxed); /* FIXME: issue an asynchronous write */ log.write(offset, {c, get_block_size()}); + if (resizing > 1 && resizing <= next_checkpoint_lsn) + { + byte *buf= static_cast<byte*>(aligned_malloc(4096, 4096)); + memset_aligned<4096>(buf, 0, 4096); + header_write(buf, resizing, is_encrypted()); + resize_log.write(0, {buf, 4096}); + aligned_free(buf); + resize_log.write(CHECKPOINT_1, {c, get_block_size()}); + } + if (srv_file_flush_method != SRV_O_DSYNC) ut_a(log.flush()); latch.wr_lock(SRW_LOCK_CALL); ut_ad(checkpoint_pending); checkpoint_pending= false; + resizing= resize_lsn.load(std::memory_order_relaxed); } ut_ad(!checkpoint_pending); next_checkpoint_no++; - last_checkpoint_lsn= next_checkpoint_lsn; + const lsn_t checkpoint_lsn{next_checkpoint_lsn}; + last_checkpoint_lsn= checkpoint_lsn; DBUG_PRINT("ib_log", ("checkpoint ended at " LSN_PF ", flushed to " LSN_PF, - next_checkpoint_lsn, get_flushed_lsn())); + checkpoint_lsn, get_flushed_lsn())); if (overwrite_warned) { sql_print_information("InnoDB: Crash recovery was broken " "between LSN=" LSN_PF " and checkpoint LSN=" LSN_PF ".", - overwrite_warned, next_checkpoint_lsn); + overwrite_warned, checkpoint_lsn); overwrite_warned= 0; } - latch.wr_unlock(); + lsn_t resizing_completed= 0; + + if (resizing > 1 && resizing <= checkpoint_lsn) + { + ut_ad(is_pmem() == !resize_flush_buf); + + if (!is_pmem()) + { + if (srv_file_flush_method != SRV_O_DSYNC) + ut_a(resize_log.flush()); + IF_WIN(log.close(),); + } + + if (resize_rename()) + { + /* Resizing failed. Discard the log_sys.resize_log. */ +#ifdef HAVE_PMEM + if (is_pmem()) + my_munmap(resize_buf, resize_target); + else +#endif + { + ut_free_dodump(resize_buf, buf_size); + ut_free_dodump(resize_flush_buf, buf_size); +#ifdef _WIN32 + ut_ad(!log.is_opened()); + bool success; + log.m_file= + os_file_create_func(get_log_file_path().c_str(), + OS_FILE_OPEN | OS_FILE_ON_ERROR_NO_EXIT, + OS_FILE_NORMAL, OS_LOG_FILE, false, &success); + ut_a(success); + ut_a(log.is_opened()); +#endif + } + } + else + { + /* Adopt the resized log. */ +#ifdef HAVE_PMEM + if (is_pmem()) + { + my_munmap(buf, file_size); + buf= resize_buf; + buf_free= START_OFFSET + (get_lsn() - resizing); + } + else +#endif + { + IF_WIN(,log.close()); + std::swap(log, resize_log); + ut_free_dodump(buf, buf_size); + ut_free_dodump(flush_buf, buf_size); + buf= resize_buf; + flush_buf= resize_flush_buf; + } + srv_log_file_size= resizing_completed= file_size= resize_target; + first_lsn= resizing; + set_capacity(); + } + ut_ad(!resize_log.is_opened()); + resize_buf= nullptr; + resize_flush_buf= nullptr; + resize_target= 0; + resize_lsn.store(0, std::memory_order_relaxed); + } + + log_resize_release(); + + if (UNIV_LIKELY(resizing <= 1)); + else if (resizing > checkpoint_lsn) + buf_flush_ahead(resizing, false); + else if (resizing_completed) + ib::info() << "Resized log to " << ib::bytes_iec{resizing_completed} + << "; start LSN=" << resizing; + else + sql_print_error("InnoDB: Resize of log failed at " LSN_PF, + get_flushed_lsn()); } /** Initiate a log checkpoint, discarding the start of the log. @@ -1758,7 +1862,9 @@ static bool log_checkpoint_low(lsn_t oldest_lsn, lsn_t end_lsn) ut_ad(end_lsn == log_sys.get_lsn()); if (oldest_lsn == log_sys.last_checkpoint_lsn || - (oldest_lsn == end_lsn && oldest_lsn == log_sys.last_checkpoint_lsn + + (oldest_lsn == end_lsn && + !log_sys.resize_in_progress() && + oldest_lsn == log_sys.last_checkpoint_lsn + (log_sys.is_encrypted() ? SIZE_OF_FILE_CHECKPOINT + 8 : SIZE_OF_FILE_CHECKPOINT))) { diff --git a/storage/innobase/handler/ha_innodb.cc b/storage/innobase/handler/ha_innodb.cc index e1b88bc0cfd..8a1bb32c973 100644 --- a/storage/innobase/handler/ha_innodb.cc +++ b/storage/innobase/handler/ha_innodb.cc @@ -18470,6 +18470,57 @@ static void innodb_log_file_buffering_update(THD *thd, st_mysql_sys_var*, } #endif +static void innodb_log_file_size_update(THD *thd, st_mysql_sys_var*, + void *var, const void *save) +{ + ut_ad(var == &srv_log_file_size); + mysql_mutex_unlock(&LOCK_global_system_variables); + + if (high_level_read_only) + ib_senderrf(thd, IB_LOG_LEVEL_ERROR, ER_READ_ONLY_MODE); + else if (!log_sys.is_pmem() && + *static_cast<const ulonglong*>(save) < log_sys.buf_size) + my_printf_error(ER_WRONG_ARGUMENTS, + "innodb_log_file_size must be at least" + " innodb_log_buffer_size=%zu", MYF(0), log_sys.buf_size); + else + { + switch (log_sys.resize_start(*static_cast<const ulonglong*>(save))) { + case log_t::RESIZE_NO_CHANGE: + break; + case log_t::RESIZE_IN_PROGRESS: + my_printf_error(ER_WRONG_USAGE, + "innodb_log_file_size change is already in progress", + MYF(0)); + break; + case log_t::RESIZE_FAILED: + ib_senderrf(thd, IB_LOG_LEVEL_ERROR, ER_CANT_CREATE_HANDLER_FILE); + break; + case log_t::RESIZE_STARTED: + for (timespec abstime;;) + { + if (thd_kill_level(thd)) + { + log_sys.resize_abort(); + break; + } + + set_timespec(abstime, 5); + mysql_mutex_lock(&buf_pool.flush_list_mutex); + const bool in_progress(buf_pool.get_oldest_modification(LSN_MAX) < + log_sys.resize_in_progress()); + if (in_progress) + my_cond_timedwait(&buf_pool.do_flush_list, + &buf_pool.flush_list_mutex.m_mutex, &abstime); + mysql_mutex_unlock(&buf_pool.flush_list_mutex); + if (!log_sys.resize_in_progress()) + break; + } + } + } + mysql_mutex_lock(&LOCK_global_system_variables); +} + /** Update innodb_status_output or innodb_status_output_locks, which control InnoDB "status monitor" output to the error log. @param[out] var current value @@ -19293,9 +19344,10 @@ static MYSQL_SYSVAR_BOOL(log_file_buffering, log_sys.log_buffered, #endif static MYSQL_SYSVAR_ULONGLONG(log_file_size, srv_log_file_size, - PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY, + PLUGIN_VAR_RQCMDARG, "Redo log size in bytes.", - NULL, NULL, 96 << 20, 4 << 20, std::numeric_limits<ulonglong>::max(), 4096); + nullptr, innodb_log_file_size_update, + 96 << 20, 4 << 20, std::numeric_limits<ulonglong>::max(), 4096); static MYSQL_SYSVAR_UINT(old_blocks_pct, innobase_old_blocks_pct, PLUGIN_VAR_RQCMDARG, @@ -19438,7 +19490,7 @@ static void innodb_change_buffering_update(THD *thd, struct st_mysql_sys_var*, } static MYSQL_SYSVAR_ENUM(change_buffering, innodb_change_buffering, - PLUGIN_VAR_RQCMDARG, + PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_DEPRECATED, "Buffer changes to secondary indexes.", nullptr, innodb_change_buffering_update, IBUF_USE_NONE, &innodb_change_buffering_typelib); diff --git a/storage/innobase/include/log0log.h b/storage/innobase/include/log0log.h index 7f5eb482e97..09e4ece8894 100644 --- a/storage/innobase/include/log0log.h +++ b/storage/innobase/include/log0log.h @@ -184,6 +184,8 @@ private: std::atomic<lsn_t> lsn; /** the first guaranteed-durable log sequence number */ std::atomic<lsn_t> flushed_to_disk_lsn; + /** log sequence number when log resizing was initiated, or 0 */ + std::atomic<lsn_t> resize_lsn; /** set when there may be need to flush the log buffer, or preflush buffer pool pages, or initiate a log checkpoint. This must hold if lsn - last_checkpoint_lsn > max_checkpoint_age. */ @@ -219,10 +221,19 @@ public: was noticed. Protected by latch.wr_lock(). */ lsn_t overwrite_warned; - /** innodb_log_buffer_size (size of buf and flush_buf, in bytes) */ + /** innodb_log_buffer_size (size of buf,flush_buf if !is_pmem(), in bytes) */ size_t buf_size; private: + /** Log file being constructed during resizing; protected by latch */ + log_file_t resize_log; + /** size of resize_log; protected by latch */ + lsn_t resize_target; + /** Buffer for writing to resize_log; @see buf */ + byte *resize_buf; + /** Buffer for writing to resize_log; @see flush_buf */ + byte *resize_flush_buf; + /** spin lock protecting lsn, buf_free in append_prepare() */ alignas(CPU_LEVEL1_DCACHE_LINESIZE) pthread_mutex_t lsn_lock; void init_lsn_lock() { pthread_mutex_init(&lsn_lock, LSN_LOCK_ATTR); } @@ -304,11 +315,48 @@ public: bool is_opened() const noexcept { return log.is_opened(); } - static constexpr bool resize_in_progress() { return false; } + /** @return LSN at which log resizing was started and is still in progress + @retval 0 if no log resizing is in progress */ + lsn_t resize_in_progress() const noexcept + { return resize_lsn.load(std::memory_order_relaxed); } + + /** Status of resize_start() */ + enum resize_start_status { + RESIZE_NO_CHANGE, RESIZE_IN_PROGRESS, RESIZE_STARTED, RESIZE_FAILED + }; + + /** Start resizing the log and release the exclusive latch. + @param size requested new file_size + @return whether the resizing was started successfully */ + resize_start_status resize_start(os_offset_t size) noexcept; + + /** Abort any resize_start(). */ + void resize_abort() noexcept; + + /** Replicate a write to the log. + @param lsn start LSN + @param end end of the mini-transaction + @param len length of the mini-transaction + @param seq offset of the sequence bit from the end */ + inline void resize_write(lsn_t lsn, const byte *end, + size_t len, size_t seq) noexcept; + + /** Write resize_buf to resize_log. + @param length the used length of resize_buf */ + ATTRIBUTE_COLD void resize_write_buf(size_t length) noexcept; /** Rename a log file after resizing. @return whether an error occurred */ - static bool rename_resized() noexcept; + static bool resize_rename() noexcept; + +#ifdef HAVE_PMEM + /** @return pointer for writing to resize_buf + @retval nullptr if no PMEM based resizing is active */ + inline byte *resize_buf_begin(lsn_t lsn) const noexcept; + /** @return end of resize_buf */ + inline const byte *resize_buf_end() const noexcept + { return resize_buf + resize_target; } +#endif #if defined __linux__ || defined _WIN32 /** Try to enable or disable file system caching (update log_buffered) */ @@ -322,6 +370,12 @@ public: /** Calculate the checkpoint safety margins. */ static void set_capacity(); + /** Write a log file header. + @param buf log header buffer + @param lsn log sequence number corresponding to log_sys.START_OFFSET + @param encrypted whether the log is encrypted */ + static void header_write(byte *buf, lsn_t lsn, bool encrypted); + lsn_t get_lsn(std::memory_order order= std::memory_order_relaxed) const { return lsn.load(order); } void set_lsn(lsn_t lsn) { this->lsn.store(lsn, std::memory_order_release); } @@ -366,7 +420,7 @@ public: { check_flush_or_checkpoint_.store(flag, std::memory_order_relaxed); } /** Make previous write_buf() durable and update flushed_to_disk_lsn. */ - inline bool flush(lsn_t lsn) noexcept; + bool flush(lsn_t lsn) noexcept; /** Initialise the redo log subsystem. */ void create(); @@ -451,8 +505,7 @@ public: /** Write buf to ib_logfile0. @tparam release_latch whether to invoke latch.wr_unlock() - @return new write target - @retval 0 if everything was written */ + @return the current log sequence number */ template<bool release_latch> inline lsn_t write_buf() noexcept; /** Create the log. */ @@ -467,3 +520,6 @@ inline void log_free_check() if (log_sys.check_flush_or_checkpoint()) log_check_margins(); } + +/** Release the latches that protect log resizing. */ +void log_resize_release(); diff --git a/storage/innobase/log/log0log.cc b/storage/innobase/log/log0log.cc index 048474921e5..2629f8a4320 100644 --- a/storage/innobase/log/log0log.cc +++ b/storage/innobase/log/log0log.cc @@ -159,13 +159,46 @@ dberr_t log_file_t::read(os_offset_t offset, span<byte> buf) noexcept void log_file_t::write(os_offset_t offset, span<const byte> buf) noexcept { ut_ad(is_opened()); - if (dberr_t err= os_file_write(IORequestWrite, "ib_logfile0", m_file, - buf.data(), offset, buf.size())) + if (dberr_t err= os_file_write_func(IORequestWrite, "ib_logfile0", m_file, + buf.data(), offset, buf.size())) ib::fatal() << "write(\"ib_logfile0\") returned " << err; } #ifdef HAVE_PMEM # include <libpmem.h> + +/** Attempt to memory map a file. +@param file log file handle +@param size file size +@return pointer to memory mapping +@retval MAP_FAILED if the memory cannot be mapped */ +static void *log_mmap(os_file_t file, os_offset_t size) +{ + void *ptr= + my_mmap(0, size_t(size), + srv_read_only_mode ? PROT_READ : PROT_READ | PROT_WRITE, + MAP_SHARED_VALIDATE | MAP_SYNC, file, 0); +#ifdef __linux__ + if (ptr == MAP_FAILED) + { + struct stat st; + if (!fstat(file, &st)) + { + MSAN_STAT_WORKAROUND(&st); + const auto st_dev= st.st_dev; + if (!stat("/dev/shm", &st)) + { + MSAN_STAT_WORKAROUND(&st); + if (st.st_dev == st_dev) + ptr= my_mmap(0, size_t(size), + srv_read_only_mode ? PROT_READ : PROT_READ | PROT_WRITE, + MAP_SHARED, file, 0); + } + } + } +#endif /* __linux__ */ + return ptr; +} #endif void log_t::attach(log_file_t file, os_offset_t size) @@ -179,29 +212,7 @@ void log_t::attach(log_file_t file, os_offset_t size) ut_ad(!flush_buf); if (size && !(size_t(size) & 4095) && srv_operation != SRV_OPERATION_BACKUP) { - void *ptr= - my_mmap(0, size_t(size), - srv_read_only_mode ? PROT_READ : PROT_READ | PROT_WRITE, - MAP_SHARED_VALIDATE | MAP_SYNC, log.m_file, 0); -#ifdef __linux__ - if (ptr == MAP_FAILED) - { - struct stat st; - if (!fstat(log.m_file, &st)) - { - MSAN_STAT_WORKAROUND(&st); - const auto st_dev= st.st_dev; - if (!stat("/dev/shm", &st)) - { - MSAN_STAT_WORKAROUND(&st); - if (st.st_dev == st_dev) - ptr= my_mmap(0, size_t(size), srv_read_only_mode - ? PROT_READ : PROT_READ | PROT_WRITE, - MAP_SHARED, log.m_file, 0); - } - } - } -#endif /* __linux__ */ + void *ptr= log_mmap(log.m_file, size); if (ptr != MAP_FAILED) { log.close(); @@ -236,6 +247,30 @@ void log_t::attach(log_file_t file, os_offset_t size) #endif } +/** Write a log file header. +@param buf log header buffer +@param lsn log sequence number corresponding to log_sys.START_OFFSET +@param encrypted whether the log is encrypted */ +void log_t::header_write(byte *buf, lsn_t lsn, bool encrypted) +{ + mach_write_to_4(my_assume_aligned<4>(buf) + LOG_HEADER_FORMAT, + log_sys.FORMAT_10_8); + mach_write_to_8(my_assume_aligned<8>(buf + LOG_HEADER_START_LSN), lsn); + static constexpr const char LOG_HEADER_CREATOR_CURRENT[]= + "MariaDB " + IB_TO_STR(MYSQL_VERSION_MAJOR) "." + IB_TO_STR(MYSQL_VERSION_MINOR) "." + IB_TO_STR(MYSQL_VERSION_PATCH); + + strcpy(reinterpret_cast<char*>(buf) + LOG_HEADER_CREATOR, + LOG_HEADER_CREATOR_CURRENT); + static_assert(LOG_HEADER_CREATOR_END - LOG_HEADER_CREATOR >= + sizeof LOG_HEADER_CREATOR_CURRENT, "compatibility"); + if (encrypted) + log_crypt_write_header(buf + LOG_HEADER_CREATOR_END); + mach_write_to_4(my_assume_aligned<4>(508 + buf), my_crc32c(0, buf, 508)); +} + void log_t::create(lsn_t lsn) noexcept { #ifndef SUX_LOCK_GENERIC @@ -267,22 +302,7 @@ void log_t::create(lsn_t lsn) noexcept memset_aligned<4096>(buf, 0, buf_size); } - mach_write_to_4(buf + LOG_HEADER_FORMAT, FORMAT_10_8); - mach_write_to_8(buf + LOG_HEADER_START_LSN, lsn); - static constexpr const char LOG_HEADER_CREATOR_CURRENT[]= - "MariaDB " - IB_TO_STR(MYSQL_VERSION_MAJOR) "." - IB_TO_STR(MYSQL_VERSION_MINOR) "." - IB_TO_STR(MYSQL_VERSION_PATCH); - - strcpy(reinterpret_cast<char*>(buf) + LOG_HEADER_CREATOR, - LOG_HEADER_CREATOR_CURRENT); - static_assert(LOG_HEADER_CREATOR_END - LOG_HEADER_CREATOR >= - sizeof LOG_HEADER_CREATOR_CURRENT, "compatibility"); - if (is_encrypted()) - log_crypt_write_header(buf + LOG_HEADER_CREATOR_END); - mach_write_to_4(my_assume_aligned<4>(508 + buf), my_crc32c(0, buf, 508)); - + log_sys.header_write(buf, lsn, is_encrypted()); DBUG_PRINT("ib_log", ("write header " LSN_PF, lsn)); #ifdef HAVE_PMEM @@ -323,7 +343,6 @@ void log_t::close_file() ib::fatal() << "closing ib_logfile0 failed: " << err; } -#if defined __linux__ || defined _WIN32 /** Acquire all latches that protect the log. */ static void log_resize_acquire() { @@ -352,6 +371,7 @@ void log_resize_release() } } +#if defined __linux__ || defined _WIN32 /** Try to enable or disable file system caching (update log_buffered) */ void log_t::set_buffered(bool buffered) { @@ -379,6 +399,140 @@ void log_t::set_buffered(bool buffered) } #endif +/** Start resizing the log and release the exclusive latch. +@param size requested new file_size +@return whether the resizing was started successfully */ +log_t::resize_start_status log_t::resize_start(os_offset_t size) noexcept +{ + ut_ad(size >= 4U << 20); + ut_ad(!(size & 4095)); + ut_ad(!srv_read_only_mode); + + log_resize_acquire(); + + resize_start_status status= RESIZE_NO_CHANGE; + lsn_t start_lsn{0}; + + if (resize_in_progress()) + status= RESIZE_IN_PROGRESS; + else if (size != file_size) + { + ut_ad(!resize_in_progress()); + ut_ad(!resize_log.is_opened()); + ut_ad(!resize_buf); + ut_ad(!resize_flush_buf); + std::string path{get_log_file_path("ib_logfile101")}; + bool success; + resize_lsn.store(1, std::memory_order_relaxed); + resize_target= 0; + resize_log.m_file= + os_file_create_func(path.c_str(), + OS_FILE_CREATE | OS_FILE_ON_ERROR_NO_EXIT, + OS_FILE_NORMAL, OS_LOG_FILE, false, &success); + if (success) + { + log_resize_release(); + + void *ptr= nullptr, *ptr2= nullptr; + success= os_file_set_size(path.c_str(), resize_log.m_file, size); + if (!success); +#ifdef HAVE_PMEM + else if (is_pmem()) + { + ptr= log_mmap(resize_log.m_file, size); + if (ptr == MAP_FAILED) + goto alloc_fail; + } +#endif + else + { + ptr= ut_malloc_dontdump(buf_size, PSI_INSTRUMENT_ME); + if (ptr) + { + TRASH_ALLOC(ptr, buf_size); + ptr2= ut_malloc_dontdump(buf_size, PSI_INSTRUMENT_ME); + if (ptr2) + TRASH_ALLOC(ptr2, buf_size); + else + { + ut_free_dodump(ptr, buf_size); + ptr= nullptr; + goto alloc_fail; + } + } + else + alloc_fail: + success= false; + } + + log_resize_acquire(); + + if (!success) + { + resize_log.close(); + IF_WIN(DeleteFile(path.c_str()), unlink(path.c_str())); + } + else + { + resize_target= size; + resize_buf= static_cast<byte*>(ptr); + resize_flush_buf= static_cast<byte*>(ptr2); + if (is_pmem()) + { + resize_log.close(); + start_lsn= get_lsn(); + } + else + { + memcpy_aligned<16>(resize_buf, buf, (buf_free + 15) & ~15); + start_lsn= first_lsn + + (~lsn_t{get_block_size() - 1} & (write_lsn - first_lsn)); + } + } + resize_lsn.store(start_lsn, std::memory_order_relaxed); + status= success ? RESIZE_STARTED : RESIZE_FAILED; + } + } + + log_resize_release(); + + if (start_lsn) + buf_flush_ahead(start_lsn, false); + + return status; +} + +/** Abort log resizing. */ +void log_t::resize_abort() noexcept +{ + log_resize_acquire(); + + if (resize_in_progress() > 1) + { + if (!is_pmem()) + { + resize_log.close(); + ut_free_dodump(resize_buf, buf_size); + ut_free_dodump(resize_flush_buf, buf_size); + resize_flush_buf= nullptr; + } +#ifdef HAVE_PMEM + else + { + ut_ad(!resize_log.is_opened()); + ut_ad(!resize_flush_buf); + if (resize_buf) + my_munmap(resize_buf, resize_target); + } +#endif + resize_buf= nullptr; + resize_target= 0; + resize_lsn.store(0, std::memory_order_relaxed); + } + + log_resize_release(); +} + /** Write an aligned buffer to ib_logfile0. @param buf buffer to be written @param len length of data to be written @@ -548,8 +702,12 @@ inline void log_t::persist(lsn_t lsn) noexcept if (old >= lsn) return; + const lsn_t resizing{resize_in_progress()}; + if (UNIV_UNLIKELY(resizing)) + latch.rd_lock(SRW_LOCK_CALL); const size_t start(calc_lsn_offset(old)); const size_t end(calc_lsn_offset(lsn)); + if (UNIV_UNLIKELY(end < start)) { pmem_persist(log_sys.buf + start, log_sys.file_size - start); @@ -561,24 +719,52 @@ inline void log_t::persist(lsn_t lsn) noexcept old= flushed_to_disk_lsn.load(std::memory_order_relaxed); - if (old >= lsn) - return; + if (old < lsn) + { + while (!flushed_to_disk_lsn.compare_exchange_weak + (old, lsn, std::memory_order_release, std::memory_order_relaxed)) + if (old >= lsn) + break; - while (!flushed_to_disk_lsn.compare_exchange_weak - (old, lsn, std::memory_order_release, std::memory_order_relaxed)) - if (old >= lsn) - break; + log_flush_notify(lsn); + DBUG_EXECUTE_IF("crash_after_log_write_upto", DBUG_SUICIDE();); + } - log_flush_notify(lsn); - DBUG_EXECUTE_IF("crash_after_log_write_upto", DBUG_SUICIDE();); + if (UNIV_UNLIKELY(resizing)) + latch.rd_unlock(); } #endif +/** Write resize_buf to resize_log. +@param length the used length of resize_buf */ +ATTRIBUTE_COLD void log_t::resize_write_buf(size_t length) noexcept +{ + const size_t block_size_1= get_block_size() - 1; + ut_ad(!(resize_target & block_size_1)); + ut_ad(!(length & block_size_1)); + ut_ad(length > block_size_1); + ut_ad(length <= resize_target); + const lsn_t resizing{resize_in_progress()}; + ut_ad(resizing <= write_lsn); + lsn_t offset= START_OFFSET + + ((write_lsn - resizing) & ~lsn_t{block_size_1}) % + (resize_target - START_OFFSET); + + if (UNIV_UNLIKELY(offset + length > resize_target)) + { + offset= START_OFFSET; + resize_lsn.store(first_lsn + + (~lsn_t{block_size_1} & (write_lsn - first_lsn)), + std::memory_order_relaxed); + } + + ut_a(os_file_write_func(IORequestWrite, "ib_logfile101", resize_log.m_file, + resize_flush_buf, offset, length) == DB_SUCCESS); +} + /** Write buf to ib_logfile0. @tparam release_latch whether to invoke latch.wr_unlock() -@return lsn of a callback pending on write_lock -@retval 0 if everything was written -*/ +@return the current log sequence number */ template<bool release_latch> inline lsn_t log_t::write_buf() noexcept { #ifndef SUX_LOCK_GENERIC @@ -601,7 +787,7 @@ template<bool release_latch> inline lsn_t log_t::write_buf() noexcept write_lock.set_pending(lsn); ut_ad(write_lsn >= get_flushed_lsn()); const size_t block_size_1{get_block_size() - 1}; - const lsn_t offset{calc_lsn_offset(write_lsn) & ~lsn_t{block_size_1}}; + lsn_t offset{calc_lsn_offset(write_lsn) & ~lsn_t{block_size_1}}; DBUG_PRINT("ib_log", ("write " LSN_PF " to " LSN_PF " at " LSN_PF, write_lsn, lsn, offset)); @@ -623,15 +809,23 @@ template<bool release_latch> inline lsn_t log_t::write_buf() noexcept (We want to avoid memset() while holding mutex.) This block will be overwritten later, once records beyond the current LSN are generated. */ +# ifdef HAVE_valgrind MEM_MAKE_DEFINED(buf + length, get_block_size() - new_buf_free); + if (UNIV_LIKELY_NULL(resize_flush_buf)) + MEM_MAKE_DEFINED(resize_buf + length, get_block_size() - new_buf_free); +# endif buf[length]= 0; /* allow recovery to catch EOF faster */ length&= ~block_size_1; memcpy_aligned<16>(flush_buf, buf + length, (new_buf_free + 15) & ~15); + if (UNIV_LIKELY_NULL(resize_flush_buf)) + memcpy_aligned<16>(resize_flush_buf, resize_buf + length, + (new_buf_free + 15) & ~15); length+= get_block_size(); #endif } std::swap(buf, flush_buf); + std::swap(resize_buf, resize_flush_buf); write_to_log++; if (release_latch) latch.wr_unlock(); @@ -644,13 +838,15 @@ template<bool release_latch> inline lsn_t log_t::write_buf() noexcept /* Do the write to the log file */ log_write_buf(write_buf, length, offset); + if (UNIV_LIKELY_NULL(resize_buf)) + resize_write_buf(length); write_lsn= lsn; } - return write_lock.release(lsn); + return lsn; } -inline bool log_t::flush(lsn_t lsn) noexcept +bool log_t::flush(lsn_t lsn) noexcept { ut_ad(lsn >= get_flushed_lsn()); flush_lock.set_pending(lsn); @@ -718,7 +914,6 @@ repeat: return; flush_lock.set_pending(log_sys.get_lsn()); } - lsn_t pending_write_lsn= 0, pending_flush_lsn= 0; @@ -726,7 +921,7 @@ repeat: group_commit_lock::ACQUIRED) { log_sys.latch.wr_lock(SRW_LOCK_CALL); - pending_write_lsn= log_sys.write_buf<true>(); + pending_write_lsn= write_lock.release(log_sys.write_buf<true>()); } if (durable) @@ -769,8 +964,9 @@ ATTRIBUTE_COLD void log_write_and_flush() ut_ad(!srv_read_only_mode); if (!log_sys.is_pmem()) { - log_sys.write_buf<false>(); - log_flush(write_lock.value()); + const lsn_t lsn{log_sys.write_buf<false>()}; + write_lock.release(lsn); + log_flush(lsn); } #ifdef HAVE_PMEM else diff --git a/storage/innobase/mtr/mtr0mtr.cc b/storage/innobase/mtr/mtr0mtr.cc index 48ab5c6835e..b866460feb5 100644 --- a/storage/innobase/mtr/mtr0mtr.cc +++ b/storage/innobase/mtr/mtr0mtr.cc @@ -1066,6 +1066,116 @@ func_exit: return finish_write(len); } +inline void log_t::resize_write(lsn_t lsn, const byte *end, size_t len, + size_t seq) noexcept +{ +#ifndef SUX_LOCK_GENERIC + ut_ad(latch.is_locked()); +#endif + + if (UNIV_LIKELY_NULL(resize_buf)) + { + ut_ad(end >= buf); + end-= len; + size_t s; + +#ifdef HAVE_PMEM + if (!resize_flush_buf) + { + ut_ad(is_pmem()); + const size_t resize_capacity{resize_target - START_OFFSET}; + const lsn_t resizing{resize_in_progress()}; + if (UNIV_UNLIKELY(lsn < resizing)) + { + size_t l= resizing - lsn; + if (l >= len) + return; + end+= l - len; + len-= l; + lsn+= l; + } + lsn-= resizing; + s= START_OFFSET + lsn % resize_capacity; + + if (UNIV_UNLIKELY(end < &buf[START_OFFSET])) + { + /* The source buffer (log_sys.buf) wrapped around */ + ut_ad(end + capacity() < &buf[file_size]); + ut_ad(end + len >= &buf[START_OFFSET]); + ut_ad(end + capacity() + len >= &buf[file_size]); + + size_t l= size_t(buf - (end - START_OFFSET)); + if (UNIV_LIKELY(s + len <= resize_target)) + { + /* The destination buffer (log_sys.resize_buf) did not wrap around */ + memcpy(resize_buf + s, end + capacity(), l); + memcpy(resize_buf + s + l, &buf[START_OFFSET], len - l); + goto pmem_nowrap; + } + else + { + /* Both log_sys.buf and log_sys.resize_buf wrapped around */ + const size_t rl= resize_target - s; + if (l <= rl) + { + /* log_sys.buf wraps around first */ + memcpy(resize_buf + s, end + capacity(), l); + memcpy(resize_buf + s + l, &buf[START_OFFSET], rl - l); + memcpy(resize_buf + START_OFFSET, &buf[START_OFFSET + rl - l], + len - l); + } + else + { + /* log_sys.resize_buf wraps around first */ + memcpy(resize_buf + s, end + capacity(), rl); + memcpy(resize_buf + START_OFFSET, end + capacity() + rl, l - rl); + memcpy(resize_buf + START_OFFSET + (l - rl), + &buf[START_OFFSET], len - l); + } + goto pmem_wrap; + } + } + else + { + ut_ad(end + len <= &buf[file_size]); + + if (UNIV_LIKELY(s + len <= resize_target)) + { + memcpy(resize_buf + s, end, len); + pmem_nowrap: + s+= len - seq; + } + else + { + /* The log_sys.resize_buf wrapped around */ + memcpy(resize_buf + s, end, resize_target - s); + memcpy(resize_buf + START_OFFSET, end + (resize_target - s), + len - (resize_target - s)); + pmem_wrap: + s+= len - seq; + if (s >= resize_target) + s-= resize_capacity; + resize_lsn.fetch_add(resize_capacity); /* Move the target ahead. */ + } + } + } + else +#endif + { + ut_ad(resize_flush_buf); + s= end - buf; + ut_ad(s + len <= buf_size); + memcpy(resize_buf + s, end, len); + s+= len - seq; + } + + /* Always set the sequence bit. If the resized log were to wrap around, + we will advance resize_lsn. */ + ut_ad(resize_buf[s] <= 1); + resize_buf[s]= 1; + } +} + /** Write the mini-transaction log to the redo log buffer. @param len number of bytes to write @return {start_lsn,flush_ahead} */ @@ -1100,6 +1210,7 @@ mtr_t::finish_write(size_t len) start.second+= 8; } mach_write_to_4(start.second, m_crc); + start.second+= 4; } #ifdef HAVE_PMEM else @@ -1146,9 +1257,14 @@ mtr_t::finish_write(size_t len) ::memcpy(start.second, tail, size_left); ::memcpy(log_sys.buf + log_sys.START_OFFSET, tail + size_left, size - size_left); + start.second= log_sys.buf + + ((size >= size_left) ? log_sys.START_OFFSET : log_sys.file_size) + + (size - size_left); } #endif + log_sys.resize_write(start.first, start.second, len, size); + m_commit_lsn= start.first + len; return {start.first, log_close(m_commit_lsn)}; } diff --git a/storage/innobase/srv/srv0start.cc b/storage/innobase/srv/srv0start.cc index ac70a52cb3b..5d08c18a8e5 100644 --- a/storage/innobase/srv/srv0start.cc +++ b/storage/innobase/srv/srv0start.cc @@ -248,22 +248,20 @@ err_exit: /** Rename the redo log file after resizing. @return whether an error occurred */ -bool log_t::rename_resized() noexcept +bool log_t::resize_rename() noexcept { - ut_ad(!srv_log_file_created); - ut_d(srv_log_file_created= true); - std::string old_name{get_log_file_path("ib_logfile101")}; std::string new_name{get_log_file_path()}; if (IF_WIN(MoveFileEx(old_name.c_str(), new_name.c_str(), - MOVEFILE_REPLACE_EXISTING), + MOVEFILE_REPLACE_EXISTING), !rename(old_name.c_str(), new_name.c_str()))) return false; - sql_print_error("InnoDB: Failed to rename log from %.*s to %.*s", + sql_print_error("InnoDB: Failed to rename log from %.*s to %.*s (error %d)", int(old_name.size()), old_name.data(), - int(new_name.size()), new_name.data()); + int(new_name.size()), new_name.data(), + IF_WIN(int(GetLastError()), errno)); return true; } @@ -1181,7 +1179,10 @@ dberr_t srv_start(bool create_new_db) buf_flush_sync(); - if (log_sys.rename_resized()) { + ut_ad(!srv_log_file_created); + ut_d(srv_log_file_created= true); + + if (log_sys.resize_rename()) { return(srv_init_abort(DB_ERROR)); } } else { @@ -1384,7 +1385,7 @@ dberr_t srv_start(bool create_new_db) err = create_log_file(false, lsn); - if (err == DB_SUCCESS && log_sys.rename_resized()) { + if (err == DB_SUCCESS && log_sys.resize_rename()) { err = DB_ERROR; } diff --git a/storage/rocksdb/ha_rocksdb.cc b/storage/rocksdb/ha_rocksdb.cc index 2239970a4e3..8067d6f6b93 100644 --- a/storage/rocksdb/ha_rocksdb.cc +++ b/storage/rocksdb/ha_rocksdb.cc @@ -600,6 +600,7 @@ static unsigned long // NOLINT(runtime/int) rocksdb_persistent_cache_size_mb; static ulong rocksdb_info_log_level; static char *rocksdb_wal_dir; +static char *rocksdb_log_dir; static char *rocksdb_persistent_cache_path; static ulong rocksdb_index_type; static uint32_t rocksdb_flush_log_at_trx_commit; @@ -1316,6 +1317,11 @@ static MYSQL_SYSVAR_STR(wal_dir, rocksdb_wal_dir, "DBOptions::wal_dir for RocksDB", nullptr, nullptr, rocksdb_db_options->wal_dir.c_str()); +static MYSQL_SYSVAR_STR(log_dir, rocksdb_log_dir, + PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY, + "DBOptions::db_log_dir for RocksDB", nullptr, nullptr, + rocksdb_db_options->db_log_dir.c_str()); + static MYSQL_SYSVAR_STR( persistent_cache_path, rocksdb_persistent_cache_path, PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY, @@ -2041,6 +2047,7 @@ static struct st_mysql_sys_var *rocksdb_system_variables[] = { MYSQL_SYSVAR(max_total_wal_size), MYSQL_SYSVAR(use_fsync), MYSQL_SYSVAR(wal_dir), + MYSQL_SYSVAR(log_dir), MYSQL_SYSVAR(persistent_cache_path), MYSQL_SYSVAR(persistent_cache_size_mb), MYSQL_SYSVAR(delete_obsolete_files_period_micros), @@ -5381,7 +5388,7 @@ static int rocksdb_init_func(void *const p) { rocksdb::NewGenericRateLimiter(rocksdb_rate_limiter_bytes_per_sec)); rocksdb_db_options->rate_limiter = rocksdb_rate_limiter; } - + rocksdb_db_options->db_log_dir = rocksdb_log_dir; rocksdb_db_options->delayed_write_rate = rocksdb_delayed_write_rate; std::shared_ptr<Rdb_logger> myrocks_logger = std::make_shared<Rdb_logger>(); diff --git a/storage/rocksdb/mysql-test/rocksdb/r/checksum_table.result b/storage/rocksdb/mysql-test/rocksdb/r/checksum_table.result index bb209856a97..85cf53044e1 100644 --- a/storage/rocksdb/mysql-test/rocksdb/r/checksum_table.result +++ b/storage/rocksdb/mysql-test/rocksdb/r/checksum_table.result @@ -70,6 +70,8 @@ col3 double # Enable the old algorithm: set @tmp_old=@@old; set old=1; +Warnings: +Warning 1287 '@@old' is deprecated and will be removed in a future release. Please use '@@old_mode' instead checksum table t1; Table Checksum test.t1 0 @@ -89,4 +91,6 @@ checksum table t1; Table Checksum test.t1 3183101003 set old=@tmp_old; +Warnings: +Warning 1287 '@@old' is deprecated and will be removed in a future release. Please use '@@old_mode' instead drop table t1; diff --git a/storage/rocksdb/mysql-test/rocksdb/r/col_opt_not_null.result b/storage/rocksdb/mysql-test/rocksdb/r/col_opt_not_null.result index a3a138555ee..4a1fc17395d 100644 --- a/storage/rocksdb/mysql-test/rocksdb/r/col_opt_not_null.result +++ b/storage/rocksdb/mysql-test/rocksdb/r/col_opt_not_null.result @@ -1423,11 +1423,11 @@ d d0 d1_1 d10_2 d60_10 n n0_0 n1 n20_4 n65_4 9999999999 9999999999 0.9 99999999.99 99999999999999999999999999999999999999999999999999.9999999999 9999999999 9999999999 9 9999999999999999.9999 9999999999999999999999999999999999999999999999999999999999999.9999 9999999999 9999999999 0.9 99999999.99 99999999999999999999999999999999999999999999999999.9999999999 9999999999 9999999999 9 9999999999999999.9999 9999999999999999999999999999999999999999999999999999999999999.9999 ALTER TABLE t1 ADD COLUMN n66 NUMERIC(66) NOT NULL; -ERROR 42000: Too big precision 66 specified for 'n66'. Maximum is 65 +ERROR 42000: Too big precision specified for 'n66'. Maximum is 65 ALTER TABLE t1 ADD COLUMN n66_6 DECIMAL(66,6) NOT NULL; -ERROR 42000: Too big precision 66 specified for 'n66_6'. Maximum is 65 +ERROR 42000: Too big precision specified for 'n66_6'. Maximum is 65 ALTER TABLE t1 ADD COLUMN n66_66 DECIMAL(66,66) NOT NULL; -ERROR 42000: Too big scale 66 specified for 'n66_66'. Maximum is 38 +ERROR 42000: Too big scale specified for 'n66_66'. Maximum is 38 DROP TABLE t1; DROP TABLE IF EXISTS t1; #---------------------------------- @@ -1825,7 +1825,7 @@ r1_1 0.9 r1_1 0.9 ALTER TABLE t1 ADD COLUMN d0_0 DOUBLE(0,0) NOT NULL; ALTER TABLE t1 ADD COLUMN n66_6 DECIMAL(256,1) NOT NULL; -ERROR 42000: Too big precision 256 specified for 'n66_6'. Maximum is 65 +ERROR 42000: Too big precision specified for 'n66_6'. Maximum is 65 ALTER TABLE t1 ADD COLUMN n66_66 DECIMAL(40,35) NOT NULL; DROP TABLE t1; DROP TABLE IF EXISTS t1; diff --git a/storage/rocksdb/mysql-test/rocksdb/r/col_opt_null.result b/storage/rocksdb/mysql-test/rocksdb/r/col_opt_null.result index f0d377890c5..d97fb8a2481 100644 --- a/storage/rocksdb/mysql-test/rocksdb/r/col_opt_null.result +++ b/storage/rocksdb/mysql-test/rocksdb/r/col_opt_null.result @@ -1232,11 +1232,11 @@ d d0 d1_1 d10_2 d60_10 n n0_0 n1 n20_4 n65_4 9999999999 9999999999 0.9 99999999.99 99999999999999999999999999999999999999999999999999.9999999999 9999999999 9999999999 9 9999999999999999.9999 9999999999999999999999999999999999999999999999999999999999999.9999 9999999999 9999999999 0.9 99999999.99 99999999999999999999999999999999999999999999999999.9999999999 9999999999 9999999999 9 9999999999999999.9999 9999999999999999999999999999999999999999999999999999999999999.9999 ALTER TABLE t1 ADD COLUMN n66 NUMERIC(66) NULL; -ERROR 42000: Too big precision 66 specified for 'n66'. Maximum is 65 +ERROR 42000: Too big precision specified for 'n66'. Maximum is 65 ALTER TABLE t1 ADD COLUMN n66_6 DECIMAL(66,6) NULL; -ERROR 42000: Too big precision 66 specified for 'n66_6'. Maximum is 65 +ERROR 42000: Too big precision specified for 'n66_6'. Maximum is 65 ALTER TABLE t1 ADD COLUMN n66_66 DECIMAL(66,66) NULL; -ERROR 42000: Too big scale 66 specified for 'n66_66'. Maximum is 38 +ERROR 42000: Too big scale specified for 'n66_66'. Maximum is 38 DROP TABLE t1; DROP TABLE IF EXISTS t1; CREATE TABLE t1 ( @@ -1612,7 +1612,7 @@ r1_1 0.9 r1_1 0.9 ALTER TABLE t1 ADD COLUMN d0_0 DOUBLE(0,0) NULL; ALTER TABLE t1 ADD COLUMN n66_6 DECIMAL(256,1) NULL; -ERROR 42000: Too big precision 256 specified for 'n66_6'. Maximum is 65 +ERROR 42000: Too big precision specified for 'n66_6'. Maximum is 65 ALTER TABLE t1 ADD COLUMN n66_66 DECIMAL(40,35) NULL; DROP TABLE t1; DROP TABLE IF EXISTS t1; diff --git a/storage/rocksdb/mysql-test/rocksdb/r/col_opt_unsigned.result b/storage/rocksdb/mysql-test/rocksdb/r/col_opt_unsigned.result index 13445fc9326..0a8f49ebf36 100644 --- a/storage/rocksdb/mysql-test/rocksdb/r/col_opt_unsigned.result +++ b/storage/rocksdb/mysql-test/rocksdb/r/col_opt_unsigned.result @@ -148,11 +148,11 @@ d d0 d1_1 d10_2 d60_10 n n0_0 n1 n20_4 n65_4 9999999999 9999999999 0.9 99999999.99 99999999999999999999999999999999999999999999999999.9999999999 9999999999 9999999999 9 9999999999999999.9999 9999999999999999999999999999999999999999999999999999999999999.9999 9999999999 9999999999 0.9 99999999.99 99999999999999999999999999999999999999999999999999.9999999999 9999999999 9999999999 9 9999999999999999.9999 9999999999999999999999999999999999999999999999999999999999999.9999 ALTER TABLE t1 ADD COLUMN n66 NUMERIC(66) UNSIGNED; -ERROR 42000: Too big precision 66 specified for 'n66'. Maximum is 65 +ERROR 42000: Too big precision specified for 'n66'. Maximum is 65 ALTER TABLE t1 ADD COLUMN n66_6 DECIMAL(66,6) UNSIGNED; -ERROR 42000: Too big precision 66 specified for 'n66_6'. Maximum is 65 +ERROR 42000: Too big precision specified for 'n66_6'. Maximum is 65 ALTER TABLE t1 ADD COLUMN n66_66 DECIMAL(66,66) UNSIGNED; -ERROR 42000: Too big scale 66 specified for 'n66_66'. Maximum is 38 +ERROR 42000: Too big scale specified for 'n66_66'. Maximum is 38 DROP TABLE t1; CREATE TABLE t1 ( a DECIMAL UNSIGNED, @@ -499,7 +499,7 @@ r1_1 0.9 r1_1 0.9 ALTER TABLE t1 ADD COLUMN d0_0 DOUBLE(0,0) UNSIGNED; ALTER TABLE t1 ADD COLUMN n66_6 DECIMAL(256,1) UNSIGNED; -ERROR 42000: Too big precision 256 specified for 'n66_6'. Maximum is 65 +ERROR 42000: Too big precision specified for 'n66_6'. Maximum is 65 ALTER TABLE t1 ADD COLUMN n66_66 DECIMAL(40,35) UNSIGNED; DROP TABLE t1; CREATE TABLE t1 ( diff --git a/storage/rocksdb/mysql-test/rocksdb/r/rocksdb.result b/storage/rocksdb/mysql-test/rocksdb/r/rocksdb.result index a23283306b0..989d28e773d 100644 --- a/storage/rocksdb/mysql-test/rocksdb/r/rocksdb.result +++ b/storage/rocksdb/mysql-test/rocksdb/r/rocksdb.result @@ -942,6 +942,7 @@ rocksdb_keep_log_file_num 1000 rocksdb_large_prefix OFF rocksdb_lock_scanned_rows OFF rocksdb_lock_wait_timeout 1 +rocksdb_log_dir rocksdb_log_file_time_to_roll 0 rocksdb_manifest_preallocation_size 4194304 rocksdb_manual_compaction_threads 0 diff --git a/storage/rocksdb/mysql-test/rocksdb/r/rocksdb_log_dir.result b/storage/rocksdb/mysql-test/rocksdb/r/rocksdb_log_dir.result new file mode 100644 index 00000000000..33f2e9f497c --- /dev/null +++ b/storage/rocksdb/mysql-test/rocksdb/r/rocksdb_log_dir.result @@ -0,0 +1,8 @@ +CREATE DATABASE mysqltest; +USE mysqltest; +CREATE TABLE t1 (a INT PRIMARY KEY); +INSERT INTO t1 VALUES(42); +DROP TABLE t1; +DROP DATABASE mysqltest; +Check for MyRocks info LOG files +db_LOG diff --git a/storage/rocksdb/mysql-test/rocksdb/r/type_fixed.result b/storage/rocksdb/mysql-test/rocksdb/r/type_fixed.result index 055952ea55f..fcbef547891 100644 --- a/storage/rocksdb/mysql-test/rocksdb/r/type_fixed.result +++ b/storage/rocksdb/mysql-test/rocksdb/r/type_fixed.result @@ -123,9 +123,9 @@ d d0 d1_1 d10_2 d60_10 n n0_0 n1 n20_4 n65_4 9999999999 9999999999 0.9 99999999.99 99999999999999999999999999999999999999999999999999.9999999999 9999999999 9999999999 9 9999999999999999.9999 9999999999999999999999999999999999999999999999999999999999999.9999 9999999999 9999999999 0.9 99999999.99 99999999999999999999999999999999999999999999999999.9999999999 9999999999 9999999999 9 9999999999999999.9999 9999999999999999999999999999999999999999999999999999999999999.9999 ALTER TABLE t1 ADD COLUMN n66 NUMERIC(66) ; -ERROR 42000: Too big precision 66 specified for 'n66'. Maximum is 65 +ERROR 42000: Too big precision specified for 'n66'. Maximum is 65 ALTER TABLE t1 ADD COLUMN n66_6 DECIMAL(66,6) ; -ERROR 42000: Too big precision 66 specified for 'n66_6'. Maximum is 65 +ERROR 42000: Too big precision specified for 'n66_6'. Maximum is 65 ALTER TABLE t1 ADD COLUMN n66_66 DECIMAL(66,66) ; -ERROR 42000: Too big scale 66 specified for 'n66_66'. Maximum is 38 +ERROR 42000: Too big scale specified for 'n66_66'. Maximum is 38 DROP TABLE t1; diff --git a/storage/rocksdb/mysql-test/rocksdb/r/type_float.result b/storage/rocksdb/mysql-test/rocksdb/r/type_float.result index 371b550d4ab..0cf5c5e0496 100644 --- a/storage/rocksdb/mysql-test/rocksdb/r/type_float.result +++ b/storage/rocksdb/mysql-test/rocksdb/r/type_float.result @@ -309,6 +309,6 @@ r1_1 0.9 r1_1 0.9 ALTER TABLE t1 ADD COLUMN d0_0 DOUBLE(0,0) ; ALTER TABLE t1 ADD COLUMN n66_6 DECIMAL(256,1) ; -ERROR 42000: Too big precision 256 specified for 'n66_6'. Maximum is 65 +ERROR 42000: Too big precision specified for 'n66_6'. Maximum is 65 ALTER TABLE t1 ADD COLUMN n66_66 DECIMAL(40,35) ; DROP TABLE t1; diff --git a/storage/rocksdb/mysql-test/rocksdb/t/rocksdb_log_dir.opt b/storage/rocksdb/mysql-test/rocksdb/t/rocksdb_log_dir.opt new file mode 100644 index 00000000000..8e5da2c042c --- /dev/null +++ b/storage/rocksdb/mysql-test/rocksdb/t/rocksdb_log_dir.opt @@ -0,0 +1,2 @@ +--plugin-load=$HA_ROCKSDB_SO --default-storage-engine=rocksdb --rocksdb_log_dir=$MYSQL_TMP_DIR + diff --git a/storage/rocksdb/mysql-test/rocksdb/t/rocksdb_log_dir.test b/storage/rocksdb/mysql-test/rocksdb/t/rocksdb_log_dir.test new file mode 100644 index 00000000000..948e12edb4d --- /dev/null +++ b/storage/rocksdb/mysql-test/rocksdb/t/rocksdb_log_dir.test @@ -0,0 +1,15 @@ +--source include/have_rocksdb.inc + +CREATE DATABASE mysqltest; +USE mysqltest; +CREATE TABLE t1 (a INT PRIMARY KEY); +INSERT INTO t1 VALUES(42); +DROP TABLE t1; +DROP DATABASE mysqltest; + +--echo Check for MyRocks info LOG files +--replace_regex /.*LOG/db_LOG/ +--list_files $MYSQL_TMP_DIR *LOG + +# Clean up +remove_files_wildcard $MYSQL_TMP_DIR/./ *LOG; diff --git a/storage/rocksdb/mysql-test/rocksdb_sys_vars/r/rocksdb_log_dir_basic.result b/storage/rocksdb/mysql-test/rocksdb_sys_vars/r/rocksdb_log_dir_basic.result new file mode 100644 index 00000000000..b5caf639850 --- /dev/null +++ b/storage/rocksdb/mysql-test/rocksdb_sys_vars/r/rocksdb_log_dir_basic.result @@ -0,0 +1,7 @@ +SET @start_global_value = @@global.ROCKSDB_LOG_DIR; +SELECT @start_global_value; +@start_global_value + +"Trying to set variable @@global.ROCKSDB_LOG_DIR to 444. It should fail because it is readonly." +SET @@global.ROCKSDB_LOG_DIR = 444; +ERROR HY000: Variable 'rocksdb_log_dir' is a read only variable diff --git a/storage/rocksdb/mysql-test/rocksdb_sys_vars/t/rocksdb_log_dir_basic.test b/storage/rocksdb/mysql-test/rocksdb_sys_vars/t/rocksdb_log_dir_basic.test new file mode 100644 index 00000000000..b8ab9c18e70 --- /dev/null +++ b/storage/rocksdb/mysql-test/rocksdb_sys_vars/t/rocksdb_log_dir_basic.test @@ -0,0 +1,6 @@ +--source include/have_rocksdb.inc + +--let $sys_var=ROCKSDB_LOG_DIR +--let $read_only=1 +--let $session=0 +--source include/rocksdb_sys_var.inc diff --git a/storage/rocksdb/nosql_access.cc b/storage/rocksdb/nosql_access.cc index 9dcbe3fbcbc..080977f3722 100644 --- a/storage/rocksdb/nosql_access.cc +++ b/storage/rocksdb/nosql_access.cc @@ -12,7 +12,7 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA */ #define MYSQL_SERVER 1 diff --git a/storage/rocksdb/nosql_access.h b/storage/rocksdb/nosql_access.h index 70aaa400668..c6e75ec01c3 100644 --- a/storage/rocksdb/nosql_access.h +++ b/storage/rocksdb/nosql_access.h @@ -12,7 +12,7 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA */ /* C++ standard header files */ #include <array> diff --git a/storage/rocksdb/rdb_converter.cc b/storage/rocksdb/rdb_converter.cc index 65f0b81cc7f..6f8aa306668 100644 --- a/storage/rocksdb/rdb_converter.cc +++ b/storage/rocksdb/rdb_converter.cc @@ -12,7 +12,7 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA */ #include <my_global.h> diff --git a/storage/rocksdb/rdb_converter.h b/storage/rocksdb/rdb_converter.h index a4eae341f16..6ace89b3366 100644 --- a/storage/rocksdb/rdb_converter.h +++ b/storage/rocksdb/rdb_converter.h @@ -12,7 +12,7 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA */ #pragma once diff --git a/storage/rocksdb/rdb_global.h b/storage/rocksdb/rdb_global.h index 7213571bf61..c6b7e705587 100644 --- a/storage/rocksdb/rdb_global.h +++ b/storage/rocksdb/rdb_global.h @@ -12,7 +12,7 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA */ /* MyRocks global type definitions goes here */ diff --git a/storage/spider/CMakeLists.txt b/storage/spider/CMakeLists.txt index bc682e96609..bc1387db236 100644 --- a/storage/spider/CMakeLists.txt +++ b/storage/spider/CMakeLists.txt @@ -1,6 +1,3 @@ -SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DHAVE_HANDLERSOCKET") -SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DHAVE_HANDLERSOCKET") - IF(HAVE_WVLA) SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Wno-vla") SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wno-vla") @@ -17,36 +14,12 @@ SET(SPIDER_SOURCES spd_param.cc spd_sys_table.cc spd_trx.cc spd_db_conn.cc spd_conn.cc spd_table.cc spd_direct_sql.cc spd_udf.cc spd_ping_table.cc spd_copy_tables.cc spd_i_s.cc spd_malloc.cc ha_spider.cc spd_udf.def - spd_db_mysql.cc spd_db_oracle.cc spd_group_by_handler.cc spd_db_include.cc + spd_db_mysql.cc spd_group_by_handler.cc spd_db_include.cc ) -IF(DEFINED ENV{ORACLE_HOME}) - SET(ORACLE_HOME $ENV{ORACLE_HOME}) - FIND_PATH(ORACLE_INCLUDE_DIR oci.h PATHS ${ORACLE_HOME}/rdbms/public) - SET(ORACLE_OCI_LIB_NAME clntsh) - SET(ORACLE_LIB_DIR ${ORACLE_HOME}/lib) - FIND_LIBRARY(ORACLE_OCI_LIBRARY NAMES ${ORACLE_OCI_LIB_NAME} PATHS ${ORACLE_LIB_DIR}) -ENDIF() - -IF(EXISTS ${PROJECT_SOURCE_DIR}/storage/mysql_storage_engine.cmake) - SET(CMAKE_CXX_FLAGS_DEBUG - "${CMAKE_CXX_FLAGS_DEBUG} -DSAFEMALLOC -DSAFE_MUTEX -DUSE_SYMDIR /Zi") - SET(CMAKE_C_FLAGS_DEBUG - "${CMAKE_C_FLAGS_DEBUG} -DSAFEMALLOC -DSAFE_MUTEX -DUSE_SYMDIR /Zi") - SET(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} /MAP /MAPINFO:EXPORTS") - INCLUDE("${PROJECT_SOURCE_DIR}/storage/mysql_storage_engine.cmake") - - INCLUDE_DIRECTORIES( - ${CMAKE_SOURCE_DIR}/include - ${CMAKE_SOURCE_DIR}/sql - ${CMAKE_SOURCE_DIR}/regex) - - MYSQL_STORAGE_ENGINE(SPIDER) -ELSEIF(PLUGIN_PARTITION MATCHES "^NO$") +IF(PLUGIN_PARTITION MATCHES "^NO$") MESSAGE(STATUS "Spider is skipped because partitioning is disabled") ELSE() - INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/storage/spider/hs_client) - IF(DEB) SET(extra_options COMPONENT spider-engine) ELSE() @@ -60,16 +33,6 @@ ELSE() ENDIF() ENDIF() -IF(ORACLE_INCLUDE_DIR AND ORACLE_OCI_LIBRARY) - SET(SPIDER_WITH_ORACLE_OCI OFF CACHE BOOL "Spider is compiled with Oracle OCI library.") - IF(SPIDER_WITH_ORACLE_OCI) - SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DHAVE_ORACLE_OCI -DLINUX -D_GNU_SOURCE -D_REENTRANT") - SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DHAVE_ORACLE_OCI -DLINUX -D_GNU_SOURCE -D_REENTRANT") - INCLUDE_DIRECTORIES(${ORACLE_INCLUDE_DIR}) - TARGET_LINK_LIBRARIES (spider ${ORACLE_OCI_LIBRARY}) - ENDIF() -ENDIF() - IF(MSVC AND (TARGET spider)) IF (CMAKE_BUILD_TYPE STREQUAL "Debug") ADD_CUSTOM_COMMAND(TARGET spider diff --git a/storage/spider/Makefile.am b/storage/spider/Makefile.am deleted file mode 100644 index 3847b3f2332..00000000000 --- a/storage/spider/Makefile.am +++ /dev/null @@ -1,89 +0,0 @@ -HAVE_HANDLERSOCKET = "-DHAVE_HANDLERSOCKET" - -pkgplugindir = $(pkglibdir)/plugin -INCLUDES = -I$(SPD_MYSQL_INC)$(top_srcdir)/include \ - -I$(SPD_MYSQL_INC)$(top_srcdir)/regex \ - -I$(SPD_MYSQL_INC)$(top_srcdir)/sql \ - -I$(SPD_MYSQL_INC)$(top_srcdir)/extra/yassl/include \ - -I./hs_client \ - $(MYSQL_INCLUDE_PATH) \ - $(HANDLERSOCKET_INCLUDE_PATH) - -noinst_HEADERS = ha_spider.h spd_conn.h spd_db_conn.h \ - spd_db_include.h spd_err.h spd_sys_table.h \ - spd_table.h spd_trx.h spd_include.h spd_param.h \ - spd_direct_sql.h spd_udf.h spd_ping_table.h \ - spd_copy_tables.h spd_malloc.h \ - spd_db_mysql.h spd_db_handlersocket.h \ - hs_client/allocator.hpp hs_client/config.hpp \ - hs_client/mutex.hpp hs_client/string_util.hpp \ - hs_client/auto_addrinfo.hpp hs_client/escape.hpp \ - hs_client/socket.hpp hs_client/thread.hpp \ - hs_client/auto_file.hpp hs_client/fatal.hpp \ - hs_client/string_buffer.hpp hs_client/util.hpp \ - hs_client/auto_ptrcontainer.hpp \ - hs_client/hstcpcli.hpp hs_client/string_ref.hpp \ - hs_client/hs_compat.h - -lib_LTLIBRARIES = $(PLUGIN_SPIDER_LTLIBRARIES_TARGET) -EXTRA_LTLIBRARIES = ha_spider.la -pkgplugin_LTLIBRARIES = @plugin_spider_shared_target@ -ha_spider_la_LDFLAGS = -shared -module -rpath $(pkgplugindir) -ha_spider_la_CXXFLAGS = $(AM_CXXFLAGS) -DMYSQL_DYNAMIC_PLUGIN \ - $(HAVE_HANDLERSOCKET) -ha_spider_la_CFLAGS = $(AM_CFLAGS) -DMYSQL_DYNAMIC_PLUGIN \ - $(HAVE_HANDLERSOCKET) -ha_spider_la_SOURCES = \ - spd_param.cc \ - spd_sys_table.cc \ - spd_trx.cc \ - spd_db_conn.cc \ - spd_conn.cc \ - spd_table.cc \ - spd_direct_sql.cc \ - spd_udf.cc \ - spd_ping_table.cc \ - spd_copy_tables.cc \ - spd_i_s.cc \ - spd_malloc.cc \ - ha_spider.cc \ - spd_db_mysql.cc \ - spd_db_handlersocket.cc \ - hs_client/config.cpp \ - hs_client/escape.cpp \ - hs_client/fatal.cpp \ - hs_client/hstcpcli.cpp \ - hs_client/socket.cpp \ - hs_client/string_util.cpp - -lib_LIBRARIES = $(PLUGIN_SPIDER_LIBRARIES_TARGET) -EXTRA_LIBRARIES = libspider.a -noinst_LIBRARIES = @plugin_spider_static_target@ -libspider_a_CXXFLAGS = $(AM_CXXFLAGS) $(HAVE_HANDLERSOCKET) -libspider_a_CFLAGS = $(AM_CFLAGS) $(HAVE_HANDLERSOCKET) -libspider_a_SOURCES = \ - spd_param.cc \ - spd_sys_table.cc \ - spd_trx.cc \ - spd_db_conn.cc \ - spd_conn.cc \ - spd_table.cc \ - spd_direct_sql.cc \ - spd_udf.cc \ - spd_ping_table.cc \ - spd_copy_tables.cc \ - spd_i_s.cc \ - spd_malloc.cc \ - ha_spider.cc \ - spd_db_mysql.cc \ - spd_db_handlersocket.cc \ - hs_client/config.cpp \ - hs_client/escape.cpp \ - hs_client/fatal.cpp \ - hs_client/hstcpcli.cpp \ - hs_client/socket.cpp \ - hs_client/string_util.cpp - -EXTRA_DIST = plug.in -# Don't update the files from bitkeeper -%::SCCS/s.% diff --git a/storage/spider/configure.in b/storage/spider/configure.in deleted file mode 100644 index 6f103aed871..00000000000 --- a/storage/spider/configure.in +++ /dev/null @@ -1,95 +0,0 @@ -AC_INIT([spider_engine], [1.0], [kentokushiba@gmail.com]) -AC_CONFIG_HEADERS([config.h]) -AM_INIT_AUTOMAKE - -AC_PROG_CC -AC_PROG_CXX -AC_PROG_LIBTOOL - -AC_TYPE_SIZE_T - -AC_DEFUN([MYSQL_PATH_TEST],[ - AC_MSG_CHECKING([mysql source path]) - AC_ARG_WITH([mysql], - [AS_HELP_STRING([--with-mysql=PATH],[mysql source directory PATH])], - [ - if test \ - -f $withval/include/mysql/plugin.h -a \ - -f $withval/include/mysql.h -a \ - -f $withval/include/errmsg.h -a \ - \( -f $withval/sql/mysql_priv.h -o -f $withval/sql/sql_priv.h \) ; - then - SPD_MYSQL_INC="$withval/" - AC_MSG_RESULT([yes]) - plugin_spider_shared_target="" - AC_SUBST(plugin_spider_shared_target) - plugin_spider_static_target="" - AC_SUBST(plugin_spider_static_target) - PLUGIN_SPIDER_LTLIBRARIES_TARGET="ha_spider.la" - AC_SUBST(PLUGIN_SPIDER_LTLIBRARIES_TARGET) - PLUGIN_SPIDER_LIBRARIES_TARGET="libspider.a" - AC_SUBST(PLUGIN_SPIDER_LIBRARIES_TARGET) - LIBTOOL="$LIBTOOL --preserve-dup-deps" - AC_SUBST(LIBTOOL) - else - AC_MSG_ERROR([Can't find header files. Please check --with-mysql=PATH option]) - fi - ], - [ - if test \ - -f ../../include/mysql/plugin.h -a \ - -f ../../include/mysql.h -a \ - -f ../../include/errmsg.h -a \ - \( -f ../../sql/mysql_priv.h -o ../../sql/sql_priv.h \) ; - then - SPD_MYSQL_INC="../../" - AC_MSG_RESULT([no]) - else - AC_MSG_ERROR([Can't find header files. Please set --with-mysql=PATH option]) - fi - ] - ) -]) - -MYSQL_PATH_TEST -AC_SUBST(SPD_MYSQL_INC) - -AC_DEFUN([MYSQL_INCLUDE_PATH_TEST],[ - AC_MSG_CHECKING([mysql include path]) - AC_ARG_WITH([mysql-include], - [AS_HELP_STRING([--with-mysql-include=PATH],[mysql include directory PATH])], - [ - if test \ - -f $withval/mysql_version.h -a \ - -f $withval/my_config.h ; - then - MYSQL_INCLUDE_PATH="-I $withval/" - AC_MSG_RESULT([yes]) - else - AC_MSG_ERROR([Can't find "my_config.h". Please check --with-mysql-include=PATH option]) - fi - ], - [ - if test \ - -f ../../include/mysql_version.h -a \ - -f ../../include/my_config.h ; - then - MYSQL_INCLUDE_PATH="-I ../../include/" - AC_MSG_RESULT([no]) - else - AC_MSG_ERROR([Can't find "my_config.h". Please set --with-mysql-include=PATH option]) - fi - ] - ) -]) - -MYSQL_INCLUDE_PATH_TEST -AC_SUBST(MYSQL_INCLUDE_PATH) - -CXXFLAGS="$CXXFLAGS -fno-implicit-templates -fno-exceptions -fno-rtti" - - -AC_CHECK_FUNCS([memset strchr strncasecmp]) - -AC_CONFIG_FILES([Makefile]) -AC_OUTPUT diff --git a/storage/spider/ha_spider.cc b/storage/spider/ha_spider.cc index 9504b5a6c26..53f74d5fc0d 100644 --- a/storage/spider/ha_spider.cc +++ b/storage/spider/ha_spider.cc @@ -22,18 +22,11 @@ #include <my_global.h> #include "mysql_version.h" #include "spd_environ.h" -#if MYSQL_VERSION_ID < 50500 -#include "mysql_priv.h" -#include <mysql/plugin.h> -#else #include "sql_priv.h" #include "probes_mysql.h" #include "sql_class.h" #include "key.h" -#ifdef HANDLER_HAS_DIRECT_AGGREGATE #include "sql_select.h" -#endif -#endif #include "ha_partition.h" #include "spd_param.h" #include "spd_err.h" @@ -48,21 +41,13 @@ #include "spd_ping_table.h" #include "spd_malloc.h" -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100002 #define SPIDER_CAN_BG_SEARCH (1LL << 37) #define SPIDER_CAN_BG_INSERT (1LL << 38) #define SPIDER_CAN_BG_UPDATE (1LL << 39) -#else -#define SPIDER_CAN_BG_SEARCH (LL(1) << 37) -#define SPIDER_CAN_BG_INSERT (LL(1) << 38) -#define SPIDER_CAN_BG_UPDATE (LL(1) << 39) -#endif extern handlerton *spider_hton_ptr; extern SPIDER_DBTON spider_dbton[SPIDER_DBTON_SIZE]; -#ifdef SPIDER_HAS_HASH_VALUE_TYPE extern HASH spider_open_tables; -#endif extern pthread_mutex_t spider_lgtm_tblhnd_share_mutex; /* UTC time zone for timestamp columns */ @@ -83,13 +68,9 @@ ha_spider::ha_spider( spider_thread_id = 0; trx_conn_adjustment = 0; search_link_query_id = 0; -#ifdef WITH_PARTITION_STORAGE_ENGINE partition_handler = NULL; -#endif -#ifdef HA_MRR_USE_DEFAULT_IMPL multi_range_keys = NULL; mrr_key_buff = NULL; -#endif append_tblnm_alias = NULL; use_index_merge = FALSE; is_clone = FALSE; @@ -103,30 +84,13 @@ ha_spider::ha_spider( sql_kinds = 0; error_mode = 0; use_spatial_index = FALSE; -#ifdef SPIDER_HAS_GROUP_BY_HANDLER use_fields = FALSE; -#endif dml_inited = FALSE; use_pre_call = FALSE; use_pre_action = FALSE; -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS do_direct_update = FALSE; -#endif -#ifdef HA_CAN_BULK_ACCESS - is_bulk_access_clone = FALSE; - synced_from_clone_source = FALSE; - bulk_access_started = FALSE; - bulk_access_executing = FALSE; - bulk_access_pre_called = FALSE; - bulk_access_link_first = NULL; -/* - init_ha_mem_root = FALSE; -*/ -#endif prev_index_rnd_init = SPD_NONE; -#ifdef HANDLER_HAS_DIRECT_AGGREGATE direct_aggregate_item_first = NULL; -#endif result_link_idx = 0; result_list.have_sql_kind_backup = FALSE; result_list.sqls = NULL; @@ -140,10 +104,8 @@ ha_spider::ha_spider( result_list.set_split_read = FALSE; result_list.insert_dup_update_pushdown = FALSE; result_list.tmp_pos_row_first = NULL; -#ifdef HANDLER_HAS_DIRECT_AGGREGATE result_list.direct_aggregate = FALSE; result_list.snap_direct_aggregate = FALSE; -#endif result_list.direct_distinct = FALSE; result_list.casual_read = NULL; result_list.use_both_key = FALSE; @@ -168,13 +130,9 @@ ha_spider::ha_spider( spider_thread_id = 0; trx_conn_adjustment = 0; search_link_query_id = 0; -#ifdef WITH_PARTITION_STORAGE_ENGINE partition_handler = NULL; -#endif -#ifdef HA_MRR_USE_DEFAULT_IMPL multi_range_keys = NULL; mrr_key_buff = NULL; -#endif append_tblnm_alias = NULL; use_index_merge = FALSE; is_clone = FALSE; @@ -188,30 +146,13 @@ ha_spider::ha_spider( sql_kinds = 0; error_mode = 0; use_spatial_index = FALSE; -#ifdef SPIDER_HAS_GROUP_BY_HANDLER use_fields = FALSE; -#endif dml_inited = FALSE; use_pre_call = FALSE; use_pre_action = FALSE; -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS do_direct_update = FALSE; -#endif -#ifdef HA_CAN_BULK_ACCESS - is_bulk_access_clone = FALSE; - synced_from_clone_source = FALSE; - bulk_access_started = FALSE; - bulk_access_executing = FALSE; - bulk_access_pre_called = FALSE; - bulk_access_link_first = NULL; -/* - init_ha_mem_root = FALSE; -*/ -#endif prev_index_rnd_init = SPD_NONE; -#ifdef HANDLER_HAS_DIRECT_AGGREGATE direct_aggregate_item_first = NULL; -#endif result_link_idx = 0; result_list.have_sql_kind_backup = FALSE; result_list.sqls = NULL; @@ -225,10 +166,8 @@ ha_spider::ha_spider( result_list.set_split_read = FALSE; result_list.insert_dup_update_pushdown = FALSE; result_list.tmp_pos_row_first = NULL; -#ifdef HANDLER_HAS_DIRECT_AGGREGATE result_list.direct_aggregate = FALSE; result_list.snap_direct_aggregate = FALSE; -#endif result_list.direct_distinct = FALSE; result_list.casual_read = NULL; result_list.use_both_key = FALSE; @@ -241,9 +180,7 @@ ha_spider::~ha_spider() { DBUG_ENTER("ha_spider::~ha_spider"); DBUG_PRINT("info",("spider this=%p", this)); -#ifdef WITH_PARTITION_STORAGE_ENGINE partition_handler = NULL; -#endif if (wide_handler_owner) { spider_free(spider_current_trx, wide_handler, MYF(0)); @@ -297,18 +234,15 @@ int ha_spider::open( ha_spider *spider, *owner; bool wide_handler_alloc = FALSE; SPIDER_WIDE_SHARE *wide_share; -#ifdef WITH_PARTITION_STORAGE_ENGINE uint part_num; bool partition_handler_alloc = FALSE; ha_spider **wide_handler_handlers = NULL; ha_partition *clone_source; -#endif DBUG_ENTER("ha_spider::open"); DBUG_PRINT("info",("spider this=%p", this)); dup_key_idx = (uint) -1; conn_kinds = SPIDER_CONN_KIND_MYSQL; -#ifdef WITH_PARTITION_STORAGE_ENGINE table->file->get_no_parts("", &part_num); if (part_num) { @@ -322,13 +256,10 @@ int ha_spider::open( is_clone = TRUE; } } else { -#endif spider = this; owner = this; -#ifdef WITH_PARTITION_STORAGE_ENGINE clone_source = NULL; } -#endif if (!spider->wide_handler) { uchar *searched_bitmap; @@ -339,7 +270,6 @@ int ha_spider::open( uchar *rnd_read_bitmap; uchar *rnd_write_bitmap; if (!(wide_handler = (SPIDER_WIDE_HANDLER *) -#ifdef WITH_PARTITION_STORAGE_ENGINE spider_bulk_malloc(spider_current_trx, 16, MYF(MY_WME | MY_ZEROFILL), &wide_handler, sizeof(SPIDER_WIDE_HANDLER), &searched_bitmap, @@ -359,25 +289,6 @@ int ha_spider::open( &partition_handler, (uint) sizeof(SPIDER_PARTITION_HANDLER), NullS) -#else - spider_bulk_malloc(spider_current_trx, 16, MYF(MY_WME | MY_ZEROFILL), - &wide_handler, sizeof(SPIDER_WIDE_HANDLER), - &searched_bitmap, - (uint) sizeof(uchar) * no_bytes_in_map(table->read_set), - &ft_discard_bitmap, - (uint) sizeof(uchar) * no_bytes_in_map(table->read_set), - &position_bitmap, - (uint) sizeof(uchar) * no_bytes_in_map(table->read_set), - &idx_read_bitmap, - (uint) sizeof(uchar) * no_bytes_in_map(table->read_set), - &idx_write_bitmap, - (uint) sizeof(uchar) * no_bytes_in_map(table->read_set), - &rnd_read_bitmap, - (uint) sizeof(uchar) * no_bytes_in_map(table->read_set), - &rnd_write_bitmap, - (uint) sizeof(uchar) * no_bytes_in_map(table->read_set), - NullS) -#endif ) ) { error_num = HA_ERR_OUT_OF_MEM; @@ -392,9 +303,7 @@ int ha_spider::open( wide_handler->idx_write_bitmap = idx_write_bitmap; wide_handler->rnd_read_bitmap = rnd_read_bitmap; wide_handler->rnd_write_bitmap = rnd_write_bitmap; -#ifdef WITH_PARTITION_STORAGE_ENGINE wide_handler->partition_handler = partition_handler; -#endif wide_handler->owner = owner; if (table_share->tmp_table == NO_TMP_TABLE) wide_handler->top_share = table->s; @@ -410,7 +319,6 @@ int ha_spider::open( wide_share = share->wide_share; -#ifdef WITH_PARTITION_STORAGE_ENGINE DBUG_PRINT("info",("spider create partition_handler")); DBUG_PRINT("info",("spider table=%p", table)); partition_handler->table = table; @@ -435,7 +343,6 @@ int ha_spider::open( thr_lock_data_init(&wide_share->lock, &wide_handler->lock, NULL); } -#endif init_sql_alloc_size = spider_param_init_sql_alloc_size(thd, share->init_sql_alloc_size); @@ -496,7 +403,6 @@ int ha_spider::open( if (is_clone) { -#ifdef WITH_PARTITION_STORAGE_ENGINE if (part_num) { for (roop_count = 0; roop_count < (int) part_num; roop_count++) @@ -509,7 +415,6 @@ int ha_spider::open( } } } -#endif wide_handler->external_lock_type = pt_clone_source_handler->wide_handler->external_lock_type; @@ -534,9 +439,6 @@ int ha_spider::open( wide_handler->semi_table_lock = TRUE; } } -#ifdef HA_CAN_BULK_ACCESS - external_lock_cnt = 0; -#endif if (reset()) { @@ -551,7 +453,6 @@ error_reset: blob_buff = NULL; error_init_blob_buff: error_init_result_list: -#ifdef WITH_PARTITION_STORAGE_ENGINE if (partition_handler_alloc) { wide_share = share->wide_share; @@ -559,7 +460,6 @@ error_init_result_list: owner->partition_handler = NULL; } partition_handler = NULL; -#endif spider_free_share(share); share = NULL; if (conn_keys) @@ -571,12 +471,10 @@ error_get_share: if (wide_handler_alloc) { spider_free(spider_current_trx, wide_handler, MYF(0)); -#ifdef WITH_PARTITION_STORAGE_ENGINE if (wide_handler_handlers) { wide_handler_handlers[0]->wide_handler = NULL; } -#endif spider->wide_handler = NULL; owner->wide_handler = NULL; owner->wide_handler_owner = FALSE; @@ -594,7 +492,6 @@ int ha_spider::close() DBUG_ENTER("ha_spider::close"); DBUG_PRINT("info",("spider this=%p", this)); -#ifdef HA_MRR_USE_DEFAULT_IMPL if (multi_range_keys) { DBUG_PRINT("info",("spider free multi_range_keys=%p", multi_range_keys)); @@ -606,24 +503,6 @@ int ha_spider::close() delete [] mrr_key_buff; mrr_key_buff = NULL; } -#endif -#ifdef HA_CAN_BULK_ACCESS - if (bulk_access_link_first) - { - do { - DBUG_PRINT("info",("spider bulk_access_link->spider=%p", - bulk_access_link_first->spider)); - DBUG_PRINT("info",("spider bulk_access_link->spider->dbton_handler=%p", - bulk_access_link_first->spider->dbton_handler)); - DBUG_PRINT("info",("spider ptr bulk_access_link->spider->dbton_handler=" - "%p", &bulk_access_link_first->spider->dbton_handler)); - bulk_access_link_current = bulk_access_link_first->next; - delete_bulk_access_link(bulk_access_link_first); - bulk_access_link_first = bulk_access_link_current; - } while (bulk_access_link_first); - } -#endif -#ifdef HANDLER_HAS_DIRECT_AGGREGATE while (direct_aggregate_item_first) { direct_aggregate_item_current = direct_aggregate_item_first->next; @@ -634,7 +513,6 @@ int ha_spider::close() spider_free(spider_current_trx, direct_aggregate_item_first, MYF(0)); direct_aggregate_item_first = direct_aggregate_item_current; } -#endif if (is_clone) { for (roop_count = 0; roop_count < (int) share->link_count; roop_count++) @@ -678,9 +556,7 @@ int ha_spider::close() spider_free(spider_current_trx, conn_keys, MYF(0)); conn_keys = NULL; } -#ifdef WITH_PARTITION_STORAGE_ENGINE partition_handler = NULL; -#endif if (wide_handler_owner) { spider_free(spider_current_trx, wide_handler, MYF(0)); @@ -777,52 +653,10 @@ void ha_spider::check_access_kind( wide_handler->sql_command = thd_sql_command(thd); DBUG_PRINT("info",("spider sql_command=%u", wide_handler->sql_command)); DBUG_PRINT("info",("spider thd->query_id=%lld", thd->query_id)); -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS wide_handler->update_request = FALSE; -#else - if ( - wide_handler->sql_command == SQLCOM_UPDATE || - wide_handler->sql_command == SQLCOM_UPDATE_MULTI || - /* for triggers */ - wide_handler->sql_command == SQLCOM_INSERT || - wide_handler->sql_command == SQLCOM_INSERT_SELECT || - wide_handler->sql_command == SQLCOM_DELETE || - wide_handler->sql_command == SQLCOM_DELETE_MULTI - ) - wide_handler->update_request = TRUE; - else - wide_handler->update_request = FALSE; -#endif DBUG_VOID_RETURN; } -#ifdef HA_CAN_BULK_ACCESS -int ha_spider::additional_lock( - THD *thd, - enum thr_lock_type lock_type -) { - DBUG_ENTER("ha_spider::additional_lock"); - DBUG_PRINT("info",("spider this=%p", this)); - if (bulk_access_executing) - { - if (is_bulk_access_clone) - { - check_access_kind(thd); - DBUG_RETURN(check_access_kind_for_connection(thd, - (lock_type >= TL_WRITE_ALLOW_WRITE))); - } else if (bulk_access_link_exec_tgt->called) - { - bulk_access_link_exec_tgt->spider->check_access_kind(thd); - DBUG_RETURN(bulk_access_link_exec_tgt->spider-> - check_access_kind_for_connection( - thd, (lock_type >= TL_WRITE_ALLOW_WRITE))); - } - } - check_access_kind(thd); - DBUG_RETURN(check_access_kind_for_connection(thd, - (lock_type >= TL_WRITE_ALLOW_WRITE))); -} -#endif THR_LOCK_DATA **ha_spider::store_lock( THD *thd, @@ -831,7 +665,6 @@ THR_LOCK_DATA **ha_spider::store_lock( ) { DBUG_ENTER("ha_spider::store_lock"); DBUG_PRINT("info",("spider this=%p", this)); -#ifdef WITH_PARTITION_STORAGE_ENGINE if ( wide_handler->stage == SPD_HND_STAGE_STORE_LOCK && wide_handler->stage_executor != this) @@ -840,7 +673,6 @@ THR_LOCK_DATA **ha_spider::store_lock( } wide_handler->stage = SPD_HND_STAGE_STORE_LOCK; wide_handler->stage_executor = this; -#endif wide_handler->lock_table_type = 0; if (lock_type == TL_IGNORE) { @@ -941,7 +773,6 @@ THR_LOCK_DATA **ha_spider::store_lock( !spider_param_local_lock_table(thd) ) { wide_handler->lock_table_type = 1; -#ifdef WITH_PARTITION_STORAGE_ENGINE if (partition_handler && partition_handler->handlers) { uint roop_count; @@ -956,11 +787,8 @@ THR_LOCK_DATA **ha_spider::store_lock( } } } else { -#endif store_error_num = append_lock_tables_list(); -#ifdef WITH_PARTITION_STORAGE_ENGINE } -#endif } } else { DBUG_PRINT("info",("spider default lock route")); @@ -976,7 +804,6 @@ THR_LOCK_DATA **ha_spider::store_lock( spider_param_semi_table_lock(thd, wide_handler->semi_table_lock) ) { wide_handler->lock_table_type = 2; -#ifdef WITH_PARTITION_STORAGE_ENGINE if (partition_handler && partition_handler->handlers) { uint roop_count; @@ -992,11 +819,8 @@ THR_LOCK_DATA **ha_spider::store_lock( } } } else { -#endif store_error_num = append_lock_tables_list(); -#ifdef WITH_PARTITION_STORAGE_ENGINE } -#endif } } if ( @@ -1128,7 +952,6 @@ int ha_spider::start_stmt( thr_lock_type lock_type ) { DBUG_ENTER("ha_spider::start_stmt"); -#ifdef WITH_PARTITION_STORAGE_ENGINE if ( wide_handler->stage == SPD_HND_STAGE_START_STMT && wide_handler->stage_executor != this) @@ -1137,7 +960,6 @@ int ha_spider::start_stmt( } wide_handler->stage = SPD_HND_STAGE_START_STMT; wide_handler->stage_executor = this; -#endif DBUG_RETURN(0); } @@ -1153,41 +975,6 @@ int ha_spider::reset() backup_error_status(); DBUG_ENTER("ha_spider::reset"); DBUG_PRINT("info",("spider this=%p", this)); -#ifdef HA_CAN_BULK_ACCESS - SPIDER_BULK_ACCESS_LINK *tmp_bulk_access_link = bulk_access_link_first; - while (tmp_bulk_access_link) - { - DBUG_PRINT("info",("spider bulk_access_link->spider->dbton_handler=%p", - tmp_bulk_access_link->spider->dbton_handler)); - DBUG_PRINT("info",("spider ptr bulk_access_link->spider->dbton_handler=%p", - &tmp_bulk_access_link->spider->dbton_handler)); - if (!tmp_bulk_access_link->used) - break; - if ((error_num2 = tmp_bulk_access_link->spider->ha_reset())) - error_num = error_num2; - tmp_bulk_access_link->used = FALSE; - tmp_bulk_access_link = tmp_bulk_access_link->next; - } - synced_from_clone_source = FALSE; - bulk_access_started = FALSE; - bulk_access_executing = FALSE; - bulk_access_pre_called = FALSE; - if ( - bulk_access_link_first && - !spider_param_bulk_access_free(share->bulk_access_free) - ) { - do { - DBUG_PRINT("info",("spider bulk_access_link->spider->dbton_handler=%p", - bulk_access_link_first->spider->dbton_handler)); - DBUG_PRINT("info",("spider ptr bulk_access_link->spider->dbton_handler=%p", - &bulk_access_link_first->spider->dbton_handler)); - bulk_access_link_current = bulk_access_link_first->next; - delete_bulk_access_link(bulk_access_link_first); - bulk_access_link_first = bulk_access_link_current; - } while (bulk_access_link_first); - } -#endif -#ifdef HANDLER_HAS_DIRECT_AGGREGATE direct_aggregate_item_current = direct_aggregate_item_first; while (direct_aggregate_item_current) { @@ -1207,7 +994,6 @@ int ha_spider::reset() } result_list.direct_aggregate = FALSE; result_list.snap_direct_aggregate = FALSE; -#endif result_list.direct_distinct = FALSE; store_error_num = 0; if (wide_handler) @@ -1240,16 +1026,12 @@ int ha_spider::reset() wide_handler->condition = tmp_cond; } wide_handler->cond_check = FALSE; -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS wide_handler->direct_update_fields = NULL; -#endif #ifdef INFO_KIND_FORCE_LIMIT_BEGIN wide_handler->info_limit = 9223372036854775807LL; #endif -#ifdef WITH_PARTITION_STORAGE_ENGINE wide_handler->stage = SPD_HND_STAGE_NONE; wide_handler->stage_executor = NULL; -#endif } if (!(tmp_trx = spider_get_trx(thd, TRUE, &error_num2))) { @@ -1306,23 +1088,19 @@ int ha_spider::reset() conn_kinds = SPIDER_CONN_KIND_MYSQL; use_index_merge = FALSE; init_rnd_handler = FALSE; -#ifdef HA_MRR_USE_DEFAULT_IMPL if (multi_range_keys) { DBUG_PRINT("info",("spider free multi_range_keys=%p", multi_range_keys)); spider_free(spider_current_trx, multi_range_keys, MYF(0)); multi_range_keys = NULL; } -#endif multi_range_num = 0; ft_handler = NULL; ft_current = NULL; ft_count = 0; ft_init_without_index_init = FALSE; sql_kinds = 0; -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS do_direct_update = FALSE; -#endif prev_index_rnd_init = SPD_NONE; result_list.have_sql_kind_backup = FALSE; result_list.direct_order_limit = FALSE; @@ -1330,21 +1108,8 @@ int ha_spider::reset() result_list.set_split_read = FALSE; result_list.insert_dup_update_pushdown = FALSE; use_spatial_index = FALSE; -#ifdef SPIDER_HAS_GROUP_BY_HANDLER use_fields = FALSE; -#endif error_mode = 0; -#ifdef HA_CAN_BULK_ACCESS -#ifndef DBUG_OFF - if (bulk_access_link_first) - { - DBUG_PRINT("info",("spider bulk_access_link->spider->dbton_handler=%p", - bulk_access_link_first->spider->dbton_handler)); - DBUG_PRINT("info",("spider ptr bulk_access_link->spider->dbton_handler=%p", - &bulk_access_link_first->spider->dbton_handler)); - } -#endif -#endif DBUG_RETURN(error_num); } @@ -1355,7 +1120,6 @@ int ha_spider::extra( DBUG_ENTER("ha_spider::extra"); DBUG_PRINT("info",("spider this=%p", this)); DBUG_PRINT("info",("spider operation=%d", (int) operation)); -#ifdef WITH_PARTITION_STORAGE_ENGINE if ( wide_handler->stage == SPD_HND_STAGE_EXTRA && wide_handler->stage_executor != this) @@ -1364,7 +1128,6 @@ int ha_spider::extra( } wide_handler->stage = SPD_HND_STAGE_EXTRA; wide_handler->stage_executor = this; -#endif switch (operation) { case HA_EXTRA_QUICK: @@ -1374,13 +1137,11 @@ int ha_spider::extra( if (!is_clone) { wide_handler->keyread = TRUE; -#ifdef WITH_PARTITION_STORAGE_ENGINE if (wide_handler->update_request) { if (check_partitioned()) wide_handler->keyread = FALSE; } -#endif } break; case HA_EXTRA_NO_KEYREAD: @@ -1398,24 +1159,19 @@ int ha_spider::extra( case HA_EXTRA_WRITE_CANNOT_REPLACE: wide_handler->write_can_replace = FALSE; break; -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS case HA_EXTRA_INSERT_WITH_UPDATE: wide_handler->insert_with_update = TRUE; break; -#endif case HA_EXTRA_ATTACH_CHILDREN: DBUG_PRINT("info",("spider HA_EXTRA_ATTACH_CHILDREN")); if (!(wide_handler->trx = spider_get_trx(ha_thd(), TRUE, &error_num))) DBUG_RETURN(error_num); break; -#if MYSQL_VERSION_ID < 50500 -#else case HA_EXTRA_ADD_CHILDREN_LIST: DBUG_PRINT("info",("spider HA_EXTRA_ADD_CHILDREN_LIST")); if (!(wide_handler->trx = spider_get_trx(ha_thd(), TRUE, &error_num))) DBUG_RETURN(error_num); break; -#endif #if defined(HA_EXTRA_HAS_STARTING_ORDERED_INDEX_SCAN) || defined(HA_EXTRA_HAS_HA_EXTRA_USE_CMP_REF) #ifdef HA_EXTRA_HAS_STARTING_ORDERED_INDEX_SCAN case HA_EXTRA_STARTING_ORDERED_INDEX_SCAN: @@ -1465,19 +1221,6 @@ int ha_spider::index_init( DBUG_ENTER("ha_spider::index_init"); DBUG_PRINT("info",("spider this=%p", this)); DBUG_PRINT("info",("spider idx=%u", idx)); -#ifdef HA_CAN_BULK_ACCESS - DBUG_ASSERT(!bulk_access_started); - if (bulk_access_executing) - { - if ( - !is_bulk_access_clone && - bulk_access_link_exec_tgt->called - ) { - DBUG_RETURN(bulk_access_link_exec_tgt->spider->ha_index_init( - idx, sorted)); - } - } -#endif if (!dml_inited) { if (unlikely((error_num = dml_init()))) @@ -1526,16 +1269,6 @@ int ha_spider::index_init( DBUG_RETURN(0); } -#ifdef HA_CAN_BULK_ACCESS -int ha_spider::pre_index_init( - uint idx, - bool sorted -) { - DBUG_ENTER("ha_spider::pre_index_init"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(bulk_access_link_current->spider->ha_index_init(idx, sorted)); -} -#endif int ha_spider::index_end() { @@ -1543,21 +1276,6 @@ int ha_spider::index_end() backup_error_status(); DBUG_ENTER("ha_spider::index_end"); DBUG_PRINT("info",("spider this=%p", this)); -#ifdef HA_CAN_BULK_ACCESS - DBUG_ASSERT(!bulk_access_started); - if (bulk_access_executing) - { - if ( - !is_bulk_access_clone && - bulk_access_link_exec_tgt->called - ) { - error_num = bulk_access_link_exec_tgt->spider->ha_index_end(); - if (error_num) - DBUG_RETURN(check_error_mode(error_num)); - DBUG_RETURN(0); - } - } -#endif active_index = MAX_KEY; /* #ifdef INFO_KIND_FORCE_LIMIT_BEGIN @@ -1577,14 +1295,6 @@ int ha_spider::index_end() DBUG_RETURN(0); } -#ifdef HA_CAN_BULK_ACCESS -int ha_spider::pre_index_end() -{ - DBUG_ENTER("ha_spider::pre_index_end"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(bulk_access_link_current->spider->ha_index_end()); -} -#endif int ha_spider::index_read_map_internal( uchar *buf, @@ -1603,9 +1313,7 @@ int ha_spider::index_read_map_internal( my_error(ER_QUERY_INTERRUPTED, MYF(0)); DBUG_RETURN(ER_QUERY_INTERRUPTED); } -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS do_direct_update = FALSE; -#endif if ( find_flag >= HA_READ_MBR_CONTAIN && find_flag <= HA_READ_MBR_EQUAL @@ -1629,13 +1337,9 @@ int ha_spider::index_read_map_internal( if ((error_num = reset_sql_sql( SPIDER_SQL_TYPE_SELECT_SQL | SPIDER_SQL_TYPE_HANDLER))) DBUG_RETURN(error_num); -#ifndef WITHOUT_SPIDER_BG_SEARCH if ((error_num = spider_set_conn_bg_param(this))) DBUG_RETURN(error_num); -#endif -#ifdef WITH_PARTITION_STORAGE_ENGINE check_select_column(FALSE); -#endif DBUG_PRINT("info",("spider result_list.finish_flg = FALSE")); result_list.finish_flg = FALSE; result_list.record_num = 0; @@ -1739,7 +1443,6 @@ int ha_spider::index_read_map_internal( conn_link_idx, roop_count, share->link_count, SPIDER_LINK_STATUS_RECOVERY) ) { -#ifndef WITHOUT_SPIDER_BG_SEARCH if (result_list.bgs_phase > 0) { if ((error_num = spider_check_and_init_casual_read( @@ -1774,7 +1477,6 @@ int ha_spider::index_read_map_internal( DBUG_RETURN(check_error_mode_eof(error_num)); } } else { -#endif ulong sql_type; conn = conns[roop_count]; if (sql_kind[roop_count] == SPIDER_SQL_KIND_SQL) @@ -1805,18 +1507,6 @@ int ha_spider::index_read_map_internal( SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos); } DBUG_PRINT("info",("spider sql_type=%lu", sql_type)); -#ifdef HA_CAN_BULK_ACCESS - if ( - is_bulk_access_clone && - !bulk_access_executing && - conn_kind[roop_count] != SPIDER_CONN_KIND_MYSQL - ) { - connection_ids[roop_count] = conn->connection_id; - spider_trx_add_bulk_access_conn(wide_handler->trx, conn); - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - } else { -#endif conn->need_mon = &need_mons[roop_count]; DBUG_ASSERT(!conn->mta_conn_mutex_lock_already); DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later); @@ -1929,12 +1619,7 @@ int ha_spider::index_read_map_internal( SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); pthread_mutex_unlock(&conn->mta_conn_mutex); } -#ifdef HA_CAN_BULK_ACCESS - } -#endif -#ifndef WITHOUT_SPIDER_BG_SEARCH } -#endif } if (buf && (error_num = spider_db_fetch(buf, this, table))) DBUG_RETURN(check_error_mode_eof(error_num)); @@ -1947,42 +1632,13 @@ int ha_spider::pre_index_read_map( enum ha_rkey_function find_flag, bool use_parallel ) { -#ifdef HA_CAN_BULK_ACCESS - int error_num; -#endif DBUG_ENTER("ha_spider::pre_index_read_map"); DBUG_PRINT("info",("spider this=%p", this)); -#ifdef HA_CAN_BULK_ACCESS - if (bulk_access_started) - { - error_num = bulk_access_link_current->spider->pre_index_read_map(key, - keypart_map, find_flag, TRUE); - bulk_access_link_current->spider->bulk_access_pre_called = TRUE; - bulk_access_link_current->called = TRUE; - DBUG_RETURN(error_num); - } else if ( - bulk_access_executing && !is_bulk_access_clone && - bulk_access_link_exec_tgt->called - ) { - DBUG_RETURN(bulk_access_link_exec_tgt->spider->pre_index_read_map(key, - keypart_map, find_flag, TRUE)); - } -#endif check_pre_call(use_parallel); if (use_pre_call) { store_error_num = index_read_map_internal(NULL, key, keypart_map, find_flag); -#ifdef HA_CAN_BULK_ACCESS - if ( - !store_error_num && - bulk_access_executing && - is_bulk_access_clone && - !bulk_access_pre_called - ) { - bulk_req_exec(); - } -#endif DBUG_RETURN(store_error_num); } DBUG_RETURN(0); @@ -1997,59 +1653,6 @@ int ha_spider::index_read_map( int error_num; DBUG_ENTER("ha_spider::index_read_map"); DBUG_PRINT("info",("spider this=%p", this)); -#ifdef HA_CAN_BULK_ACCESS - DBUG_ASSERT(!bulk_access_started); - if (bulk_access_executing) - { - if (is_bulk_access_clone) - { - if (bulk_access_pre_called) - { - SPIDER_CONN *conn; - int roop_count, roop_start, roop_end, tmp_lock_mode, link_ok, - tmp_error_num; - tmp_lock_mode = spider_conn_lock_mode(this); - if (tmp_lock_mode) - { - /* "for update" or "lock in share mode" */ - link_ok = spider_conn_link_idx_next(share->link_statuses, - conn_link_idx, -1, share->link_count, - SPIDER_LINK_STATUS_OK); - roop_start = spider_conn_link_idx_next(share->link_statuses, - conn_link_idx, -1, share->link_count, - SPIDER_LINK_STATUS_RECOVERY); - roop_end = share->link_count; - } else { - link_ok = search_link_idx; - roop_start = search_link_idx; - roop_end = search_link_idx + 1; - } - for (roop_count = roop_start; roop_count < roop_end; - roop_count = spider_conn_link_idx_next(share->link_statuses, - conn_link_idx, roop_count, share->link_count, - SPIDER_LINK_STATUS_RECOVERY) - ) { - conn = conns[roop_count]; - if ((tmp_error_num = spider_db_bulk_store_result(this, conn, - roop_count, (roop_count != link_ok)))) - { - store_error_num = tmp_error_num; - } else { - result_link_idx = link_ok; - } - } - use_pre_call = TRUE; - bulk_access_pre_called = FALSE; - } else { - /* do access normally */ - } - } else if (bulk_access_link_exec_tgt->called) - { - DBUG_RETURN(bulk_access_link_exec_tgt->spider->index_read_map(buf, key, - keypart_map, find_flag)); - } - } -#endif if (use_pre_call) { if (store_error_num) @@ -2088,9 +1691,7 @@ int ha_spider::index_read_last_map_internal( my_error(ER_QUERY_INTERRUPTED, MYF(0)); DBUG_RETURN(ER_QUERY_INTERRUPTED); } -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS do_direct_update = FALSE; -#endif if ((error_num = index_handler_init())) DBUG_RETURN(check_error_mode_eof(error_num)); if (is_clone) @@ -2116,13 +1717,9 @@ int ha_spider::index_read_last_map_internal( if ((error_num = reset_sql_sql( SPIDER_SQL_TYPE_SELECT_SQL | SPIDER_SQL_TYPE_HANDLER))) DBUG_RETURN(error_num); -#ifndef WITHOUT_SPIDER_BG_SEARCH if ((error_num = spider_set_conn_bg_param(this))) DBUG_RETURN(error_num); -#endif -#ifdef WITH_PARTITION_STORAGE_ENGINE check_select_column(FALSE); -#endif DBUG_PRINT("info",("spider result_list.finish_flg = FALSE")); result_list.finish_flg = FALSE; result_list.record_num = 0; @@ -2214,7 +1811,6 @@ int ha_spider::index_read_last_map_internal( conn_link_idx, roop_count, share->link_count, SPIDER_LINK_STATUS_RECOVERY) ) { -#ifndef WITHOUT_SPIDER_BG_SEARCH if (result_list.bgs_phase > 0) { if ((error_num = spider_check_and_init_casual_read( @@ -2249,7 +1845,6 @@ int ha_spider::index_read_last_map_internal( DBUG_RETURN(check_error_mode_eof(error_num)); } } else { -#endif ulong sql_type; conn = conns[roop_count]; if (sql_kind[roop_count] == SPIDER_SQL_KIND_SQL) @@ -2280,15 +1875,6 @@ int ha_spider::index_read_last_map_internal( SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos); } DBUG_PRINT("info",("spider sql_type=%lu", sql_type)); -#ifdef HA_CAN_BULK_ACCESS - if (is_bulk_access_clone) - { - connection_ids[roop_count] = conn->connection_id; - spider_trx_add_bulk_access_conn(wide_handler->trx, conn); - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - } else { -#endif conn->need_mon = &need_mons[roop_count]; DBUG_ASSERT(!conn->mta_conn_mutex_lock_already); DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later); @@ -2401,12 +1987,7 @@ int ha_spider::index_read_last_map_internal( SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); pthread_mutex_unlock(&conn->mta_conn_mutex); } -#ifdef HA_CAN_BULK_ACCESS - } -#endif -#ifndef WITHOUT_SPIDER_BG_SEARCH } -#endif } if (buf && (error_num = spider_db_fetch(buf, this, table))) DBUG_RETURN(check_error_mode_eof(error_num)); @@ -2466,21 +2047,6 @@ int ha_spider::index_next( my_error(ER_QUERY_INTERRUPTED, MYF(0)); DBUG_RETURN(ER_QUERY_INTERRUPTED); } -#ifdef HA_CAN_BULK_ACCESS - DBUG_ASSERT(!bulk_access_started); - if (bulk_access_executing) - { - if ( - !is_bulk_access_clone && - bulk_access_link_exec_tgt->called - ) { - error_num = bulk_access_link_exec_tgt->spider->index_next(buf); - if (error_num) - DBUG_RETURN(check_error_mode(error_num)); - DBUG_RETURN(0); - } - } -#endif if (is_clone) { DBUG_PRINT("info",("spider set pt_clone_last_searcher to %p", @@ -2512,21 +2078,6 @@ int ha_spider::index_prev( my_error(ER_QUERY_INTERRUPTED, MYF(0)); DBUG_RETURN(ER_QUERY_INTERRUPTED); } -#ifdef HA_CAN_BULK_ACCESS - DBUG_ASSERT(!bulk_access_started); - if (bulk_access_executing) - { - if ( - !is_bulk_access_clone && - bulk_access_link_exec_tgt->called - ) { - error_num = bulk_access_link_exec_tgt->spider->index_prev(buf); - if (error_num) - DBUG_RETURN(check_error_mode(error_num)); - DBUG_RETURN(0); - } - } -#endif if (is_clone) { DBUG_PRINT("info",("spider set pt_clone_last_searcher to %p", @@ -2559,9 +2110,7 @@ int ha_spider::index_first_internal( my_error(ER_QUERY_INTERRUPTED, MYF(0)); DBUG_RETURN(ER_QUERY_INTERRUPTED); } -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS do_direct_update = FALSE; -#endif if ((error_num = index_handler_init())) DBUG_RETURN(check_error_mode_eof(error_num)); if (is_clone) @@ -2584,13 +2133,9 @@ int ha_spider::index_first_internal( DBUG_RETURN(error_num); check_direct_order_limit(); -#ifndef WITHOUT_SPIDER_BG_SEARCH if ((error_num = spider_set_conn_bg_param(this))) DBUG_RETURN(error_num); -#endif -#ifdef WITH_PARTITION_STORAGE_ENGINE check_select_column(FALSE); -#endif DBUG_PRINT("info",("spider result_list.finish_flg = FALSE")); result_list.finish_flg = FALSE; result_list.record_num = 0; @@ -2683,7 +2228,6 @@ int ha_spider::index_first_internal( conn_link_idx, roop_count, share->link_count, SPIDER_LINK_STATUS_RECOVERY) ) { -#ifndef WITHOUT_SPIDER_BG_SEARCH if (result_list.bgs_phase > 0) { if ((error_num = spider_check_and_init_casual_read( @@ -2718,7 +2262,6 @@ int ha_spider::index_first_internal( DBUG_RETURN(check_error_mode_eof(error_num)); } } else { -#endif ulong sql_type; conn = conns[roop_count]; if (sql_kind[roop_count] == SPIDER_SQL_KIND_SQL) @@ -2750,15 +2293,6 @@ int ha_spider::index_first_internal( SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos); } DBUG_PRINT("info",("spider sql_type=%lu", sql_type)); -#ifdef HA_CAN_BULK_ACCESS - if (is_bulk_access_clone) - { - connection_ids[roop_count] = conn->connection_id; - spider_trx_add_bulk_access_conn(wide_handler->trx, conn); - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - } else { -#endif conn->need_mon = &need_mons[roop_count]; DBUG_ASSERT(!conn->mta_conn_mutex_lock_already); DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later); @@ -2871,12 +2405,7 @@ int ha_spider::index_first_internal( SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); pthread_mutex_unlock(&conn->mta_conn_mutex); } -#ifdef HA_CAN_BULK_ACCESS - } -#endif -#ifndef WITHOUT_SPIDER_BG_SEARCH } -#endif } } @@ -2946,9 +2475,7 @@ int ha_spider::index_last_internal( my_error(ER_QUERY_INTERRUPTED, MYF(0)); DBUG_RETURN(ER_QUERY_INTERRUPTED); } -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS do_direct_update = FALSE; -#endif if ((error_num = index_handler_init())) DBUG_RETURN(check_error_mode_eof(error_num)); if (is_clone) @@ -2971,13 +2498,9 @@ int ha_spider::index_last_internal( DBUG_RETURN(error_num); check_direct_order_limit(); -#ifndef WITHOUT_SPIDER_BG_SEARCH if ((error_num = spider_set_conn_bg_param(this))) DBUG_RETURN(error_num); -#endif -#ifdef WITH_PARTITION_STORAGE_ENGINE check_select_column(FALSE); -#endif DBUG_PRINT("info",("spider result_list.finish_flg = FALSE")); result_list.finish_flg = FALSE; result_list.record_num = 0; @@ -3070,7 +2593,6 @@ int ha_spider::index_last_internal( conn_link_idx, roop_count, share->link_count, SPIDER_LINK_STATUS_RECOVERY) ) { -#ifndef WITHOUT_SPIDER_BG_SEARCH if (result_list.bgs_phase > 0) { if ((error_num = spider_check_and_init_casual_read( @@ -3105,7 +2627,6 @@ int ha_spider::index_last_internal( DBUG_RETURN(check_error_mode_eof(error_num)); } } else { -#endif ulong sql_type; conn = conns[roop_count]; if (sql_kind[roop_count] == SPIDER_SQL_KIND_SQL) @@ -3137,15 +2658,6 @@ int ha_spider::index_last_internal( SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos); } DBUG_PRINT("info",("spider sql_type=%lu", sql_type)); -#ifdef HA_CAN_BULK_ACCESS - if (is_bulk_access_clone) - { - connection_ids[roop_count] = conn->connection_id; - spider_trx_add_bulk_access_conn(wide_handler->trx, conn); - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - } else { -#endif conn->need_mon = &need_mons[roop_count]; DBUG_ASSERT(!conn->mta_conn_mutex_lock_already); DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later); @@ -3258,12 +2770,7 @@ int ha_spider::index_last_internal( SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); pthread_mutex_unlock(&conn->mta_conn_mutex); } -#ifdef HA_CAN_BULK_ACCESS - } -#endif -#ifndef WITHOUT_SPIDER_BG_SEARCH } -#endif } } @@ -3334,22 +2841,6 @@ int ha_spider::index_next_same( my_error(ER_QUERY_INTERRUPTED, MYF(0)); DBUG_RETURN(ER_QUERY_INTERRUPTED); } -#ifdef HA_CAN_BULK_ACCESS - DBUG_ASSERT(!bulk_access_started); - if (bulk_access_executing) - { - if ( - !is_bulk_access_clone && - bulk_access_link_exec_tgt->called - ) { - error_num = bulk_access_link_exec_tgt->spider->index_next_same(buf, key, - keylen); - if (error_num) - DBUG_RETURN(check_error_mode(error_num)); - DBUG_RETURN(0); - } - } -#endif if (is_clone) { DBUG_PRINT("info",("spider set pt_clone_last_searcher to %p", @@ -3386,9 +2877,7 @@ int ha_spider::read_range_first_internal( my_error(ER_QUERY_INTERRUPTED, MYF(0)); DBUG_RETURN(ER_QUERY_INTERRUPTED); } -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS do_direct_update = FALSE; -#endif if ( start_key && start_key->flag >= HA_READ_MBR_CONTAIN && @@ -3417,13 +2906,9 @@ int ha_spider::read_range_first_internal( if ((error_num = reset_sql_sql( SPIDER_SQL_TYPE_SELECT_SQL | SPIDER_SQL_TYPE_HANDLER))) DBUG_RETURN(error_num); -#ifndef WITHOUT_SPIDER_BG_SEARCH if ((error_num = spider_set_conn_bg_param(this))) DBUG_RETURN(error_num); -#endif -#ifdef WITH_PARTITION_STORAGE_ENGINE check_select_column(FALSE); -#endif DBUG_PRINT("info",("spider result_list.finish_flg = FALSE")); result_list.finish_flg = FALSE; result_list.record_num = 0; @@ -3516,7 +3001,6 @@ int ha_spider::read_range_first_internal( conn_link_idx, roop_count, share->link_count, SPIDER_LINK_STATUS_RECOVERY) ) { -#ifndef WITHOUT_SPIDER_BG_SEARCH if (result_list.bgs_phase > 0) { if ((error_num = spider_check_and_init_casual_read( @@ -3551,7 +3035,6 @@ int ha_spider::read_range_first_internal( DBUG_RETURN(check_error_mode_eof(error_num)); } } else { -#endif ulong sql_type; conn = conns[roop_count]; if (sql_kind[roop_count] == SPIDER_SQL_KIND_SQL) @@ -3582,15 +3065,6 @@ int ha_spider::read_range_first_internal( SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos); } DBUG_PRINT("info",("spider sql_type=%lu", sql_type)); -#ifdef HA_CAN_BULK_ACCESS - if (is_bulk_access_clone) - { - connection_ids[roop_count] = conn->connection_id; - spider_trx_add_bulk_access_conn(wide_handler->trx, conn); - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - } else { -#endif conn->need_mon = &need_mons[roop_count]; DBUG_ASSERT(!conn->mta_conn_mutex_lock_already); DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later); @@ -3703,12 +3177,7 @@ int ha_spider::read_range_first_internal( SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); pthread_mutex_unlock(&conn->mta_conn_mutex); } -#ifdef HA_CAN_BULK_ACCESS - } -#endif -#ifndef WITHOUT_SPIDER_BG_SEARCH } -#endif } if (buf && (error_num = spider_db_fetch(buf, this, table))) DBUG_RETURN(check_error_mode_eof(error_num)); @@ -3821,8 +3290,6 @@ bool ha_spider::check_no_where_cond() DBUG_RETURN(FALSE); } -#ifdef HA_MRR_USE_DEFAULT_IMPL -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000 ha_rows ha_spider::multi_range_read_info_const( uint keyno, RANGE_SEQ_IF *seq, @@ -3832,17 +3299,6 @@ ha_rows ha_spider::multi_range_read_info_const( uint *flags, Cost_estimate *cost ) -#else -ha_rows ha_spider::multi_range_read_info_const( - uint keyno, - RANGE_SEQ_IF *seq, - void *seq_init_param, - uint n_ranges, - uint *bufsz, - uint *flags, - COST_VECT *cost -) -#endif { DBUG_ENTER("ha_spider::multi_range_read_info_const"); DBUG_PRINT("info",("spider this=%p", this)); @@ -3887,7 +3343,6 @@ ha_rows ha_spider::multi_range_read_info_const( DBUG_RETURN(rows); } -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000 ha_rows ha_spider::multi_range_read_info( uint keyno, uint n_ranges, @@ -3897,17 +3352,6 @@ ha_rows ha_spider::multi_range_read_info( uint *flags, Cost_estimate *cost ) -#else -ha_rows ha_spider::multi_range_read_info( - uint keyno, - uint n_ranges, - uint keys, - uint key_parts, - uint *bufsz, - uint *flags, - COST_VECT *cost -) -#endif { DBUG_ENTER("ha_spider::multi_range_read_info"); DBUG_PRINT("info",("spider this=%p", this)); @@ -3977,49 +3421,23 @@ int ha_spider::multi_range_read_init( ) ); } -#endif -#ifdef HA_MRR_USE_DEFAULT_IMPL -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000 int ha_spider::multi_range_read_next_first( range_id_t *range_info ) -#else -int ha_spider::multi_range_read_next_first( - char **range_info -) -#endif -#else -int ha_spider::read_multi_range_first_internal( - uchar *buf, - KEY_MULTI_RANGE **found_range_p, - KEY_MULTI_RANGE *ranges, - uint range_count, - bool sorted, - HANDLER_BUFFER *buffer -) -#endif { int error_num, roop_count; SPIDER_CONN *conn; -#ifdef HA_MRR_USE_DEFAULT_IMPL int range_res; backup_error_status(); DBUG_ENTER("ha_spider::multi_range_read_next_first"); -#else - bka_mode = spider_param_bka_mode(wide_handler->trx->thd, share->bka_mode); - backup_error_status(); - DBUG_ENTER("ha_spider::read_multi_range_first_internal"); -#endif DBUG_PRINT("info",("spider this=%p", this)); if (wide_handler->trx->thd->killed) { my_error(ER_QUERY_INTERRUPTED, MYF(0)); DBUG_RETURN(ER_QUERY_INTERRUPTED); } -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS do_direct_update = FALSE; -#endif if ((error_num = index_handler_init())) DBUG_RETURN(check_error_mode_eof(error_num)); if (is_clone) @@ -4028,21 +3446,12 @@ int ha_spider::read_multi_range_first_internal( pt_clone_source_handler)); pt_clone_source_handler->pt_clone_last_searcher = this; } -#ifdef HA_MRR_USE_DEFAULT_IMPL -#else - multi_range_sorted = sorted; - multi_range_buffer = buffer; -#endif spider_db_free_one_result_for_start_next(this); check_direct_order_limit(); -#ifndef WITHOUT_SPIDER_BG_SEARCH if ((error_num = spider_set_conn_bg_param(this))) DBUG_RETURN(error_num); -#endif -#ifdef WITH_PARTITION_STORAGE_ENGINE check_select_column(FALSE); -#endif DBUG_PRINT("info",("spider result_list.finish_flg = FALSE")); result_list.finish_flg = FALSE; result_list.record_num = 0; @@ -4050,16 +3459,10 @@ int ha_spider::read_multi_range_first_internal( SPIDER_SQL_TYPE_SELECT_SQL | SPIDER_SQL_TYPE_HANDLER))) DBUG_RETURN(error_num); result_list.desc_flg = FALSE; -#ifdef HA_MRR_USE_DEFAULT_IMPL result_list.sorted = mrr_is_output_sorted; -#else - result_list.sorted = sorted; -#endif result_list.key_info = &table->key_info[active_index]; if ( -#ifdef HA_MRR_USE_DEFAULT_IMPL multi_range_num == 1 || -#endif result_list.multi_split_read <= 1 || (sql_kinds & SPIDER_SQL_KIND_HANDLER) ) { @@ -4080,21 +3483,10 @@ int ha_spider::read_multi_range_first_internal( ) DBUG_RETURN(error_num); set_where_pos_sql(SPIDER_SQL_TYPE_SELECT_SQL); -#ifdef HA_MRR_USE_DEFAULT_IMPL error_num = HA_ERR_END_OF_FILE; while (!(range_res = mrr_funcs.next(mrr_iter, &mrr_cur_range))) -#else - for ( - multi_range_curr = ranges, - multi_range_end = ranges + range_count; - multi_range_curr < multi_range_end; - multi_range_curr++ - ) -#endif { -#ifdef HA_MRR_USE_DEFAULT_IMPL DBUG_PRINT("info",("spider range_res1=%d", range_res)); -#endif result_list.limit_num = result_list.internal_limit - result_list.record_num >= result_list.split_read ? @@ -4102,17 +3494,10 @@ int ha_spider::read_multi_range_first_internal( result_list.internal_limit - result_list.record_num; DBUG_PRINT("info",("spider limit_num=%lld", result_list.limit_num)); if ( -#ifdef HA_MRR_USE_DEFAULT_IMPL (error_num = spider_db_append_key_where( &mrr_cur_range.start_key, SPIDER_TEST(mrr_cur_range.range_flag & EQ_RANGE) ? NULL : &mrr_cur_range.end_key, this)) -#else - (error_num = spider_db_append_key_where( - &multi_range_curr->start_key, - SPIDER_TEST(multi_range_curr->range_flag & EQ_RANGE) ? - NULL : &multi_range_curr->end_key, this)) -#endif ) DBUG_RETURN(error_num); if (sql_kinds & SPIDER_SQL_KIND_SQL) @@ -4175,7 +3560,6 @@ int ha_spider::read_multi_range_first_internal( conn_link_idx, roop_count, share->link_count, SPIDER_LINK_STATUS_RECOVERY) ) { -#ifndef WITHOUT_SPIDER_BG_SEARCH if (result_list.bgs_phase > 0) { if ((error_num = spider_check_and_init_casual_read( @@ -4208,7 +3592,6 @@ int ha_spider::read_multi_range_first_internal( ); } } else { -#endif ulong sql_type; conn = conns[roop_count]; if (sql_kind[roop_count] == SPIDER_SQL_KIND_SQL) @@ -4240,21 +3623,6 @@ int ha_spider::read_multi_range_first_internal( SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos); } DBUG_PRINT("info",("spider sql_type=%lu", sql_type)); -#ifdef HA_CAN_BULK_ACCESS - if (is_bulk_access_clone) - { - connection_ids[roop_count] = conn->connection_id; - spider_trx_add_bulk_access_conn(wide_handler->trx, conn); - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); -#ifdef HA_MRR_USE_DEFAULT_IMPL - *range_info = (char *) mrr_cur_range.ptr; -#else - *found_range_p = multi_range_curr; -#endif - DBUG_RETURN(0); - } else { -#endif conn->need_mon = &need_mons[roop_count]; DBUG_ASSERT(!conn->mta_conn_mutex_lock_already); DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later); @@ -4369,12 +3737,7 @@ int ha_spider::read_multi_range_first_internal( pthread_mutex_unlock(&conn->mta_conn_mutex); } } -#ifdef HA_CAN_BULK_ACCESS - } -#endif -#ifndef WITHOUT_SPIDER_BG_SEARCH } -#endif if (error_num) break; } @@ -4401,19 +3764,11 @@ int ha_spider::read_multi_range_first_internal( result_list.current = result_list.current->prev; } } else { -#ifdef HA_MRR_USE_DEFAULT_IMPL if (!range_info) DBUG_RETURN(0); if (!(error_num = spider_db_fetch(table->record[0], this, table))) -#else - if (!buf || !(error_num = spider_db_fetch(buf, this, table))) -#endif { -#ifdef HA_MRR_USE_DEFAULT_IMPL *range_info = (char *) mrr_cur_range.ptr; -#else - *found_range_p = multi_range_curr; -#endif DBUG_RETURN(check_ha_range_eof()); } if ( @@ -4444,21 +3799,17 @@ int ha_spider::read_multi_range_first_internal( set_where_to_pos_sql(SPIDER_SQL_TYPE_SELECT_SQL); set_where_to_pos_sql(SPIDER_SQL_TYPE_HANDLER); } -#ifdef HA_MRR_USE_DEFAULT_IMPL DBUG_PRINT("info",("spider range_res2=%d", range_res)); -#endif if (error_num) DBUG_RETURN(check_error_mode_eof(error_num)); } else { bool tmp_high_priority = wide_handler->high_priority; bool have_multi_range; -#ifdef HA_MRR_USE_DEFAULT_IMPL const uchar *first_mrr_start_key; const uchar *first_mrr_end_key; uint first_mrr_start_key_length; uint first_mrr_end_key_length; have_second_range = FALSE; -#endif if (wide_handler->keyread) result_list.keyread = TRUE; else @@ -4466,25 +3817,16 @@ int ha_spider::read_multi_range_first_internal( mrr_with_cnt = TRUE; multi_range_cnt = 0; multi_range_hit_point = 0; -#ifdef HA_MRR_USE_DEFAULT_IMPL if (multi_range_keys) { DBUG_PRINT("info",("spider free multi_range_keys=%p", multi_range_keys)); spider_free(spider_current_trx, multi_range_keys, MYF(0)); } -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000 if (!(multi_range_keys = (range_id_t *) spider_malloc(spider_current_trx, 1, sizeof(range_id_t) * (multi_range_num < result_list.multi_split_read ? multi_range_num : result_list.multi_split_read), MYF(MY_WME))) ) -#else - if (!(multi_range_keys = (char **) - spider_malloc(spider_current_trx, 1, sizeof(char *) * - (multi_range_num < result_list.multi_split_read ? - multi_range_num : result_list.multi_split_read), MYF(MY_WME))) - ) -#endif DBUG_RETURN(HA_ERR_OUT_OF_MEM); DBUG_PRINT("info",("spider alloc multi_range_keys=%p", multi_range_keys)); if (!mrr_key_buff) @@ -4496,11 +3838,7 @@ int ha_spider::read_multi_range_first_internal( for (roop_count = 0; roop_count < 2; roop_count++) mrr_key_buff[roop_count].init_calc_mem(235); } -#else - multi_range_ranges = ranges; -#endif error_num = 0; -#ifdef HA_MRR_USE_DEFAULT_IMPL if ((range_res = mrr_funcs.next(mrr_iter, &mrr_cur_range))) { DBUG_PRINT("info",("spider range_res3=%d", range_res)); @@ -4537,64 +3875,36 @@ int ha_spider::read_multi_range_first_internal( first_mrr_end_key_length); mrr_cur_range.end_key.key = (const uchar *) mrr_key_buff[1].ptr(); } -#else - multi_range_curr = ranges; - multi_range_end = ranges + range_count; -#endif result_list.tmp_table_join = FALSE; memset(result_list.tmp_table_join_first, 0, share->link_bitmap_size); do { -#ifdef HA_MRR_USE_DEFAULT_IMPL if ((range_res = mrr_funcs.next(mrr_iter, &mrr_second_range))) -#else - if (multi_range_curr + 1 >= multi_range_end) -#endif { -#ifdef HA_MRR_USE_DEFAULT_IMPL have_second_range = FALSE; -#endif have_multi_range = FALSE; } else { -#ifdef HA_MRR_USE_DEFAULT_IMPL have_second_range = TRUE; -#endif have_multi_range = TRUE; } -#ifdef HA_MRR_USE_DEFAULT_IMPL DBUG_PRINT("info",("spider range_res5=%d", range_res)); -#endif result_list.tmp_reuse_sql = FALSE; if (bka_mode && have_multi_range && -#ifdef HA_MRR_USE_DEFAULT_IMPL SPIDER_TEST(mrr_cur_range.range_flag & EQ_RANGE) -#else - SPIDER_TEST(multi_range_curr->range_flag & EQ_RANGE) -#endif ) { if ( result_list.tmp_table_join && -#ifdef HA_MRR_USE_DEFAULT_IMPL result_list.tmp_table_join_key_part_map == mrr_cur_range.start_key.keypart_map -#else - result_list.tmp_table_join_key_part_map == - multi_range_curr->start_key.keypart_map -#endif ) { /* reuse tmp_sql */ result_list.tmp_reuse_sql = TRUE; } else { /* create tmp_sql */ result_list.tmp_table_join = TRUE; -#ifdef HA_MRR_USE_DEFAULT_IMPL result_list.tmp_table_join_key_part_map = mrr_cur_range.start_key.keypart_map; -#else - result_list.tmp_table_join_key_part_map = - multi_range_curr->start_key.keypart_map; -#endif if ((error_num = reset_sql_sql( SPIDER_SQL_TYPE_SELECT_SQL | SPIDER_SQL_TYPE_TMP_SQL))) DBUG_RETURN(error_num); @@ -4639,11 +3949,7 @@ int ha_spider::read_multi_range_first_internal( if (!result_list.tmp_reuse_sql) { if ((error_num = append_union_table_and_sql_for_bka( -#ifdef HA_MRR_USE_DEFAULT_IMPL &mrr_cur_range.start_key -#else - &multi_range_curr->start_key -#endif ))) { DBUG_RETURN(error_num); } @@ -4657,11 +3963,7 @@ int ha_spider::read_multi_range_first_internal( if (!result_list.tmp_reuse_sql) { if ((error_num = append_tmp_table_and_sql_for_bka( -#ifdef HA_MRR_USE_DEFAULT_IMPL &mrr_cur_range.start_key -#else - &multi_range_curr->start_key -#endif ))) { DBUG_RETURN(error_num); } @@ -4673,38 +3975,18 @@ int ha_spider::read_multi_range_first_internal( } } -#ifdef HA_MRR_USE_DEFAULT_IMPL do -#else - for ( - ; - multi_range_curr < multi_range_end; - multi_range_curr++ - ) -#endif { if ( -#ifdef HA_MRR_USE_DEFAULT_IMPL !SPIDER_TEST(mrr_cur_range.range_flag & EQ_RANGE) || result_list.tmp_table_join_key_part_map != mrr_cur_range.start_key.keypart_map -#else - !SPIDER_TEST(multi_range_curr->range_flag & EQ_RANGE) || - result_list.tmp_table_join_key_part_map != - multi_range_curr->start_key.keypart_map -#endif ) { result_list.tmp_table_join_break_after_get_next = TRUE; break; } -#ifdef HA_MRR_USE_DEFAULT_IMPL -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000 multi_range_keys[multi_range_cnt] = mrr_cur_range.ptr; -#else - multi_range_keys[multi_range_cnt] = (char *) mrr_cur_range.ptr; -#endif -#endif if (bka_mode == 2) { if ((error_num = spider_db_append_select(this))) @@ -4715,11 +3997,7 @@ int ha_spider::read_multi_range_first_internal( SPIDER_SQL_TYPE_SELECT_SQL, multi_range_cnt))) DBUG_RETURN(error_num); if ((error_num = append_key_column_values_with_name_sql_part( -#ifdef HA_MRR_USE_DEFAULT_IMPL &mrr_cur_range.start_key, -#else - &multi_range_curr->start_key, -#endif SPIDER_SQL_TYPE_SELECT_SQL))) DBUG_RETURN(error_num); } else { @@ -4727,11 +4005,7 @@ int ha_spider::read_multi_range_first_internal( SPIDER_SQL_TYPE_SELECT_SQL, multi_range_cnt, TRUE))) DBUG_RETURN(error_num); if ((error_num = append_key_column_values_sql_part( -#ifdef HA_MRR_USE_DEFAULT_IMPL &mrr_cur_range.start_key, -#else - &multi_range_curr->start_key, -#endif SPIDER_SQL_TYPE_SELECT_SQL))) DBUG_RETURN(error_num); } @@ -4743,11 +4017,7 @@ int ha_spider::read_multi_range_first_internal( SPIDER_SQL_TYPE_TMP_SQL, multi_range_cnt, TRUE))) DBUG_RETURN(error_num); if ((error_num = append_key_column_values_sql_part( -#ifdef HA_MRR_USE_DEFAULT_IMPL &mrr_cur_range.start_key, -#else - &multi_range_curr->start_key, -#endif SPIDER_SQL_TYPE_TMP_SQL))) DBUG_RETURN(error_num); if ((error_num = @@ -4758,7 +4028,6 @@ int ha_spider::read_multi_range_first_internal( multi_range_cnt++; if (multi_range_cnt >= (uint) result_list.multi_split_read) break; -#ifdef HA_MRR_USE_DEFAULT_IMPL if (multi_range_cnt == 1) { if (have_multi_range) @@ -4774,11 +4043,8 @@ int ha_spider::read_multi_range_first_internal( range_res = mrr_funcs.next(mrr_iter, &mrr_cur_range); DBUG_PRINT("info",("spider range_res6=%d", range_res)); } -#endif } -#ifdef HA_MRR_USE_DEFAULT_IMPL while (!range_res); -#endif if (bka_mode == 2) { if ((error_num = append_union_table_terminator_sql_part( @@ -4814,24 +4080,10 @@ int ha_spider::read_multi_range_first_internal( ) DBUG_RETURN(error_num); -#ifdef HA_MRR_USE_DEFAULT_IMPL do -#else - for ( - ; - multi_range_curr < multi_range_end; - multi_range_curr++ - ) -#endif { -#ifdef HA_MRR_USE_DEFAULT_IMPL DBUG_PRINT("info",("spider range_res7=%d", range_res)); -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000 multi_range_keys[multi_range_cnt] = mrr_cur_range.ptr; -#else - multi_range_keys[multi_range_cnt] = (char *) mrr_cur_range.ptr; -#endif -#endif if ((error_num = spider_db_append_select(this))) DBUG_RETURN(error_num); if ((error_num = append_multi_range_cnt_sql_part( @@ -4854,17 +4106,10 @@ int ha_spider::read_multi_range_first_internal( result_list.internal_offset)); DBUG_PRINT("info",("spider limit_num=%lld", result_list.limit_num)); if ( -#ifdef HA_MRR_USE_DEFAULT_IMPL (error_num = spider_db_append_key_where( &mrr_cur_range.start_key, SPIDER_TEST(mrr_cur_range.range_flag & EQ_RANGE) ? NULL : &mrr_cur_range.end_key, this)) -#else - (error_num = spider_db_append_key_where( - &multi_range_curr->start_key, - SPIDER_TEST(multi_range_curr->range_flag & EQ_RANGE) ? - NULL : &multi_range_curr->end_key, this)) -#endif ) DBUG_RETURN(error_num); if (result_list.direct_order_limit) @@ -4896,7 +4141,6 @@ int ha_spider::read_multi_range_first_internal( multi_range_cnt++; if (multi_range_cnt >= (uint) result_list.multi_split_read) break; -#ifdef HA_MRR_USE_DEFAULT_IMPL if (multi_range_cnt == 1) { if (have_multi_range) @@ -4912,30 +4156,21 @@ int ha_spider::read_multi_range_first_internal( range_res = mrr_funcs.next(mrr_iter, &mrr_cur_range); DBUG_PRINT("info",("spider range_res8=%d", range_res)); } -#endif if (check_no_where_cond()) { -#ifdef HA_MRR_USE_DEFAULT_IMPL range_res = 1; -#else - multi_range_curr = multi_range_end; -#endif break; } } -#ifdef HA_MRR_USE_DEFAULT_IMPL while (!range_res); -#endif wide_handler->high_priority = tmp_high_priority; if ((error_num = append_union_all_end_sql_part( SPIDER_SQL_TYPE_SELECT_SQL))) DBUG_RETURN(error_num); result_list.use_union = TRUE; -#ifdef HANDLER_HAS_DIRECT_AGGREGATE bool direct_aggregate_backup = result_list.direct_aggregate; result_list.direct_aggregate = FALSE; -#endif if (result_list.direct_order_limit) { if ((error_num = @@ -4947,9 +4182,7 @@ int ha_spider::read_multi_range_first_internal( NULL, 0, SPIDER_SQL_TYPE_SELECT_SQL))) DBUG_RETURN(error_num); } -#ifdef HANDLER_HAS_DIRECT_AGGREGATE result_list.direct_aggregate = direct_aggregate_backup; -#endif if ((error_num = append_limit_sql_part( result_list.internal_offset, result_list.limit_num, @@ -4982,7 +4215,6 @@ int ha_spider::read_multi_range_first_internal( conn_link_idx, roop_count, share->link_count, SPIDER_LINK_STATUS_RECOVERY) ) { -#ifndef WITHOUT_SPIDER_BG_SEARCH if (result_list.bgs_phase > 0) { if ((error_num = spider_check_and_init_casual_read( @@ -5017,7 +4249,6 @@ int ha_spider::read_multi_range_first_internal( break; } } else { -#endif ulong sql_type; conn = conns[roop_count]; if (sql_kind[roop_count] == SPIDER_SQL_KIND_SQL) @@ -5050,21 +4281,6 @@ int ha_spider::read_multi_range_first_internal( } sql_type &= ~SPIDER_SQL_TYPE_TMP_SQL; DBUG_PRINT("info",("spider sql_type=%lu", sql_type)); -#ifdef HA_CAN_BULK_ACCESS - if (is_bulk_access_clone) - { - connection_ids[roop_count] = conn->connection_id; - spider_trx_add_bulk_access_conn(wide_handler->trx, conn); - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); -#ifdef HA_MRR_USE_DEFAULT_IMPL - *range_info = multi_range_keys[multi_range_hit_point]; -#else - *found_range_p = &multi_range_ranges[multi_range_hit_point]; -#endif - DBUG_RETURN(0); - } else { -#endif conn->need_mon = &need_mons[roop_count]; DBUG_ASSERT(!conn->mta_conn_mutex_lock_already); DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later); @@ -5222,12 +4438,7 @@ int ha_spider::read_multi_range_first_internal( SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); pthread_mutex_unlock(&conn->mta_conn_mutex); } -#ifdef HA_CAN_BULK_ACCESS - } -#endif -#ifndef WITHOUT_SPIDER_BG_SEARCH } -#endif } if (error_num) { @@ -5240,19 +4451,11 @@ int ha_spider::read_multi_range_first_internal( { if (multi_range_cnt >= (uint) result_list.multi_split_read) { -#ifdef HA_MRR_USE_DEFAULT_IMPL range_res = mrr_funcs.next(mrr_iter, &mrr_cur_range); DBUG_PRINT("info",("spider range_res9=%d", range_res)); -#else - multi_range_curr++; -#endif } if ( -#ifdef HA_MRR_USE_DEFAULT_IMPL range_res -#else - multi_range_curr == multi_range_end -#endif ) { table->status = STATUS_NOT_FOUND; DBUG_RETURN(error_num); @@ -5277,19 +4480,11 @@ int ha_spider::read_multi_range_first_internal( } else DBUG_RETURN(error_num); } else { -#ifdef HA_MRR_USE_DEFAULT_IMPL if (!range_info) DBUG_RETURN(0); if (!(error_num = spider_db_fetch(table->record[0], this, table))) -#else - if (!buf || !(error_num = spider_db_fetch(buf, this, table))) -#endif { -#ifdef HA_MRR_USE_DEFAULT_IMPL *range_info = multi_range_keys[multi_range_hit_point]; -#else - *found_range_p = &multi_range_ranges[multi_range_hit_point]; -#endif DBUG_RETURN(0); } if ( @@ -5301,19 +4496,11 @@ int ha_spider::read_multi_range_first_internal( { if (multi_range_cnt >= (uint) result_list.multi_split_read) { -#ifdef HA_MRR_USE_DEFAULT_IMPL range_res = mrr_funcs.next(mrr_iter, &mrr_cur_range); DBUG_PRINT("info",("spider range_res10=%d", range_res)); -#else - multi_range_curr++; -#endif } if ( -#ifdef HA_MRR_USE_DEFAULT_IMPL range_res -#else - multi_range_curr == multi_range_end -#endif ) { table->status = STATUS_NOT_FOUND; DBUG_RETURN(error_num); @@ -5346,16 +4533,11 @@ int ha_spider::read_multi_range_first_internal( if ((error_num = reset_sql_sql( SPIDER_SQL_TYPE_SELECT_SQL | SPIDER_SQL_TYPE_HANDLER))) DBUG_RETURN(error_num); -#ifdef HA_MRR_USE_DEFAULT_IMPL -#else - multi_range_ranges = multi_range_curr; -#endif } while (!error_num); } DBUG_RETURN(0); } -#ifdef HA_MRR_USE_DEFAULT_IMPL int ha_spider::pre_multi_range_read_next( bool use_parallel ) { @@ -5371,15 +4553,9 @@ int ha_spider::pre_multi_range_read_next( DBUG_RETURN(0); } -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000 int ha_spider::multi_range_read_next( range_id_t *range_info ) -#else -int ha_spider::multi_range_read_next( - char **range_info -) -#endif { int error_num; DBUG_ENTER("ha_spider::multi_range_read_next"); @@ -5406,82 +4582,16 @@ int ha_spider::multi_range_read_next( error_num = multi_range_read_next_next(range_info); DBUG_RETURN(error_num); } -#else -int ha_spider::pre_read_multi_range_first( - KEY_MULTI_RANGE **found_range_p, - KEY_MULTI_RANGE *ranges, - uint range_count, - bool sorted, - HANDLER_BUFFER *buffer, - bool use_parallel -) { - DBUG_ENTER("ha_spider::pre_read_multi_range_first"); - DBUG_PRINT("info",("spider this=%p", this)); - check_pre_call(use_parallel); - if (use_pre_call) - { - store_error_num = - read_multi_range_first_internal(NULL, found_range_p, ranges, - range_count, sorted, buffer); - DBUG_RETURN(store_error_num); - } - DBUG_RETURN(0); -} - -int ha_spider::read_multi_range_first( - KEY_MULTI_RANGE **found_range_p, - KEY_MULTI_RANGE *ranges, - uint range_count, - bool sorted, - HANDLER_BUFFER *buffer -) { - int error_num; - DBUG_ENTER("ha_spider::read_multi_range_first"); - DBUG_PRINT("info",("spider this=%p", this)); - if (use_pre_call) - { - if (store_error_num) - { - if (store_error_num == HA_ERR_END_OF_FILE) - table->status = STATUS_NOT_FOUND; - DBUG_RETURN(store_error_num); - } - if ((error_num = spider_bg_all_conn_pre_next(this, search_link_idx))) - DBUG_RETURN(error_num); - use_pre_call = FALSE; - DBUG_RETURN(read_multi_range_next(found_range_p)); - } - DBUG_RETURN(read_multi_range_first_internal(table->record[0], found_range_p, - ranges, range_count, sorted, buffer)); -} -#endif -#ifdef HA_MRR_USE_DEFAULT_IMPL -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000 int ha_spider::multi_range_read_next_next( range_id_t *range_info ) -#else -int ha_spider::multi_range_read_next_next( - char **range_info -) -#endif -#else -int ha_spider::read_multi_range_next( - KEY_MULTI_RANGE **found_range_p -) -#endif { int error_num, roop_count; SPIDER_CONN *conn; -#ifdef HA_MRR_USE_DEFAULT_IMPL int range_res; backup_error_status(); DBUG_ENTER("ha_spider::multi_range_read_next_next"); -#else - backup_error_status(); - DBUG_ENTER("ha_spider::read_multi_range_next"); -#endif DBUG_PRINT("info",("spider this=%p", this)); if (wide_handler->trx->thd->killed) { @@ -5495,29 +4605,19 @@ int ha_spider::read_multi_range_next( pt_clone_source_handler->pt_clone_last_searcher = this; } if ( -#ifdef HA_MRR_USE_DEFAULT_IMPL multi_range_num == 1 || -#endif result_list.multi_split_read <= 1 || (sql_kinds & SPIDER_SQL_KIND_HANDLER) ) { if (!(error_num = spider_db_seek_next(table->record[0], this, search_link_idx, table))) { -#ifdef HA_MRR_USE_DEFAULT_IMPL *range_info = (char *) mrr_cur_range.ptr; -#else - *found_range_p = multi_range_curr; -#endif DBUG_RETURN(0); } -#ifdef HA_MRR_USE_DEFAULT_IMPL range_res = mrr_funcs.next(mrr_iter, &mrr_cur_range); DBUG_PRINT("info",("spider range_res1=%d", range_res)); -#else - multi_range_curr++; -#endif if ( error_num != HA_ERR_END_OF_FILE && !check_error_mode(error_num) @@ -5525,19 +4625,13 @@ int ha_spider::read_multi_range_next( error_num = HA_ERR_END_OF_FILE; if ( error_num != HA_ERR_END_OF_FILE || -#ifdef HA_MRR_USE_DEFAULT_IMPL range_res -#else - multi_range_curr == multi_range_end -#endif ) DBUG_RETURN(error_num); spider_db_free_one_result_for_start_next(this); spider_first_split_read_param(this); -#ifndef WITHOUT_SPIDER_BG_SEARCH if ((error_num = spider_set_conn_bg_param(this))) DBUG_RETURN(error_num); -#endif DBUG_PRINT("info",("spider result_list.finish_flg = FALSE")); result_list.finish_flg = FALSE; if (result_list.current) @@ -5546,19 +4640,9 @@ int ha_spider::read_multi_range_next( result_list.current->finish_flg = FALSE; } result_list.record_num = 0; -#ifdef HA_MRR_USE_DEFAULT_IMPL do -#else - for ( - ; - multi_range_curr < multi_range_end; - multi_range_curr++ - ) -#endif { -#ifdef HA_MRR_USE_DEFAULT_IMPL DBUG_PRINT("info",("spider range_res2=%d", range_res)); -#endif if (check_no_where_cond()) { DBUG_RETURN(check_error_mode_eof(0)); @@ -5571,17 +4655,10 @@ int ha_spider::read_multi_range_next( result_list.split_read : result_list.internal_limit - result_list.record_num; if ( -#ifdef HA_MRR_USE_DEFAULT_IMPL (error_num = spider_db_append_key_where( &mrr_cur_range.start_key, SPIDER_TEST(mrr_cur_range.range_flag & EQ_RANGE) ? NULL : &mrr_cur_range.end_key, this)) -#else - (error_num = spider_db_append_key_where( - &multi_range_curr->start_key, - SPIDER_TEST(multi_range_curr->range_flag & EQ_RANGE) ? - NULL : &multi_range_curr->end_key, this)) -#endif ) DBUG_RETURN(error_num); if (sql_kinds & SPIDER_SQL_KIND_SQL) @@ -5644,7 +4721,6 @@ int ha_spider::read_multi_range_next( conn_link_idx, roop_count, share->link_count, SPIDER_LINK_STATUS_RECOVERY) ) { -#ifndef WITHOUT_SPIDER_BG_SEARCH if (result_list.bgs_phase > 0) { if ((error_num = spider_check_and_init_casual_read( @@ -5677,7 +4753,6 @@ int ha_spider::read_multi_range_next( ); } } else { -#endif ulong sql_type; conn = conns[roop_count]; if (sql_kind[roop_count] == SPIDER_SQL_KIND_SQL) @@ -5709,21 +4784,6 @@ int ha_spider::read_multi_range_next( SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos); } DBUG_PRINT("info",("spider sql_type=%lu", sql_type)); -#ifdef HA_CAN_BULK_ACCESS - if (is_bulk_access_clone) - { - connection_ids[roop_count] = conn->connection_id; - spider_trx_add_bulk_access_conn(wide_handler->trx, conn); - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); -#ifdef HA_MRR_USE_DEFAULT_IMPL - *range_info = multi_range_keys[multi_range_hit_point]; -#else - *found_range_p = &multi_range_ranges[multi_range_hit_point]; -#endif - DBUG_RETURN(0); - } else { -#endif conn->need_mon = &need_mons[roop_count]; DBUG_ASSERT(!conn->mta_conn_mutex_lock_already); DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later); @@ -5838,12 +4898,7 @@ int ha_spider::read_multi_range_next( pthread_mutex_unlock(&conn->mta_conn_mutex); } } -#ifdef HA_CAN_BULK_ACCESS - } -#endif -#ifndef WITHOUT_SPIDER_BG_SEARCH } -#endif if (error_num) break; } @@ -5873,11 +4928,7 @@ int ha_spider::read_multi_range_next( } else { if (!(error_num = spider_db_fetch(table->record[0], this, table))) { -#ifdef HA_MRR_USE_DEFAULT_IMPL *range_info = (char *) mrr_cur_range.ptr; -#else - *found_range_p = multi_range_curr; -#endif DBUG_RETURN(check_ha_range_eof()); } if ( @@ -5902,37 +4953,26 @@ int ha_spider::read_multi_range_next( } else DBUG_RETURN(error_num); } -#ifdef HA_MRR_USE_DEFAULT_IMPL range_res = mrr_funcs.next(mrr_iter, &mrr_cur_range); DBUG_PRINT("info",("spider range_res3=%d", range_res)); -#endif } -#ifdef HA_MRR_USE_DEFAULT_IMPL while (!range_res); -#endif if (error_num) DBUG_RETURN(check_error_mode_eof(error_num)); } else { if (!(error_num = spider_db_seek_next(table->record[0], this, search_link_idx, table))) { -#ifdef HA_MRR_USE_DEFAULT_IMPL *range_info = multi_range_keys[multi_range_hit_point]; -#else - *found_range_p = &multi_range_ranges[multi_range_hit_point]; -#endif DBUG_RETURN(0); } -#ifdef HA_MRR_USE_DEFAULT_IMPL const uchar *first_mrr_start_key; const uchar *first_mrr_end_key; uint first_mrr_start_key_length; uint first_mrr_end_key_length; -#endif if (!result_list.tmp_table_join_break_after_get_next) { -#ifdef HA_MRR_USE_DEFAULT_IMPL range_res = mrr_funcs.next(mrr_iter, &mrr_cur_range); DBUG_PRINT("info",("spider range_res4=%d", range_res)); if (!range_res) @@ -5960,15 +5000,9 @@ int ha_spider::read_multi_range_next( mrr_cur_range.end_key.key = (const uchar *) mrr_key_buff[1].ptr(); } } -#else - if (multi_range_curr < multi_range_end) - multi_range_curr++; -#endif } else { result_list.tmp_table_join_break_after_get_next = FALSE; -#ifdef HA_MRR_USE_DEFAULT_IMPL range_res = 0; -#endif } if ( @@ -5978,11 +5012,7 @@ int ha_spider::read_multi_range_next( error_num = HA_ERR_END_OF_FILE; if ( error_num != HA_ERR_END_OF_FILE || -#ifdef HA_MRR_USE_DEFAULT_IMPL range_res -#else - multi_range_curr == multi_range_end -#endif ) DBUG_RETURN(error_num); if (check_no_where_cond()) @@ -5991,10 +5021,8 @@ int ha_spider::read_multi_range_next( } spider_db_free_one_result_for_start_next(this); spider_first_split_read_param(this); -#ifndef WITHOUT_SPIDER_BG_SEARCH if ((error_num = spider_set_conn_bg_param(this))) DBUG_RETURN(error_num); -#endif DBUG_PRINT("info",("spider result_list.finish_flg = FALSE")); result_list.finish_flg = FALSE; if (result_list.current) @@ -6007,10 +5035,6 @@ int ha_spider::read_multi_range_next( if ((error_num = reset_sql_sql( SPIDER_SQL_TYPE_SELECT_SQL | SPIDER_SQL_TYPE_HANDLER))) DBUG_RETURN(error_num); -#ifdef HA_MRR_USE_DEFAULT_IMPL -#else - multi_range_ranges = multi_range_curr; -#endif bool tmp_high_priority = wide_handler->high_priority; bool have_multi_range; @@ -6018,59 +5042,35 @@ int ha_spider::read_multi_range_next( error_num = 0; do { -#ifdef HA_MRR_USE_DEFAULT_IMPL if ( !have_second_range && (range_res = mrr_funcs.next(mrr_iter, &mrr_second_range)) ) -#else - if (multi_range_curr + 1 >= multi_range_end) -#endif { -#ifdef HA_MRR_USE_DEFAULT_IMPL have_second_range = FALSE; -#endif have_multi_range = FALSE; } else { -#ifdef HA_MRR_USE_DEFAULT_IMPL have_second_range = TRUE; -#endif have_multi_range = TRUE; } -#ifdef HA_MRR_USE_DEFAULT_IMPL DBUG_PRINT("info",("spider range_res5=%d", range_res)); -#endif result_list.tmp_reuse_sql = FALSE; if (bka_mode && have_multi_range && -#ifdef HA_MRR_USE_DEFAULT_IMPL SPIDER_TEST(mrr_cur_range.range_flag & EQ_RANGE) -#else - SPIDER_TEST(multi_range_curr->range_flag & EQ_RANGE) -#endif ) { if ( result_list.tmp_table_join && -#ifdef HA_MRR_USE_DEFAULT_IMPL result_list.tmp_table_join_key_part_map == mrr_cur_range.start_key.keypart_map -#else - result_list.tmp_table_join_key_part_map == - multi_range_curr->start_key.keypart_map -#endif ) { /* reuse tmp_sql */ result_list.tmp_reuse_sql = TRUE; } else { /* create tmp_sql */ result_list.tmp_table_join = TRUE; -#ifdef HA_MRR_USE_DEFAULT_IMPL result_list.tmp_table_join_key_part_map = mrr_cur_range.start_key.keypart_map; -#else - result_list.tmp_table_join_key_part_map = - multi_range_curr->start_key.keypart_map; -#endif if ((error_num = reset_sql_sql( SPIDER_SQL_TYPE_SELECT_SQL | SPIDER_SQL_TYPE_TMP_SQL))) DBUG_RETURN(error_num); @@ -6116,11 +5116,7 @@ int ha_spider::read_multi_range_next( if (!result_list.tmp_reuse_sql) { if ((error_num = append_union_table_and_sql_for_bka( -#ifdef HA_MRR_USE_DEFAULT_IMPL &mrr_cur_range.start_key -#else - &multi_range_curr->start_key -#endif ))) { DBUG_RETURN(error_num); } @@ -6134,11 +5130,7 @@ int ha_spider::read_multi_range_next( if (!result_list.tmp_reuse_sql) { if ((error_num = append_tmp_table_and_sql_for_bka( -#ifdef HA_MRR_USE_DEFAULT_IMPL &mrr_cur_range.start_key -#else - &multi_range_curr->start_key -#endif ))) { DBUG_RETURN(error_num); } @@ -6150,38 +5142,18 @@ int ha_spider::read_multi_range_next( } } -#ifdef HA_MRR_USE_DEFAULT_IMPL do -#else - for ( - ; - multi_range_curr < multi_range_end; - multi_range_curr++ - ) -#endif { if ( -#ifdef HA_MRR_USE_DEFAULT_IMPL !SPIDER_TEST(mrr_cur_range.range_flag & EQ_RANGE) || result_list.tmp_table_join_key_part_map != mrr_cur_range.start_key.keypart_map -#else - !SPIDER_TEST(multi_range_curr->range_flag & EQ_RANGE) || - result_list.tmp_table_join_key_part_map != - multi_range_curr->start_key.keypart_map -#endif ) { result_list.tmp_table_join_break_after_get_next = TRUE; break; } -#ifdef HA_MRR_USE_DEFAULT_IMPL -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000 multi_range_keys[multi_range_cnt] = mrr_cur_range.ptr; -#else - multi_range_keys[multi_range_cnt] = (char *) mrr_cur_range.ptr; -#endif -#endif if (bka_mode == 2) { if ((error_num = spider_db_append_select(this))) @@ -6192,11 +5164,7 @@ int ha_spider::read_multi_range_next( SPIDER_SQL_TYPE_SELECT_SQL, multi_range_cnt))) DBUG_RETURN(error_num); if ((error_num = append_key_column_values_with_name_sql_part( -#ifdef HA_MRR_USE_DEFAULT_IMPL &mrr_cur_range.start_key, -#else - &multi_range_curr->start_key, -#endif SPIDER_SQL_TYPE_SELECT_SQL))) DBUG_RETURN(error_num); } else { @@ -6204,11 +5172,7 @@ int ha_spider::read_multi_range_next( SPIDER_SQL_TYPE_SELECT_SQL, multi_range_cnt, TRUE))) DBUG_RETURN(error_num); if ((error_num = append_key_column_values_sql_part( -#ifdef HA_MRR_USE_DEFAULT_IMPL &mrr_cur_range.start_key, -#else - &multi_range_curr->start_key, -#endif SPIDER_SQL_TYPE_SELECT_SQL))) DBUG_RETURN(error_num); } @@ -6220,11 +5184,7 @@ int ha_spider::read_multi_range_next( SPIDER_SQL_TYPE_TMP_SQL, multi_range_cnt, TRUE))) DBUG_RETURN(error_num); if ((error_num = append_key_column_values_sql_part( -#ifdef HA_MRR_USE_DEFAULT_IMPL &mrr_cur_range.start_key, -#else - &multi_range_curr->start_key, -#endif SPIDER_SQL_TYPE_TMP_SQL))) DBUG_RETURN(error_num); @@ -6235,7 +5195,6 @@ int ha_spider::read_multi_range_next( multi_range_cnt++; if (multi_range_cnt >= (uint) result_list.multi_split_read) break; -#ifdef HA_MRR_USE_DEFAULT_IMPL if (multi_range_cnt == 1) { if (have_multi_range) @@ -6251,11 +5210,8 @@ int ha_spider::read_multi_range_next( range_res = mrr_funcs.next(mrr_iter, &mrr_cur_range); DBUG_PRINT("info",("spider range_res6=%d", range_res)); } -#endif } -#ifdef HA_MRR_USE_DEFAULT_IMPL while (!range_res); -#endif if (bka_mode == 2) { if ((error_num = append_union_table_terminator_sql_part( @@ -6290,23 +5246,9 @@ int ha_spider::read_multi_range_next( append_union_all_start_sql_part(SPIDER_SQL_TYPE_SELECT_SQL)) ) DBUG_RETURN(error_num); -#ifdef HA_MRR_USE_DEFAULT_IMPL do -#else - for ( - ; - multi_range_curr < multi_range_end; - multi_range_curr++ - ) -#endif { -#ifdef HA_MRR_USE_DEFAULT_IMPL -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000 multi_range_keys[multi_range_cnt] = mrr_cur_range.ptr; -#else - multi_range_keys[multi_range_cnt] = (char *) mrr_cur_range.ptr; -#endif -#endif if ((error_num = spider_db_append_select(this))) DBUG_RETURN(error_num); if ((error_num = append_multi_range_cnt_sql_part( @@ -6326,17 +5268,10 @@ int ha_spider::read_multi_range_next( DBUG_RETURN(error_num); set_where_pos_sql(SPIDER_SQL_TYPE_SELECT_SQL); if ( -#ifdef HA_MRR_USE_DEFAULT_IMPL (error_num = spider_db_append_key_where( &mrr_cur_range.start_key, SPIDER_TEST(mrr_cur_range.range_flag & EQ_RANGE) ? NULL : &mrr_cur_range.end_key, this)) -#else - (error_num = spider_db_append_key_where( - &multi_range_curr->start_key, - SPIDER_TEST(multi_range_curr->range_flag & EQ_RANGE) ? - NULL : &multi_range_curr->end_key, this)) -#endif ) DBUG_RETURN(error_num); if (result_list.direct_order_limit) @@ -6366,7 +5301,6 @@ int ha_spider::read_multi_range_next( multi_range_cnt++; if (multi_range_cnt >= (uint) result_list.multi_split_read) break; -#ifdef HA_MRR_USE_DEFAULT_IMPL if (multi_range_cnt == 1) { if (have_multi_range) @@ -6382,21 +5316,16 @@ int ha_spider::read_multi_range_next( range_res = mrr_funcs.next(mrr_iter, &mrr_cur_range); DBUG_PRINT("info",("spider range_res7=%d", range_res)); } -#endif } -#ifdef HA_MRR_USE_DEFAULT_IMPL while (!range_res); -#endif wide_handler->high_priority = tmp_high_priority; if ((error_num = append_union_all_end_sql_part(SPIDER_SQL_TYPE_SELECT_SQL))) DBUG_RETURN(error_num); result_list.use_union = TRUE; -#ifdef HANDLER_HAS_DIRECT_AGGREGATE bool direct_aggregate_backup = result_list.direct_aggregate; result_list.direct_aggregate = FALSE; -#endif if (result_list.direct_order_limit) { if ((error_num = @@ -6408,9 +5337,7 @@ int ha_spider::read_multi_range_next( NULL, 0, SPIDER_SQL_TYPE_SELECT_SQL))) DBUG_RETURN(error_num); } -#ifdef HANDLER_HAS_DIRECT_AGGREGATE result_list.direct_aggregate = direct_aggregate_backup; -#endif if ((error_num = append_limit_sql_part( result_list.internal_offset, result_list.limit_num, @@ -6442,7 +5369,6 @@ int ha_spider::read_multi_range_next( conn_link_idx, roop_count, share->link_count, SPIDER_LINK_STATUS_RECOVERY) ) { -#ifndef WITHOUT_SPIDER_BG_SEARCH if (result_list.bgs_phase > 0) { if ((error_num = spider_check_and_init_casual_read( @@ -6477,7 +5403,6 @@ int ha_spider::read_multi_range_next( break; } } else { -#endif ulong sql_type; conn = conns[roop_count]; if (sql_kind[roop_count] == SPIDER_SQL_KIND_SQL) @@ -6510,21 +5435,6 @@ int ha_spider::read_multi_range_next( } sql_type &= ~SPIDER_SQL_TYPE_TMP_SQL; DBUG_PRINT("info",("spider sql_type=%lu", sql_type)); -#ifdef HA_CAN_BULK_ACCESS - if (is_bulk_access_clone) - { - connection_ids[roop_count] = conn->connection_id; - spider_trx_add_bulk_access_conn(wide_handler->trx, conn); - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); -#ifdef HA_MRR_USE_DEFAULT_IMPL - *range_info = multi_range_keys[multi_range_hit_point]; -#else - *found_range_p = &multi_range_ranges[multi_range_hit_point]; -#endif - DBUG_RETURN(0); - } else { -#endif conn->need_mon = &need_mons[roop_count]; DBUG_ASSERT(!conn->mta_conn_mutex_lock_already); DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later); @@ -6682,12 +5592,7 @@ int ha_spider::read_multi_range_next( SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); pthread_mutex_unlock(&conn->mta_conn_mutex); } -#ifdef HA_CAN_BULK_ACCESS - } -#endif -#ifndef WITHOUT_SPIDER_BG_SEARCH } -#endif } if (error_num) { @@ -6700,19 +5605,11 @@ int ha_spider::read_multi_range_next( { if (multi_range_cnt >= (uint) result_list.multi_split_read) { -#ifdef HA_MRR_USE_DEFAULT_IMPL range_res = mrr_funcs.next(mrr_iter, &mrr_cur_range); DBUG_PRINT("info",("spider range_res8=%d", range_res)); -#else - multi_range_curr++; -#endif } if ( -#ifdef HA_MRR_USE_DEFAULT_IMPL range_res -#else - multi_range_curr == multi_range_end -#endif ) { table->status = STATUS_NOT_FOUND; DBUG_RETURN(error_num); @@ -6739,11 +5636,7 @@ int ha_spider::read_multi_range_next( } else { if (!(error_num = spider_db_fetch(table->record[0], this, table))) { -#ifdef HA_MRR_USE_DEFAULT_IMPL *range_info = multi_range_keys[multi_range_hit_point]; -#else - *found_range_p = &multi_range_ranges[multi_range_hit_point]; -#endif DBUG_RETURN(0); } if ( @@ -6755,19 +5648,11 @@ int ha_spider::read_multi_range_next( { if (multi_range_cnt >= (uint) result_list.multi_split_read) { -#ifdef HA_MRR_USE_DEFAULT_IMPL range_res = mrr_funcs.next(mrr_iter, &mrr_cur_range); DBUG_PRINT("info",("spider range_res9=%d", range_res)); -#else - multi_range_curr++; -#endif } if ( -#ifdef HA_MRR_USE_DEFAULT_IMPL range_res -#else - multi_range_curr == multi_range_end -#endif ) { table->status = STATUS_NOT_FOUND; DBUG_RETURN(error_num); @@ -6800,10 +5685,6 @@ int ha_spider::read_multi_range_next( if ((error_num = reset_sql_sql( SPIDER_SQL_TYPE_SELECT_SQL | SPIDER_SQL_TYPE_HANDLER))) DBUG_RETURN(error_num); -#ifdef HA_MRR_USE_DEFAULT_IMPL -#else - multi_range_ranges = multi_range_curr; -#endif } while (!error_num); } DBUG_RETURN(0); @@ -6867,10 +5748,8 @@ int ha_spider::rnd_init( conn_link_idx, roop_count, share->link_count, SPIDER_LINK_STATUS_RECOVERY) ) { -#ifndef WITHOUT_SPIDER_BG_SEARCH if (conns[roop_count] && result_list.bgs_working) spider_bg_conn_break(conns[roop_count], this); -#endif if (quick_targets[roop_count]) { spider_db_free_one_quick_result( @@ -6887,9 +5766,7 @@ int ha_spider::rnd_init( DBUG_PRINT("info",("spider result_list.finish_flg = FALSE")); result_list.finish_flg = FALSE; result_list.quick_phase = 0; -#ifndef WITHOUT_SPIDER_BG_SEARCH result_list.bgs_phase = 0; -#endif } mrr_with_cnt = FALSE; @@ -6921,15 +5798,6 @@ int ha_spider::rnd_init( DBUG_RETURN(0); } -#ifdef HA_CAN_BULK_ACCESS -int ha_spider::pre_rnd_init( - bool scan -) { - DBUG_ENTER("ha_spider::pre_rnd_init"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(bulk_access_link_current->spider->ha_rnd_init(scan)); -} -#endif int ha_spider::rnd_end() { @@ -6953,14 +5821,6 @@ int ha_spider::rnd_end() DBUG_RETURN(0); } -#ifdef HA_CAN_BULK_ACCESS -int ha_spider::pre_rnd_end() -{ - DBUG_ENTER("ha_spider::pre_rnd_end"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(bulk_access_link_current->spider->ha_rnd_end()); -} -#endif int ha_spider::rnd_next_internal( uchar *buf @@ -6979,22 +5839,16 @@ int ha_spider::rnd_next_internal( /* do not copy table data at alter table */ if (wide_handler->sql_command == SQLCOM_ALTER_TABLE) DBUG_RETURN(HA_ERR_END_OF_FILE); -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS do_direct_update = FALSE; -#endif if (rnd_scan_and_first) { -#ifndef WITHOUT_SPIDER_BG_SEARCH if ((error_num = spider_set_conn_bg_param(this))) DBUG_RETURN(error_num); -#endif if ((error_num = rnd_handler_init())) DBUG_RETURN(check_error_mode_eof(error_num)); check_direct_order_limit(); -#ifdef WITH_PARTITION_STORAGE_ENGINE check_select_column(TRUE); -#endif if (this->result_list.direct_limit_offset) { @@ -7053,14 +5907,12 @@ int ha_spider::rnd_next_internal( NULL, 0, SPIDER_SQL_TYPE_SELECT_SQL))) DBUG_RETURN(error_num); } -#ifdef HANDLER_HAS_DIRECT_AGGREGATE else if (result_list.direct_aggregate) { if ((error_num = append_group_by_sql_part(NULL, 0, SPIDER_SQL_TYPE_SELECT_SQL))) DBUG_RETURN(error_num); } -#endif result_list.desc_flg = FALSE; result_list.sorted = FALSE; result_list.key_info = NULL; @@ -7116,7 +5968,6 @@ int ha_spider::rnd_next_internal( conn_link_idx, roop_count, share->link_count, SPIDER_LINK_STATUS_RECOVERY) ) { -#ifndef WITHOUT_SPIDER_BG_SEARCH if (result_list.bgs_phase > 0) { if ((error_num = spider_check_and_init_casual_read( @@ -7151,7 +6002,6 @@ int ha_spider::rnd_next_internal( DBUG_RETURN(check_error_mode_eof(error_num)); } } else { -#endif SPIDER_CONN *conn = conns[roop_count]; ulong sql_type; if (sql_kind[roop_count] == SPIDER_SQL_KIND_SQL) @@ -7295,9 +6145,7 @@ int ha_spider::rnd_next_internal( SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); pthread_mutex_unlock(&conn->mta_conn_mutex); } -#ifndef WITHOUT_SPIDER_BG_SEARCH } -#endif } rnd_scan_and_first = FALSE; @@ -7645,13 +6493,9 @@ int ha_spider::ft_read_internal( ft_init_and_first = FALSE; spider_db_free_one_result_for_start_next(this); check_direct_order_limit(); -#ifndef WITHOUT_SPIDER_BG_SEARCH if ((error_num = spider_set_conn_bg_param(this))) DBUG_RETURN(error_num); -#endif -#ifdef WITH_PARTITION_STORAGE_ENGINE check_select_column(FALSE); -#endif DBUG_PRINT("info",("spider result_list.finish_flg = FALSE")); result_list.finish_flg = FALSE; result_list.record_num = 0; @@ -7696,14 +6540,12 @@ int ha_spider::ft_read_internal( SPIDER_SQL_TYPE_SELECT_SQL))) DBUG_RETURN(error_num); } -#ifdef HANDLER_HAS_DIRECT_AGGREGATE else if (result_list.direct_aggregate) { if ((error_num = append_group_by_sql_part(NULL, 0, SPIDER_SQL_TYPE_SELECT_SQL))) DBUG_RETURN(error_num); } -#endif if (sql_kinds & SPIDER_SQL_KIND_SQL) { if ((error_num = append_limit_sql_part( @@ -7753,7 +6595,6 @@ int ha_spider::ft_read_internal( conn_link_idx, roop_count, share->link_count, SPIDER_LINK_STATUS_RECOVERY) ) { -#ifndef WITHOUT_SPIDER_BG_SEARCH if (result_list.bgs_phase > 0) { if ((error_num = spider_check_and_init_casual_read( @@ -7788,7 +6629,6 @@ int ha_spider::ft_read_internal( DBUG_RETURN(check_error_mode_eof(error_num)); } } else { -#endif uint dbton_id = share->use_sql_dbton_ids[roop_count]; spider_db_handler *dbton_hdl = dbton_handler[dbton_id]; SPIDER_CONN *conn = conns[roop_count]; @@ -7927,9 +6767,7 @@ int ha_spider::ft_read_internal( SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); pthread_mutex_unlock(&conn->mta_conn_mutex); } -#ifndef WITHOUT_SPIDER_BG_SEARCH } -#endif } } @@ -7988,12 +6826,8 @@ int ha_spider::info( THD *thd = ha_thd(); double sts_interval = spider_param_sts_interval(thd, share->sts_interval); int sts_mode = spider_param_sts_mode(thd, share->sts_mode); -#ifdef WITH_PARTITION_STORAGE_ENGINE int sts_sync = spider_param_sts_sync(thd, share->sts_sync); -#endif -#ifndef WITHOUT_SPIDER_BG_SEARCH int sts_bg_mode = spider_param_sts_bg_mode(thd, share->sts_bg_mode); -#endif SPIDER_INIT_ERROR_TABLE *spider_init_error_table = NULL; set_error_mode(); backup_error_status(); @@ -8045,9 +6879,7 @@ int ha_spider::info( { tmp_auto_increment_mode = spider_param_auto_increment_mode(thd, share->auto_increment_mode); -#ifdef HANDLER_HAS_NEED_INFO_FOR_AUTO_INC info_auto_called = TRUE; -#endif } if (!share->sts_init) { @@ -8083,10 +6915,8 @@ int ha_spider::info( } pthread_mutex_unlock(&share->sts_mutex); sts_interval = 0; -#ifdef WITH_PARTITION_STORAGE_ENGINE if (tmp_auto_increment_mode == 1) sts_sync = 0; -#endif } } if (flag & HA_STATUS_AUTO) @@ -8097,9 +6927,7 @@ int ha_spider::info( !share->lgtm_tblhnd_share->auto_increment_init ) { sts_interval = 0; -#ifdef WITH_PARTITION_STORAGE_ENGINE sts_sync = 0; -#endif } } if (difftime(tmp_time, share->sts_get_time) >= sts_interval) @@ -8108,10 +6936,8 @@ int ha_spider::info( sts_interval == 0 || !pthread_mutex_trylock(&share->sts_mutex) ) { -#ifndef WITHOUT_SPIDER_BG_SEARCH if (sts_interval == 0 || sts_bg_mode == 0) { -#endif if (sts_interval == 0) pthread_mutex_lock(&share->sts_mutex); if (difftime(tmp_time, share->sts_get_time) >= sts_interval) @@ -8153,9 +6979,7 @@ int ha_spider::info( } if ((error_num = spider_get_sts(share, search_link_idx, tmp_time, this, sts_interval, sts_mode, -#ifdef WITH_PARTITION_STORAGE_ENGINE sts_sync, -#endif share->sts_init ? 2 : 1, flag | (share->sts_init ? 0 : HA_STATUS_AUTO))) ) { @@ -8217,7 +7041,6 @@ int ha_spider::info( DBUG_RETURN(check_error_mode(error_num)); } } -#ifndef WITHOUT_SPIDER_BG_SEARCH } else if (sts_bg_mode == 1) { /* background */ if (!share->bg_sts_init || share->bg_sts_thd_wait) @@ -8226,9 +7049,7 @@ int ha_spider::info( share->bg_sts_try_time = tmp_time; share->bg_sts_interval = sts_interval; share->bg_sts_mode = sts_mode; -#ifdef WITH_PARTITION_STORAGE_ENGINE share->bg_sts_sync = sts_sync; -#endif if (!share->bg_sts_init) { if ((error_num = spider_create_sts_thread(share))) @@ -8253,12 +7074,9 @@ int ha_spider::info( share->bg_sts_try_time = tmp_time; share->bg_sts_interval = sts_interval; share->bg_sts_mode = sts_mode; -#ifdef WITH_PARTITION_STORAGE_ENGINE share->bg_sts_sync = sts_sync; -#endif spider_table_add_share_to_sts_thread(share); } -#endif pthread_mutex_unlock(&share->sts_mutex); } } @@ -8364,12 +7182,8 @@ ha_rows ha_spider::records_in_range( double crd_interval = spider_param_crd_interval(thd, share->crd_interval); int crd_mode = spider_param_crd_mode(thd, share->crd_mode); int crd_type = spider_param_crd_type(thd, share->crd_type); -#ifdef WITH_PARTITION_STORAGE_ENGINE int crd_sync = spider_param_crd_sync(thd, share->crd_sync); -#endif -#ifndef WITHOUT_SPIDER_BG_SEARCH int crd_bg_mode = spider_param_crd_bg_mode(thd, share->crd_bg_mode); -#endif SPIDER_INIT_ERROR_TABLE *spider_init_error_table = NULL; uint dbton_id; spider_db_handler *dbton_hdl; @@ -8435,19 +7249,15 @@ ha_rows ha_spider::records_in_range( crd_interval == 0 || !pthread_mutex_trylock(&share->crd_mutex) ) { -#ifndef WITHOUT_SPIDER_BG_SEARCH if (crd_interval == 0 || crd_bg_mode == 0) { -#endif if (crd_interval == 0) pthread_mutex_lock(&share->crd_mutex); if (difftime(tmp_time, share->crd_get_time) >= crd_interval) { if ((error_num = spider_get_crd(share, search_link_idx, tmp_time, this, table, crd_interval, crd_mode, -#ifdef WITH_PARTITION_STORAGE_ENGINE crd_sync, -#endif share->crd_init ? 2 : 1))) { pthread_mutex_unlock(&share->crd_mutex); @@ -8500,7 +7310,6 @@ ha_rows ha_spider::records_in_range( DBUG_RETURN(HA_POS_ERROR); } } -#ifndef WITHOUT_SPIDER_BG_SEARCH } else if (crd_bg_mode == 1) { /* background */ if (!share->bg_crd_init || share->bg_crd_thd_wait) @@ -8509,9 +7318,7 @@ ha_rows ha_spider::records_in_range( share->bg_crd_try_time = tmp_time; share->bg_crd_interval = crd_interval; share->bg_crd_mode = crd_mode; -#ifdef WITH_PARTITION_STORAGE_ENGINE share->bg_crd_sync = crd_sync; -#endif if (!share->bg_crd_init) { if ((error_num = spider_create_crd_thread(share))) @@ -8527,12 +7334,9 @@ ha_rows ha_spider::records_in_range( share->bg_crd_try_time = tmp_time; share->bg_crd_interval = crd_interval; share->bg_crd_mode = crd_mode; -#ifdef WITH_PARTITION_STORAGE_ENGINE share->bg_crd_sync = crd_sync; -#endif spider_table_add_share_to_crd_thread(share); } -#endif pthread_mutex_unlock(&share->crd_mutex); } } @@ -8688,12 +7492,8 @@ int ha_spider::check_crd() THD *thd = ha_thd(); double crd_interval = spider_param_crd_interval(thd, share->crd_interval); int crd_mode = spider_param_crd_mode(thd, share->crd_mode); -#ifdef WITH_PARTITION_STORAGE_ENGINE int crd_sync = spider_param_crd_sync(thd, share->crd_sync); -#endif -#ifndef WITHOUT_SPIDER_BG_SEARCH int crd_bg_mode = spider_param_crd_bg_mode(thd, share->crd_bg_mode); -#endif SPIDER_INIT_ERROR_TABLE *spider_init_error_table = NULL; uint dbton_id; spider_db_handler *dbton_hdl; @@ -8745,19 +7545,15 @@ int ha_spider::check_crd() crd_interval == 0 || !pthread_mutex_trylock(&share->crd_mutex) ) { -#ifndef WITHOUT_SPIDER_BG_SEARCH if (crd_interval == 0 || crd_bg_mode == 0) { -#endif if (crd_interval == 0) pthread_mutex_lock(&share->crd_mutex); if (difftime(tmp_time, share->crd_get_time) >= crd_interval) { if ((error_num = spider_get_crd(share, search_link_idx, tmp_time, this, table, crd_interval, crd_mode, -#ifdef WITH_PARTITION_STORAGE_ENGINE crd_sync, -#endif share->crd_init ? 2 : 1))) { pthread_mutex_unlock(&share->crd_mutex); @@ -8803,7 +7599,6 @@ int ha_spider::check_crd() DBUG_RETURN(check_error_mode(error_num)); } } -#ifndef WITHOUT_SPIDER_BG_SEARCH } else if (crd_bg_mode == 1) { /* background */ if (!share->bg_crd_init || share->bg_crd_thd_wait) @@ -8812,9 +7607,7 @@ int ha_spider::check_crd() share->bg_crd_try_time = tmp_time; share->bg_crd_interval = crd_interval; share->bg_crd_mode = crd_mode; -#ifdef WITH_PARTITION_STORAGE_ENGINE share->bg_crd_sync = crd_sync; -#endif if (!share->bg_crd_init) { if ((error_num = spider_create_crd_thread(share))) @@ -8829,12 +7622,9 @@ int ha_spider::check_crd() share->bg_crd_try_time = tmp_time; share->bg_crd_interval = crd_interval; share->bg_crd_mode = crd_mode; -#ifdef WITH_PARTITION_STORAGE_ENGINE share->bg_crd_sync = crd_sync; -#endif spider_table_add_share_to_crd_thread(share); } -#endif pthread_mutex_unlock(&share->crd_mutex); } } @@ -8910,7 +7700,6 @@ ha_rows ha_spider::records() DBUG_RETURN(table_rows); } -#ifdef HA_HAS_CHECKSUM_EXTENDED int ha_spider::pre_calculate_checksum() { int error_num; @@ -8988,7 +7777,6 @@ int ha_spider::calculate_checksum() } DBUG_RETURN(0); } -#endif const char *ha_spider::table_type() const { @@ -9147,7 +7935,6 @@ uint8 ha_spider::table_cache_type() DBUG_RETURN(HA_CACHE_TBL_NOCACHE); } -#ifdef HANDLER_HAS_NEED_INFO_FOR_AUTO_INC bool ha_spider::need_info_for_auto_inc() { THD *thd = ha_thd(); @@ -9168,7 +7955,6 @@ bool ha_spider::need_info_for_auto_inc() ) )); } -#endif #ifdef HANDLER_HAS_CAN_USE_FOR_AUTO_INC_INIT bool ha_spider::can_use_for_auto_inc_init() @@ -9342,16 +8128,10 @@ void ha_spider::release_auto_increment() DBUG_VOID_RETURN; } -#ifdef SPIDER_HANDLER_START_BULK_INSERT_HAS_FLAGS void ha_spider::start_bulk_insert( ha_rows rows, uint flags ) -#else -void ha_spider::start_bulk_insert( - ha_rows rows -) -#endif { DBUG_ENTER("ha_spider::start_bulk_insert"); DBUG_PRINT("info",("spider this=%p", this)); @@ -9394,39 +8174,6 @@ int ha_spider::write_row( table_share->db.str, table_share->table_name.str); DBUG_RETURN(ER_SPIDER_READ_ONLY_NUM); } -#ifdef HA_CAN_BULK_ACCESS - if ( - bulk_access_executing && - ( - ( - !is_bulk_access_clone && - bulk_access_link_exec_tgt->called - ) || - bulk_access_pre_called - ) - ) { - ulonglong option_backup = 0; - if (is_bulk_access_clone) - { - bulk_access_pre_called = FALSE; - DBUG_RETURN(spider_db_bulk_bulk_insert(this)); - } -#if MYSQL_VERSION_ID < 50500 - option_backup = thd->options; - thd->options &= ~OPTION_BIN_LOG; -#else - option_backup = thd->variables.option_bits; - thd->variables.option_bits &= ~OPTION_BIN_LOG; -#endif - error_num = bulk_access_link_exec_tgt->spider->ha_write_row(buf); -#if MYSQL_VERSION_ID < 50500 - thd->options = option_backup; -#else - thd->variables.option_bits = option_backup; -#endif - DBUG_RETURN(error_num); - } -#endif if (!dml_inited) { if (unlikely((error_num = dml_init()))) @@ -9437,11 +8184,6 @@ int ha_spider::write_row( #ifndef SPIDER_WITHOUT_HA_STATISTIC_INCREMENT ha_statistic_increment(&SSV::ha_write_count); #endif -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000 -#else - if (table->timestamp_field_type & TIMESTAMP_AUTO_SET_ON_INSERT) - table->timestamp_field->set_time(); -#endif if (!bulk_insert) store_last_insert_id = 0; if (auto_increment_flag) @@ -9503,12 +8245,8 @@ int ha_spider::write_row( DBUG_RETURN(check_error_mode(error_num)); if (bulk_insert) bulk_size = -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS (wide_handler->insert_with_update && !result_list.insert_dup_update_pushdown) || -#else - wide_handler->insert_with_update || -#endif (!direct_dup_insert && wide_handler->ignore_dup_key) ? 0 : spider_param_bulk_size(wide_handler->trx->thd, share->bulk_size); else @@ -9517,46 +8255,10 @@ int ha_spider::write_row( if ((error_num = spider_db_bulk_insert(this, table, ©_info, FALSE))) DBUG_RETURN(check_error_mode(error_num)); -#ifdef HA_CAN_BULK_ACCESS - /* bulk access disabled case (like using partitioning) */ - if (bulk_access_executing && is_bulk_access_clone) - { - bulk_req_exec(); - DBUG_RETURN(spider_db_bulk_bulk_insert(this)); - } -#endif DBUG_RETURN(0); } -#ifdef HA_CAN_BULK_ACCESS -int ha_spider::pre_write_row( - uchar *buf -) { - int error_num; - ulonglong option_backup = 0; - THD *thd = wide_handler->trx->thd; - DBUG_ENTER("ha_spider::pre_write_row"); - DBUG_PRINT("info",("spider this=%p", this)); -#if MYSQL_VERSION_ID < 50500 - option_backup = thd->options; - thd->options &= ~OPTION_BIN_LOG; -#else - option_backup = thd->variables.option_bits; - thd->variables.option_bits &= ~OPTION_BIN_LOG; -#endif - error_num = bulk_access_link_current->spider->ha_write_row(buf); - bulk_access_link_current->spider->bulk_access_pre_called = TRUE; - bulk_access_link_current->called = TRUE; -#if MYSQL_VERSION_ID < 50500 - thd->options = option_backup; -#else - thd->variables.option_bits = option_backup; -#endif - DBUG_RETURN(error_num); -} -#endif -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS void ha_spider::direct_update_init( THD *thd, bool hs_request @@ -9566,7 +8268,6 @@ void ha_spider::direct_update_init( do_direct_update = TRUE; DBUG_VOID_RETURN; } -#endif bool ha_spider::start_bulk_update( ) { @@ -9645,40 +8346,10 @@ int ha_spider::update_row( table_share->db.str, table_share->table_name.str); DBUG_RETURN(ER_SPIDER_READ_ONLY_NUM); } -#ifdef HA_CAN_BULK_ACCESS - if ( - bulk_access_executing && !is_bulk_access_clone && - bulk_access_link_exec_tgt->called - ) { - ulonglong option_backup = 0; -#if MYSQL_VERSION_ID < 50500 - option_backup = thd->options; - thd->options &= ~OPTION_BIN_LOG; -#else - option_backup = thd->variables.option_bits; - thd->variables.option_bits &= ~OPTION_BIN_LOG; -#endif - error_num = bulk_access_link_exec_tgt->spider->ha_update_row( - old_data, new_data); -#if MYSQL_VERSION_ID < 50500 - thd->options = option_backup; -#else - thd->variables.option_bits = option_backup; -#endif - DBUG_RETURN(error_num); - } -#endif #ifndef SPIDER_WITHOUT_HA_STATISTIC_INCREMENT ha_statistic_increment(&SSV::ha_update_count); #endif -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS do_direct_update = FALSE; -#endif -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000 -#else - if (table->timestamp_field_type & TIMESTAMP_AUTO_SET_ON_UPDATE) - table->timestamp_field->set_time(); -#endif if ((error_num = spider_db_update(this, table, old_data))) DBUG_RETURN(check_error_mode(error_num)); if (table->found_next_number_field && @@ -9722,7 +8393,6 @@ int ha_spider::update_row( DBUG_RETURN(0); } -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS bool ha_spider::check_direct_update_sql_part( st_select_lex *select_lex, longlong select_limit, @@ -9745,136 +8415,6 @@ bool ha_spider::check_direct_update_sql_part( DBUG_RETURN(FALSE); } -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS_WITH_HS -#ifdef SPIDER_MDEV_16246 -int ha_spider::direct_update_rows_init( - List<Item> *update_fields, - uint mode, - KEY_MULTI_RANGE *ranges, - uint range_count, - bool sorted, - uchar *new_data -) -#else -int ha_spider::direct_update_rows_init( - uint mode, - KEY_MULTI_RANGE *ranges, - uint range_count, - bool sorted, - uchar *new_data -) -#endif -{ - st_select_lex *select_lex; - longlong select_limit; - longlong offset_limit; - THD *thd = wide_handler->trx->thd; - DBUG_ENTER("ha_spider::direct_update_rows_init"); - DBUG_PRINT("info",("spider this=%p", this)); -#ifdef HA_CAN_BULK_ACCESS - if ( - bulk_access_executing && - ( - ( - !is_bulk_access_clone && - bulk_access_link_exec_tgt->called - ) || - bulk_access_pre_called - ) - ) { - if (is_bulk_access_clone) - { - DBUG_PRINT("info",("spider return pre_direct_init_result %d", - pre_direct_init_result)); - DBUG_RETURN(pre_direct_init_result); - } -#ifdef SPIDER_MDEV_16246 - DBUG_RETURN(bulk_access_link_exec_tgt->spider->direct_update_rows_init( - update_fields, mode, ranges, range_count, sorted, new_data)); -#else - DBUG_RETURN(bulk_access_link_exec_tgt->spider->direct_update_rows_init( - mode, ranges, range_count, sorted, new_data)); -#endif - } -#endif - if (!dml_inited) - { - if (unlikely((error_num = dml_init()))) - { - DBUG_RETURN(error_num); - } - } - direct_update_init( - thd, - FALSE - ); - if (!condition) - cond_check = FALSE; - spider_get_select_limit(this, &select_lex, &select_limit, &offset_limit); - if ( - !range_count && - direct_update_fields - ) { - if ( -#if MYSQL_VERSION_ID < 50500 - !thd->variables.engine_condition_pushdown || -#else -#ifdef SPIDER_ENGINE_CONDITION_PUSHDOWN_IS_ALWAYS_ON -#else - !(thd->variables.optimizer_switch & - OPTIMIZER_SWITCH_ENGINE_CONDITION_PUSHDOWN) || -#endif -#endif - !select_lex || - select_lex->table_list.elements != 1 || - check_update_columns_sql_part() || - check_direct_update_sql_part(select_lex, select_limit, offset_limit) || - spider_db_append_condition(this, NULL, 0, TRUE) - ) { - DBUG_PRINT("info",("spider FALSE by condition")); - do_direct_update = FALSE; - DBUG_RETURN(HA_ERR_WRONG_COMMAND); - } - if (select_lex->order_list.elements) - { - ORDER *order; - for (order = (ORDER *) select_lex->order_list.first; order; - order = order->next) - { - if (check_item_type_sql((*order->item))) - { - DBUG_PRINT("info",("spider FALSE by order")); - do_direct_update = FALSE; - DBUG_RETURN(HA_ERR_WRONG_COMMAND); - } - } - result_list.direct_order_limit = TRUE; - } - wide_handler->trx->direct_update_count++; - DBUG_PRINT("info",("spider OK")); - DBUG_RETURN(0); - } - - DBUG_PRINT("info",("spider offset_limit=%lld", offset_limit)); - DBUG_PRINT("info",("spider mode=%u", mode)); - DBUG_PRINT("info",("spider sql_command=%u", sql_command)); - DBUG_PRINT("info",("spider do_direct_update=%s", - do_direct_update ? "TRUE" : "FALSE")); - if ( - ( - !offset_limit - ) && - do_direct_update - ) { - wide_handler->trx->direct_update_count++; - DBUG_PRINT("info",("spider OK")); - DBUG_RETURN(0); - } - DBUG_PRINT("info",("spider FALSE by default")); - do_direct_update = FALSE; - DBUG_RETURN(HA_ERR_WRONG_COMMAND); -} -#else #ifdef SPIDER_MDEV_16246 /** Perform initialization for a direct update request. @@ -9922,31 +8462,6 @@ int ha_spider::direct_update_rows_init() } } } -#ifdef HA_CAN_BULK_ACCESS - if ( - bulk_access_executing && - ( - ( - !is_bulk_access_clone && - bulk_access_link_exec_tgt->called - ) || - bulk_access_pre_called - ) - ) { - if (is_bulk_access_clone) - { - DBUG_PRINT("info",("spider return pre_direct_init_result %d", - pre_direct_init_result)); - DBUG_RETURN(pre_direct_init_result); - } -#ifdef SPIDER_MDEV_16246 - DBUG_RETURN(bulk_access_link_exec_tgt->spider-> - direct_update_rows_init(update_fields)); -#else - DBUG_RETURN(bulk_access_link_exec_tgt->spider->direct_update_rows_init()); -#endif - } -#endif if (!dml_inited) { if (unlikely(dml_init())) @@ -9964,15 +8479,11 @@ int ha_spider::direct_update_rows_init() if (wide_handler->direct_update_fields) { if ( -#if MYSQL_VERSION_ID < 50500 - !thd->variables.engine_condition_pushdown || -#else #ifdef SPIDER_ENGINE_CONDITION_PUSHDOWN_IS_ALWAYS_ON #else !(thd->variables.optimizer_switch & OPTIMIZER_SWITCH_ENGINE_CONDITION_PUSHDOWN) || #endif -#endif !select_lex || select_lex->table_list.elements != 1 || check_update_columns_sql_part() || @@ -10019,121 +8530,9 @@ int ha_spider::direct_update_rows_init() do_direct_update = FALSE; DBUG_RETURN(HA_ERR_WRONG_COMMAND); } -#endif - -#ifdef HA_CAN_BULK_ACCESS -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS_WITH_HS -#ifdef SPIDER_MDEV_16246 -int ha_spider::pre_direct_update_rows_init( - List<Item> *update_fields, - uint mode, - KEY_MULTI_RANGE *ranges, - uint range_count, - bool sorted, - uchar *new_data -) -#else -int ha_spider::pre_direct_update_rows_init( - uint mode, - KEY_MULTI_RANGE *ranges, - uint range_count, - bool sorted, - uchar *new_data -) -#endif -{ - int error_num; - DBUG_ENTER("ha_spider::pre_direct_update_rows_init"); - DBUG_PRINT("info",("spider this=%p", this)); - if (bulk_access_started) - { -#ifdef SPIDER_MDEV_16246 - error_num = bulk_access_link_current->spider-> - pre_direct_update_rows_init( - update_fields, mode, ranges, range_count, sorted, new_data); -#else - error_num = bulk_access_link_current->spider-> - pre_direct_update_rows_init( - mode, ranges, range_count, sorted, new_data); -#endif - bulk_access_link_current->spider->bulk_access_pre_called = TRUE; - bulk_access_link_current->called = TRUE; - DBUG_RETURN(error_num); - } - if (!dml_inited) - { - if (unlikely((error_num = dml_init()))) - { - DBUG_RETURN(error_num); - } - } -#ifdef SPIDER_MDEV_16246 - pre_direct_init_result = direct_update_rows_init( - update_fields, mode, ranges, range_count, sorted, new_data); -#else - pre_direct_init_result = direct_update_rows_init( - mode, ranges, range_count, sorted, new_data); -#endif - DBUG_RETURN(pre_direct_init_result); -} -#else -#ifdef SPIDER_MDEV_16246 -/** - Do initialization for performing parallel direct update - for a handlersocket update request. - - @param update fields Pointer to the list of fields to update. - @return >0 Error. - 0 Success. -*/ - -int ha_spider::pre_direct_update_rows_init( - List<Item> *update_fields -) -#else -int ha_spider::pre_direct_update_rows_init() -#endif -{ - int error_num; - DBUG_ENTER("ha_spider::pre_direct_update_rows_init"); - DBUG_PRINT("info",("spider this=%p", this)); - if (bulk_access_started) - { -#ifdef SPIDER_MDEV_16246 - error_num = bulk_access_link_current->spider-> - pre_direct_update_rows_init(update_fields); -#else - error_num = bulk_access_link_current->spider-> - pre_direct_update_rows_init(); -#endif - bulk_access_link_current->spider->bulk_access_pre_called = TRUE; - bulk_access_link_current->called = TRUE; - DBUG_RETURN(error_num); - } - if (!dml_inited) - { - if (unlikely((error_num = dml_init()))) - { - DBUG_RETURN(error_num); - } - } -#ifdef SPIDER_MDEV_16246 - pre_direct_init_result = direct_update_rows_init(update_fields); -#else - pre_direct_init_result = direct_update_rows_init(); -#endif - DBUG_RETURN(pre_direct_init_result); -} -#endif -#endif -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS_WITH_HS int ha_spider::direct_update_rows( - KEY_MULTI_RANGE *ranges, - uint range_count, - bool sorted, - uchar *new_data, ha_rows *update_rows, ha_rows *found_rows ) { @@ -10148,79 +8547,6 @@ int ha_spider::direct_update_rows( table_share->db.str, table_share->table_name.str); DBUG_RETURN(ER_SPIDER_READ_ONLY_NUM); } -#ifdef HA_CAN_BULK_ACCESS - if ( - bulk_access_executing && - ( - ( - !is_bulk_access_clone && - bulk_access_link_exec_tgt->called - ) || - bulk_access_pre_called - ) - ) { - if (is_bulk_access_clone) - { - bulk_access_pre_called = FALSE; - DBUG_RETURN(spider_db_bulk_direct_update(this, update_rows, found_rows)); - } - DBUG_RETURN(bulk_access_link_exec_tgt->spider->ha_direct_update_rows( - ranges, range_count, sorted, new_data, update_rows, found_rows)); - } -#endif - if ( - (active_index != MAX_KEY && (error_num = index_handler_init())) || - (active_index == MAX_KEY && (error_num = rnd_handler_init())) || - (error_num = spider_db_direct_update(this, table, ranges, range_count, - update_rows, found_rows)) - ) - DBUG_RETURN(check_error_mode(error_num)); - -#ifdef HA_CAN_BULK_ACCESS - if (bulk_access_executing && is_bulk_access_clone) - { - bulk_req_exec(); - DBUG_RETURN(spider_db_bulk_direct_update(this, update_rows, found_rows)); - } -#endif - DBUG_RETURN(0); -} -#else -int ha_spider::direct_update_rows( - ha_rows *update_rows, - ha_rows *found_rows -) { - int error_num; - THD *thd = ha_thd(); - backup_error_status(); - DBUG_ENTER("ha_spider::direct_update_rows"); - DBUG_PRINT("info",("spider this=%p", this)); - if (spider_param_read_only_mode(thd, share->read_only_mode)) - { - my_printf_error(ER_SPIDER_READ_ONLY_NUM, ER_SPIDER_READ_ONLY_STR, MYF(0), - table_share->db.str, table_share->table_name.str); - DBUG_RETURN(ER_SPIDER_READ_ONLY_NUM); - } -#ifdef HA_CAN_BULK_ACCESS - if ( - bulk_access_executing && - ( - ( - !is_bulk_access_clone && - bulk_access_link_exec_tgt->called - ) || - bulk_access_pre_called - ) - ) { - if (is_bulk_access_clone) - { - bulk_access_pre_called = FALSE; - DBUG_RETURN(spider_db_bulk_direct_update(this, update_rows, found_rows)); - } - DBUG_RETURN(bulk_access_link_exec_tgt->spider->ha_direct_update_rows( - update_rows, found_rows)); - } -#endif if ( (active_index != MAX_KEY && (error_num = index_handler_init())) || (active_index == MAX_KEY && (error_num = rnd_handler_init())) || @@ -10228,45 +8554,9 @@ int ha_spider::direct_update_rows( ) DBUG_RETURN(check_error_mode(error_num)); -#ifdef HA_CAN_BULK_ACCESS - if (bulk_access_executing && is_bulk_access_clone) - { - bulk_req_exec(); - DBUG_RETURN(spider_db_bulk_direct_update(this, update_rows, found_rows)); - } -#endif DBUG_RETURN(0); } -#endif -#ifdef HA_CAN_BULK_ACCESS -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS_WITH_HS -int ha_spider::pre_direct_update_rows( - KEY_MULTI_RANGE *ranges, - uint range_count, - bool sorted, - uchar *new_data, - ha_rows *update_rows, - ha_rows *found_rows -) { - DBUG_ENTER("ha_spider::pre_direct_update_rows"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(bulk_access_link_current->spider->ha_direct_update_rows(ranges, - range_count, sorted, new_data, update_rows, found_rows)); -} -#else -int ha_spider::pre_direct_update_rows() -{ - uint update_rows; - uint found_rows; - DBUG_ENTER("ha_spider::pre_direct_update_rows"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(bulk_access_link_current->spider->ha_direct_update_rows( - &update_rows, &found_rows)); -} -#endif -#endif -#endif bool ha_spider::start_bulk_delete( ) { @@ -10300,40 +8590,15 @@ int ha_spider::delete_row( table_share->db.str, table_share->table_name.str); DBUG_RETURN(ER_SPIDER_READ_ONLY_NUM); } -#ifdef HA_CAN_BULK_ACCESS - if ( - bulk_access_executing && !is_bulk_access_clone && - bulk_access_link_exec_tgt->called - ) { - ulonglong option_backup = 0; -#if MYSQL_VERSION_ID < 50500 - option_backup = thd->options; - thd->options &= ~OPTION_BIN_LOG; -#else - option_backup = thd->variables.option_bits; - thd->variables.option_bits &= ~OPTION_BIN_LOG; -#endif - error_num = bulk_access_link_exec_tgt->spider->ha_delete_row(buf); -#if MYSQL_VERSION_ID < 50500 - thd->options = option_backup; -#else - thd->variables.option_bits = option_backup; -#endif - DBUG_RETURN(error_num); - } -#endif #ifndef SPIDER_WITHOUT_HA_STATISTIC_INCREMENT ha_statistic_increment(&SSV::ha_delete_count); #endif -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS do_direct_update = FALSE; -#endif if ((error_num = spider_db_delete(this, table, buf))) DBUG_RETURN(check_error_mode(error_num)); DBUG_RETURN(0); } -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS bool ha_spider::check_direct_delete_sql_part( st_select_lex *select_lex, longlong select_limit, @@ -10356,108 +8621,6 @@ bool ha_spider::check_direct_delete_sql_part( DBUG_RETURN(FALSE); } -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS_WITH_HS -int ha_spider::direct_delete_rows_init( - uint mode, - KEY_MULTI_RANGE *ranges, - uint range_count, - bool sorted -) { - st_select_lex *select_lex; - longlong select_limit; - longlong offset_limit; - THD *thd = wide_handler->trx->thd; - DBUG_ENTER("ha_spider::direct_delete_rows_init"); - DBUG_PRINT("info",("spider this=%p", this)); -#ifdef HA_CAN_BULK_ACCESS - if ( - bulk_access_executing && - ( - ( - !is_bulk_access_clone && - bulk_access_link_exec_tgt->called - ) || - bulk_access_pre_called - ) - ) { - if (is_bulk_access_clone) - { - DBUG_RETURN(pre_direct_init_result); - } - DBUG_RETURN(bulk_access_link_exec_tgt->spider->direct_delete_rows_init( - mode, ranges, range_count, sorted)); - } -#endif - if (!dml_inited) - { - if (unlikely((error_num = dml_init()))) - { - DBUG_RETURN(error_num); - } - } - direct_update_init( - thd, - FALSE - ); - if (!condition) - cond_check = FALSE; - spider_get_select_limit(this, &select_lex, &select_limit, &offset_limit); - if (!range_count) - { - if ( -#if MYSQL_VERSION_ID < 50500 - !thd->variables.engine_condition_pushdown || -#else -#ifdef SPIDER_ENGINE_CONDITION_PUSHDOWN_IS_ALWAYS_ON -#else - !(thd->variables.optimizer_switch & - OPTIMIZER_SWITCH_ENGINE_CONDITION_PUSHDOWN) || -#endif -#endif - !select_lex || - select_lex->table_list.elements != 1 || - check_direct_delete_sql_part(select_lex, select_limit, offset_limit) || - spider_db_append_condition(this, NULL, 0, TRUE) - ) { - DBUG_PRINT("info",("spider FALSE by condition")); - do_direct_update = FALSE; - DBUG_RETURN(HA_ERR_WRONG_COMMAND); - } - if (select_lex->order_list.elements) - { - ORDER *order; - for (order = (ORDER *) select_lex->order_list.first; order; - order = order->next) - { - if (check_item_type_sql((*order->item))) - { - DBUG_PRINT("info",("spider FALSE by order")); - do_direct_update = FALSE; - DBUG_RETURN(HA_ERR_WRONG_COMMAND); - } - } - result_list.direct_order_limit = TRUE; - } - wide_handler->trx->direct_delete_count++; - DBUG_PRINT("info",("spider OK")); - DBUG_RETURN(0); - } - - if ( - ( - !offset_limit - ) && - do_direct_update - ) { - wide_handler->trx->direct_delete_count++; - DBUG_PRINT("info",("spider OK")); - DBUG_RETURN(0); - } - DBUG_PRINT("info",("spider FALSE by default")); - do_direct_update = FALSE; - DBUG_RETURN(HA_ERR_WRONG_COMMAND); -} -#else int ha_spider::direct_delete_rows_init() { st_select_lex *select_lex; @@ -10466,24 +8629,6 @@ int ha_spider::direct_delete_rows_init() THD *thd = wide_handler->trx->thd; DBUG_ENTER("ha_spider::direct_delete_rows_init"); DBUG_PRINT("info",("spider this=%p", this)); -#ifdef HA_CAN_BULK_ACCESS - if ( - bulk_access_executing && - ( - ( - !is_bulk_access_clone && - bulk_access_link_exec_tgt->called - ) || - bulk_access_pre_called - ) - ) { - if (is_bulk_access_clone) - { - DBUG_RETURN(pre_direct_init_result); - } - DBUG_RETURN(bulk_access_link_exec_tgt->spider->direct_delete_rows_init()); - } -#endif if (!dml_inited) { if (unlikely(dml_init())) @@ -10499,15 +8644,11 @@ int ha_spider::direct_delete_rows_init() wide_handler->cond_check = FALSE; spider_get_select_limit(this, &select_lex, &select_limit, &offset_limit); if ( -#if MYSQL_VERSION_ID < 50500 - !thd->variables.engine_condition_pushdown || -#else #ifdef SPIDER_ENGINE_CONDITION_PUSHDOWN_IS_ALWAYS_ON #else !(thd->variables.optimizer_switch & OPTIMIZER_SWITCH_ENGINE_CONDITION_PUSHDOWN) || #endif -#endif !select_lex || select_lex->table_list.elements != 1 || check_direct_delete_sql_part(select_lex, select_limit, offset_limit) || @@ -10536,71 +8677,9 @@ int ha_spider::direct_delete_rows_init() DBUG_PRINT("info",("spider OK")); DBUG_RETURN(0); } -#endif -#ifdef HA_CAN_BULK_ACCESS -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS_WITH_HS -int ha_spider::pre_direct_delete_rows_init( - uint mode, - KEY_MULTI_RANGE *ranges, - uint range_count, - bool sorted -) { - int error_num; - DBUG_ENTER("ha_spider::pre_direct_delete_rows_init"); - DBUG_PRINT("info",("spider this=%p", this)); - if (bulk_access_started) - { - error_num = bulk_access_link_current->spider-> - pre_direct_delete_rows_init( - mode, ranges, range_count, sorted); - bulk_access_link_current->spider->bulk_access_pre_called = TRUE; - bulk_access_link_current->called = TRUE; - DBUG_RETURN(error_num); - } - if (!dml_inited) - { - if (unlikely((error_num = dml_init()))) - { - DBUG_RETURN(error_num); - } - } - pre_direct_init_result = direct_delete_rows_init( - mode, ranges, range_count, sorted); - DBUG_RETURN(pre_direct_init_result); -} -#else -int ha_spider::pre_direct_delete_rows_init() -{ - int error_num; - DBUG_ENTER("ha_spider::pre_direct_delete_rows_init"); - DBUG_PRINT("info",("spider this=%p", this)); - if (bulk_access_started) - { - error_num = bulk_access_link_current->spider-> - pre_direct_delete_rows_init(); - bulk_access_link_current->spider->bulk_access_pre_called = TRUE; - bulk_access_link_current->called = TRUE; - DBUG_RETURN(error_num); - } - if (!dml_inited) - { - if (unlikely((error_num = dml_init()))) - { - DBUG_RETURN(error_num); - } - } - pre_direct_init_result = direct_delete_rows_init(); - DBUG_RETURN(pre_direct_init_result); -} -#endif -#endif -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS_WITH_HS int ha_spider::direct_delete_rows( - KEY_MULTI_RANGE *ranges, - uint range_count, - bool sorted, ha_rows *delete_rows ) { int error_num; @@ -10614,78 +8693,6 @@ int ha_spider::direct_delete_rows( table_share->db.str, table_share->table_name.str); DBUG_RETURN(ER_SPIDER_READ_ONLY_NUM); } -#ifdef HA_CAN_BULK_ACCESS - if ( - bulk_access_executing && - ( - ( - !is_bulk_access_clone && - bulk_access_link_exec_tgt->called - ) || - bulk_access_pre_called - ) - ) { - if (is_bulk_access_clone) - { - bulk_access_pre_called = FALSE; - DBUG_RETURN(spider_db_bulk_direct_update(this, delete_rows)); - } - DBUG_RETURN(bulk_access_link_exec_tgt->spider->ha_direct_delete_rows( - ranges, range_count, sorted, delete_rows)); - } -#endif - if ( - (active_index != MAX_KEY && (error_num = index_handler_init())) || - (active_index == MAX_KEY && (error_num = rnd_handler_init())) || - (error_num = spider_db_direct_delete(this, table, ranges, range_count, - delete_rows)) - ) - DBUG_RETURN(check_error_mode(error_num)); - -#ifdef HA_CAN_BULK_ACCESS - if (bulk_access_executing && is_bulk_access_clone) - { - bulk_req_exec(); - DBUG_RETURN(spider_db_bulk_direct_update(this, delete_rows)); - } -#endif - DBUG_RETURN(0); -} -#else -int ha_spider::direct_delete_rows( - ha_rows *delete_rows -) { - int error_num; - THD *thd = ha_thd(); - backup_error_status(); - DBUG_ENTER("ha_spider::direct_delete_rows"); - DBUG_PRINT("info",("spider this=%p", this)); - if (spider_param_read_only_mode(thd, share->read_only_mode)) - { - my_printf_error(ER_SPIDER_READ_ONLY_NUM, ER_SPIDER_READ_ONLY_STR, MYF(0), - table_share->db.str, table_share->table_name.str); - DBUG_RETURN(ER_SPIDER_READ_ONLY_NUM); - } -#ifdef HA_CAN_BULK_ACCESS - if ( - bulk_access_executing && - ( - ( - !is_bulk_access_clone && - bulk_access_link_exec_tgt->called - ) || - bulk_access_pre_called - ) - ) { - if (is_bulk_access_clone) - { - bulk_access_pre_called = FALSE; - DBUG_RETURN(spider_db_bulk_direct_update(this, delete_rows)); - } - DBUG_RETURN(bulk_access_link_exec_tgt->spider->ha_direct_delete_rows( - delete_rows)); - } -#endif if ( (active_index != MAX_KEY && (error_num = index_handler_init())) || (active_index == MAX_KEY && (error_num = rnd_handler_init())) || @@ -10693,42 +8700,9 @@ int ha_spider::direct_delete_rows( ) DBUG_RETURN(check_error_mode(error_num)); -#ifdef HA_CAN_BULK_ACCESS - if (bulk_access_executing && is_bulk_access_clone) - { - bulk_req_exec(); - DBUG_RETURN(spider_db_bulk_direct_update(this, delete_rows)); - } -#endif DBUG_RETURN(0); } -#endif -#ifdef HA_CAN_BULK_ACCESS -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS_WITH_HS -int ha_spider::pre_direct_delete_rows( - KEY_MULTI_RANGE *ranges, - uint range_count, - bool sorted, - ha_rows *delete_rows -) { - DBUG_ENTER("ha_spider::pre_direct_delete_rows"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(bulk_access_link_current->spider->ha_direct_delete_rows( - ranges, range_count, sorted, delete_rows)); -} -#else -int ha_spider::pre_direct_delete_rows() -{ - uint delete_rows; - DBUG_ENTER("ha_spider::pre_direct_delete_rows"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(bulk_access_link_current->spider->ha_direct_delete_rows( - &delete_rows)); -} -#endif -#endif -#endif int ha_spider::delete_all_rows() { @@ -10745,9 +8719,7 @@ int ha_spider::delete_all_rows() table_share->db.str, table_share->table_name.str); DBUG_RETURN(ER_SPIDER_READ_ONLY_NUM); } -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS do_direct_update = FALSE; -#endif sql_kinds = SPIDER_SQL_KIND_SQL; for (roop_count = 0; roop_count < (int) share->link_count; roop_count++) sql_kind[roop_count] = SPIDER_SQL_KIND_SQL; @@ -10788,9 +8760,7 @@ int ha_spider::truncate() { DBUG_RETURN(error_num); } -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS do_direct_update = FALSE; -#endif sql_kinds = SPIDER_SQL_KIND_SQL; for (roop_count = 0; roop_count < (int) share->link_count; roop_count++) sql_kind[roop_count] = SPIDER_SQL_KIND_SQL; @@ -10813,59 +8783,6 @@ int ha_spider::truncate() DBUG_RETURN(0); } -#ifdef HA_CAN_BULK_ACCESS -void ha_spider::bulk_req_exec() -{ - int need_mon; - SPIDER_CONN *conn = wide_handler->trx->bulk_access_conn_first; - DBUG_ENTER("ha_spider::bulk_req_exec"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_PRINT("info",("spider trx=%p", wide_handler->trx)); - DBUG_PRINT("info",("spider first_conn=%p", conn)); - while (conn) - { - DBUG_PRINT("info",("spider conn=%p", conn)); - DBUG_PRINT("info",("spider conn->bulk_access_requests=%u", - conn->bulk_access_requests)); - if (conn->bulk_access_requests) - { - spider_bg_conn_wait(conn); - pthread_mutex_assert_not_owner(&conn->mta_conn_mutex); - pthread_mutex_lock(&conn->mta_conn_mutex); - SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos); - conn->need_mon = &need_mon; - DBUG_ASSERT(!conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = TRUE; - conn->mta_conn_mutex_unlock_later = TRUE; - /* currently only used for HS */ - conn->bulk_access_error_num = 0; - if (spider_db_query( - conn, - NULL, - 0, - -1, - &need_mon) - ) { - conn->bulk_access_error_num = spider_db_errorno(conn); - } -/* - conn->bulk_access_sended += conn->bulk_access_requests; -*/ - conn->bulk_access_requests = 0; - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - } - conn = conn->bulk_access_next; - } - wide_handler->trx->bulk_access_conn_first = NULL; - DBUG_VOID_RETURN; -} -#endif double ha_spider::scan_time() { @@ -11005,16 +8922,11 @@ int ha_spider::create( memset((void*)&tmp_share, 0, sizeof(SPIDER_SHARE)); tmp_share.table_name = (char*) name; tmp_share.table_name_length = strlen(name); -#ifdef SPIDER_HAS_HASH_VALUE_TYPE tmp_share.table_name_hash_value = my_calc_hash(&trx->trx_alter_table_hash, (uchar*) tmp_share.table_name, tmp_share.table_name_length); tmp_share.lgtm_tblhnd_share = spider_get_lgtm_tblhnd_share( name, tmp_share.table_name_length, tmp_share.table_name_hash_value, FALSE, TRUE, &error_num); -#else - tmp_share.lgtm_tblhnd_share = spider_get_lgtm_tblhnd_share( - name, tmp_share.table_name_length, FALSE, TRUE, &error_num); -#endif if (!tmp_share.lgtm_tblhnd_share) { goto error; @@ -11040,9 +8952,7 @@ int ha_spider::create( tmp_share.key_hint[roop_count].init_calc_mem(85); DBUG_PRINT("info",("spider tmp_share.key_hint=%p", tmp_share.key_hint)); if ((error_num = spider_parse_connect_info(&tmp_share, form->s, -#ifdef WITH_PARTITION_STORAGE_ENGINE form->part_info, -#endif 1))) goto error; DBUG_PRINT("info",("spider tmp_table=%d", form->s->tmp_table)); @@ -11058,7 +8968,6 @@ int ha_spider::create( ) { goto error; } -#ifdef SPIDER_SUPPORT_CREATE_OR_REPLACE_TABLE if ( thd->lex->create_info.or_replace() && (error_num = spider_delete_tables( @@ -11066,7 +8975,6 @@ int ha_spider::create( ) { goto error; } -#endif if ( (error_num = spider_insert_tables(table_tables, &tmp_share)) ) { @@ -11084,16 +8992,10 @@ int ha_spider::create( spider_free_trx_alter_table(trx); trx->query_id = thd->query_id; } -#ifdef SPIDER_HAS_HASH_VALUE_TYPE if (!(alter_table = (SPIDER_ALTER_TABLE*) my_hash_search_using_hash_value( &trx->trx_alter_table_hash, tmp_share.table_name_hash_value, (uchar*) tmp_share.table_name, tmp_share.table_name_length))) -#else - if (!(alter_table = - (SPIDER_ALTER_TABLE*) my_hash_search(&trx->trx_alter_table_hash, - (uchar*) tmp_share.table_name, tmp_share.table_name_length))) -#endif { if ((error_num = spider_create_trx_alter_table(trx, &tmp_share, TRUE))) goto error; @@ -11218,12 +9120,10 @@ int ha_spider::rename_table( ) { int error_num, roop_count, old_link_count, from_len = strlen(from), to_len = strlen(to), tmp_error_num; -#ifdef SPIDER_HAS_HASH_VALUE_TYPE my_hash_value_type from_hash_value = my_calc_hash(&spider_open_tables, (uchar*) from, from_len); my_hash_value_type to_hash_value = my_calc_hash(&spider_open_tables, (uchar*) to, to_len); -#endif THD *thd = ha_thd(); uint sql_command = thd_sql_command(thd); SPIDER_TRX *trx; @@ -11391,22 +9291,12 @@ int ha_spider::rename_table( } pthread_mutex_lock(&spider_lgtm_tblhnd_share_mutex); -#ifdef SPIDER_HAS_HASH_VALUE_TYPE from_lgtm_tblhnd_share = spider_get_lgtm_tblhnd_share( from, from_len, from_hash_value, TRUE, FALSE, &error_num); -#else - from_lgtm_tblhnd_share = spider_get_lgtm_tblhnd_share( - from, from_len, TRUE, FALSE, &error_num); -#endif if (from_lgtm_tblhnd_share) { -#ifdef SPIDER_HAS_HASH_VALUE_TYPE to_lgtm_tblhnd_share = spider_get_lgtm_tblhnd_share( to, to_len, to_hash_value, TRUE, TRUE, &error_num); -#else - to_lgtm_tblhnd_share = spider_get_lgtm_tblhnd_share( - to, to_len, TRUE, TRUE, &error_num); -#endif if (!to_lgtm_tblhnd_share) { pthread_mutex_unlock(&spider_lgtm_tblhnd_share_mutex); @@ -11432,13 +9322,8 @@ error: spider_close_sys_table(current_thd, table_tables, &open_tables_backup, need_lock); pthread_mutex_lock(&spider_lgtm_tblhnd_share_mutex); -#ifdef SPIDER_HAS_HASH_VALUE_TYPE to_lgtm_tblhnd_share = spider_get_lgtm_tblhnd_share( to, to_len, to_hash_value, TRUE, FALSE, &tmp_error_num); -#else - to_lgtm_tblhnd_share = spider_get_lgtm_tblhnd_share( - to, to_len, TRUE, FALSE, &tmp_error_num); -#endif if (to_lgtm_tblhnd_share) spider_free_lgtm_tblhnd_share_alloc(to_lgtm_tblhnd_share, TRUE); pthread_mutex_unlock(&spider_lgtm_tblhnd_share_mutex); @@ -11486,22 +9371,14 @@ int ha_spider::delete_table( { SPIDER_LGTM_TBLHND_SHARE *lgtm_tblhnd_share; int roop_count, old_link_count = 0, name_len = strlen(name); -#ifdef SPIDER_HAS_HASH_VALUE_TYPE my_hash_value_type hash_value = my_calc_hash(&spider_open_tables, (uchar*) name, name_len); -#endif if ( sql_command == SQLCOM_ALTER_TABLE && -#ifdef SPIDER_HAS_HASH_VALUE_TYPE (alter_table = (SPIDER_ALTER_TABLE*) my_hash_search_using_hash_value( &trx->trx_alter_table_hash, hash_value, (uchar*) name, name_len)) && -#else - (alter_table = - (SPIDER_ALTER_TABLE*) my_hash_search(&trx->trx_alter_table_hash, - (uchar*) name, name_len)) && -#endif alter_table->now_create ) DBUG_RETURN(0); @@ -11554,13 +9431,8 @@ int ha_spider::delete_table( } pthread_mutex_lock(&spider_lgtm_tblhnd_share_mutex); -#ifdef SPIDER_HAS_HASH_VALUE_TYPE lgtm_tblhnd_share = spider_get_lgtm_tblhnd_share( name, name_len, hash_value, TRUE, FALSE, &error_num); -#else - lgtm_tblhnd_share = spider_get_lgtm_tblhnd_share( - name, name_len, TRUE, FALSE, &error_num); -#endif if (lgtm_tblhnd_share) spider_free_lgtm_tblhnd_share_alloc(lgtm_tblhnd_share, TRUE); pthread_mutex_unlock(&spider_lgtm_tblhnd_share_mutex); @@ -11709,12 +9581,6 @@ Field *ha_spider::field_exchange( Field *field ) { DBUG_ENTER("ha_spider::field_exchange"); -#ifdef HA_CAN_BULK_ACCESS - if (is_bulk_access_clone) - { - DBUG_RETURN(pt_clone_source_handler->field_exchange(field)); - } -#endif DBUG_PRINT("info",("spider in field=%p", field)); DBUG_PRINT("info",("spider in field->table=%p", field->table)); DBUG_PRINT("info",("spider table=%p", table)); @@ -11728,7 +9594,6 @@ const COND *ha_spider::cond_push( const COND *cond ) { DBUG_ENTER("ha_spider::cond_push"); -#ifdef WITH_PARTITION_STORAGE_ENGINE if ( wide_handler->stage == SPD_HND_STAGE_COND_PUSH && wide_handler->stage_executor != this) @@ -11737,7 +9602,6 @@ const COND *ha_spider::cond_push( } wide_handler->stage = SPD_HND_STAGE_COND_PUSH; wide_handler->stage_executor = this; -#endif wide_handler->cond_check = FALSE; if (cond) { @@ -11756,7 +9620,6 @@ const COND *ha_spider::cond_push( void ha_spider::cond_pop() { DBUG_ENTER("ha_spider::cond_pop"); -#ifdef WITH_PARTITION_STORAGE_ENGINE if ( wide_handler->stage == SPD_HND_STAGE_COND_POP && wide_handler->stage_executor != this) @@ -11765,7 +9628,6 @@ void ha_spider::cond_pop() } wide_handler->stage = SPD_HND_STAGE_COND_POP; wide_handler->stage_executor = this; -#endif if (wide_handler->condition) { SPIDER_CONDITION *tmp_cond = wide_handler->condition->next; @@ -11782,7 +9644,6 @@ int ha_spider::info_push( int error_num = 0; DBUG_ENTER("ha_spider::info_push"); DBUG_PRINT("info",("spider this=%p", this)); -#ifdef WITH_PARTITION_STORAGE_ENGINE if ( wide_handler->stage == SPD_HND_STAGE_INFO_PUSH && wide_handler->stage_executor != this) @@ -11791,45 +9652,16 @@ int ha_spider::info_push( } wide_handler->stage = SPD_HND_STAGE_INFO_PUSH; wide_handler->stage_executor = this; -#endif -#ifdef HA_CAN_BULK_ACCESS - if ( -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS -#endif - info_type != INFO_KIND_BULK_ACCESS_BEGIN && - info_type != INFO_KIND_BULK_ACCESS_CURRENT && - info_type != INFO_KIND_BULK_ACCESS_END - ) { - if (!is_bulk_access_clone) - { - if ( - bulk_access_executing && - bulk_access_link_exec_tgt->called - ) { - DBUG_RETURN(bulk_access_link_exec_tgt->spider->info_push(info_type, - info)); - } else if (bulk_access_started) - { - DBUG_RETURN(bulk_access_link_current->spider->info_push(info_type, - info)); - } - } - } -#endif -#if defined(HANDLER_HAS_DIRECT_UPDATE_ROWS) || defined(HA_CAN_BULK_ACCESS) switch (info_type) { -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS #ifdef INFO_KIND_UPDATE_FIELDS case INFO_KIND_UPDATE_FIELDS: DBUG_PRINT("info",("spider INFO_KIND_UPDATE_FIELDS")); wide_handler->direct_update_fields = (List<Item> *) info; wide_handler->update_request = TRUE; -#ifdef WITH_PARTITION_STORAGE_ENGINE if (wide_handler->keyread && check_partitioned()) wide_handler->keyread = FALSE; -#endif break; #endif #ifdef INFO_KIND_UPDATE_VALUES @@ -11848,74 +9680,12 @@ int ha_spider::info_push( wide_handler->info_limit = 9223372036854775807LL; break; #endif -#endif -#ifdef HA_CAN_BULK_ACCESS - case INFO_KIND_BULK_ACCESS_BEGIN: - DBUG_PRINT("info",("spider INFO_KIND_BULK_ACCESS_BEGIN")); - if (partition_handler && partition_handler->handlers) - { - size_t roop_count; - ha_spider **handlers = partition_handler->handlers; - for (roop_count = 0; roop_count < partition_handler->no_parts; - ++roop_count) - { - if ((error_num = handlers[roop_count]->bulk_access_begin(info))) - { - DBUG_RETURN(error_num); - } - } - } else { - if ((error_num = bulk_access_begin(info))) - { - DBUG_RETURN(error_num); - } - } - break; - case INFO_KIND_BULK_ACCESS_CURRENT: - DBUG_PRINT("info",("spider INFO_KIND_BULK_ACCESS_CURRENT")); - if (partition_handler && partition_handler->handlers) - { - size_t roop_count; - ha_spider **handlers = partition_handler->handlers; - for (roop_count = 0; roop_count < partition_handler->no_parts; - ++roop_count) - { - if ((error_num = handlers[roop_count]->bulk_access_current(info))) - { - DBUG_RETURN(error_num); - } - } - } else { - if ((error_num = bulk_access_current(info))) - { - DBUG_RETURN(error_num); - } - } - break; - case INFO_KIND_BULK_ACCESS_END: - DBUG_PRINT("info",("spider INFO_KIND_BULK_ACCESS_END")); - if (partition_handler && partition_handler->handlers) - { - size_t roop_count; - ha_spider **handlers = partition_handler->handlers; - for (roop_count = 0; roop_count < partition_handler->no_parts; - ++roop_count) - { - handlers[roop_count]->bulk_access_end(); - } - } else { - bulk_access_end(); - } - break; -#endif default: break; } -#endif DBUG_RETURN(error_num); } -#ifdef HANDLER_HAS_DIRECT_AGGREGATE void ha_spider::return_record_by_parent() { DBUG_ENTER("ha_spider::return_record_by_parent"); @@ -11923,7 +9693,6 @@ void ha_spider::return_record_by_parent() spider_db_refetch_for_item_sum_funcs(this); DBUG_VOID_RETURN; } -#endif TABLE *ha_spider::get_table() { @@ -12156,15 +9925,11 @@ void ha_spider::set_select_column_mode() if (wide_handler->external_lock_type == F_WRLCK && wide_handler->sql_command != SQLCOM_SELECT) { -#ifdef WITH_PARTITION_STORAGE_ENGINE uint part_num = 0; if (wide_handler->update_request) part_num = check_partitioned(); -#endif if ( -#ifdef WITH_PARTITION_STORAGE_ENGINE part_num || -#endif table_share->primary_key == MAX_KEY ) { /* need all columns */ @@ -12195,7 +9960,6 @@ void ha_spider::set_select_column_mode() DBUG_VOID_RETURN; } -#ifdef WITH_PARTITION_STORAGE_ENGINE void ha_spider::check_select_column(bool rnd) { THD *thd = wide_handler->trx->thd; @@ -12254,7 +10018,6 @@ void ha_spider::check_select_column(bool rnd) } DBUG_VOID_RETURN; } -#endif bool ha_spider::check_and_start_bulk_update( spider_bulk_upd_start bulk_upd_start @@ -12278,11 +10041,7 @@ bool ha_spider::check_and_start_bulk_update( */ result_list.bulk_update_size = spider_param_bulk_update_size(thd, share->bulk_update_size); -/* -#ifndef WITHOUT_SPIDER_BG_SEARCH - int bgs_mode = spider_param_bgs_mode(thd, share->bgs_mode); -#endif -*/ + if (!support_bulk_update_sql()) { result_list.bulk_update_mode = 0; @@ -12290,9 +10049,6 @@ bool ha_spider::check_and_start_bulk_update( result_list.bulk_update_mode)); /* } else if ( -#ifndef WITHOUT_SPIDER_BG_SEARCH - bgs_mode || -#endif split_read != 9223372036854775807LL ) { result_list.bulk_update_mode = 2; @@ -12736,9 +10492,7 @@ int ha_spider::index_handler_init() roop_end = search_link_idx + 1; } sql_kinds = 0; -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS direct_update_kinds = 0; -#endif for (roop_count = roop_start; roop_count < roop_end; roop_count = spider_conn_link_idx_next(share->link_statuses, conn_link_idx, roop_count, share->link_count, @@ -12824,9 +10578,7 @@ int ha_spider::rnd_handler_init() roop_end = search_link_idx + 1; } sql_kinds = 0; -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS direct_update_kinds = 0; -#endif for (roop_count = roop_start; roop_count < roop_end; roop_count = spider_conn_link_idx_next(share->link_statuses, conn_link_idx, roop_count, share->link_count, @@ -13015,11 +10767,7 @@ void ha_spider::check_pre_call( ) || ( (skip_parallel_search & 2) && -#ifdef SPIDER_SQL_CACHE_IS_IN_LEX lex->sql_cache == LEX::SQL_NO_CACHE // for mysqldump -#else - select_lex && select_lex->sql_cache == SELECT_LEX::SQL_NO_CACHE // for mysqldump -#endif ) ) { use_pre_call = FALSE; @@ -13049,7 +10797,6 @@ void ha_spider::check_pre_call( DBUG_VOID_RETURN; } -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS void ha_spider::check_insert_dup_update_pushdown() { THD *thd = wide_handler->trx->thd; @@ -13068,147 +10815,7 @@ void ha_spider::check_insert_dup_update_pushdown() } DBUG_VOID_RETURN; } -#endif -#ifdef HA_CAN_BULK_ACCESS -SPIDER_BULK_ACCESS_LINK *ha_spider::create_bulk_access_link() -{ - uchar *ref; - ha_spider *spider; - SPIDER_BULK_ACCESS_LINK *bulk_access_link; - DBUG_ENTER("ha_spider::create_bulk_access_link"); - DBUG_PRINT("info",("spider this=%p", this)); -/* - if (!init_ha_mem_root) - { - SPD_INIT_ALLOC_ROOT(&ha_mem_root, sizeof(ha_spider) * 16, - sizeof(ha_spider) * 16, MYF(MY_WME)); - init_ha_mem_root = TRUE; - } -*/ - if (!(bulk_access_link = (SPIDER_BULK_ACCESS_LINK *) - spider_bulk_malloc(spider_current_trx, 168, MYF(MY_WME), - &bulk_access_link, (uint) (sizeof(SPIDER_BULK_ACCESS_LINK)), - &ref, (uint) (ALIGN_SIZE(ref_length) * 2), - NullS)) - ) { - goto error_bulk_malloc; - } - SPD_INIT_ALLOC_ROOT(&bulk_access_link->mem_root, sizeof(ha_spider), 0, - MYF(MY_WME)); -/* - if (!(spider = new ha_spider(spider_hton_ptr, table_share))) - if (!(spider = (ha_spider *) spider_create_handler( - spider_hton_ptr, table_share, &ha_mem_root))) -*/ - if (!(spider = (ha_spider *) spider_create_handler( - spider_hton_ptr, table_share, &bulk_access_link->mem_root))) - { - goto error_new_spider; - } - DBUG_PRINT("info",("spider spider=%p", spider)); - bulk_access_link->spider = spider; - spider->ref = ref; - bulk_access_link->next = NULL; - spider->is_clone = TRUE; - spider->is_bulk_access_clone = TRUE; - spider->pt_clone_source_handler = this; - if (spider->ha_open(table, share->table_name, table->db_stat, - HA_OPEN_IGNORE_IF_LOCKED)) - { - goto error_ha_open; - } - DBUG_RETURN(bulk_access_link); - -error_ha_open: - delete spider; -error_new_spider: - free_root(&bulk_access_link->mem_root, MYF(0)); - spider_free(spider_current_trx, bulk_access_link, MYF(0)); -error_bulk_malloc: - DBUG_RETURN(NULL); -} - -void ha_spider::delete_bulk_access_link( - SPIDER_BULK_ACCESS_LINK *bulk_access_link -) { - ha_spider *spider = bulk_access_link->spider; - DBUG_ENTER("ha_spider::delete_bulk_access_link"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_PRINT("info",("spider spider=%p", spider)); - DBUG_PRINT("info",("spider bulk_access_link->spider->dbton_handler=%p", - spider->dbton_handler)); - DBUG_PRINT("info",("spider ptr bulk_access_link->spider->dbton_handler=%p", - &spider->dbton_handler)); - spider->close(); - delete spider; - free_root(&bulk_access_link->mem_root, MYF(0)); - spider_free(spider_current_trx, bulk_access_link, MYF(0)); - DBUG_VOID_RETURN; -} - -int ha_spider::sync_from_clone_source( - ha_spider *spider -) { - int error_num; - DBUG_ENTER("ha_spider::sync_from_clone_source"); - sync_from_clone_source_base(spider); - if (!synced_from_clone_source) - { - DBUG_PRINT("info",("spider synced from clone source all")); - wide_handler->trx = spider->wide_handler->trx; - sql_command = spider->sql_command; - wide_handler->external_lock_type = - spider->wide_handler->external_lock_type; - selupd_lock_mode = spider->selupd_lock_mode; - update_request = spider->update_request; - lock_mode = spider->lock_mode; - high_priority = spider->high_priority; - low_priority = spider->low_priority; - memcpy(conns, spider->conns, - sizeof(SPIDER_CONN *) * share->link_count); - spider_thread_id = spider->spider_thread_id; - trx_conn_adjustment = spider->trx_conn_adjustment; - search_link_idx = spider->search_link_idx; - external_lock_cnt = spider->external_lock_cnt; - uint roop_count, dbton_id; - spider_db_handler *dbton_hdl, *dbton_hdl2; - for (roop_count = 0; roop_count < share->use_dbton_count; roop_count++) - { - dbton_id = share->use_dbton_ids[roop_count]; - dbton_hdl = dbton_handler[dbton_id]; - dbton_hdl2 = spider->dbton_handler[dbton_id]; - dbton_hdl->sync_from_clone_source(dbton_hdl2); - } - synced_from_clone_source = TRUE; - } else if (external_lock_cnt != spider->external_lock_cnt) - { - DBUG_PRINT("info",("spider synced from clone source")); - sql_command = spider->sql_command; - wide_handler->external_lock_type = - spider->wide_handler->external_lock_type; - selupd_lock_mode = spider->selupd_lock_mode; - update_request = spider->update_request; - lock_mode = spider->lock_mode; - high_priority = spider->high_priority; - low_priority = spider->low_priority; - - if ((error_num = spider_check_trx_and_get_conn( - spider->wide_handler->trx->thd, - this, TRUE))) - { - DBUG_RETURN(error_num); - } - external_lock_cnt = spider->external_lock_cnt; - } - - DBUG_PRINT("info",("spider bulk_access_link->spider->dbton_handler=%p", - dbton_handler)); - DBUG_PRINT("info",("spider ptr bulk_access_link->spider->dbton_handler=%p", - &dbton_handler)); - DBUG_RETURN(0); -} -#endif void ha_spider::sync_from_clone_source_base( ha_spider *spider @@ -13463,7 +11070,6 @@ int ha_spider::append_update_set_sql_part() DBUG_RETURN(0); } -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS int ha_spider::append_direct_update_set_sql_part() { int error_num; @@ -13483,9 +11089,7 @@ int ha_spider::append_direct_update_set_sql_part() } DBUG_RETURN(0); } -#endif -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS int ha_spider::append_dup_update_pushdown_sql_part( const char *alias, uint alias_length @@ -13551,7 +11155,6 @@ int ha_spider::check_update_columns_sql_part() } DBUG_RETURN(0); } -#endif int ha_spider::append_delete_sql_part() { @@ -13959,7 +11562,6 @@ int ha_spider::append_condition_sql_part( DBUG_RETURN(0); } -#ifdef HANDLER_HAS_DIRECT_AGGREGATE int ha_spider::append_sum_select_sql_part( ulong sql_type, const char *alias, @@ -13984,7 +11586,6 @@ int ha_spider::append_sum_select_sql_part( wide_handler->trx->direct_aggregate_count++; DBUG_RETURN(0); } -#endif int ha_spider::append_match_select_sql_part( ulong sql_type, @@ -14042,7 +11643,6 @@ void ha_spider::set_order_to_pos_sql( DBUG_VOID_RETURN; } -#ifdef HANDLER_HAS_DIRECT_AGGREGATE int ha_spider::append_group_by_sql_part( const char *alias, uint alias_length, @@ -14066,7 +11666,6 @@ int ha_spider::append_group_by_sql_part( } DBUG_RETURN(0); } -#endif int ha_spider::append_key_order_for_merge_with_alias_sql_part( const char *alias, @@ -14077,7 +11676,6 @@ int ha_spider::append_key_order_for_merge_with_alias_sql_part( uint roop_count, dbton_id; spider_db_handler *dbton_hdl; DBUG_ENTER("ha_spider::append_key_order_for_merge_with_alias_sql_part"); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE if (result_list.direct_aggregate) { st_select_lex *select_lex = spider_get_select_lex(this); @@ -14088,7 +11686,6 @@ int ha_spider::append_key_order_for_merge_with_alias_sql_part( DBUG_RETURN(0); } } -#endif for (roop_count = 0; roop_count < share->use_sql_dbton_count; roop_count++) { dbton_id = share->use_sql_dbton_ids[roop_count]; @@ -14138,7 +11735,6 @@ int ha_spider::append_key_order_with_alias_sql_part( uint roop_count, dbton_id; spider_db_handler *dbton_hdl; DBUG_ENTER("ha_spider::append_key_order_with_alias_sql_part"); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE if (result_list.direct_aggregate) { st_select_lex *select_lex = spider_get_select_lex(this); @@ -14149,7 +11745,6 @@ int ha_spider::append_key_order_with_alias_sql_part( DBUG_RETURN(0); } } -#endif for (roop_count = 0; roop_count < share->use_sql_dbton_count; roop_count++) { dbton_id = share->use_sql_dbton_ids[roop_count]; @@ -14782,13 +12377,8 @@ int ha_spider::bulk_tmp_table_rnd_next() if (tmp_table[roop_count]) { if ( -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 50200 !(error_num = tmp_table[roop_count]->file->ha_rnd_next( tmp_table[roop_count]->record[0])) -#else - !(error_num = tmp_table[roop_count]->file->rnd_next( - tmp_table[roop_count]->record[0])) -#endif ) { DBUG_RETURN(error_num); } @@ -15362,102 +12952,11 @@ int ha_spider::dml_init() conns[roop_count]->semi_trx_isolation = -1; } } -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS if (wide_handler->insert_with_update) { check_insert_dup_update_pushdown(); } -#endif dml_inited = TRUE; DBUG_RETURN(0); } -#ifdef HA_CAN_BULK_ACCESS -int ha_spider::bulk_access_begin( - void *info -) { - DBUG_ENTER("ha_spider::bulk_access_begin"); - DBUG_PRINT("info",("spider this=%p", this)); - if (bulk_access_started) - { - if (!bulk_access_link_current->next) - { - if (!(bulk_access_link_current->next = create_bulk_access_link())) - { - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - bulk_access_link_current->next->sequence_num = - bulk_access_link_current->sequence_num + 1; - } - bulk_access_link_current = bulk_access_link_current->next; - } else { - if (!bulk_access_link_first) - { - if (!(bulk_access_link_first = create_bulk_access_link())) - { - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - bulk_access_link_first->sequence_num = 0; - } - bulk_access_link_current = bulk_access_link_first; - bulk_access_started = TRUE; - bulk_access_executing = FALSE; - } - bulk_access_link_current->spider-> - check_access_kind(wide_handler->trx->thd); - if ( - (error_num = bulk_access_link_current->spider-> - sync_from_clone_source(this)) || - (error_num = bulk_access_link_current->spider-> - check_access_kind_for_connection(wide_handler->trx->thd, - (lock_type >= TL_WRITE_ALLOW_WRITE))) - ) { - DBUG_RETURN(error_num); - } - bulk_access_link_current->spider->bulk_access_executing = FALSE; - bulk_access_link_current->spider->bulk_access_pre_called = FALSE; - bulk_access_link_current->used = TRUE; - bulk_access_link_current->called = FALSE; - *((void **) info) = bulk_access_link_current; - DBUG_RETURN(0); -} - -int ha_spider::bulk_access_current( - void *info -) { - DBUG_ENTER("ha_spider::bulk_access_current"); - DBUG_PRINT("info",("spider this=%p", this)); - bulk_access_executing = TRUE; - bulk_access_link_exec_tgt = (SPIDER_BULK_ACCESS_LINK *) info; - if (bulk_access_link_exec_tgt->spider->pt_clone_source_handler != this) - { - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_PRINT("info",("spider pt_clone_source_handler=%p", - bulk_access_link_exec_tgt->spider->pt_clone_source_handler)); - /* partitioned */ - uint sequence_num = bulk_access_link_exec_tgt->sequence_num; - for ( - bulk_access_link_exec_tgt = bulk_access_link_first; - bulk_access_link_exec_tgt; - bulk_access_link_exec_tgt = bulk_access_link_exec_tgt->next - ) { - if (bulk_access_link_exec_tgt->sequence_num >= sequence_num) - { - DBUG_ASSERT( - bulk_access_link_exec_tgt->sequence_num == sequence_num); - break; - } - } - } - bulk_access_link_exec_tgt->spider->bulk_access_executing = TRUE; - DBUG_RETURN(0); -} - -void ha_spider::bulk_access_end() -{ - DBUG_ENTER("ha_spider::bulk_access_end"); - DBUG_PRINT("info",("spider this=%p", this)); - bulk_access_started = FALSE; - DBUG_VOID_RETURN; -} -#endif diff --git a/storage/spider/ha_spider.h b/storage/spider/ha_spider.h index cd847760bcf..579700d855b 100644 --- a/storage/spider/ha_spider.h +++ b/storage/spider/ha_spider.h @@ -79,27 +79,10 @@ public: spider_string *blob_buff; SPIDER_POSITION *pushed_pos; SPIDER_POSITION pushed_pos_buf; -#ifdef WITH_PARTITION_STORAGE_ENGINE SPIDER_PARTITION_HANDLER *partition_handler; -#endif bool wide_handler_owner = FALSE; SPIDER_WIDE_HANDLER *wide_handler = NULL; -#ifdef HA_CAN_BULK_ACCESS - int pre_direct_init_result; - bool is_bulk_access_clone; - bool synced_from_clone_source; - bool bulk_access_started; - bool bulk_access_executing; - bool bulk_access_pre_called; - SPIDER_BULK_ACCESS_LINK *bulk_access_link_first; - SPIDER_BULK_ACCESS_LINK *bulk_access_link_current; - SPIDER_BULK_ACCESS_LINK *bulk_access_link_exec_tgt; -/* - bool init_ha_mem_root; - MEM_ROOT ha_mem_root; -*/ -#endif bool is_clone; ha_spider *pt_clone_source_handler; ha_spider *pt_clone_last_searcher; @@ -111,31 +94,21 @@ public: bool da_status; bool use_spatial_index; -#ifdef SPIDER_HAS_GROUP_BY_HANDLER uint idx_for_direct_join; bool use_fields; spider_fields *fields; SPIDER_LINK_IDX_CHAIN *link_idx_chain; SPIDER_LINK_IDX_CHAIN *result_link_idx_chain; -#endif /* for mrr */ bool mrr_with_cnt; uint multi_range_cnt; uint multi_range_hit_point; -#ifdef HA_MRR_USE_DEFAULT_IMPL int multi_range_num; bool have_second_range; KEY_MULTI_RANGE mrr_second_range; spider_string *mrr_key_buff; -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000 range_id_t *multi_range_keys; -#else - char **multi_range_keys; -#endif -#else - KEY_MULTI_RANGE *multi_range_ranges; -#endif char *append_tblnm_alias; uint append_tblnm_alias_length; @@ -148,9 +121,7 @@ public: bool use_pre_action; bool pre_bitmap_checked; bool bulk_insert; -#ifdef HANDLER_HAS_NEED_INFO_FOR_AUTO_INC bool info_auto_called; -#endif #ifdef HANDLER_HAS_CAN_USE_FOR_AUTO_INC_INIT bool auto_inc_temporary; #endif @@ -170,21 +141,15 @@ public: uchar *m_handler_opened; uint *m_handler_id; char **m_handler_cid; -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS bool do_direct_update; uint direct_update_kinds; -#endif spider_index_rnd_init prev_index_rnd_init; -#ifdef HANDLER_HAS_DIRECT_AGGREGATE SPIDER_ITEM_HLD *direct_aggregate_item_first; SPIDER_ITEM_HLD *direct_aggregate_item_current; -#endif ha_rows table_rows; -#ifdef HA_HAS_CHECKSUM_EXTENDED ha_checksum checksum_val; bool checksum_null; uint action_flags; -#endif /* for fulltext search */ bool ft_init_and_first; @@ -226,12 +191,6 @@ public: void check_access_kind( THD *thd ); -#ifdef HA_CAN_BULK_ACCESS - int additional_lock( - THD *thd, - enum thr_lock_type lock_type - ); -#endif THR_LOCK_DATA **store_lock( THD *thd, THR_LOCK_DATA **to, @@ -253,16 +212,7 @@ public: uint idx, bool sorted ); -#ifdef HA_CAN_BULK_ACCESS - int pre_index_init( - uint idx, - bool sorted - ); -#endif int index_end(); -#ifdef HA_CAN_BULK_ACCESS - int pre_index_end(); -#endif int index_read_map( uchar *buf, const uchar *key, @@ -300,8 +250,6 @@ public: int read_range_next(); void reset_no_where_cond(); bool check_no_where_cond(); -#ifdef HA_MRR_USE_DEFAULT_IMPL -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000 ha_rows multi_range_read_info_const( uint keyno, RANGE_SEQ_IF *seq, @@ -320,26 +268,6 @@ public: uint *flags, Cost_estimate *cost ); -#else - ha_rows multi_range_read_info_const( - uint keyno, - RANGE_SEQ_IF *seq, - void *seq_init_param, - uint n_ranges, - uint *bufsz, - uint *flags, - COST_VECT *cost - ); - ha_rows multi_range_read_info( - uint keyno, - uint n_ranges, - uint keys, - uint key_parts, - uint *bufsz, - uint *flags, - COST_VECT *cost - ); -#endif int multi_range_read_init( RANGE_SEQ_IF *seq, void *seq_init_param, @@ -347,7 +275,6 @@ public: uint mode, HANDLER_BUFFER *buf ); -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000 int multi_range_read_next( range_id_t *range_info ); @@ -357,41 +284,10 @@ public: int multi_range_read_next_next( range_id_t *range_info ); -#else - int multi_range_read_next( - char **range_info - ); - int multi_range_read_next_first( - char **range_info - ); - int multi_range_read_next_next( - char **range_info - ); -#endif -#else - int read_multi_range_first( - KEY_MULTI_RANGE **found_range_p, - KEY_MULTI_RANGE *ranges, - uint range_count, - bool sorted, - HANDLER_BUFFER *buffer - ); - int read_multi_range_next( - KEY_MULTI_RANGE **found_range_p - ); -#endif int rnd_init( bool scan ); -#ifdef HA_CAN_BULK_ACCESS - int pre_rnd_init( - bool scan - ); -#endif int rnd_end(); -#ifdef HA_CAN_BULK_ACCESS - int pre_rnd_end(); -#endif int rnd_next( uchar *buf ); @@ -429,20 +325,9 @@ public: key_part_map keypart_map, bool use_parallel ); -#ifdef HA_MRR_USE_DEFAULT_IMPL int pre_multi_range_read_next( bool use_parallel ); -#else - int pre_read_multi_range_first( - KEY_MULTI_RANGE **found_range_p, - KEY_MULTI_RANGE *ranges, - uint range_count, - bool sorted, - HANDLER_BUFFER *buffer, - bool use_parallel - ); -#endif int pre_read_range_first( const key_range *start_key, const key_range *end_key, @@ -464,10 +349,8 @@ public: int check_crd(); int pre_records(); ha_rows records(); -#ifdef HA_HAS_CHECKSUM_EXTENDED int pre_calculate_checksum(); int calculate_checksum(); -#endif const char *table_type() const; ulonglong table_flags() const; ulong table_flags_for_partition(); @@ -485,9 +368,7 @@ public: uint max_supported_key_length() const; uint max_supported_key_part_length() const; uint8 table_cache_type(); -#ifdef HANDLER_HAS_NEED_INFO_FOR_AUTO_INC bool need_info_for_auto_inc(); -#endif #ifdef HANDLER_HAS_CAN_USE_FOR_AUTO_INC_INIT bool can_use_for_auto_inc_init(); #endif @@ -503,31 +384,18 @@ public: ulonglong value ); void release_auto_increment(); -#ifdef SPIDER_HANDLER_START_BULK_INSERT_HAS_FLAGS void start_bulk_insert( ha_rows rows, uint flags ); -#else - void start_bulk_insert( - ha_rows rows - ); -#endif int end_bulk_insert(); int write_row( const uchar *buf ); -#ifdef HA_CAN_BULK_ACCESS - int pre_write_row( - uchar *buf - ); -#endif -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS void direct_update_init( THD *thd, bool hs_request ); -#endif bool start_bulk_update(); int exec_bulk_update( ha_rows *dup_key_found @@ -554,41 +422,11 @@ public: uchar *new_data ); #endif -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS bool check_direct_update_sql_part( st_select_lex *select_lex, longlong select_limit, longlong offset_limit ); -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS_WITH_HS -#ifdef SPIDER_MDEV_16246 - inline int direct_update_rows_init( - List<Item> *update_fields - ) { - return direct_update_rows_init(update_fields, 2, NULL, 0, FALSE, NULL); - } - int direct_update_rows_init( - List<Item> *update_fields, - uint mode, - KEY_MULTI_RANGE *ranges, - uint range_count, - bool sorted, - uchar *new_data - ); -#else - inline int direct_update_rows_init() - { - return direct_update_rows_init(2, NULL, 0, FALSE, NULL); - } - int direct_update_rows_init( - uint mode, - KEY_MULTI_RANGE *ranges, - uint range_count, - bool sorted, - uchar *new_data - ); -#endif -#else #ifdef SPIDER_MDEV_16246 int direct_update_rows_init( List<Item> *update_fields @@ -596,164 +434,24 @@ public: #else int direct_update_rows_init(); #endif -#endif -#ifdef HA_CAN_BULK_ACCESS -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS_WITH_HS -#ifdef SPIDER_MDEV_16246 - inline int pre_direct_update_rows_init( - List<Item> *update_fields - ) { - return pre_direct_update_rows_init(update_fields, 2, NULL, 0, FALSE, NULL); - } - int pre_direct_update_rows_init( - List<Item> *update_fields, - uint mode, - KEY_MULTI_RANGE *ranges, - uint range_count, - bool sorted, - uchar *new_data - ); -#else - inline int pre_direct_update_rows_init() - { - return pre_direct_update_rows_init(2, NULL, 0, FALSE, NULL); - } - int pre_direct_update_rows_init( - uint mode, - KEY_MULTI_RANGE *ranges, - uint range_count, - bool sorted, - uchar *new_data - ); -#endif -#else -#ifdef SPIDER_MDEV_16246 - int pre_direct_update_rows_init( - List<Item> *update_fields - ); -#else - int pre_direct_update_rows_init(); -#endif -#endif -#endif -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS_WITH_HS - inline int direct_update_rows(ha_rows *update_rows, ha_rows *found_rows) - { - return direct_update_rows(NULL, 0, FALSE, NULL, update_rows, found_rows); - } - int direct_update_rows( - KEY_MULTI_RANGE *ranges, - uint range_count, - bool sorted, - uchar *new_data, - ha_rows *update_rows, - ha_rows *found_row - ); -#else int direct_update_rows( ha_rows *update_rows, ha_rows *found_row ); -#endif -#ifdef HA_CAN_BULK_ACCESS -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS_WITH_HS - inline int pre_direct_update_rows() - { - ha_rows update_rows; - ha_rows found_rows; - - return pre_direct_update_rows(NULL, 0, FALSE, NULL, &update_rows, - &found_rows); - } - int pre_direct_update_rows( - KEY_MULTI_RANGE *ranges, - uint range_count, - bool sorted, - uchar *new_data, - ha_rows *update_rows, - ha_rows *found_row - ); -#else - int pre_direct_update_rows(); -#endif -#endif -#endif bool start_bulk_delete(); int end_bulk_delete(); int delete_row( const uchar *buf ); -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS bool check_direct_delete_sql_part( st_select_lex *select_lex, longlong select_limit, longlong offset_limit ); -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS_WITH_HS - inline int direct_delete_rows_init() - { - return direct_delete_rows_init(2, NULL, 0, FALSE); - } - int direct_delete_rows_init( - uint mode, - KEY_MULTI_RANGE *ranges, - uint range_count, - bool sorted - ); -#else int direct_delete_rows_init(); -#endif -#ifdef HA_CAN_BULK_ACCESS -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS_WITH_HS - inline int pre_direct_delete_rows_init() - { - return pre_direct_delete_rows_init(2, NULL, 0, FALSE); - } - int pre_direct_delete_rows_init( - uint mode, - KEY_MULTI_RANGE *ranges, - uint range_count, - bool sorted - ); -#else - int pre_direct_delete_rows_init(); -#endif -#endif -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS_WITH_HS - inline int direct_delete_rows(ha_rows *delete_rows) - { - return direct_delete_rows(NULL, 0, FALSE, delete_rows); - } int direct_delete_rows( - KEY_MULTI_RANGE *ranges, - uint range_count, - bool sorted, ha_rows *delete_rows ); -#else - int direct_delete_rows( - ha_rows *delete_rows - ); -#endif -#ifdef HA_CAN_BULK_ACCESS -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS_WITH_HS - inline int pre_direct_delete_rows() - { - ha_rows delete_rows; - - return pre_direct_delete_rows(NULL, 0, FALSE, &delete_rows); - } - int pre_direct_delete_rows( - KEY_MULTI_RANGE *ranges, - uint range_count, - bool sorted, - ha_rows *delete_rows - ); -#else - int pre_direct_delete_rows(); -#endif -#endif -#endif int delete_all_rows(); int truncate(); double scan_time(); @@ -762,9 +460,6 @@ public: uint ranges, ha_rows rows ); -#ifdef HA_CAN_BULK_ACCESS - void bulk_req_exec(); -#endif const key_map *keys_to_use_for_scanning(); ha_rows estimate_rows_upper_bound(); void print_error( @@ -836,18 +531,14 @@ public: uint info_type, void *info ); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE void return_record_by_parent(); -#endif TABLE *get_table(); void set_ft_discard_bitmap(); void set_searched_bitmap(); void set_clone_searched_bitmap(); void set_searched_bitmap_from_item_list(); void set_select_column_mode(); -#ifdef WITH_PARTITION_STORAGE_ENGINE void check_select_column(bool rnd); -#endif bool check_and_start_bulk_update( spider_bulk_upd_start bulk_upd_start ); @@ -907,34 +598,12 @@ public: bool eq_range, bool sorted ); -#ifdef HA_MRR_USE_DEFAULT_IMPL -#else - int read_multi_range_first_internal( - uchar *buf, - KEY_MULTI_RANGE **found_range_p, - KEY_MULTI_RANGE *ranges, - uint range_count, - bool sorted, - HANDLER_BUFFER *buffer - ); -#endif int ft_read_internal(uchar *buf); int rnd_next_internal(uchar *buf); void check_pre_call( bool use_parallel ); -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS void check_insert_dup_update_pushdown(); -#endif -#ifdef HA_CAN_BULK_ACCESS - SPIDER_BULK_ACCESS_LINK *create_bulk_access_link(); - void delete_bulk_access_link( - SPIDER_BULK_ACCESS_LINK *bulk_access_link - ); - int sync_from_clone_source( - ha_spider *spider - ); -#endif void sync_from_clone_source_base( ha_spider *spider ); @@ -954,10 +623,7 @@ public: int append_insert_sql_part(); int append_update_sql_part(); int append_update_set_sql_part(); -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS int append_direct_update_set_sql_part(); -#endif -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS int append_dup_update_pushdown_sql_part( const char *alias, uint alias_length @@ -967,7 +633,6 @@ public: uint alias_length ); int check_update_columns_sql_part(); -#endif int append_delete_sql_part(); int append_select_sql_part( ulong sql_type @@ -1031,13 +696,11 @@ public: ulong sql_type, bool test_flg ); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE int append_sum_select_sql_part( ulong sql_type, const char *alias, uint alias_length ); -#endif int append_match_select_sql_part( ulong sql_type, const char *alias, @@ -1049,13 +712,11 @@ public: void set_order_to_pos_sql( ulong sql_type ); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE int append_group_by_sql_part( const char *alias, uint alias_length, ulong sql_type ); -#endif int append_key_order_for_merge_with_alias_sql_part( const char *alias, uint alias_length, @@ -1160,13 +821,4 @@ public: int append_lock_tables_list(); int lock_tables(); int dml_init(); -#ifdef HA_CAN_BULK_ACCESS - int bulk_access_begin( - void *info - ); - int bulk_access_current( - void *info - ); - void bulk_access_end(); -#endif }; diff --git a/storage/spider/mysql-test/spider/oracle/include/deinit_child2_1.inc b/storage/spider/mysql-test/spider/oracle/include/deinit_child2_1.inc deleted file mode 100644 index e69de29bb2d..00000000000 --- a/storage/spider/mysql-test/spider/oracle/include/deinit_child2_1.inc +++ /dev/null diff --git a/storage/spider/mysql-test/spider/oracle/include/deinit_child2_2.inc b/storage/spider/mysql-test/spider/oracle/include/deinit_child2_2.inc deleted file mode 100644 index e69de29bb2d..00000000000 --- a/storage/spider/mysql-test/spider/oracle/include/deinit_child2_2.inc +++ /dev/null diff --git a/storage/spider/mysql-test/spider/oracle/include/deinit_child2_3.inc b/storage/spider/mysql-test/spider/oracle/include/deinit_child2_3.inc deleted file mode 100644 index e69de29bb2d..00000000000 --- a/storage/spider/mysql-test/spider/oracle/include/deinit_child2_3.inc +++ /dev/null diff --git a/storage/spider/mysql-test/spider/oracle/include/deinit_child3_1.inc b/storage/spider/mysql-test/spider/oracle/include/deinit_child3_1.inc deleted file mode 100644 index 74c8efa90aa..00000000000 --- a/storage/spider/mysql-test/spider/oracle/include/deinit_child3_1.inc +++ /dev/null @@ -1,3 +0,0 @@ ---let $TEST_ENGINE_TYPE= $CHILD3_1_ENGINE_TYPE ---let $INIT_TEST_ENGINE= $INIT_CHILD3_1_ENGINE ---source ../../include/deinit_engine.inc diff --git a/storage/spider/mysql-test/spider/oracle/include/deinit_child3_2.inc b/storage/spider/mysql-test/spider/oracle/include/deinit_child3_2.inc deleted file mode 100644 index f42a980ad23..00000000000 --- a/storage/spider/mysql-test/spider/oracle/include/deinit_child3_2.inc +++ /dev/null @@ -1,3 +0,0 @@ ---let $TEST_ENGINE_TYPE= $CHILD3_2_ENGINE_TYPE ---let $INIT_TEST_ENGINE= $INIT_CHILD3_2_ENGINE ---source ../../include/deinit_engine.inc diff --git a/storage/spider/mysql-test/spider/oracle/include/deinit_child3_3.inc b/storage/spider/mysql-test/spider/oracle/include/deinit_child3_3.inc deleted file mode 100644 index 0696fb991cf..00000000000 --- a/storage/spider/mysql-test/spider/oracle/include/deinit_child3_3.inc +++ /dev/null @@ -1,3 +0,0 @@ ---let $TEST_ENGINE_TYPE= $CHILD3_3_ENGINE_TYPE ---let $INIT_TEST_ENGINE= $INIT_CHILD3_3_ENGINE ---source ../../include/deinit_engine.inc diff --git a/storage/spider/mysql-test/spider/oracle/include/deinit_master_1.inc b/storage/spider/mysql-test/spider/oracle/include/deinit_master_1.inc deleted file mode 100644 index c19e376d10a..00000000000 --- a/storage/spider/mysql-test/spider/oracle/include/deinit_master_1.inc +++ /dev/null @@ -1 +0,0 @@ ---source ../../include/deinit_spider.inc diff --git a/storage/spider/mysql-test/spider/oracle/include/deinit_slave1_1.inc b/storage/spider/mysql-test/spider/oracle/include/deinit_slave1_1.inc deleted file mode 100644 index e69de29bb2d..00000000000 --- a/storage/spider/mysql-test/spider/oracle/include/deinit_slave1_1.inc +++ /dev/null diff --git a/storage/spider/mysql-test/spider/oracle/include/ha_deinit_child2_1.inc b/storage/spider/mysql-test/spider/oracle/include/ha_deinit_child2_1.inc deleted file mode 100644 index e69de29bb2d..00000000000 --- a/storage/spider/mysql-test/spider/oracle/include/ha_deinit_child2_1.inc +++ /dev/null diff --git a/storage/spider/mysql-test/spider/oracle/include/ha_deinit_child2_2.inc b/storage/spider/mysql-test/spider/oracle/include/ha_deinit_child2_2.inc deleted file mode 100644 index e69de29bb2d..00000000000 --- a/storage/spider/mysql-test/spider/oracle/include/ha_deinit_child2_2.inc +++ /dev/null diff --git a/storage/spider/mysql-test/spider/oracle/include/ha_deinit_child2_3.inc b/storage/spider/mysql-test/spider/oracle/include/ha_deinit_child2_3.inc deleted file mode 100644 index e69de29bb2d..00000000000 --- a/storage/spider/mysql-test/spider/oracle/include/ha_deinit_child2_3.inc +++ /dev/null diff --git a/storage/spider/mysql-test/spider/oracle/include/ha_deinit_child3_1.inc b/storage/spider/mysql-test/spider/oracle/include/ha_deinit_child3_1.inc deleted file mode 100644 index c19e376d10a..00000000000 --- a/storage/spider/mysql-test/spider/oracle/include/ha_deinit_child3_1.inc +++ /dev/null @@ -1 +0,0 @@ ---source ../../include/deinit_spider.inc diff --git a/storage/spider/mysql-test/spider/oracle/include/ha_deinit_child3_2.inc b/storage/spider/mysql-test/spider/oracle/include/ha_deinit_child3_2.inc deleted file mode 100644 index c19e376d10a..00000000000 --- a/storage/spider/mysql-test/spider/oracle/include/ha_deinit_child3_2.inc +++ /dev/null @@ -1 +0,0 @@ ---source ../../include/deinit_spider.inc diff --git a/storage/spider/mysql-test/spider/oracle/include/ha_deinit_child3_3.inc b/storage/spider/mysql-test/spider/oracle/include/ha_deinit_child3_3.inc deleted file mode 100644 index c19e376d10a..00000000000 --- a/storage/spider/mysql-test/spider/oracle/include/ha_deinit_child3_3.inc +++ /dev/null @@ -1 +0,0 @@ ---source ../../include/deinit_spider.inc diff --git a/storage/spider/mysql-test/spider/oracle/include/ha_deinit_master_1.inc b/storage/spider/mysql-test/spider/oracle/include/ha_deinit_master_1.inc deleted file mode 100644 index e69de29bb2d..00000000000 --- a/storage/spider/mysql-test/spider/oracle/include/ha_deinit_master_1.inc +++ /dev/null diff --git a/storage/spider/mysql-test/spider/oracle/include/ha_init_child2_1.inc b/storage/spider/mysql-test/spider/oracle/include/ha_init_child2_1.inc deleted file mode 100644 index 2684829408d..00000000000 --- a/storage/spider/mysql-test/spider/oracle/include/ha_init_child2_1.inc +++ /dev/null @@ -1,8 +0,0 @@ -let $CHILD2_1_HA_AS_DROP_TABLES= - $CHILD2_1_DROP_TABLES; -let $CHILD2_1_HA_AS_CREATE_TABLES= - $CHILD2_1_CREATE_TABLES; -let $CHILD2_1_HA_AS_DROP_TABLES2= - $CHILD2_1_DROP_TABLES2; -let $CHILD2_1_HA_AS_CREATE_TABLES2= - $CHILD2_1_CREATE_TABLES2; diff --git a/storage/spider/mysql-test/spider/oracle/include/ha_init_child2_2.inc b/storage/spider/mysql-test/spider/oracle/include/ha_init_child2_2.inc deleted file mode 100644 index 205eaa6fe35..00000000000 --- a/storage/spider/mysql-test/spider/oracle/include/ha_init_child2_2.inc +++ /dev/null @@ -1,4 +0,0 @@ -let $CHILD2_2_HA_DROP_TABLES= - $CHILD2_2_DROP_TABLES; -let $CHILD2_2_HA_CREATE_TABLES= - $CHILD2_2_CREATE_TABLES; diff --git a/storage/spider/mysql-test/spider/oracle/include/ha_init_child2_3.inc b/storage/spider/mysql-test/spider/oracle/include/ha_init_child2_3.inc deleted file mode 100644 index 55cb858372c..00000000000 --- a/storage/spider/mysql-test/spider/oracle/include/ha_init_child2_3.inc +++ /dev/null @@ -1,4 +0,0 @@ -let $CHILD2_3_HA_DROP_TABLES= - $CHILD2_3_DROP_TABLES; -let $CHILD2_3_HA_CREATE_TABLES= - $CHILD2_3_CREATE_TABLES; diff --git a/storage/spider/mysql-test/spider/oracle/include/ha_init_child3_1.inc b/storage/spider/mysql-test/spider/oracle/include/ha_init_child3_1.inc deleted file mode 100644 index 8357f0bdbc2..00000000000 --- a/storage/spider/mysql-test/spider/oracle/include/ha_init_child3_1.inc +++ /dev/null @@ -1,140 +0,0 @@ ---let $CHILD3_1_ENGINE_TYPE=Spider ---let $CHILD3_1_ENGINE=ENGINE=Spider ---source ../include/init_spider.inc -eval INSERT INTO mysql.spider_link_mon_servers -(db_name, table_name, link_id, sid, server, scheme, host, port, socket, - username, password, ssl_ca, ssl_capath, ssl_cert, ssl_cipher, ssl_key, - ssl_verify_server_cert, default_file, default_group) VALUES -('%auto_test_local%', '%ta_l%', '%', $CHILD3_1_SERVER_ID, 's_3_1', NULL, NULL, - NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, NULL, NULL), -('%auto_test_local%', '%ta_l%', '%', $CHILD3_2_SERVER_ID, 's_3_2', NULL, NULL, - NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, NULL, NULL), -('%auto_test_local%', '%ta_l%', '%', $CHILD3_3_SERVER_ID, 's_3_3', NULL, NULL, - NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, NULL, NULL); -let $CHILD3_1_CHECK_LINK_STATUS= - SELECT db_name, table_name, link_id, link_status FROM mysql.spider_tables - ORDER BY db_name, table_name, link_id; -let $CHILD3_1_CHECK_LINK_FAILED_LOG= - SELECT db_name, table_name, link_id FROM mysql.spider_link_failed_log; -let $CHILD3_1_SET_RECOVERY_STATUS_2_1= - ALTER TABLE ta_l - CONNECTION='host "localhost", user "root", password "", - msi "$CHILD3_1_SERVER_ID", mkd "2", - database "auto_test_remote auto_test_remote2", lst "0 2"'; -let $CHILD3_1_SET_OK_STATUS_2_1= - ALTER TABLE ta_l - CONNECTION='host "localhost", user "root", password "", - msi "$CHILD3_1_SERVER_ID", mkd "2", - database "auto_test_remote auto_test_remote2", lst "0 1"'; -let $CHILD3_1_SET_OK_STATUS_AS_2_1= - ALTER TABLE ta_l - CONNECTION='host "localhost", user "root", password "", - msi "$CHILD3_1_SERVER_ID", mkd "2", alc "1", - database "auto_test_remote auto_test_remote2", lst "1 0"'; - -let $CHILD3_1_DROP_TABLES_HA_2_1= - DROP TABLE IF EXISTS ta_l; -if ($VERSION_COMPILE_OS_WIN) -{ - let $CHILD3_1_CREATE_TABLES_HA_2_1= - CREATE TABLE ta_l ( - a INT DEFAULT 10, - b CHAR(1) DEFAULT 'c', - c DATETIME DEFAULT '1999-10-10 10:10:10', - PRIMARY KEY(a) - ) $CHILD3_1_ENGINE $CHILD3_1_CHARSET - COMMENT='port "$CHILD2_1_MYPORT $CHILD2_2_MYPORT", table "ta_r ta_r3"' - CONNECTION='host "localhost", user "root", password "", - msi "$CHILD3_1_SERVER_ID", mkd "2", - database "auto_test_remote auto_test_remote2"'; - let $CHILD3_1_CREATE_TABLES_HA_AS_2_1= - CREATE TABLE ta_l ( - a INT DEFAULT 10, - b CHAR(1) DEFAULT 'c', - c DATETIME DEFAULT '1999-10-10 10:10:10', - PRIMARY KEY(a) - ) $CHILD3_1_ENGINE $CHILD3_1_CHARSET - COMMENT='port "$CHILD2_1_MYPORT $CHILD2_2_MYPORT", table "ta_r ta_r3"' - CONNECTION='host "localhost", user "root", password "", - msi "$CHILD3_1_SERVER_ID", mkd "2", alc "1", - database "auto_test_remote auto_test_remote2"'; -} -if (!$VERSION_COMPILE_OS_WIN) -{ - let $CHILD3_1_CREATE_TABLES_HA_2_1= - CREATE TABLE ta_l ( - a INT DEFAULT 10, - b CHAR(1) DEFAULT 'c', - c DATETIME DEFAULT '1999-10-10 10:10:10', - PRIMARY KEY(a) - ) $CHILD3_1_ENGINE $CHILD3_1_CHARSET - COMMENT='socket "$CHILD2_1_MYSOCK $CHILD2_2_MYSOCK", table "ta_r ta_r3"' - CONNECTION='host "localhost", user "root", password "", - msi "$CHILD3_1_SERVER_ID", mkd "2", - database "auto_test_remote auto_test_remote2"'; - let $CHILD3_1_CREATE_TABLES_HA_AS_2_1= - CREATE TABLE ta_l ( - a INT DEFAULT 10, - b CHAR(1) DEFAULT 'c', - c DATETIME DEFAULT '1999-10-10 10:10:10', - PRIMARY KEY(a) - ) $CHILD3_1_ENGINE $CHILD3_1_CHARSET - COMMENT='socket "$CHILD2_1_MYSOCK $CHILD2_2_MYSOCK", table "ta_r ta_r3"' - CONNECTION='host "localhost", user "root", password "", - msi "$CHILD3_1_SERVER_ID", mkd "2", alc "1", - database "auto_test_remote auto_test_remote2"'; -} -let $CHILD3_1_DROP_TABLES_HA_P_2_1= - DROP TABLE IF EXISTS ta_l2; -let $CHILD3_1_CREATE_TABLES_HA_P_2_1= - CREATE TABLE ta_l2 ( - a INT DEFAULT 10, - b CHAR(1) DEFAULT 'c', - c DATETIME DEFAULT '1999-10-10 10:10:10', - PRIMARY KEY(a) - ) $CHILD3_1_ENGINE $CHILD3_1_CHARSET - COMMENT='msi "$CHILD3_1_SERVER_ID", mkd "2"' - PARTITION BY KEY(a) ( - PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', - PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001"' - ); -let $CHILD3_1_CREATE_TABLES_HA_AS_P_2_1= - CREATE TABLE ta_l2 ( - a INT DEFAULT 10, - b CHAR(1) DEFAULT 'c', - c DATETIME DEFAULT '1999-10-10 10:10:10', - PRIMARY KEY(a) - ) $CHILD3_1_ENGINE $CHILD3_1_CHARSET - COMMENT='msi "$CHILD3_1_SERVER_ID", mkd "2", alc "1"' - PARTITION BY KEY(a) ( - PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', - PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001"' - ); -let $CHILD3_1_SET_RECOVERY_STATUS_P_2_1= - ALTER TABLE ta_l2 - PARTITION BY KEY(a) ( - PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', - PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001", lst "0 2"' - ); -let $CHILD3_1_SET_OK_STATUS_P_2_1= - ALTER TABLE ta_l2 - PARTITION BY KEY(a) ( - PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', - PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001", lst "0 1"' - ); -let $CHILD3_1_SET_OK_STATUS_AS_P_2_1= - ALTER TABLE ta_l2 - PARTITION BY KEY(a) ( - PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', - PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001", lst "1 0"' - ); diff --git a/storage/spider/mysql-test/spider/oracle/include/ha_init_child3_2.inc b/storage/spider/mysql-test/spider/oracle/include/ha_init_child3_2.inc deleted file mode 100644 index 3ffcec24f51..00000000000 --- a/storage/spider/mysql-test/spider/oracle/include/ha_init_child3_2.inc +++ /dev/null @@ -1,140 +0,0 @@ ---let $CHILD3_2_ENGINE_TYPE=Spider ---let $CHILD3_2_ENGINE=ENGINE=Spider ---source ../include/init_spider.inc -eval INSERT INTO mysql.spider_link_mon_servers -(db_name, table_name, link_id, sid, server, scheme, host, port, socket, - username, password, ssl_ca, ssl_capath, ssl_cert, ssl_cipher, ssl_key, - ssl_verify_server_cert, default_file, default_group) VALUES -('%auto_test_local%', '%ta_l%', '%', $CHILD3_1_SERVER_ID, 's_3_1', NULL, NULL, - NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, NULL, NULL), -('%auto_test_local%', '%ta_l%', '%', $CHILD3_2_SERVER_ID, 's_3_2', NULL, NULL, - NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, NULL, NULL), -('%auto_test_local%', '%ta_l%', '%', $CHILD3_3_SERVER_ID, 's_3_3', NULL, NULL, - NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, NULL, NULL); -let $CHILD3_2_CHECK_LINK_STATUS= - SELECT db_name, table_name, link_id, link_status FROM mysql.spider_tables - ORDER BY db_name, table_name, link_id; -let $CHILD3_2_CHECK_LINK_FAILED_LOG= - SELECT db_name, table_name, link_id FROM mysql.spider_link_failed_log; -let $CHILD3_2_SET_RECOVERY_STATUS_2_1= - ALTER TABLE ta_l - CONNECTION='host "localhost", user "root", password "", - msi "$CHILD3_1_SERVER_ID", mkd "2", - database "auto_test_remote auto_test_remote2", lst "0 2"'; -let $CHILD3_2_SET_OK_STATUS_2_1= - ALTER TABLE ta_l - CONNECTION='host "localhost", user "root", password "", - msi "$CHILD3_1_SERVER_ID", mkd "2", - database "auto_test_remote auto_test_remote2", lst "0 1"'; -let $CHILD3_2_SET_OK_STATUS_AS_2_1= - ALTER TABLE ta_l - CONNECTION='host "localhost", user "root", password "", - msi "$CHILD3_1_SERVER_ID", mkd "2", alc "1", - database "auto_test_remote auto_test_remote2", lst "1 0"'; - -let $CHILD3_2_DROP_TABLES_HA_2_1= - DROP TABLE IF EXISTS ta_l; -if ($VERSION_COMPILE_OS_WIN) -{ - let $CHILD3_2_CREATE_TABLES_HA_2_1= - CREATE TABLE ta_l ( - a INT DEFAULT 10, - b CHAR(1) DEFAULT 'c', - c DATETIME DEFAULT '1999-10-10 10:10:10', - PRIMARY KEY(a) - ) $CHILD3_2_ENGINE $CHILD3_2_CHARSET - COMMENT='port "$CHILD2_1_MYPORT $CHILD2_2_MYPORT", table "ta_r ta_r3"' - CONNECTION='host "localhost", user "root", password "", - msi "$CHILD3_1_SERVER_ID", mkd "2", - database "auto_test_remote auto_test_remote2"'; - let $CHILD3_2_CREATE_TABLES_HA_AS_2_1= - CREATE TABLE ta_l ( - a INT DEFAULT 10, - b CHAR(1) DEFAULT 'c', - c DATETIME DEFAULT '1999-10-10 10:10:10', - PRIMARY KEY(a) - ) $CHILD3_2_ENGINE $CHILD3_2_CHARSET - COMMENT='port "$CHILD2_1_MYPORT $CHILD2_2_MYPORT", table "ta_r ta_r3"' - CONNECTION='host "localhost", user "root", password "", - msi "$CHILD3_1_SERVER_ID", mkd "2", alc "1", - database "auto_test_remote auto_test_remote2"'; -} -if (!$VERSION_COMPILE_OS_WIN) -{ - let $CHILD3_2_CREATE_TABLES_HA_2_1= - CREATE TABLE ta_l ( - a INT DEFAULT 10, - b CHAR(1) DEFAULT 'c', - c DATETIME DEFAULT '1999-10-10 10:10:10', - PRIMARY KEY(a) - ) $CHILD3_2_ENGINE $CHILD3_2_CHARSET - COMMENT='socket "$CHILD2_1_MYSOCK $CHILD2_2_MYSOCK", table "ta_r ta_r3"' - CONNECTION='host "localhost", user "root", password "", - msi "$CHILD3_1_SERVER_ID", mkd "2", - database "auto_test_remote auto_test_remote2"'; - let $CHILD3_2_CREATE_TABLES_HA_AS_2_1= - CREATE TABLE ta_l ( - a INT DEFAULT 10, - b CHAR(1) DEFAULT 'c', - c DATETIME DEFAULT '1999-10-10 10:10:10', - PRIMARY KEY(a) - ) $CHILD3_2_ENGINE $CHILD3_2_CHARSET - COMMENT='socket "$CHILD2_1_MYSOCK $CHILD2_2_MYSOCK", table "ta_r ta_r3"' - CONNECTION='host "localhost", user "root", password "", - msi "$CHILD3_1_SERVER_ID", mkd "2", alc "1", - database "auto_test_remote auto_test_remote2"'; -} -let $CHILD3_2_DROP_TABLES_HA_P_2_1= - DROP TABLE IF EXISTS ta_l2; -let $CHILD3_2_CREATE_TABLES_HA_P_2_1= - CREATE TABLE ta_l2 ( - a INT DEFAULT 10, - b CHAR(1) DEFAULT 'c', - c DATETIME DEFAULT '1999-10-10 10:10:10', - PRIMARY KEY(a) - ) $CHILD3_2_ENGINE $CHILD3_2_CHARSET - COMMENT='msi "$CHILD3_1_SERVER_ID", mkd "2"' - PARTITION BY KEY(a) ( - PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', - PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001"' - ); -let $CHILD3_2_CREATE_TABLES_HA_AS_P_2_1= - CREATE TABLE ta_l2 ( - a INT DEFAULT 10, - b CHAR(1) DEFAULT 'c', - c DATETIME DEFAULT '1999-10-10 10:10:10', - PRIMARY KEY(a) - ) $CHILD3_2_ENGINE $CHILD3_2_CHARSET - COMMENT='msi "$CHILD3_1_SERVER_ID", mkd "2", alc "1"' - PARTITION BY KEY(a) ( - PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', - PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001"' - ); -let $CHILD3_2_SET_RECOVERY_STATUS_P_2_1= - ALTER TABLE ta_l2 - PARTITION BY KEY(a) ( - PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', - PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001", lst "0 2"' - ); -let $CHILD3_2_SET_OK_STATUS_P_2_1= - ALTER TABLE ta_l2 - PARTITION BY KEY(a) ( - PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', - PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001", lst "0 1"' - ); -let $CHILD3_2_SET_OK_STATUS_AS_P_2_1= - ALTER TABLE ta_l2 - PARTITION BY KEY(a) ( - PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', - PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001", lst "1 0"' - ); diff --git a/storage/spider/mysql-test/spider/oracle/include/ha_init_child3_3.inc b/storage/spider/mysql-test/spider/oracle/include/ha_init_child3_3.inc deleted file mode 100644 index 67bd00109f5..00000000000 --- a/storage/spider/mysql-test/spider/oracle/include/ha_init_child3_3.inc +++ /dev/null @@ -1,140 +0,0 @@ ---let $CHILD3_3_ENGINE_TYPE=Spider ---let $CHILD3_3_ENGINE=ENGINE=Spider ---source ../include/init_spider.inc -eval INSERT INTO mysql.spider_link_mon_servers -(db_name, table_name, link_id, sid, server, scheme, host, port, socket, - username, password, ssl_ca, ssl_capath, ssl_cert, ssl_cipher, ssl_key, - ssl_verify_server_cert, default_file, default_group) VALUES -('%auto_test_local%', '%ta_l%', '%', $CHILD3_1_SERVER_ID, 's_3_1', NULL, NULL, - NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, NULL, NULL), -('%auto_test_local%', '%ta_l%', '%', $CHILD3_2_SERVER_ID, 's_3_2', NULL, NULL, - NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, NULL, NULL), -('%auto_test_local%', '%ta_l%', '%', $CHILD3_3_SERVER_ID, 's_3_3', NULL, NULL, - NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, NULL, NULL); -let $CHILD3_3_CHECK_LINK_STATUS= - SELECT db_name, table_name, link_id, link_status FROM mysql.spider_tables - ORDER BY db_name, table_name, link_id; -let $CHILD3_3_CHECK_LINK_FAILED_LOG= - SELECT db_name, table_name, link_id FROM mysql.spider_link_failed_log; -let $CHILD3_3_SET_RECOVERY_STATUS_2_1= - ALTER TABLE ta_l - CONNECTION='host "localhost", user "root", password "", - msi "$CHILD3_1_SERVER_ID", mkd "2", - database "auto_test_remote auto_test_remote2", lst "0 2"'; -let $CHILD3_3_SET_OK_STATUS_2_1= - ALTER TABLE ta_l - CONNECTION='host "localhost", user "root", password "", - msi "$CHILD3_1_SERVER_ID", mkd "2", - database "auto_test_remote auto_test_remote2", lst "0 1"'; -let $CHILD3_3_SET_OK_STATUS_AS_2_1= - ALTER TABLE ta_l - CONNECTION='host "localhost", user "root", password "", - msi "$CHILD3_1_SERVER_ID", mkd "2", alc "1", - database "auto_test_remote auto_test_remote2", lst "1 0"'; - -let $CHILD3_3_DROP_TABLES_HA_2_1= - DROP TABLE IF EXISTS ta_l; -if ($VERSION_COMPILE_OS_WIN) -{ - let $CHILD3_3_CREATE_TABLES_HA_2_1= - CREATE TABLE ta_l ( - a INT DEFAULT 10, - b CHAR(1) DEFAULT 'c', - c DATETIME DEFAULT '1999-10-10 10:10:10', - PRIMARY KEY(a) - ) $CHILD3_3_ENGINE $CHILD3_3_CHARSET - COMMENT='port "$CHILD2_1_MYPORT $CHILD2_2_MYPORT", table "ta_r ta_r3"' - CONNECTION='host "localhost", user "root", password "", - msi "$CHILD3_1_SERVER_ID", mkd "2", - database "auto_test_remote auto_test_remote2"'; - let $CHILD3_3_CREATE_TABLES_HA_AS_2_1= - CREATE TABLE ta_l ( - a INT DEFAULT 10, - b CHAR(1) DEFAULT 'c', - c DATETIME DEFAULT '1999-10-10 10:10:10', - PRIMARY KEY(a) - ) $CHILD3_3_ENGINE $CHILD3_3_CHARSET - COMMENT='port "$CHILD2_1_MYPORT $CHILD2_2_MYPORT", table "ta_r ta_r3"' - CONNECTION='host "localhost", user "root", password "", - msi "$CHILD3_1_SERVER_ID", mkd "2", alc "1", - database "auto_test_remote auto_test_remote2"'; -} -if (!$VERSION_COMPILE_OS_WIN) -{ - let $CHILD3_3_CREATE_TABLES_HA_2_1= - CREATE TABLE ta_l ( - a INT DEFAULT 10, - b CHAR(1) DEFAULT 'c', - c DATETIME DEFAULT '1999-10-10 10:10:10', - PRIMARY KEY(a) - ) $CHILD3_3_ENGINE $CHILD3_3_CHARSET - COMMENT='socket "$CHILD2_1_MYSOCK $CHILD2_2_MYSOCK", table "ta_r ta_r3"' - CONNECTION='host "localhost", user "root", password "", - msi "$CHILD3_1_SERVER_ID", mkd "2", - database "auto_test_remote auto_test_remote2"'; - let $CHILD3_3_CREATE_TABLES_HA_AS_2_1= - CREATE TABLE ta_l ( - a INT DEFAULT 10, - b CHAR(1) DEFAULT 'c', - c DATETIME DEFAULT '1999-10-10 10:10:10', - PRIMARY KEY(a) - ) $CHILD3_3_ENGINE $CHILD3_3_CHARSET - COMMENT='socket "$CHILD2_1_MYSOCK $CHILD2_2_MYSOCK", table "ta_r ta_r3"' - CONNECTION='host "localhost", user "root", password "", - msi "$CHILD3_1_SERVER_ID", mkd "2", alc "1", - database "auto_test_remote auto_test_remote2"'; -} -let $CHILD3_3_DROP_TABLES_HA_P_2_1= - DROP TABLE IF EXISTS ta_l2; -let $CHILD3_3_CREATE_TABLES_HA_P_2_1= - CREATE TABLE ta_l2 ( - a INT DEFAULT 10, - b CHAR(1) DEFAULT 'c', - c DATETIME DEFAULT '1999-10-10 10:10:10', - PRIMARY KEY(a) - ) $CHILD3_3_ENGINE $CHILD3_3_CHARSET - COMMENT='msi "$CHILD3_1_SERVER_ID", mkd "2"' - PARTITION BY KEY(a) ( - PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', - PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001"' - ); -let $CHILD3_3_CREATE_TABLES_HA_AS_P_2_1= - CREATE TABLE ta_l2 ( - a INT DEFAULT 10, - b CHAR(1) DEFAULT 'c', - c DATETIME DEFAULT '1999-10-10 10:10:10', - PRIMARY KEY(a) - ) $CHILD3_3_ENGINE $CHILD3_3_CHARSET - COMMENT='msi "$CHILD3_1_SERVER_ID", mkd "2", alc "1"' - PARTITION BY KEY(a) ( - PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', - PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001"' - ); -let $CHILD3_3_SET_RECOVERY_STATUS_P_2_1= - ALTER TABLE ta_l2 - PARTITION BY KEY(a) ( - PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', - PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001", lst "0 2"' - ); -let $CHILD3_3_SET_OK_STATUS_P_2_1= - ALTER TABLE ta_l2 - PARTITION BY KEY(a) ( - PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', - PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001", lst "0 1"' - ); -let $CHILD3_3_SET_OK_STATUS_AS_P_2_1= - ALTER TABLE ta_l2 - PARTITION BY KEY(a) ( - PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', - PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001", lst "1 0"' - ); diff --git a/storage/spider/mysql-test/spider/oracle/include/ha_init_master_1.inc b/storage/spider/mysql-test/spider/oracle/include/ha_init_master_1.inc deleted file mode 100644 index 8ace39ab641..00000000000 --- a/storage/spider/mysql-test/spider/oracle/include/ha_init_master_1.inc +++ /dev/null @@ -1,109 +0,0 @@ -eval INSERT INTO mysql.spider_link_mon_servers -(db_name, table_name, link_id, sid, server, scheme, host, port, socket, - username, password, ssl_ca, ssl_capath, ssl_cert, ssl_cipher, ssl_key, - ssl_verify_server_cert, default_file, default_group) VALUES -('%auto_test_local%', '%ta_l%', '%', $CHILD3_1_SERVER_ID, 's_3_1', NULL, NULL, - NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, NULL, NULL), -('%auto_test_local%', '%ta_l%', '%', $CHILD3_2_SERVER_ID, 's_3_2', NULL, NULL, - NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, NULL, NULL), -('%auto_test_local%', '%ta_l%', '%', $CHILD3_3_SERVER_ID, 's_3_3', NULL, NULL, - NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, NULL, NULL); -let $MASTER_1_CHECK_LINK_STATUS= - SELECT db_name, table_name, link_id, link_status FROM mysql.spider_tables - ORDER BY db_name, table_name, link_id; -let $MASTER_1_CHECK_LINK_FAILED_LOG= - SELECT db_name, table_name, link_id FROM mysql.spider_link_failed_log; -let $MASTER_1_SET_RECOVERY_STATUS_2_1= - ALTER TABLE ta_l - CONNECTION='host "$ORACLE_HOST", user "$ORACLE_USER", - password "$ORACLE_PASSWORD", msi "$CHILD3_1_SERVER_ID", mkd "2", - database "$ORACLE_DATABASE", lst "0 2"'; -let $MASTER_1_SET_OK_STATUS_2_1= - ALTER TABLE ta_l - CONNECTION='host "$ORACLE_HOST", user "$ORACLE_USER", - password "$ORACLE_PASSWORD", msi "$CHILD3_1_SERVER_ID", mkd "2", - database "$ORACLE_DATABASE", lst "0 1"'; -let $MASTER_1_SET_OK_STATUS_AS_2_1= - ALTER TABLE ta_l - CONNECTION='host "$ORACLE_HOST", user "$ORACLE_USER", - password "$ORACLE_PASSWORD", msi "$CHILD3_1_SERVER_ID", mkd "2", alc "1", - database "$ORACLE_DATABASE", lst "1 0"'; -let $MASTER_1_COPY_TABLES_2_1= - SELECT spider_copy_tables('ta_l', '0', '1'); - -if ($VERSION_COMPILE_OS_WIN) -{ - let $MASTER_1_COMMENT_HA_2_1= - COMMENT='port "$CHILD2_1_MYPORT $CHILD2_2_MYPORT", table "ta_r ta_r3", - wrapper "oracle"' - CONNECTION='host "$ORACLE_HOST", user "$ORACLE_USER", - password "$ORACLE_PASSWORD", msi "$CHILD3_1_SERVER_ID", mkd "2", - database "$ORACLE_DATABASE"'; - let $MASTER_1_COMMENT_HA_AS_2_1= - COMMENT='port "$CHILD2_1_MYPORT $CHILD2_2_MYPORT", table "ta_r ta_r3", - wrapper "oracle"' - CONNECTION='host "$ORACLE_HOST", user "$ORACLE_USER", - password "$ORACLE_PASSWORD", msi "$CHILD3_1_SERVER_ID", mkd "2", alc "1", - database "$ORACLE_DATABASE"'; -} -if (!$VERSION_COMPILE_OS_WIN) -{ - let $MASTER_1_COMMENT_HA_2_1= - COMMENT='socket "$CHILD2_1_MYSOCK $CHILD2_2_MYSOCK", table "ta_r ta_r3", - wrapper "oracle"' - CONNECTION='host "$ORACLE_HOST", user "$ORACLE_USER", - password "$ORACLE_PASSWORD", msi "$CHILD3_1_SERVER_ID", mkd "2", - database "$ORACLE_DATABASE"'; - let $MASTER_1_COMMENT_HA_AS_2_1= - COMMENT='socket "$CHILD2_1_MYSOCK $CHILD2_2_MYSOCK", table "ta_r ta_r3", - wrapper "oracle"' - CONNECTION='host "$ORACLE_HOST", user "$ORACLE_USER", - password "$ORACLE_PASSWORD", msi "$CHILD3_1_SERVER_ID", mkd "2", alc "1", - database "$ORACLE_DATABASE"'; -} -let $MASTER_1_COMMENT_HA_P_2_1= - COMMENT='msi "$CHILD3_1_SERVER_ID", mkd "2"' - PARTITION BY KEY(a) ( - PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', - PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001"' - ); -let $MASTER_1_COMMENT_HA_AS_P_2_1= - COMMENT='msi "$CHILD3_1_SERVER_ID", mkd "2", alc "1"' - PARTITION BY KEY(a) ( - PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', - PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001"' - ); -let $MASTER_1_SET_RECOVERY_STATUS_P_2_1= - ALTER TABLE ta_l2 - PARTITION BY KEY(a) ( - PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', - PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001", lst "0 2"' - ); -let $MASTER_1_SET_OK_STATUS_P_2_1= - ALTER TABLE ta_l2 - PARTITION BY KEY(a) ( - PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', - PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001", lst "0 1"' - ); -let $MASTER_1_SET_OK_STATUS_AS_P_2_1= - ALTER TABLE ta_l2 - PARTITION BY KEY(a) ( - PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', - PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001", lst "1 0"' - ); -let $MASTER_1_COPY_TABLES_P_2_1= - SELECT spider_copy_tables('ta_l2#P#pt2', '0', '1'); -let $MASTER_1_CHECK_HA_STATUS= - SHOW GLOBAL STATUS LIKE 'Spider_mon_table_cache_version%'; -let $MASTER_1_CHANGE_HA_MON= - SELECT spider_flush_table_mon_cache(); diff --git a/storage/spider/mysql-test/spider/oracle/include/hs_deinit_child2_1.inc b/storage/spider/mysql-test/spider/oracle/include/hs_deinit_child2_1.inc deleted file mode 100644 index e69de29bb2d..00000000000 --- a/storage/spider/mysql-test/spider/oracle/include/hs_deinit_child2_1.inc +++ /dev/null diff --git a/storage/spider/mysql-test/spider/oracle/include/hs_deinit_child2_2.inc b/storage/spider/mysql-test/spider/oracle/include/hs_deinit_child2_2.inc deleted file mode 100644 index e69de29bb2d..00000000000 --- a/storage/spider/mysql-test/spider/oracle/include/hs_deinit_child2_2.inc +++ /dev/null diff --git a/storage/spider/mysql-test/spider/oracle/include/hs_deinit_child2_3.inc b/storage/spider/mysql-test/spider/oracle/include/hs_deinit_child2_3.inc deleted file mode 100644 index e69de29bb2d..00000000000 --- a/storage/spider/mysql-test/spider/oracle/include/hs_deinit_child2_3.inc +++ /dev/null diff --git a/storage/spider/mysql-test/spider/oracle/include/hs_deinit_master_1.inc b/storage/spider/mysql-test/spider/oracle/include/hs_deinit_master_1.inc deleted file mode 100644 index e69de29bb2d..00000000000 --- a/storage/spider/mysql-test/spider/oracle/include/hs_deinit_master_1.inc +++ /dev/null diff --git a/storage/spider/mysql-test/spider/oracle/include/hs_init_child2_1.inc b/storage/spider/mysql-test/spider/oracle/include/hs_init_child2_1.inc deleted file mode 100644 index f3f92a61e6f..00000000000 --- a/storage/spider/mysql-test/spider/oracle/include/hs_init_child2_1.inc +++ /dev/null @@ -1,24 +0,0 @@ -let $CHILD2_1_HS_DROP_TABLES= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "hs_r"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"'); -let $CHILD2_1_HS_CREATE_TABLES= - SELECT spider_direct_sql('CREATE TABLE "hs_r" ( - "a" INT DEFAULT 10, - "b" CHAR(1) DEFAULT \'c\', - "c" DATE DEFAULT TO_DATE(\'1999-10-10 10:10:10\', \'YYYY-MM-DD HH24:MI:SS\'), - "d" INT DEFAULT 11, - CONSTRAINT "pk_s_2_1_hs_r" PRIMARY KEY("a") - )', '', 'srv "s_2_1"'); -let $CHILD2_1_HS_SELECT_TABLES= - SELECT spider_direct_sql('SELECT "a", "b", TO_CHAR("c", \'YYYY-MM-DD HH24:MI:SS\'), "d" FROM "hs_r" ORDER BY "a"', '', 'srv "s_2_1"'); -let $CHILD2_1_HS_DROP_TABLES2= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "hs_r2"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"'); -let $CHILD2_1_HS_CREATE_TABLES2= - SELECT spider_direct_sql('CREATE TABLE "hs_r2" ( - "a" INT DEFAULT 10, - "b" CHAR(1) DEFAULT \'c\', - "c" DATE DEFAULT TO_DATE(\'1999-10-10 10:10:10\', \'YYYY-MM-DD HH24:MI:SS\'), - "d" INT DEFAULT 11, - CONSTRAINT "pk_s_2_1_hs_r2" PRIMARY KEY("a") - )', '', 'srv "s_2_1"'); -let $CHILD2_1_HS_SELECT_TABLES2= - SELECT spider_direct_sql('SELECT "a", "b", TO_CHAR("c", \'YYYY-MM-DD HH24:MI:SS\'), "d" FROM "hs_r2" ORDER BY "a"', '', 'srv "s_2_1"'); diff --git a/storage/spider/mysql-test/spider/oracle/include/hs_init_child2_2.inc b/storage/spider/mysql-test/spider/oracle/include/hs_init_child2_2.inc deleted file mode 100644 index 4bd8d49c17c..00000000000 --- a/storage/spider/mysql-test/spider/oracle/include/hs_init_child2_2.inc +++ /dev/null @@ -1,12 +0,0 @@ -let $CHILD2_2_HS_DROP_TABLES= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "hs_r3"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_2"'); -let $CHILD2_2_HS_CREATE_TABLES= - SELECT spider_direct_sql('CREATE TABLE "hs_r3" ( - "a" INT DEFAULT 10, - "b" CHAR(1) DEFAULT \'c\', - "c" DATE DEFAULT TO_DATE(\'1999-10-10 10:10:10\', \'YYYY-MM-DD HH24:MI:SS\'), - "d" INT DEFAULT 11, - CONSTRAINT "pk_s_2_2_hs_r3" PRIMARY KEY("a") - )', '', 'srv "s_2_2"'); -let $CHILD2_2_HS_SELECT_TABLES= - SELECT spider_direct_sql('SELECT "a", "b", TO_CHAR("c", \'YYYY-MM-DD HH24:MI:SS\'), "d" FROM "hs_r3" ORDER BY "a"', '', 'srv "s_2_2"'); diff --git a/storage/spider/mysql-test/spider/oracle/include/hs_init_child2_3.inc b/storage/spider/mysql-test/spider/oracle/include/hs_init_child2_3.inc deleted file mode 100644 index e69de29bb2d..00000000000 --- a/storage/spider/mysql-test/spider/oracle/include/hs_init_child2_3.inc +++ /dev/null diff --git a/storage/spider/mysql-test/spider/oracle/include/hs_init_master_1.inc b/storage/spider/mysql-test/spider/oracle/include/hs_init_master_1.inc deleted file mode 100644 index 0ff5e2a10d9..00000000000 --- a/storage/spider/mysql-test/spider/oracle/include/hs_init_master_1.inc +++ /dev/null @@ -1,12 +0,0 @@ -let $MASTER_1_HS_COMMENT_TMP= - COMMENT=''; -let $MASTER_1_HS_COMMENT_2_1= - COMMENT='srv "s_2_1", table "hs_r", uhr "1", uhw "1", hrp "$CHILD2_1_HSRPORT", hwp "$CHILD2_1_HSWPORT"'; -let $MASTER_1_HS_COMMENT_P_2_1= - COMMENT='uhr "1", uhw "1"' - PARTITION BY RANGE(a) ( - PARTITION pt1 VALUES LESS THAN (4) - COMMENT='srv "s_2_1", table "hs_r2", hrp "$CHILD2_1_HSRPORT", hwp "$CHILD2_1_HSWPORT"', - PARTITION pt2 VALUES LESS THAN MAXVALUE - COMMENT='srv "s_2_2", table "hs_r3", hrp "$CHILD2_2_HSRPORT", hwp "$CHILD2_2_HSWPORT"' - ); diff --git a/storage/spider/mysql-test/spider/oracle/include/init_child2_1.inc b/storage/spider/mysql-test/spider/oracle/include/init_child2_1.inc deleted file mode 100644 index c24736eefca..00000000000 --- a/storage/spider/mysql-test/spider/oracle/include/init_child2_1.inc +++ /dev/null @@ -1,192 +0,0 @@ ---connection master_1 -SELECT spider_direct_sql('ALTER SESSION SET NLS_DATE_FORMAT=\'YYYY-MM-DD HH24:MI:SS\'', '', 'srv "s_2_1"'); -SELECT spider_direct_sql('ALTER SESSION SET NLS_TIME_FORMAT=\'HH24:MI:SSXFF\'', '', 'srv "s_2_1"'); -SELECT spider_direct_sql('ALTER SESSION SET NLS_TIMESTAMP_FORMAT=\'YYYY-MM-DD HH24:MI:SSXFF\'', '', 'srv "s_2_1"'); -let $CHILD2_1_DROP_TABLES= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "ta_r"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"'); -let $CHILD2_1_CREATE_TABLES= - SELECT spider_direct_sql('CREATE TABLE "ta_r" ( - "a" INT DEFAULT 10, - "b" CHAR(1) DEFAULT \'c\', - "c" DATE DEFAULT TO_DATE(\'1999-10-10 10:10:10\', \'YYYY-MM-DD HH24:MI:SS\'), - CONSTRAINT "pk_s_2_1_ta_r" PRIMARY KEY("a") - )', '', 'srv "s_2_1"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE INDEX "idx1" ON "ta_r"("b")', '', 'srv "s_2_1"'); -let $CHILD2_1_SELECT_TABLES= - SELECT spider_direct_sql('SELECT "a", "b", TO_CHAR("c", \'YYYY-MM-DD HH24:MI:SS\') FROM "ta_r" ORDER BY "a"', '', 'srv "s_2_1"'); -let $CHILD2_1_DROP_TABLES2= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "ta_r2"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"'); -let $CHILD2_1_CREATE_TABLES2= - SELECT spider_direct_sql('CREATE TABLE "ta_r2" ( - "a" INT DEFAULT 10, - "b" CHAR(1) DEFAULT \'c\', - "c" DATE DEFAULT TO_DATE(\'1999-10-10 10:10:10\', \'YYYY-MM-DD HH24:MI:SS\'), - CONSTRAINT "pk_s_2_1_ta_r2" PRIMARY KEY("a") - )', '', 'srv "s_2_1"'); -let $CHILD2_1_SELECT_TABLES2= - SELECT spider_direct_sql('SELECT "a", "b", TO_CHAR("c", \'YYYY-MM-DD HH24:MI:SS\') FROM "ta_r2" ORDER BY "a"', '', 'srv "s_2_1"'); -let $CHILD2_1_DROP_TABLES3= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "ta_r_no_idx"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"'); -let $CHILD2_1_CREATE_TABLES3= - SELECT spider_direct_sql('CREATE TABLE "ta_r_no_idx" ( - "a" INT DEFAULT 10, - "b" CHAR(1) DEFAULT \'c\', - "c" DATE DEFAULT TO_DATE(\'1999-10-10 10:10:10\', \'YYYY-MM-DD HH24:MI:SS\') - )', '', 'srv "s_2_1"'); -let $CHILD2_1_SELECT_TABLES3= - SELECT spider_direct_sql('SELECT "a", "b", TO_CHAR("c", \'YYYY-MM-DD HH24:MI:SS\') FROM "ta_r_no_idx" ORDER BY "a"', '', 'srv "s_2_1"'); -let $CHILD2_1_DROP_TABLES4= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "ta_r_auto_inc"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"'); -let $CHILD2_1_CREATE_TABLES4= - SELECT spider_direct_sql('CREATE TABLE "ta_r_auto_inc" ( - "a" INT DEFAULT 10, - "b" CHAR(1) DEFAULT \'c\', - "c" DATE DEFAULT TO_DATE(\'1999-10-10 10:10:10\', \'YYYY-MM-DD HH24:MI:SS\'), - CONSTRAINT "pk_s_2_1_ta_r_auto_inc" PRIMARY KEY("a") - )', '', 'srv "s_2_1"'); -let $CHILD2_1_SELECT_TABLES4= - SELECT spider_direct_sql('SELECT "a", "b", TO_CHAR("c", \'YYYY-MM-DD HH24:MI:SS\') FROM "ta_r_auto_inc" - ORDER BY "a"', '', 'srv "s_2_1"'); -let $CHILD2_1_DROP_TABLES5= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "s_2_1_ta_r_int"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"'); -let $CHILD2_1_CREATE_TABLES5= - SELECT spider_direct_sql('CREATE TABLE "s_2_1_ta_r_int" ( - "a" INT DEFAULT 3, - "b" INT DEFAULT 10, - "c" INT DEFAULT 11, - CONSTRAINT "pk_s_2_1_ta_r_int" PRIMARY KEY("a") - )', '', 'srv "s_2_1"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE INDEX "idx1_s_2_1_ta_r_int" ON "s_2_1_ta_r_int"("b")', '', 'srv "s_2_1"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE INDEX "idx2_s_2_1_ta_r_int" ON "s_2_1_ta_r_int"("c")', '', 'srv "s_2_1"'); -let $CHILD2_1_SELECT_TABLES5= - SELECT spider_direct_sql('SELECT "a", "b", "c" FROM "s_2_1_ta_r_int" ORDER BY "a"', '', 'srv "s_2_1"'); -let $CHILD2_1_DROP_TABLES6= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "ta_r_3"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"'); -let $CHILD2_1_CREATE_TABLES6= - SELECT spider_direct_sql('CREATE TABLE "ta_r_3" ( - "a" INT DEFAULT 10, - "b" CHAR(1) DEFAULT \'c\', - "c" DATE DEFAULT TO_DATE(\'1999-10-10 10:10:10\', \'YYYY-MM-DD HH24:MI:SS\') - )', '', 'srv "s_2_1"'); -let $CHILD2_1_SELECT_TABLES6= - SELECT spider_direct_sql('SELECT "a", "b", TO_CHAR("c", \'YYYY-MM-DD HH24:MI:SS\') FROM "ta_r_3" ORDER BY "a"', '', 'srv "s_2_1"'); -let $CHILD2_1_DROP_FT_TABLES= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "ft_r"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"'); -let $CHILD2_1_CREATE_FT_TABLES= - SELECT spider_direct_sql('CREATE TABLE "ft_r" ( - "a" INT DEFAULT 0, - "b" TEXT, - "c" TEXT, - "d" TEXT, - CONSTRAINT "pk_s_2_1_ft_r" PRIMARY KEY("a"), - FULLTEXT INDEX "ft_idx1"("b"), - FULLTEXT INDEX "ft_idx2"("c") - )', '', 'srv "s_2_1"'); -let $CHILD2_1_SELECT_FT_TABLES= - SELECT spider_direct_sql('SELECT "a", "b", "c", "d" FROM "ft_r" ORDER BY "a"', '', 'srv "s_2_1"'); -let $CHILD2_1_DROP_FT_TABLES2= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "ft_r2"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"'); -let $CHILD2_1_CREATE_FT_TABLES2= - SELECT spider_direct_sql('CREATE TABLE "ft_r2" ( - "a" INT DEFAULT 0, - "b" TEXT, - "c" TEXT, - "d" TEXT, - CONSTRAINT "pk_s_2_1_ft_r2" PRIMARY KEY("a"), - FULLTEXT INDEX "ft_idx1"("b"), - FULLTEXT INDEX "ft_idx2"("c") - )', '', 'srv "s_2_1"'); -let $CHILD2_1_SELECT_FT_TABLES2= - SELECT spider_direct_sql('SELECT "a", "b", "c", "d" FROM "ft_r2" ORDER BY "a"', '', 'srv "s_2_1"'); -let $CHILD2_1_DROP_GM_TABLES= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "gm_r"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"'); -let $CHILD2_1_CREATE_GM_TABLES= - SELECT spider_direct_sql('CREATE TABLE "gm_r" ( - "a" INT DEFAULT 0, - "b" GEOMETRY NOT NULL, - "c" GEOMETRY NOT NULL, - CONSTRAINT "pk_s_2_1_gm_r" PRIMARY KEY("a"), - SPATIAL INDEX "sp_idx1"("b"), - SPATIAL INDEX "sp_idx2"("c") - )', '', 'srv "s_2_1"'); -let $CHILD2_1_SELECT_GM_TABLES= - SELECT spider_direct_sql('SELECT "a", "b", "c" FROM "gm_r" ORDER BY "a"', '', 'srv "s_2_1"'); -let $CHILD2_1_DROP_GM_TABLES2= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "gm_r2"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"'); -let $CHILD2_1_CREATE_GM_TABLES2= - SELECT spider_direct_sql('CREATE TABLE "gm_r2" ( - "a" INT DEFAULT 0, - "b" GEOMETRY NOT NULL, - "c" GEOMETRY NOT NULL, - CONSTRAINT "pk_s_2_1_gm_r2" PRIMARY KEY("a"), - SPATIAL INDEX "sp_idx1"("b"), - SPATIAL INDEX "sp_idx2"("c") - )', '', 'srv "s_2_1"'); -let $CHILD2_1_SELECT_GM_TABLES2= - SELECT spider_direct_sql('SELECT "a", "b", "c" FROM "gm_r2" ORDER BY "a"', '', 'srv "s_2_1"'); -let $CHILD2_1_DROP_LOCK_TABLES1= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "t1_1"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"'); -let $CHILD2_1_CREATE_LOCK_TABLES1= - SELECT spider_direct_sql('CREATE TABLE "t1_1" ( - "id" INT NOT NULL, - CONSTRAINT "pk_s_2_1_t1_1" PRIMARY KEY ("id") - )', '', 'srv "s_2_1"'); -let $CHILD2_1_DROP_LOCK_TABLES2= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "t2_2"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"'); -let $CHILD2_1_CREATE_LOCK_TABLES2= - SELECT spider_direct_sql('CREATE TABLE "t2_2" ( - "id" INT NOT NULL, - CONSTRAINT "pk_s_2_1_t2_2" PRIMARY KEY ("id") - )', '', 'srv "s_2_1"'); -let $CHILD2_1_DROP_INCREMENT_TABLES1= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "t1_1"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"'); -let $CHILD2_1_CREATE_INCREMENT_TABLES1= - SELECT spider_direct_sql('CREATE TABLE "t1_1" ( - "id" INT NOT NULL, - CONSTRAINT "pk_s_2_1_t1_1" PRIMARY KEY ("id") - )', '', 'srv "s_2_1"'); -let $CHILD2_1_SELECT_INCREMENT_TABLES1= - SELECT spider_direct_sql('SELECT "id" FROM "t1_1" ORDER BY "id"', '', 'srv "s_2_1"'); -let $CHILD2_1_DROP_TEXT_PK_TABLES1= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "t1"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"'); -let $CHILD2_1_CREATE_TEXT_PK_TABLES1= - SELECT spider_direct_sql('CREATE TABLE "t1" ( - "a" VARCHAR(255), - CONSTRAINT "pk_s_2_1_t1" PRIMARY KEY ("a") - )', '', 'srv "s_2_1"'); -let $CHILD2_1_SELECT_TEXT_PK_TABLES1= - SELECT spider_direct_sql('SELECT "a" FROM "t1" ORDER BY "a"', '', 'srv "s_2_1"'); -let $CHILD2_1_DROP_TEXT_KEY_TABLES1= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "t1"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"'); -let $CHILD2_1_CREATE_TEXT_KEY_TABLES1= - SELECT spider_direct_sql('CREATE TABLE "t1" ( - "a" VARCHAR(255), - "b" VARCHAR(255), - "c" VARCHAR(255), - CONSTRAINT "pk_s_2_1_t1" PRIMARY KEY ("c") - )', '', 'srv "s_2_1"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE INDEX "idx1_t1" ON "t1"("a","b")', '', 'srv "s_2_1"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE INDEX "idx2_t1" ON "t1"("b")', '', 'srv "s_2_1"'); -let $CHILD2_1_SELECT_TEXT_KEY_TABLES1= - SELECT spider_direct_sql('SELECT "a", "b", "c" FROM "t1" ORDER BY "c"', '', 'srv "s_2_1"'); -let $CHILD2_1_AUTO_INCREMENT_INCREMENT1= - SELECT spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_1"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE SEQUENCE "seq_t1_1" START WITH 1 INCREMENT BY 1', '', 'srv "s_2_1"'); -let $CHILD2_1_AUTO_INCREMENT_INCREMENT2= - SELECT spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_1"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE SEQUENCE "seq_t1_1" START WITH 2 INCREMENT BY 4', '', 'srv "s_2_1"'); -let $CHILD2_1_AUTO_INCREMENT_OFFSET1= - SELECT spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_1"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE SEQUENCE "seq_t1_1" START WITH 1 INCREMENT BY 1', '', 'srv "s_2_1"'); -let $CHILD2_1_AUTO_INCREMENT_OFFSET2= - SELECT spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_1"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE SEQUENCE "seq_t1_1" START WITH 2 INCREMENT BY 4', '', 'srv "s_2_1"'); diff --git a/storage/spider/mysql-test/spider/oracle/include/init_child2_2.inc b/storage/spider/mysql-test/spider/oracle/include/init_child2_2.inc deleted file mode 100644 index fd4497c0b59..00000000000 --- a/storage/spider/mysql-test/spider/oracle/include/init_child2_2.inc +++ /dev/null @@ -1,94 +0,0 @@ ---connection master_1 -SELECT spider_direct_sql('ALTER SESSION SET NLS_DATE_FORMAT=\'YYYY-MM-DD HH24:MI:SS\'', '', 'srv "s_2_2"'); -SELECT spider_direct_sql('ALTER SESSION SET NLS_TIME_FORMAT=\'HH24:MI:SSXFF\'', '', 'srv "s_2_2"'); -SELECT spider_direct_sql('ALTER SESSION SET NLS_TIMESTAMP_FORMAT=\'YYYY-MM-DD HH24:MI:SSXFF\'', '', 'srv "s_2_2"'); -let $CHILD2_2_DROP_TABLES= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "ta_r3"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_2"'); -let $CHILD2_2_CREATE_TABLES= - SELECT spider_direct_sql('CREATE TABLE "ta_r3" ( - "a" INT DEFAULT 10, - "b" CHAR(1) DEFAULT \'c\', - "c" DATE DEFAULT TO_DATE(\'1999-10-10 10:10:10\', \'YYYY-MM-DD HH24:MI:SS\'), - CONSTRAINT "pk_s_2_2_ta_r3" PRIMARY KEY("a") - )', '', 'srv "s_2_2"'); -let $CHILD2_2_DROP_TABLES5= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "s_2_2_ta_r_int"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_2"'); -let $CHILD2_2_CREATE_TABLES5= - SELECT spider_direct_sql('CREATE TABLE "s_2_2_ta_r_int" ( - "a" INT DEFAULT 3, - "b" INT DEFAULT 10, - "c" INT DEFAULT 11, - CONSTRAINT "pk_s_2_2_ta_r_int" PRIMARY KEY("a") - )', '', 'srv "s_2_2"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE INDEX "idx1_s_2_2_ta_r_int" ON "s_2_2_ta_r_int"("b")', '', 'srv "s_2_2"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE INDEX "idx2_s_2_2_ta_r_int" ON "s_2_2_ta_r_int"("c")', '', 'srv "s_2_2"'); -let $CHILD2_2_SELECT_TABLES= - SELECT spider_direct_sql('SELECT "a", "b", TO_CHAR("c", \'YYYY-MM-DD HH24:MI:SS\') FROM "ta_r3" ORDER BY "a"', '', 'srv "s_2_2"'); -let $CHILD2_2_DROP_FT_TABLES= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "ft_r3"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_2"'); -let $CHILD2_2_CREATE_FT_TABLES= - SELECT spider_direct_sql('CREATE TABLE "ft_r3" ( - "a" INT DEFAULT 0, - "b" TEXT, - "c" TEXT, - "d" TEXT, - CONSTRAINT "pk_s_2_2_ft_r3" PRIMARY KEY("a"), - FULLTEXT INDEX "ft_idx1"("b"), - FULLTEXT INDEX "ft_idx2"("c") - )', '', 'srv "s_2_2"'); -let $CHILD2_2_SELECT_FT_TABLES= - SELECT spider_direct_sql('SELECT "a", "b", "c", "d" FROM "ft_r3" ORDER BY "a"', '', 'srv "s_2_2"'); -let $CHILD2_2_DROP_GM_TABLES= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "gm_r3"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_2"'); -let $CHILD2_2_CREATE_GM_TABLES= - SELECT spider_direct_sql('CREATE TABLE "gm_r3" ( - "a" INT DEFAULT 0, - "b" GEOMETRY NOT NULL, - "c" GEOMETRY NOT NULL, - CONSTRAINT "pk_s_2_2_gm_r3" PRIMARY KEY("a"), - SPATIAL INDEX "sp_idx1"("b"), - SPATIAL INDEX "sp_idx2"("c") - )', '', 'srv "s_2_2"'); -let $CHILD2_2_SELECT_GM_TABLES= - SELECT spider_direct_sql('SELECT "a", "b", "c" FROM "gm_r3" ORDER BY "a"', '', 'srv "s_2_2"'); -let $CHILD2_2_DROP_LOCK_TABLES1= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "t1_2"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_2"'); -let $CHILD2_2_CREATE_LOCK_TABLES1= - SELECT spider_direct_sql('CREATE TABLE "t1_2" ( - "id" INT NOT NULL, - CONSTRAINT "pk_s_2_2_t1_2" PRIMARY KEY ("id") - )', '', 'srv "s_2_2"'); -let $CHILD2_2_DROP_LOCK_TABLES2= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "t2_1"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_2"'); -let $CHILD2_2_CREATE_LOCK_TABLES2= - SELECT spider_direct_sql('CREATE TABLE "t2_1" ( - "id" INT NOT NULL, - CONSTRAINT "pk_s_2_2_t2_1" PRIMARY KEY ("id") - )', '', 'srv "s_2_2"'); -let $CHILD2_2_DROP_INCREMENT_TABLES1= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "t1_2"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_2"'); -let $CHILD2_2_CREATE_INCREMENT_TABLES1= - SELECT spider_direct_sql('CREATE TABLE "t1_2" ( - "id" INT NOT NULL, - CONSTRAINT "pk_s_2_2_t1_2" PRIMARY KEY ("id") - )', '', 'srv "s_2_2"'); -let $CHILD2_2_SELECT_INCREMENT_TABLES1= - SELECT spider_direct_sql('SELECT "id" FROM "t1_2" ORDER BY "id"', '', 'srv "s_2_2"'); -let $CHILD2_2_AUTO_INCREMENT_INCREMENT1= - SELECT spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_2"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_2"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE SEQUENCE "seq_t1_2" START WITH 1 INCREMENT BY 1', '', 'srv "s_2_2"'); -let $CHILD2_2_AUTO_INCREMENT_INCREMENT2= - SELECT spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_2"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_2"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE SEQUENCE "seq_t1_2" START WITH 3 INCREMENT BY 4', '', 'srv "s_2_2"'); -let $CHILD2_2_AUTO_INCREMENT_OFFSET1= - SELECT spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_2"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_2"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE SEQUENCE "seq_t1_2" START WITH 1 INCREMENT BY 1', '', 'srv "s_2_2"'); -let $CHILD2_2_AUTO_INCREMENT_OFFSET2= - SELECT spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_2"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_2"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE SEQUENCE "seq_t1_2" START WITH 3 INCREMENT BY 4', '', 'srv "s_2_2"'); diff --git a/storage/spider/mysql-test/spider/oracle/include/init_child2_3.inc b/storage/spider/mysql-test/spider/oracle/include/init_child2_3.inc deleted file mode 100644 index e16dfeffd81..00000000000 --- a/storage/spider/mysql-test/spider/oracle/include/init_child2_3.inc +++ /dev/null @@ -1,15 +0,0 @@ ---connection master_1 -SELECT spider_direct_sql('ALTER SESSION SET NLS_DATE_FORMAT=\'YYYY-MM-DD HH24:MI:SS\'', '', 'srv "s_2_3"'); -SELECT spider_direct_sql('ALTER SESSION SET NLS_TIME_FORMAT=\'HH24:MI:SSXFF\'', '', 'srv "s_2_3"'); -SELECT spider_direct_sql('ALTER SESSION SET NLS_TIMESTAMP_FORMAT=\'YYYY-MM-DD HH24:MI:SSXFF\'', '', 'srv "s_2_3"'); -let $CHILD2_3_DROP_TABLES= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "ta_r4"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_3"'); -let $CHILD2_3_CREATE_TABLES= - SELECT spider_direct_sql('CREATE TABLE "ta_r4" ( - "a" INT DEFAULT 10, - "b" CHAR(1) DEFAULT \'c\', - "c" DATE DEFAULT TO_DATE(\'1999-10-10 10:10:10\', \'YYYY-MM-DD HH24:MI:SS\'), - CONSTRAINT "pk_s_2_3_ta_r4" PRIMARY KEY("a") - )', '', 'srv "s_2_3"'); -let $CHILD2_3_SELECT_TABLES= - SELECT spider_direct_sql('SELECT "a", "b", TO_CHAR("c", \'YYYY-MM-DD HH24:MI:SS\') FROM "ta_r4" ORDER BY "a"', '', 'srv "s_2_3"'); diff --git a/storage/spider/mysql-test/spider/oracle/include/init_child3_1.inc b/storage/spider/mysql-test/spider/oracle/include/init_child3_1.inc deleted file mode 100644 index d2d308cbefe..00000000000 --- a/storage/spider/mysql-test/spider/oracle/include/init_child3_1.inc +++ /dev/null @@ -1,3 +0,0 @@ ---let $TEST_ENGINE_TYPE= $CHILD3_1_ENGINE_TYPE ---source ../../include/init_engine.inc ---let $INIT_CHILD3_1_ENGINE= $INIT_TEST_ENGINE diff --git a/storage/spider/mysql-test/spider/oracle/include/init_child3_2.inc b/storage/spider/mysql-test/spider/oracle/include/init_child3_2.inc deleted file mode 100644 index 3fbe1bd55bb..00000000000 --- a/storage/spider/mysql-test/spider/oracle/include/init_child3_2.inc +++ /dev/null @@ -1,3 +0,0 @@ ---let $TEST_ENGINE_TYPE= $CHILD3_2_ENGINE_TYPE ---source ../../include/init_engine.inc ---let $INIT_CHILD3_2_ENGINE= $INIT_TEST_ENGINE diff --git a/storage/spider/mysql-test/spider/oracle/include/init_child3_3.inc b/storage/spider/mysql-test/spider/oracle/include/init_child3_3.inc deleted file mode 100644 index 3c7aaa8af84..00000000000 --- a/storage/spider/mysql-test/spider/oracle/include/init_child3_3.inc +++ /dev/null @@ -1,3 +0,0 @@ ---let $TEST_ENGINE_TYPE= $CHILD3_3_ENGINE_TYPE ---source ../../include/init_engine.inc ---let $INIT_CHILD3_3_ENGINE= $INIT_TEST_ENGINE diff --git a/storage/spider/mysql-test/spider/oracle/include/init_master_1.inc b/storage/spider/mysql-test/spider/oracle/include/init_master_1.inc deleted file mode 100644 index 8e79b984364..00000000000 --- a/storage/spider/mysql-test/spider/oracle/include/init_master_1.inc +++ /dev/null @@ -1,149 +0,0 @@ ---source ../include/init_spider.inc -SET spider_direct_order_limit= 10000; -SET spider_init_sql_alloc_size= 1; -SET spider_conn_recycle_mode= 2; -let $MASTER_1_COMMENT_2_1= - COMMENT='database "$ORACLE_DATABASE", table "ta_r", wrapper "oracle", - pk_name "pk_s_2_1_ta_r"' - CONNECTION='host "$ORACLE_HOST", port "$ORACLE_PORT", user "$ORACLE_USER", - password "$ORACLE_PASSWORD"'; -let $MASTER_1_COMMENT2_2_1= - COMMENT='database "$ORACLE_DATABASE", table "ta_r_no_idx", wrapper "oracle", - pk_name "pk_s_2_1_ta_r_no_idx"' - CONNECTION='host "$ORACLE_HOST", port "$ORACLE_PORT", user "$ORACLE_USER", - password "$ORACLE_PASSWORD", prt "2000000"'; -let $MASTER_1_COMMENT_P_2_1= - COMMENT='table "ta_r3"' - PARTITION BY KEY(a) ( - PARTITION pt1 COMMENT='srv "s_2_1", table "ta_r2", - priority "1000", pk_name "pk_s_2_1_ta_r2"', - PARTITION pt2 COMMENT='srv "s_2_2", priority "1000001", - pk_name "pk_s_2_2_ta_r3"' - ); -let $MASTER_1_COMMENT2_P_2_1= - COMMENT='table "ta_r3"' - PARTITION BY RANGE(a) ( - PARTITION pt1 VALUES LESS THAN (4) COMMENT='srv "s_2_1", - table "ta_r2", priority "1000", pk_name "pk_s_2_1_ta_r2"', - PARTITION pt2 VALUES LESS THAN MAXVALUE - COMMENT='srv "s_2_2", priority "1000001", pk_name "pk_s_2_2_ta_r3"' - ); -let $MASTER_1_COMMENT3_2_1= - COMMENT='database "$ORACLE_DATABASE", table "ta_r_auto_inc", - wrapper "oracle"' - CONNECTION='host "$ORACLE_HOST", port "$ORACLE_PORT", user "$ORACLE_USER", - password "$ORACLE_PASSWORD", pk_name "pk_s_2_1_ta_r_auto_inc"'; -let $MASTER_1_COMMENT3_P_2_1= - COMMENT='table "s_2_1_ta_r_int"' - PARTITION BY LIST(MOD(a, 2)) ( - PARTITION pt1 VALUES IN (0) - COMMENT='srv "s_2_1", priority "1000", pk_name "pk_s_2_1_ta_r_int"', - PARTITION pt2 VALUES IN (1) - COMMENT='srv "s_2_2", priority "1000001", pk_name "pk_s_2_2_ta_r_int", - table "s_2_2_ta_r_int"' - ); -let $MASTER_1_COMMENT4_2_1= - COMMENT='database "$ORACLE_DATABASE", table "s_2_1_ta_r_int", - wrapper "oracle"' - CONNECTION='host "$ORACLE_HOST", port "$ORACLE_PORT", user "$ORACLE_USER", - password "$ORACLE_PASSWORD", pk_name "pk_s_2_1_ta_r_int"'; -let $MASTER_1_COMMENT5_2_1= - COMMENT='database "$ORACLE_DATABASE", table "ta_r_3", wrapper "oracle"' - CONNECTION='host "$ORACLE_HOST", port "$ORACLE_PORT", user "$ORACLE_USER", - password "$ORACLE_PASSWORD", pk_name "pk_s_2_1_ta_r_3"'; -let $MASTER_1_COMMENT_FT_2_1= - COMMENT='database "$ORACLE_DATABASE", table "ft_r", wrapper "oracle"' - CONNECTION='host "$ORACLE_HOST", port "$ORACLE_PORT", user "$ORACLE_USER", - password "$ORACLE_PASSWORD", pk_name "pk_s_2_1_ft_r"'; -let $MASTER_1_COMMENT2_FT_P_2_1= - COMMENT='table "ft_r3"' - PARTITION BY RANGE(a) ( - PARTITION pt1 VALUES LESS THAN (4) COMMENT='srv "s_2_1", - table "ft_r2", priority "1000", pk_name "pk_s_2_1_ft_r2"', - PARTITION pt2 VALUES LESS THAN MAXVALUE - COMMENT='srv "s_2_2", priority "1000001", pk_name "pk_s_2_2_ft_r3"' - ); -let $MASTER_1_COMMENT_GM_2_1= - COMMENT='srv "s_2_1", table "gm_r", pk_name "pk_s_2_1_gm_r"'; -let $MASTER_1_COMMENT2_GM_P_2_1= - COMMENT='table "gm_r3"' - PARTITION BY RANGE(a) ( - PARTITION pt1 VALUES LESS THAN (4) COMMENT='srv "s_2_1", - table "gm_r2", priority "1000", pk_name "pk_s_2_1_gm_r2"', - PARTITION pt2 VALUES LESS THAN MAXVALUE - COMMENT='srv "s_2_2", priority "1000001", pk_name "pk_s_2_2_gm_r3"' - ); -let $MASTER_1_COMMENT_LOCK1= - COMMENT 'tbl "t1_1 t1_2", srv "s_2_1 s_2_2", - pk_name "pk_s_2_1_t1_1 pk_s_2_2_t1_2"'; -let $MASTER_1_COMMENT_LOCK2= - COMMENT 'tbl "t2_1 t2_2", srv "s_2_2 s_2_1", - pk_name "pk_s_2_2_t2_1 pk_s_2_1_t2_2"'; -let $MASTER_1_COMMENT_INCREMENT1_1= - COMMENT 'aim "0", tbl "t1_1", srv "s_2_1", pk_name "pk_s_2_1_t1_1"'; -let $MASTER_1_COMMENT_INCREMENT1_P_1= - COMMENT 'aim "0"' - PARTITION BY LIST(MOD(id, 2)) ( - PARTITION pt1 VALUES IN (0) - COMMENT='tbl "t1_1", srv "s_2_1", pk_name "pk_s_2_1_t1_1"', - PARTITION pt2 VALUES IN (1) - COMMENT='tbl "t1_2", srv "s_2_2", pk_name "pk_s_2_2_t1_2"' - ); -let $MASTER_1_COMMENT_READONLY1_1= - COMMENT 'read_only_mode "1", tbl "t1_1", srv "s_2_1", - pk_name "pk_s_2_1_t1_1"'; -let $MASTER_1_COMMENT_ERROR_MODE1_1= - COMMENT 'erm "1", ewm "1", tbl "ter1_1", srv "s_2_1", - pk_name "pk_s_2_1_ter1_1"'; -let $MASTER_1_COMMENT_TEXT_PK1_1= - COMMENT 'tbl "t1", srv "s_2_1", pk_name "pk_s_2_1_t1"'; -let $MASTER_1_COMMENT_TEXT_KEY1_1= - COMMENT 'tbl "t1", srv "s_2_1", pk_name "pk_s_2_1_t1"'; -let $MASTER_1_CHECK_DIRECT_UPDATE_STATUS= - SHOW GLOBAL STATUS LIKE 'Spider_direct_update%'; -let $MASTER_1_CHECK_DIRECT_DELETE_STATUS= - SHOW GLOBAL STATUS LIKE 'Spider_direct_delete%'; -let $MASTER_1_CHECK_DIRECT_ORDER_LIMIT_STATUS= - SHOW GLOBAL STATUS LIKE 'Spider_direct_order_limit%'; -let $MASTER_1_CHECK_DIRECT_AGGREGATE_STATUS= - SHOW GLOBAL STATUS LIKE 'Spider_direct_aggregate%'; -let $MASTER_1_AUTO_INCREMENT_INCREMENT1= - SET SESSION AUTO_INCREMENT_INCREMENT = 1 $STR_SEMICOLON - SELECT spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_1"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE SEQUENCE "seq_t1_1" START WITH 1 INCREMENT BY 1', '', 'srv "s_2_1"') - $STR_SEMICOLON - SELECT spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_2"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_2"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE SEQUENCE "seq_t1_2" START WITH 1 INCREMENT BY 1', '', 'srv "s_2_2"'); -let $MASTER_1_AUTO_INCREMENT_INCREMENT2= - SET SESSION AUTO_INCREMENT_INCREMENT = 777 $STR_SEMICOLON - SELECT spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_1"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE SEQUENCE "seq_t1_1" START WITH 2 INCREMENT BY 4', '', 'srv "s_2_1"') - $STR_SEMICOLON - SELECT spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_2"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_2"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE SEQUENCE "seq_t1_2" START WITH 3 INCREMENT BY 4', '', 'srv "s_2_2"'); -let $MASTER_1_AUTO_INCREMENT_OFFSET1= - SET SESSION AUTO_INCREMENT_OFFSET = 1 $STR_SEMICOLON - SELECT spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_1"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE SEQUENCE "seq_t1_1" START WITH 1 INCREMENT BY 1', '', 'srv "s_2_1"') - $STR_SEMICOLON - SELECT spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_2"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_2"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE SEQUENCE "seq_t1_2" START WITH 1 INCREMENT BY 1', '', 'srv "s_2_2"'); -let $MASTER_1_AUTO_INCREMENT_OFFSET2= - SET SESSION AUTO_INCREMENT_OFFSET = 777 $STR_SEMICOLON - SELECT spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_1"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE SEQUENCE "seq_t1_1" START WITH 2 INCREMENT BY 4', '', 'srv "s_2_1"') - $STR_SEMICOLON - SELECT spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_2"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_2"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE SEQUENCE "seq_t1_2" START WITH 3 INCREMENT BY 4', '', 'srv "s_2_2"'); -let $MASTER_1_AUTO_INCREMENT_OFFSET3= - SET SESSION AUTO_INCREMENT_OFFSET = 1; -let $MASTER_1_AUTO_INCREMENT_OFFSET4= - SET SESSION AUTO_INCREMENT_OFFSET = 777; diff --git a/storage/spider/mysql-test/spider/oracle/include/init_slave1_1.inc b/storage/spider/mysql-test/spider/oracle/include/init_slave1_1.inc deleted file mode 100644 index 73c3c6b9ef2..00000000000 --- a/storage/spider/mysql-test/spider/oracle/include/init_slave1_1.inc +++ /dev/null @@ -1,10 +0,0 @@ -let $SLAVE1_1_COMMENT_INCREMENT1_1= - COMMENT ''; -let $SLAVE1_1_COMMENT_INCREMENT1_P_1= - COMMENT '' - PARTITION BY LIST(MOD(id, 2)) ( - PARTITION pt1 VALUES IN (0) - COMMENT='', - PARTITION pt2 VALUES IN (1) - COMMENT='' - ); diff --git a/storage/spider/mysql-test/spider/oracle/include/init_spider.inc b/storage/spider/mysql-test/spider/oracle/include/init_spider.inc deleted file mode 100644 index ff9ac9aee29..00000000000 --- a/storage/spider/mysql-test/spider/oracle/include/init_spider.inc +++ /dev/null @@ -1,105 +0,0 @@ ---source ../../include/init_spider.inc -let $VERSION_COMPILE_OS_WIN= - `SELECT IF(@@version_compile_os like 'Win%', 1, 0)`; -if ($VERSION_COMPILE_OS_WIN) -{ - eval DROP SERVER s_2_1; - eval CREATE SERVER s_2_1 FOREIGN DATA WRAPPER oracle OPTIONS ( - HOST '$ORACLE_HOST', - DATABASE '$ORACLE_DATABASE', - USER '$ORACLE_USER', - PASSWORD '$ORACLE_PASSWORD', - PORT $ORACLE_PORT - ); - eval DROP SERVER s_2_2; - eval CREATE SERVER s_2_2 FOREIGN DATA WRAPPER oracle OPTIONS ( - HOST '$ORACLE_HOST', - DATABASE '$ORACLE_DATABASE', - USER '$ORACLE_USER', - PASSWORD '$ORACLE_PASSWORD', - PORT $ORACLE_PORT - ); - eval DROP SERVER s_2_3; - eval CREATE SERVER s_2_3 FOREIGN DATA WRAPPER oracle OPTIONS ( - HOST '$ORACLE_HOST', - DATABASE '$ORACLE_DATABASE', - USER '$ORACLE_USER', - PASSWORD '$ORACLE_PASSWORD', - PORT $ORACLE_PORT - ); - eval DROP SERVER s_3_1; - eval CREATE SERVER s_3_1 FOREIGN DATA WRAPPER mysql OPTIONS ( - HOST 'localhost', - DATABASE 'auto_test_local', - USER 'root', - PASSWORD '', - PORT $CHILD3_1_MYPORT - ); - eval DROP SERVER s_3_2; - eval CREATE SERVER s_3_2 FOREIGN DATA WRAPPER mysql OPTIONS ( - HOST 'localhost', - DATABASE 'auto_test_local', - USER 'root', - PASSWORD '', - PORT $CHILD3_2_MYPORT - ); - eval DROP SERVER s_3_3; - eval CREATE SERVER s_3_3 FOREIGN DATA WRAPPER mysql OPTIONS ( - HOST 'localhost', - DATABASE 'auto_test_local', - USER 'root', - PASSWORD '', - PORT $CHILD2_3_MYPORT - ); -} -if (!$VERSION_COMPILE_OS_WIN) -{ - eval DROP SERVER s_2_1; - eval CREATE SERVER s_2_1 FOREIGN DATA WRAPPER oracle OPTIONS ( - HOST '$ORACLE_HOST', - DATABASE '$ORACLE_DATABASE', - USER '$ORACLE_USER', - PASSWORD '$ORACLE_PASSWORD', - PORT $ORACLE_PORT - ); - eval DROP SERVER s_2_2; - eval CREATE SERVER s_2_2 FOREIGN DATA WRAPPER oracle OPTIONS ( - HOST '$ORACLE_HOST', - DATABASE '$ORACLE_DATABASE', - USER '$ORACLE_USER', - PASSWORD '$ORACLE_PASSWORD', - PORT $ORACLE_PORT - ); - eval DROP SERVER s_2_3; - eval CREATE SERVER s_2_3 FOREIGN DATA WRAPPER oracle OPTIONS ( - HOST '$ORACLE_HOST', - DATABASE '$ORACLE_DATABASE', - USER '$ORACLE_USER', - PASSWORD '$ORACLE_PASSWORD', - PORT $ORACLE_PORT - ); - eval DROP SERVER s_3_1; - eval CREATE SERVER s_3_1 FOREIGN DATA WRAPPER mysql OPTIONS ( - HOST 'localhost', - DATABASE 'auto_test_local', - USER 'root', - PASSWORD '', - SOCKET '$CHILD3_1_MYSOCK' - ); - eval DROP SERVER s_3_2; - eval CREATE SERVER s_3_2 FOREIGN DATA WRAPPER mysql OPTIONS ( - HOST 'localhost', - DATABASE 'auto_test_local', - USER 'root', - PASSWORD '', - SOCKET '$CHILD3_2_MYSOCK' - ); - eval DROP SERVER s_3_3; - eval CREATE SERVER s_3_3 FOREIGN DATA WRAPPER mysql OPTIONS ( - HOST 'localhost', - DATABASE 'auto_test_local', - USER 'root', - PASSWORD '', - SOCKET '$CHILD3_3_MYSOCK' - ); -} diff --git a/storage/spider/mysql-test/spider/oracle/my.cnf b/storage/spider/mysql-test/spider/oracle/my.cnf deleted file mode 100644 index efa05c8e8b0..00000000000 --- a/storage/spider/mysql-test/spider/oracle/my.cnf +++ /dev/null @@ -1,146 +0,0 @@ -# Use default setting for mysqld processes -!include include/default_mysqld.cnf - -[mysqld.1.1] -log-bin= master-bin -loose_handlersocket_port= 20000 -loose_handlersocket_port_wr= 20001 -loose_handlersocket_threads= 2 -loose_handlersocket_threads_wr= 1 -loose_handlersocket_support_merge_table= 0 -loose_handlersocket_direct_update_mode= 2 -loose_handlersocket_unlimited_boundary= 65536 -loose_handlersocket_bulk_insert= 0 -loose_handlersocket_bulk_insert_timeout= 0 -loose_handlersocket_general_log= 1 -loose_handlersocket_timeout= 30 -loose_handlersocket_close_table_interval=2 -open_files_limit= 4096 -loose_partition= 1 - -[mysqld.3.1] -loose_partition= 1 - -[mysqld.3.2] -loose_partition= 1 - -[mysqld.3.3] -loose_partition= 1 - -[mysqld.4.1] -loose_partition= 1 - - -[ENV] -USE_GEOMETRY_TEST= 0 -USE_FULLTEXT_TEST= 0 -USE_HA_TEST= 1 -USE_GENERAL_LOG= 1 -USE_REPLICATION= 0 -MASTER_1_MYPORT= @mysqld.1.1.port -MASTER_1_HSRPORT= 20000 -MASTER_1_HSWPORT= 20001 -MASTER_1_MYSOCK= @mysqld.1.1.socket -MASTER_1_ENGINE_TYPE= Spider -#MASTER_1_ENGINE_TYPE= MyISAM -MASTER_1_ENGINE= ENGINE=Spider -MASTER_1_CHARSET= DEFAULT CHARSET=utf8 -MASTER_1_ENGINE2= ENGINE=MyISAM -MASTER_1_CHARSET2= DEFAULT CHARSET=utf8 -MASTER_1_CHARSET3= DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci -SLAVE1_1_MYPORT= @mysqld.4.1.port -SLAVE1_1_MYSOCK= @mysqld.4.1.socket -SLAVE1_1_ENGINE_TYPE= MyISAM -SLAVE1_1_ENGINE= ENGINE=MyISAM -SLAVE1_1_CHARSET= DEFAULT CHARSET=utf8 -USE_CHILD_GROUP2= 1 -OUTPUT_CHILD_GROUP2= 0 -CHILD2_1_MYPORT= @mysqld.1.1.port -CHILD2_1_MYSOCK= @mysqld.1.1.socket -CHILD2_1_ENGINE_TYPE= InnoDB -CHILD2_1_ENGINE= ENGINE=InnoDB -CHILD2_1_CHARSET= DEFAULT CHARSET=utf8 -CHILD2_1_CHARSET2= DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci -CHILD2_2_MYPORT= @mysqld.1.1.port -CHILD2_2_MYSOCK= @mysqld.1.1.socket -CHILD2_2_ENGINE_TYPE= InnoDB -CHILD2_2_ENGINE= ENGINE=InnoDB -CHILD2_2_CHARSET= DEFAULT CHARSET=utf8 -CHILD2_3_MYPORT= @mysqld.1.1.port -CHILD2_3_MYSOCK= @mysqld.1.1.socket -CHILD2_3_ENGINE_TYPE= InnoDB -CHILD2_3_ENGINE= ENGINE=InnoDB -CHILD2_3_CHARSET= DEFAULT CHARSET=utf8 -CHILD2_1_FT_MYPORT= @mysqld.1.1.port -CHILD2_1_FT_MYSOCK= @mysqld.1.1.socket -CHILD2_1_FT_ENGINE_TYPE= MyISAM -CHILD2_1_FT_ENGINE= ENGINE=MyISAM -CHILD2_1_FT_CHARSET= DEFAULT CHARSET=utf8 -CHILD2_2_FT_MYPORT= @mysqld.1.1.port -CHILD2_2_FT_MYSOCK= @mysqld.1.1.socket -CHILD2_2_FT_ENGINE_TYPE= MyISAM -CHILD2_2_FT_ENGINE= ENGINE=MyISAM -CHILD2_2_FT_CHARSET= DEFAULT CHARSET=utf8 -CHILD2_1_GM_MYPORT= @mysqld.1.1.port -CHILD2_1_GM_MYSOCK= @mysqld.1.1.socket -CHILD2_1_GM_ENGINE_TYPE= MyISAM -CHILD2_1_GM_ENGINE= ENGINE=MyISAM -CHILD2_1_GM_CHARSET= DEFAULT CHARSET=utf8 -CHILD2_2_GM_MYPORT= @mysqld.1.1.port -CHILD2_2_GM_MYSOCK= @mysqld.1.1.socket -CHILD2_2_GM_ENGINE_TYPE= MyISAM -CHILD2_2_GM_ENGINE= ENGINE=MyISAM -CHILD2_2_GM_CHARSET= DEFAULT CHARSET=utf8 -USE_CHILD_GROUP3= 1 -OUTPUT_CHILD_GROUP3= 0 -CHILD3_1_MYPORT= @mysqld.3.1.port -CHILD3_1_MYSOCK= @mysqld.3.1.socket -CHILD3_1_ENGINE_TYPE= InnoDB -CHILD3_1_ENGINE= ENGINE=InnoDB -CHILD3_1_CHARSET= DEFAULT CHARSET=utf8 -CHILD3_2_MYPORT= @mysqld.3.2.port -CHILD3_2_MYSOCK= @mysqld.3.2.socket -CHILD3_2_ENGINE_TYPE= InnoDB -CHILD3_2_ENGINE= ENGINE=InnoDB -CHILD3_2_CHARSET= DEFAULT CHARSET=utf8 -CHILD3_3_MYPORT= @mysqld.3.3.port -CHILD3_3_MYSOCK= @mysqld.3.3.socket -CHILD3_3_ENGINE_TYPE= InnoDB -CHILD3_3_ENGINE= ENGINE=InnoDB -CHILD3_3_CHARSET= DEFAULT CHARSET=utf8 -ORACLE_HOST= xe -ORACLE_PORT= 1521 -ORACLE_USER= system -ORACLE_PASSWORD= oracle -ORACLE_DATABASE= SYSTEM - -STR_SEMICOLON= ; - -#The followings are set in include/init_xxx.inc files -# MASTER_1_COMMENT_2_1 -# MASTER_1_COMMENT2_2_1 -# MASTER_1_COMMENT3_2_1 -# MASTER_1_COMMENT4_2_1 -# MASTER_1_COMMENT5_2_1 -# MASTER_1_COMMENT_P_2_1 -# CHILD2_1_DROP_TABLES -# CHILD2_1_CREATE_TABLES -# CHILD2_1_SELECT_TABLES -# CHILD2_1_DROP_TABLES2 -# CHILD2_1_CREATE_TABLES2 -# CHILD2_1_SELECT_TABLES2 -# CHILD2_1_DROP_TABLES3 -# CHILD2_1_CREATE_TABLES3 -# CHILD2_1_SELECT_TABLES3 -# CHILD2_1_DROP_TABLES4 -# CHILD2_1_CREATE_TABLES4 -# CHILD2_1_SELECT_TABLES4 -# CHILD2_1_DROP_TABLES5 -# CHILD2_1_CREATE_TABLES5 -# CHILD2_1_SELECT_TABLES5 -# CHILD2_1_DROP_TABLES6 -# CHILD2_1_CREATE_TABLES6 -# CHILD2_1_SELECT_TABLES6 -# CHILD2_2_DROP_TABLES -# CHILD2_2_CREATE_TABLES -# CHILD2_2_SELECT_TABLES diff --git a/storage/spider/mysql-test/spider/oracle/r/basic_sql.result b/storage/spider/mysql-test/spider/oracle/r/basic_sql.result deleted file mode 100644 index 1e9fe78acea..00000000000 --- a/storage/spider/mysql-test/spider/oracle/r/basic_sql.result +++ /dev/null @@ -1,634 +0,0 @@ -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -drop and create databases -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -CREATE DATABASE auto_test_remote; -USE auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -CREATE DATABASE auto_test_remote2; -USE auto_test_remote2; - -test select 1 -SELECT 1; -1 -1 - -create table select test -DROP TABLE IF EXISTS tb_l; -CREATE TABLE tb_l ( -a INT, -b CHAR(1), -c DATETIME, -PRIMARY KEY(a) -) MASTER_1_ENGINE2 MASTER_1_CHARSET2 -INSERT INTO tb_l (a, b, c) VALUES -(1, 'a', '2008-08-01 10:21:39'), -(2, 'b', '2000-01-01 00:00:00'), -(3, 'e', '2007-06-04 20:03:11'), -(4, 'd', '2003-11-30 05:01:03'), -(5, 'c', '2001-12-31 23:59:59'); -DROP TABLE IF EXISTS ta_l; -CREATE TABLE ta_l ( -PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_2_1 -SELECT a, b, c FROM tb_l -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-01 10:21:39 -2 b 2000-01-01 00:00:00 -3 e 2007-06-04 20:03:11 -4 d 2003-11-30 05:01:03 -5 c 2001-12-31 23:59:59 - -create table ignore select test -DROP TABLE IF EXISTS ta_l; -DROP TABLE IF EXISTS tb_l; -CREATE TABLE tb_l ( -a INT, -b CHAR(1), -c DATETIME, -PRIMARY KEY(a) -) MASTER_1_ENGINE2 MASTER_1_CHARSET2 -INSERT INTO tb_l (a, b, c) VALUES -(1, 'f', '2008-07-01 10:21:39'), -(2, 'g', '2000-02-01 00:00:00'), -(3, 'j', '2007-05-04 20:03:11'), -(4, 'i', '2003-10-30 05:01:03'), -(5, 'h', '2001-10-31 23:59:59'); -CREATE TABLE ta_l ( -PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_2_1 -IGNORE SELECT a, b, c FROM tb_l -Warnings: -Warning 1062 Duplicate entry '1' for key 'PRIMARY' -Warning 1062 Duplicate entry '2' for key 'PRIMARY' -Warning 1062 Duplicate entry '3' for key 'PRIMARY' -Warning 1062 Duplicate entry '4' for key 'PRIMARY' -Warning 1062 Duplicate entry '5' for key 'PRIMARY' -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-01 10:21:39 -2 b 2000-01-01 00:00:00 -3 e 2007-06-04 20:03:11 -4 d 2003-11-30 05:01:03 -5 c 2001-12-31 23:59:59 - -create table ignore select test -DROP TABLE IF EXISTS ta_l; -CREATE TABLE ta_l ( -PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_2_1 -REPLACE SELECT a, b, c FROM tb_l -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -create no index table -DROP TABLE IF EXISTS ta_l_no_idx; -CREATE TABLE ta_l_no_idx -MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT2_2_1 -SELECT a, b, c FROM tb_l -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l_no_idx ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -select table -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -select table shared mode -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a -LOCK IN SHARE MODE; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -select table for update -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a -FOR UPDATE; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -select table join -SELECT a.a, a.b, date_format(b.c, '%Y-%m-%d %H:%i:%s') FROM ta_l a, tb_l b -WHERE a.a = b.a ORDER BY a.a; -a b date_format(b.c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -select table straight_join -SELECT STRAIGHT_JOIN a.a, a.b, date_format(b.c, '%Y-%m-%d %H:%i:%s') -FROM ta_l a, tb_l b WHERE a.a = b.a ORDER BY a.a; -a b date_format(b.c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -select sql_small_result -SELECT SQL_SMALL_RESULT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l -ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -select sql_big_result -SELECT SQL_BIG_RESULT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l -ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -select sql_buffer_result -SELECT SQL_BUFFER_RESULT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l -ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -select sql_cache -SELECT SQL_CACHE a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l -ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -select sql_no_cache -SELECT SQL_NO_CACHE a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l -ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -select sql_calc_found_rows -SELECT SQL_CALC_FOUND_ROWS a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l -ORDER BY a LIMIT 4; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -SELECT found_rows(); -found_rows() -5 - -select high_priority -SELECT HIGH_PRIORITY a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l -ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -select distinct -SELECT DISTINCT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l -ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -select count -SELECT count(*) FROM ta_l ORDER BY a; -count(*) -5 - -select table join not use index -SELECT a.a, a.b, date_format(a.c, '%Y-%m-%d %H:%i:%s') FROM tb_l a WHERE -EXISTS (SELECT * FROM ta_l b WHERE b.b = a.b) ORDER BY a.a; -a b date_format(a.c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -select using pushdown -SELECT a.a, a.b, date_format(a.c, '%Y-%m-%d %H:%i:%s') FROM ta_l a WHERE -a.b = 'g' ORDER BY a.a; -a b date_format(a.c, '%Y-%m-%d %H:%i:%s') -2 g 2000-02-01 00:00:00 - -select using index and pushdown -SELECT a.a, a.b, date_format(a.c, '%Y-%m-%d %H:%i:%s') FROM ta_l a WHERE -a.a > 0 AND a.b = 'g' ORDER BY a.a; -a b date_format(a.c, '%Y-%m-%d %H:%i:%s') -2 g 2000-02-01 00:00:00 - -insert -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (2, 'e', '2008-01-01 23:59:59'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -2 e 2008-01-01 23:59:59 - -insert select -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) SELECT a, b, c FROM tb_l; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -insert select a -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES ((SELECT a FROM tb_l ORDER BY a LIMIT 1), -'e', '2008-01-01 23:59:59'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 e 2008-01-01 23:59:59 - -insert low_priority -TRUNCATE TABLE ta_l; -INSERT LOW_PRIORITY INTO ta_l (a, b, c) values (2, 'e', '2008-01-01 23:59:59'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -2 e 2008-01-01 23:59:59 - -insert high_priority -TRUNCATE TABLE ta_l; -INSERT HIGH_PRIORITY INTO ta_l (a, b, c) VALUES (2, 'e', -'2008-01-01 23:59:59'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -2 e 2008-01-01 23:59:59 - -insert ignore -INSERT IGNORE INTO ta_l (a, b, c) VALUES (2, 'd', '2009-02-02 01:01:01'); -Warnings: -Warning 1062 Duplicate entry '2' for key 'PRIMARY' -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -2 e 2008-01-01 23:59:59 - -insert update (insert) -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (2, 'e', '2008-01-01 23:59:59') ON DUPLICATE -KEY UPDATE b = 'f', c = '2005-08-08 11:11:11'; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -2 e 2008-01-01 23:59:59 - -insert update (update) -INSERT INTO ta_l (a, b, c) VALUES (2, 'e', '2008-01-01 23:59:59') ON DUPLICATE -KEY UPDATE b = 'f', c = '2005-08-08 11:11:11'; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -2 f 2005-08-08 11:11:11 - -replace -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (2, 'e', '2008-01-01 23:59:59'); -REPLACE INTO ta_l (a, b, c) VALUES (2, 'f', '2008-02-02 02:02:02'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -2 f 2008-02-02 02:02:02 - -replace select -REPLACE INTO ta_l (a, b, c) SELECT a, b, c FROM tb_l; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -replace select a -REPLACE INTO ta_l (a, b, c) VALUES ((SELECT a FROM tb_l ORDER BY a LIMIT 1), -'e', '2008-01-01 23:59:59'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 e 2008-01-01 23:59:59 -2 g 2000-02-01 00:00:00 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -replace low_priority -REPLACE LOW_PRIORITY INTO ta_l (a, b, c) VALUES (3, 'g', -'2009-03-03 03:03:03'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 e 2008-01-01 23:59:59 -2 g 2000-02-01 00:00:00 -3 g 2009-03-03 03:03:03 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -update -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (1, 'e', '2008-01-01 23:59:59'), -(2, 'e', '2008-01-01 23:59:59'); -UPDATE ta_l SET b = 'f', c = '2008-02-02 02:02:02' WHERE a = 2; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 e 2008-01-01 23:59:59 -2 f 2008-02-02 02:02:02 - -update select -UPDATE ta_l SET b = 'g', c = '2009-03-03 03:03:03' WHERE a IN (SELECT a FROM -tb_l); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 g 2009-03-03 03:03:03 -2 g 2009-03-03 03:03:03 - -update select a -UPDATE ta_l SET b = 'h', c = '2010-04-04 04:04:04' WHERE a = (SELECT a FROM -tb_l ORDER BY a LIMIT 1); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 h 2010-04-04 04:04:04 -2 g 2009-03-03 03:03:03 - -update join -UPDATE ta_l a, tb_l b SET a.b = b.b, a.c = b.c WHERE a.a = b.a; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 - -update join a -UPDATE ta_l a, tb_l b SET a.b = 'g', a.c = '2009-03-03 03:03:03' WHERE -a.a = b.a; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 g 2009-03-03 03:03:03 -2 g 2009-03-03 03:03:03 - -update low_priority -UPDATE LOW_PRIORITY ta_l SET b = 'f', c = '2008-02-02 02:02:02' WHERE a = 2; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 g 2009-03-03 03:03:03 -2 f 2008-02-02 02:02:02 - -update ignore -UPDATE IGNORE ta_l SET a = 1, b = 'g', c = '2009-03-03 03:03:03' WHERE a = 2; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 g 2009-03-03 03:03:03 -2 f 2008-02-02 02:02:02 - -update pushdown -update ta_l set b = 'j', c = '2009-03-03 03:03:03' where b = 'f'; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 g 2009-03-03 03:03:03 -2 j 2009-03-03 03:03:03 - -update index pushdown -UPDATE ta_l SET b = 'g', c = '2009-03-03 03:03:03' WHERE a > 0 AND b = 'j'; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 g 2009-03-03 03:03:03 -2 g 2009-03-03 03:03:03 - -delete -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (1, 'e', '2008-01-01 23:59:59'), -(2, 'e', '2008-01-01 23:59:59'), (3, 'e', '2008-01-01 23:59:59'), -(4, 'e', '2008-01-01 23:59:59'), (5, 'e', '2008-01-01 23:59:59'), -(6, 'e', '2008-01-01 23:59:59'), (7, 'e', '2008-01-01 23:59:59'), -(8, 'e', '2008-01-01 23:59:59'), (9, 'e', '2008-01-01 23:59:59'), -(10, 'j', '2008-01-01 23:59:59'); -DELETE FROM ta_l WHERE a = 2; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 e 2008-01-01 23:59:59 -3 e 2008-01-01 23:59:59 -4 e 2008-01-01 23:59:59 -5 e 2008-01-01 23:59:59 -6 e 2008-01-01 23:59:59 -7 e 2008-01-01 23:59:59 -8 e 2008-01-01 23:59:59 -9 e 2008-01-01 23:59:59 -10 j 2008-01-01 23:59:59 - -delete all -DELETE FROM ta_l; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') - -delete select -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (1, 'e', '2008-01-01 23:59:59'), -(2, 'e', '2008-01-01 23:59:59'), (3, 'e', '2008-01-01 23:59:59'), -(4, 'e', '2008-01-01 23:59:59'), (5, 'e', '2008-01-01 23:59:59'), -(6, 'e', '2008-01-01 23:59:59'), (7, 'e', '2008-01-01 23:59:59'), -(8, 'e', '2008-01-01 23:59:59'), (9, 'e', '2008-01-01 23:59:59'), -(10, 'j', '2008-01-01 23:59:59'); -DELETE FROM ta_l WHERE a IN (SELECT a FROM tb_l); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -6 e 2008-01-01 23:59:59 -7 e 2008-01-01 23:59:59 -8 e 2008-01-01 23:59:59 -9 e 2008-01-01 23:59:59 -10 j 2008-01-01 23:59:59 - -delete select a -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (1, 'e', '2008-01-01 23:59:59'), -(2, 'e', '2008-01-01 23:59:59'), (3, 'e', '2008-01-01 23:59:59'), -(4, 'e', '2008-01-01 23:59:59'), (5, 'e', '2008-01-01 23:59:59'), -(6, 'e', '2008-01-01 23:59:59'), (7, 'e', '2008-01-01 23:59:59'), -(8, 'e', '2008-01-01 23:59:59'), (9, 'e', '2008-01-01 23:59:59'), -(10, 'j', '2008-01-01 23:59:59'); -DELETE FROM ta_l WHERE a = (SELECT a FROM tb_l ORDER BY a LIMIT 1); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -2 e 2008-01-01 23:59:59 -3 e 2008-01-01 23:59:59 -4 e 2008-01-01 23:59:59 -5 e 2008-01-01 23:59:59 -6 e 2008-01-01 23:59:59 -7 e 2008-01-01 23:59:59 -8 e 2008-01-01 23:59:59 -9 e 2008-01-01 23:59:59 -10 j 2008-01-01 23:59:59 - -delete join -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (1, 'e', '2008-01-01 23:59:59'), -(2, 'e', '2008-01-01 23:59:59'), (3, 'e', '2008-01-01 23:59:59'), -(4, 'e', '2008-01-01 23:59:59'), (5, 'e', '2008-01-01 23:59:59'), -(6, 'e', '2008-01-01 23:59:59'), (7, 'e', '2008-01-01 23:59:59'), -(8, 'e', '2008-01-01 23:59:59'), (9, 'e', '2008-01-01 23:59:59'), -(10, 'j', '2008-01-01 23:59:59'); -DELETE a FROM ta_l a, (SELECT a FROM tb_l ORDER BY a) b WHERE a.a = b.a; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -6 e 2008-01-01 23:59:59 -7 e 2008-01-01 23:59:59 -8 e 2008-01-01 23:59:59 -9 e 2008-01-01 23:59:59 -10 j 2008-01-01 23:59:59 - -delete low_priority -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (1, 'e', '2008-01-01 23:59:59'), -(2, 'e', '2008-01-01 23:59:59'), (3, 'e', '2008-01-01 23:59:59'), -(4, 'e', '2008-01-01 23:59:59'), (5, 'e', '2008-01-01 23:59:59'), -(6, 'e', '2008-01-01 23:59:59'), (7, 'e', '2008-01-01 23:59:59'), -(8, 'e', '2008-01-01 23:59:59'), (9, 'e', '2008-01-01 23:59:59'), -(10, 'j', '2008-01-01 23:59:59'); -DELETE LOW_PRIORITY FROM ta_l WHERE a = 2; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 e 2008-01-01 23:59:59 -3 e 2008-01-01 23:59:59 -4 e 2008-01-01 23:59:59 -5 e 2008-01-01 23:59:59 -6 e 2008-01-01 23:59:59 -7 e 2008-01-01 23:59:59 -8 e 2008-01-01 23:59:59 -9 e 2008-01-01 23:59:59 -10 j 2008-01-01 23:59:59 - -delete ignore -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (1, 'e', '2008-01-01 23:59:59'), -(2, 'e', '2008-01-01 23:59:59'), (3, 'e', '2008-01-01 23:59:59'), -(4, 'e', '2008-01-01 23:59:59'), (5, 'e', '2008-01-01 23:59:59'), -(6, 'e', '2008-01-01 23:59:59'), (7, 'e', '2008-01-01 23:59:59'), -(8, 'e', '2008-01-01 23:59:59'), (9, 'e', '2008-01-01 23:59:59'), -(10, 'j', '2008-01-01 23:59:59'); -DELETE IGNORE FROM ta_l WHERE a = 2; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 e 2008-01-01 23:59:59 -3 e 2008-01-01 23:59:59 -4 e 2008-01-01 23:59:59 -5 e 2008-01-01 23:59:59 -6 e 2008-01-01 23:59:59 -7 e 2008-01-01 23:59:59 -8 e 2008-01-01 23:59:59 -9 e 2008-01-01 23:59:59 -10 j 2008-01-01 23:59:59 - -delete quick -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (1, 'e', '2008-01-01 23:59:59'), -(2, 'e', '2008-01-01 23:59:59'), (3, 'e', '2008-01-01 23:59:59'), -(4, 'e', '2008-01-01 23:59:59'), (5, 'e', '2008-01-01 23:59:59'), -(6, 'e', '2008-01-01 23:59:59'), (7, 'e', '2008-01-01 23:59:59'), -(8, 'e', '2008-01-01 23:59:59'), (9, 'e', '2008-01-01 23:59:59'), -(10, 'j', '2008-01-01 23:59:59'); -DELETE QUICK FROM ta_l WHERE a = 2; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 e 2008-01-01 23:59:59 -3 e 2008-01-01 23:59:59 -4 e 2008-01-01 23:59:59 -5 e 2008-01-01 23:59:59 -6 e 2008-01-01 23:59:59 -7 e 2008-01-01 23:59:59 -8 e 2008-01-01 23:59:59 -9 e 2008-01-01 23:59:59 -10 j 2008-01-01 23:59:59 - -delete pushdown -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (1, 'e', '2008-01-01 23:59:59'), -(2, 'e', '2008-01-01 23:59:59'), (3, 'e', '2008-01-01 23:59:59'), -(4, 'e', '2008-01-01 23:59:59'), (5, 'e', '2008-01-01 23:59:59'), -(6, 'e', '2008-01-01 23:59:59'), (7, 'e', '2008-01-01 23:59:59'), -(8, 'e', '2008-01-01 23:59:59'), (9, 'e', '2008-01-01 23:59:59'), -(10, 'j', '2008-01-01 23:59:59'); -DELETE FROM ta_l WHERE b = 'e'; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -10 j 2008-01-01 23:59:59 - -delete index pushdown -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (1, 'e', '2008-01-01 23:59:59'), -(2, 'e', '2008-01-01 23:59:59'), (3, 'e', '2008-01-01 23:59:59'), -(4, 'e', '2008-01-01 23:59:59'), (5, 'e', '2008-01-01 23:59:59'), -(6, 'e', '2008-01-01 23:59:59'), (7, 'e', '2008-01-01 23:59:59'), -(8, 'e', '2008-01-01 23:59:59'), (9, 'e', '2008-01-01 23:59:59'), -(10, 'j', '2008-01-01 23:59:59'); -DELETE FROM ta_l WHERE a > 0 AND b = 'e'; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -10 j 2008-01-01 23:59:59 - -truncate -TRUNCATE TABLE ta_l; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') - -deinit -DROP DATABASE IF EXISTS auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -end of test diff --git a/storage/spider/mysql-test/spider/oracle/r/basic_sql_part.result b/storage/spider/mysql-test/spider/oracle/r/basic_sql_part.result deleted file mode 100644 index 9e1201c17c9..00000000000 --- a/storage/spider/mysql-test/spider/oracle/r/basic_sql_part.result +++ /dev/null @@ -1,121 +0,0 @@ -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -drop and create databases -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -CREATE DATABASE auto_test_remote; -USE auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -CREATE DATABASE auto_test_remote2; -USE auto_test_remote2; - -test select 1 -SELECT 1; -1 -1 -DROP TABLE IF EXISTS tb_l; -CREATE TABLE tb_l ( -a INT, -b CHAR(1), -c DATETIME, -PRIMARY KEY(a) -) MASTER_1_ENGINE2 MASTER_1_CHARSET2 -INSERT INTO tb_l (a, b, c) VALUES -(1, 'f', '2008-07-01 10:21:39'), -(2, 'g', '2000-02-01 00:00:00'), -(3, 'j', '2007-05-04 20:03:11'), -(4, 'i', '2003-10-30 05:01:03'), -(5, 'h', '2001-10-31 23:59:59'); - -create table with partition and select test -CREATE TABLE ta_l2 ( -PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_COMMENT_P_2_1 -SELECT a, b, c FROM tb_l -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -select partition using pushdown -SELECT a.a, a.b, date_format(a.c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 a WHERE -a.b = 'g' ORDER BY a.a; -a b date_format(a.c, '%Y-%m-%d %H:%i:%s') -2 g 2000-02-01 00:00:00 - -select partition using index pushdown -SELECT a.a, a.b, date_format(a.c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 a WHERE -a.a > 0 AND a.b = 'g' ORDER BY a.a; -a b date_format(a.c, '%Y-%m-%d %H:%i:%s') -2 g 2000-02-01 00:00:00 - -update partition pushdown -UPDATE ta_l2 SET b = 'e', c = '2009-03-03 03:03:03' WHERE b = 'j'; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 -3 e 2009-03-03 03:03:03 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -update partition index pushdown -UPDATE ta_l2 SET b = 'j', c = '2009-03-03 03:03:03' WHERE a > 0 AND b = 'e'; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 -3 j 2009-03-03 03:03:03 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -delete partition pushdown -TRUNCATE TABLE ta_l2; -INSERT INTO ta_l2 SELECT a, b, c FROM tb_l; -DELETE FROM ta_l2 WHERE b = 'g'; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -delete partition index pushdown -TRUNCATE TABLE ta_l2; -INSERT INTO ta_l2 SELECT a, b, c FROM tb_l; -DELETE FROM ta_l2 WHERE a > 0 AND b = 'g'; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -deinit -DROP DATABASE IF EXISTS auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -end of test diff --git a/storage/spider/mysql-test/spider/oracle/r/direct_aggregate.result b/storage/spider/mysql-test/spider/oracle/r/direct_aggregate.result deleted file mode 100644 index fe5752cff65..00000000000 --- a/storage/spider/mysql-test/spider/oracle/r/direct_aggregate.result +++ /dev/null @@ -1,91 +0,0 @@ -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -drop and create databases -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -CREATE DATABASE auto_test_remote; -USE auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -CREATE DATABASE auto_test_remote2; -USE auto_test_remote2; - -test select 1 -SELECT 1; -1 -1 - -create table select test -DROP TABLE IF EXISTS ta_l; -CREATE TABLE ta_l ( -a INT, -b CHAR(1), -c DATETIME, -PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_2_1 -INSERT INTO ta_l (a, b, c) VALUES -(1, 'a', '2008-08-01 10:21:39'), -(2, 'b', '2000-01-01 00:00:00'), -(3, 'e', '2007-06-04 20:03:11'), -(4, 'd', '2003-11-30 05:01:03'), -(5, 'c', '2001-12-31 23:59:59'); - -direct_aggregating test -SHOW GLOBAL STATUS LIKE 'Spider_direct_aggregate%'; -Variable_name Value -Spider_direct_aggregate 0 -SELECT COUNT(*) FROM ta_l; -COUNT(*) -5 -SHOW GLOBAL STATUS LIKE 'Spider_direct_aggregate%'; -Variable_name Value -Spider_direct_aggregate 1 -SELECT MAX(a) FROM ta_l; -MAX(a) -5 -SHOW GLOBAL STATUS LIKE 'Spider_direct_aggregate%'; -Variable_name Value -Spider_direct_aggregate 1 -SELECT MIN(a) FROM ta_l; -MIN(a) -1 -SHOW GLOBAL STATUS LIKE 'Spider_direct_aggregate%'; -Variable_name Value -Spider_direct_aggregate 1 -SELECT MAX(a) FROM ta_l WHERE a < 5; -MAX(a) -4 -SHOW GLOBAL STATUS LIKE 'Spider_direct_aggregate%'; -Variable_name Value -Spider_direct_aggregate 1 -SELECT MIN(a) FROM ta_l WHERE a > 1; -MIN(a) -2 -SHOW GLOBAL STATUS LIKE 'Spider_direct_aggregate%'; -Variable_name Value -Spider_direct_aggregate 1 - -deinit -DROP DATABASE IF EXISTS auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -end of test diff --git a/storage/spider/mysql-test/spider/oracle/r/direct_aggregate_part.result b/storage/spider/mysql-test/spider/oracle/r/direct_aggregate_part.result deleted file mode 100644 index 9bde4a1746a..00000000000 --- a/storage/spider/mysql-test/spider/oracle/r/direct_aggregate_part.result +++ /dev/null @@ -1,82 +0,0 @@ -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -drop and create databases -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -CREATE DATABASE auto_test_remote; -USE auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -CREATE DATABASE auto_test_remote2; -USE auto_test_remote2; - -test select 1 -SELECT 1; -1 -1 - -with partition test -CREATE TABLE ta_l2 ( -a INT, -b CHAR(1), -c DATETIME, -PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_COMMENT2_P_2_1 -SHOW GLOBAL STATUS LIKE 'Spider_direct_aggregate%'; -Variable_name Value -Spider_direct_aggregate 0 -SELECT COUNT(*) FROM ta_l2; -COUNT(*) -5 -SHOW GLOBAL STATUS LIKE 'Spider_direct_aggregate%'; -Variable_name Value -Spider_direct_aggregate 2 -SELECT MAX(a) FROM ta_l2; -MAX(a) -5 -SHOW GLOBAL STATUS LIKE 'Spider_direct_aggregate%'; -Variable_name Value -Spider_direct_aggregate 2 -SELECT MIN(a) FROM ta_l2; -MIN(a) -1 -SHOW GLOBAL STATUS LIKE 'Spider_direct_aggregate%'; -Variable_name Value -Spider_direct_aggregate 2 -SELECT MAX(a) FROM ta_l2 WHERE a < 5; -MAX(a) -4 -SHOW GLOBAL STATUS LIKE 'Spider_direct_aggregate%'; -Variable_name Value -Spider_direct_aggregate 2 -SELECT MIN(a) FROM ta_l2 WHERE a > 1; -MIN(a) -2 -SHOW GLOBAL STATUS LIKE 'Spider_direct_aggregate%'; -Variable_name Value -Spider_direct_aggregate 2 - -deinit -DROP DATABASE IF EXISTS auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -end of test diff --git a/storage/spider/mysql-test/spider/oracle/r/direct_update.result b/storage/spider/mysql-test/spider/oracle/r/direct_update.result deleted file mode 100644 index 3dc39d5f630..00000000000 --- a/storage/spider/mysql-test/spider/oracle/r/direct_update.result +++ /dev/null @@ -1,138 +0,0 @@ -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -drop and create databases -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -CREATE DATABASE auto_test_remote; -USE auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -CREATE DATABASE auto_test_remote2; -USE auto_test_remote2; - -test select 1 -SELECT 1; -1 -1 - -create table select test -DROP TABLE IF EXISTS ta_l; -CREATE TABLE ta_l ( -a INT, -b CHAR(1), -c DATETIME, -PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_2_1 -INSERT INTO ta_l (a, b, c) VALUES -(1, 'a', '2008-08-01 10:21:39'), -(2, 'b', '2000-01-01 00:00:00'), -(3, 'e', '2007-06-04 20:03:11'), -(4, 'd', '2003-11-30 05:01:03'), -(5, 'c', '2001-12-31 23:59:59'); - -direct_updating test -SHOW GLOBAL STATUS LIKE 'Spider_direct_update%'; -Variable_name Value -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-01 10:21:39 -2 b 2000-01-01 00:00:00 -3 e 2007-06-04 20:03:11 -4 d 2003-11-30 05:01:03 -5 c 2001-12-31 23:59:59 -update all rows with function -UPDATE ta_l SET c = ADDDATE(c, 1); -SHOW GLOBAL STATUS LIKE 'Spider_direct_update%'; -Variable_name Value -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-02 10:21:39 -2 b 2000-01-02 00:00:00 -3 e 2007-06-05 20:03:11 -4 d 2003-12-01 05:01:03 -5 c 2002-01-01 23:59:59 -update by primary key -UPDATE ta_l SET b = 'x' WHERE a = 3; -SHOW GLOBAL STATUS LIKE 'Spider_direct_update%'; -Variable_name Value -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-02 10:21:39 -2 b 2000-01-02 00:00:00 -3 x 2007-06-05 20:03:11 -4 d 2003-12-01 05:01:03 -5 c 2002-01-01 23:59:59 -update by a column without index -UPDATE ta_l SET c = '2011-10-17' WHERE b = 'x'; -SHOW GLOBAL STATUS LIKE 'Spider_direct_update%'; -Variable_name Value -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-02 10:21:39 -2 b 2000-01-02 00:00:00 -3 x 2011-10-17 00:00:00 -4 d 2003-12-01 05:01:03 -5 c 2002-01-01 23:59:59 -update by primary key with order and limit -UPDATE ta_l SET c = ADDDATE(c, 1) WHERE a < 4 ORDER BY b DESC LIMIT 1; -SHOW GLOBAL STATUS LIKE 'Spider_direct_update%'; -Variable_name Value -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-02 10:21:39 -2 b 2000-01-02 00:00:00 -3 x 2011-10-18 00:00:00 -4 d 2003-12-01 05:01:03 -5 c 2002-01-01 23:59:59 -delete by primary key with order and limit -DELETE FROM ta_l WHERE a < 4 ORDER BY c LIMIT 1; -SHOW GLOBAL STATUS LIKE 'Spider_direct_delete%'; -Variable_name Value -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-02 10:21:39 -3 x 2011-10-18 00:00:00 -4 d 2003-12-01 05:01:03 -5 c 2002-01-01 23:59:59 -delete by a column without index -DELETE FROM ta_l WHERE b = 'c'; -SHOW GLOBAL STATUS LIKE 'Spider_direct_delete%'; -Variable_name Value -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-02 10:21:39 -3 x 2011-10-18 00:00:00 -4 d 2003-12-01 05:01:03 -delete by primary key -DELETE FROM ta_l WHERE a = 3; -SHOW GLOBAL STATUS LIKE 'Spider_direct_delete%'; -Variable_name Value -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-02 10:21:39 -4 d 2003-12-01 05:01:03 - -deinit -DROP DATABASE IF EXISTS auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -end of test diff --git a/storage/spider/mysql-test/spider/oracle/r/direct_update_part.result b/storage/spider/mysql-test/spider/oracle/r/direct_update_part.result deleted file mode 100644 index 8a22c40a0da..00000000000 --- a/storage/spider/mysql-test/spider/oracle/r/direct_update_part.result +++ /dev/null @@ -1,129 +0,0 @@ -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -drop and create databases -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -CREATE DATABASE auto_test_remote; -USE auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -CREATE DATABASE auto_test_remote2; -USE auto_test_remote2; - -test select 1 -SELECT 1; -1 -1 - -with partition test -CREATE TABLE ta_l2 ( -a INT, -b CHAR(1), -c DATETIME, -PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_COMMENT2_P_2_1 -SHOW GLOBAL STATUS LIKE 'Spider_direct_update%'; -Variable_name Value -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-01 10:21:39 -2 b 2000-01-01 00:00:00 -3 e 2007-06-04 20:03:11 -4 d 2003-11-30 05:01:03 -5 c 2001-12-31 23:59:59 -update all rows with function -UPDATE ta_l2 SET c = ADDDATE(c, 1); -SHOW GLOBAL STATUS LIKE 'Spider_direct_update%'; -Variable_name Value -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-02 10:21:39 -2 b 2000-01-02 00:00:00 -3 e 2007-06-05 20:03:11 -4 d 2003-12-01 05:01:03 -5 c 2002-01-01 23:59:59 -update by primary key -UPDATE ta_l2 SET b = 'x' WHERE a = 3; -SHOW GLOBAL STATUS LIKE 'Spider_direct_update%'; -Variable_name Value -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-02 10:21:39 -2 b 2000-01-02 00:00:00 -3 x 2007-06-05 20:03:11 -4 d 2003-12-01 05:01:03 -5 c 2002-01-01 23:59:59 -update by a column without index -UPDATE ta_l2 SET c = '2011-10-17' WHERE b = 'x'; -SHOW GLOBAL STATUS LIKE 'Spider_direct_update%'; -Variable_name Value -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-02 10:21:39 -2 b 2000-01-02 00:00:00 -3 x 2011-10-17 00:00:00 -4 d 2003-12-01 05:01:03 -5 c 2002-01-01 23:59:59 -update by primary key with order and limit -UPDATE ta_l2 SET c = ADDDATE(c, 1) WHERE a < 4 ORDER BY b DESC LIMIT 1; -SHOW GLOBAL STATUS LIKE 'Spider_direct_update%'; -Variable_name Value -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-02 10:21:39 -2 b 2000-01-02 00:00:00 -3 x 2011-10-18 00:00:00 -4 d 2003-12-01 05:01:03 -5 c 2002-01-01 23:59:59 -delete by primary key with order and limit -DELETE FROM ta_l2 WHERE a < 4 ORDER BY c LIMIT 1; -SHOW GLOBAL STATUS LIKE 'Spider_direct_delete%'; -Variable_name Value -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-02 10:21:39 -3 x 2011-10-18 00:00:00 -4 d 2003-12-01 05:01:03 -5 c 2002-01-01 23:59:59 -delete by a column without index -DELETE FROM ta_l2 WHERE b = 'c'; -SHOW GLOBAL STATUS LIKE 'Spider_direct_delete%'; -Variable_name Value -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-02 10:21:39 -3 x 2011-10-18 00:00:00 -4 d 2003-12-01 05:01:03 -delete by primary key -DELETE FROM ta_l2 WHERE a = 3; -SHOW GLOBAL STATUS LIKE 'Spider_direct_delete%'; -Variable_name Value -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-02 10:21:39 -4 d 2003-12-01 05:01:03 - -deinit -DROP DATABASE IF EXISTS auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -end of test diff --git a/storage/spider/mysql-test/spider/oracle/r/function.result b/storage/spider/mysql-test/spider/oracle/r/function.result deleted file mode 100644 index 764c774514b..00000000000 --- a/storage/spider/mysql-test/spider/oracle/r/function.result +++ /dev/null @@ -1,149 +0,0 @@ -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -drop and create databases -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -CREATE DATABASE auto_test_remote; -USE auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -CREATE DATABASE auto_test_remote2; -USE auto_test_remote2; - -test select 1 -SELECT 1; -1 -1 - -in() -CREATE TABLE t1 ( -a VARCHAR(255), -PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET3 MASTER_1_COMMENT_TEXT_PK1_1 -insert into t1 values ('1'); -insert into t1 select a + 1 from t1; -insert into t1 select a + 2 from t1; -insert into t1 select a + 4 from t1; -insert into t1 select a + 8 from t1; -insert into t1 select a + 16 from t1; -insert into t1 select a + 32 from t1; -insert into t1 select a + 64 from t1; -insert into t1 select a + 128 from t1; -insert into t1 select a + 256 from t1; -insert into t1 select a + 512 from t1; -flush tables; -select a from t1 where a in ('15', '120'); -a -120 -15 - -date_sub() -DROP TABLE IF EXISTS ta_l; -CREATE TABLE ta_l ( -a INT, -b CHAR(1), -c DATETIME, -PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_2_1 -INSERT INTO ta_l (a, b, c) VALUES -(1, 'a', '2008-08-01 10:21:39'), -(2, 'b', '2000-01-01 00:00:00'), -(3, 'e', '2007-06-04 20:03:11'), -(4, 'd', '2003-11-30 05:01:03'), -(5, 'c', '2001-12-31 23:59:59'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-01 10:21:39 -2 b 2000-01-01 00:00:00 -3 e 2007-06-04 20:03:11 -4 d 2003-11-30 05:01:03 -5 c 2001-12-31 23:59:59 -UPDATE ta_l SET c = DATE_SUB(c, INTERVAL 1 YEAR); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2007-08-01 10:21:39 -2 b 1999-01-01 00:00:00 -3 e 2006-06-04 20:03:11 -4 d 2002-11-30 05:01:03 -5 c 2000-12-31 23:59:59 -UPDATE ta_l SET c = DATE_ADD(c, INTERVAL 1 QUARTER); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2007-11-01 10:21:39 -2 b 1999-04-01 00:00:00 -3 e 2006-09-04 20:03:11 -4 d 2003-02-28 05:01:03 -5 c 2001-03-31 23:59:59 -UPDATE ta_l SET c = DATE_SUB(c, INTERVAL 1 MONTH); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2007-10-01 10:21:39 -2 b 1999-03-01 00:00:00 -3 e 2006-08-04 20:03:11 -4 d 2003-01-28 05:01:03 -5 c 2001-02-28 23:59:59 -UPDATE ta_l SET c = DATE_ADD(c, INTERVAL 1 WEEK); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2007-10-08 10:21:39 -2 b 1999-03-08 00:00:00 -3 e 2006-08-11 20:03:11 -4 d 2003-02-04 05:01:03 -5 c 2001-03-07 23:59:59 -UPDATE ta_l SET c = DATE_SUB(c, INTERVAL 1 DAY); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2007-10-07 10:21:39 -2 b 1999-03-07 00:00:00 -3 e 2006-08-10 20:03:11 -4 d 2003-02-03 05:01:03 -5 c 2001-03-06 23:59:59 -UPDATE ta_l SET c = DATE_ADD(c, INTERVAL 1 HOUR); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2007-10-07 11:21:39 -2 b 1999-03-07 01:00:00 -3 e 2006-08-10 21:03:11 -4 d 2003-02-03 06:01:03 -5 c 2001-03-07 00:59:59 -UPDATE ta_l SET c = DATE_SUB(c, INTERVAL 1 MINUTE); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2007-10-07 11:20:39 -2 b 1999-03-07 00:59:00 -3 e 2006-08-10 21:02:11 -4 d 2003-02-03 06:00:03 -5 c 2001-03-07 00:58:59 -UPDATE ta_l SET c = DATE_ADD(c, INTERVAL 1 SECOND); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2007-10-07 11:20:40 -2 b 1999-03-07 00:59:01 -3 e 2006-08-10 21:02:12 -4 d 2003-02-03 06:00:04 -5 c 2001-03-07 00:59:00 - -deinit -DROP DATABASE IF EXISTS auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -end of test diff --git a/storage/spider/mysql-test/spider/oracle/r/ha.result b/storage/spider/mysql-test/spider/oracle/r/ha.result deleted file mode 100644 index 8ca64dec6df..00000000000 --- a/storage/spider/mysql-test/spider/oracle/r/ha.result +++ /dev/null @@ -1,240 +0,0 @@ -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -drop and create databases -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -CREATE DATABASE auto_test_remote; -USE auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -CREATE DATABASE auto_test_remote2; -USE auto_test_remote2; -DROP DATABASE IF EXISTS auto_test_remote3; -CREATE DATABASE auto_test_remote3; -USE auto_test_remote3; -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; - -test select 1 -SELECT 1; -1 -1 - -create table test -DROP TABLE IF EXISTS ta_l; -CREATE TABLE ta_l ( -a INT, -b CHAR(1), -c DATETIME, -PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_HA_2_1 -INSERT INTO ta_l (a, b, c) VALUES -(1, 'a', '2008-08-01 10:21:39'), -(2, 'b', '2000-01-01 00:00:00'), -(3, 'e', '2007-06-04 20:03:11'), -(4, 'd', '2003-11-30 05:01:03'), -(5, 'c', '2001-12-31 23:59:59'); - -select test -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-01 10:21:39 -2 b 2000-01-01 00:00:00 -3 e 2007-06-04 20:03:11 -4 d 2003-11-30 05:01:03 -5 c 2001-12-31 23:59:59 - -fail-over test -SHOW GLOBAL STATUS LIKE 'Spider_mon_table_cache_version%'; -Variable_name Value -Spider_mon_table_cache_version 0 -Spider_mon_table_cache_version_req 1 -INSERT INTO ta_l (a, b, c) VALUES -(6, 'e', '2011-05-05 20:04:05'); -ERROR HY000: Table 'SYSTEM.ta_r3' get a problem -SELECT db_name, table_name, link_id, link_status FROM mysql.spider_tables -ORDER BY db_name, table_name, link_id; -db_name table_name link_id link_status -auto_test_local ta_l 0 1 -auto_test_local ta_l 1 3 -SELECT db_name, table_name, link_id FROM mysql.spider_link_failed_log; -db_name table_name link_id -auto_test_local ta_l 1 -SHOW GLOBAL STATUS LIKE 'Spider_mon_table_cache_version%'; -Variable_name Value -Spider_mon_table_cache_version 1 -Spider_mon_table_cache_version_req 1 -INSERT INTO ta_l (a, b, c) VALUES -(6, 'e', '2011-05-05 20:04:05'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-01 10:21:39 -2 b 2000-01-01 00:00:00 -3 e 2007-06-04 20:03:11 -4 d 2003-11-30 05:01:03 -5 c 2001-12-31 23:59:59 -6 e 2011-05-05 20:04:05 - -recovery test -ALTER TABLE ta_l -CONNECTION='host "xe", user "system", - password "oracle", msi "2", mkd "2", - database "SYSTEM", lst "0 2"'; -SELECT db_name, table_name, link_id, link_status FROM mysql.spider_tables -ORDER BY db_name, table_name, link_id; -db_name table_name link_id link_status -auto_test_local ta_l 0 1 -auto_test_local ta_l 1 2 -SELECT spider_copy_tables('ta_l', '0', '1'); -spider_copy_tables('ta_l', '0', '1') -1 -ALTER TABLE ta_l -CONNECTION='host "xe", user "system", - password "oracle", msi "2", mkd "2", - database "SYSTEM", lst "0 1"'; -SELECT db_name, table_name, link_id, link_status FROM mysql.spider_tables -ORDER BY db_name, table_name, link_id; -db_name table_name link_id link_status -auto_test_local ta_l 0 1 -auto_test_local ta_l 1 1 -INSERT INTO ta_l (a, b, c) VALUES -(8, 'g', '2011-05-05 21:33:30'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-01 10:21:39 -2 b 2000-01-01 00:00:00 -3 e 2007-06-04 20:03:11 -4 d 2003-11-30 05:01:03 -5 c 2001-12-31 23:59:59 -6 e 2011-05-05 20:04:05 -8 g 2011-05-05 21:33:30 -DROP TABLE ta_l; -SELECT spider_flush_table_mon_cache(); -spider_flush_table_mon_cache() -1 - -active standby test -create table test -DROP TABLE IF EXISTS ta_l; -CREATE TABLE ta_l ( -a INT, -b CHAR(1), -c DATETIME, -PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_HA_AS_2_1 -INSERT INTO ta_l (a, b, c) VALUES -(1, 'a', '2008-08-01 10:21:39'), -(2, 'b', '2000-01-01 00:00:00'), -(3, 'e', '2007-06-04 20:03:11'), -(4, 'd', '2003-11-30 05:01:03'), -(5, 'c', '2001-12-31 23:59:59'); - -select test -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-01 10:21:39 -2 b 2000-01-01 00:00:00 -3 e 2007-06-04 20:03:11 -4 d 2003-11-30 05:01:03 -5 c 2001-12-31 23:59:59 - -fail-over test -SHOW GLOBAL STATUS LIKE 'Spider_mon_table_cache_version%'; -Variable_name Value -Spider_mon_table_cache_version 1 -Spider_mon_table_cache_version_req 2 -INSERT INTO ta_l (a, b, c) VALUES -(6, 'e', '2011-05-05 20:04:05'); -ERROR HY000: Table 'SYSTEM.ta_r' get a problem -SELECT db_name, table_name, link_id, link_status FROM mysql.spider_tables -ORDER BY db_name, table_name, link_id; -db_name table_name link_id link_status -auto_test_local ta_l 0 3 -auto_test_local ta_l 1 1 -SELECT db_name, table_name, link_id FROM mysql.spider_link_failed_log; -db_name table_name link_id -auto_test_local ta_l 1 -auto_test_local ta_l 0 -SHOW GLOBAL STATUS LIKE 'Spider_mon_table_cache_version%'; -Variable_name Value -Spider_mon_table_cache_version 2 -Spider_mon_table_cache_version_req 2 -INSERT INTO ta_l (a, b, c) VALUES -(6, 'e', '2011-05-05 20:04:05'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -6 e 2011-05-05 20:04:05 - -recovery test -ALTER TABLE ta_l -CONNECTION='host "xe", user "system", - password "oracle", msi "2", mkd "2", alc "1", - database "SYSTEM", lst "1 0"'; -SELECT db_name, table_name, link_id, link_status FROM mysql.spider_tables -ORDER BY db_name, table_name, link_id; -db_name table_name link_id link_status -auto_test_local ta_l 0 1 -auto_test_local ta_l 1 1 -INSERT INTO ta_l (a, b, c) VALUES -(8, 'g', '2011-05-05 21:33:30'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -8 g 2011-05-05 21:33:30 -DROP TABLE ta_l; -SELECT spider_flush_table_mon_cache(); -spider_flush_table_mon_cache() -1 - -deinit -DROP DATABASE IF EXISTS auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -DROP DATABASE IF EXISTS auto_test_remote3; -DROP DATABASE IF EXISTS auto_test_local; -DROP DATABASE IF EXISTS auto_test_local; -DROP DATABASE IF EXISTS auto_test_local; -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -end of test diff --git a/storage/spider/mysql-test/spider/oracle/r/ha_part.result b/storage/spider/mysql-test/spider/oracle/r/ha_part.result deleted file mode 100644 index e11b6f695e0..00000000000 --- a/storage/spider/mysql-test/spider/oracle/r/ha_part.result +++ /dev/null @@ -1,262 +0,0 @@ -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -drop and create databases -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -CREATE DATABASE auto_test_remote; -USE auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -CREATE DATABASE auto_test_remote2; -USE auto_test_remote2; -DROP DATABASE IF EXISTS auto_test_remote3; -CREATE DATABASE auto_test_remote3; -USE auto_test_remote3; -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; - -test select 1 -SELECT 1; -1 -1 - -create table with partition test -DROP TABLE IF EXISTS ta_l2; -CREATE TABLE ta_l2 ( -a INT, -b CHAR(1), -c DATETIME, -PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_HA_P_2_1 -INSERT INTO ta_l2 (a, b, c) VALUES -(1, 'a', '2008-08-01 10:21:39'), -(2, 'b', '2000-01-01 00:00:00'), -(3, 'e', '2007-06-04 20:03:11'), -(4, 'd', '2003-11-30 05:01:03'), -(5, 'c', '2001-12-31 23:59:59'); - -select test -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-01 10:21:39 -2 b 2000-01-01 00:00:00 -3 e 2007-06-04 20:03:11 -4 d 2003-11-30 05:01:03 -5 c 2001-12-31 23:59:59 - -fail-over test -SHOW GLOBAL STATUS LIKE 'Spider_mon_table_cache_version%'; -Variable_name Value -Spider_mon_table_cache_version 0 -Spider_mon_table_cache_version_req 1 -INSERT INTO ta_l2 (a, b, c) VALUES -(6, 'e', '2011-05-05 20:04:05'); -ERROR HY000: Table 'SYSTEM.ta_r4' get a problem -SELECT db_name, table_name, link_id, link_status FROM mysql.spider_tables -ORDER BY db_name, table_name, link_id; -db_name table_name link_id link_status -auto_test_local ta_l2#P#pt1 0 1 -auto_test_local ta_l2#P#pt1 1 1 -auto_test_local ta_l2#P#pt2 0 1 -auto_test_local ta_l2#P#pt2 1 3 -SELECT db_name, table_name, link_id FROM mysql.spider_link_failed_log; -db_name table_name link_id -auto_test_local ta_l2#P#pt2 1 -SHOW GLOBAL STATUS LIKE 'Spider_mon_table_cache_version%'; -Variable_name Value -Spider_mon_table_cache_version 1 -Spider_mon_table_cache_version_req 1 -INSERT INTO ta_l2 (a, b, c) VALUES -(6, 'e', '2011-05-05 20:04:05'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-01 10:21:39 -2 b 2000-01-01 00:00:00 -3 e 2007-06-04 20:03:11 -4 d 2003-11-30 05:01:03 -5 c 2001-12-31 23:59:59 -6 e 2011-05-05 20:04:05 - -recovery test -ALTER TABLE ta_l2 -PARTITION BY KEY(a) ( -PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', -PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001", lst "0 2"' - ); -SELECT db_name, table_name, link_id, link_status FROM mysql.spider_tables -ORDER BY db_name, table_name, link_id; -db_name table_name link_id link_status -auto_test_local ta_l2#P#pt1 0 1 -auto_test_local ta_l2#P#pt1 1 1 -auto_test_local ta_l2#P#pt2 0 1 -auto_test_local ta_l2#P#pt2 1 2 -SELECT spider_copy_tables('ta_l2#P#pt2', '0', '1'); -spider_copy_tables('ta_l2#P#pt2', '0', '1') -1 -ALTER TABLE ta_l2 -PARTITION BY KEY(a) ( -PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', -PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001", lst "0 1"' - ); -SELECT db_name, table_name, link_id, link_status FROM mysql.spider_tables -ORDER BY db_name, table_name, link_id; -db_name table_name link_id link_status -auto_test_local ta_l2#P#pt1 0 1 -auto_test_local ta_l2#P#pt1 1 1 -auto_test_local ta_l2#P#pt2 0 1 -auto_test_local ta_l2#P#pt2 1 1 -INSERT INTO ta_l2 (a, b, c) VALUES -(8, 'g', '2011-05-05 21:33:30'), -(9, 'h', '2011-05-05 22:32:10'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-01 10:21:39 -2 b 2000-01-01 00:00:00 -3 e 2007-06-04 20:03:11 -4 d 2003-11-30 05:01:03 -5 c 2001-12-31 23:59:59 -6 e 2011-05-05 20:04:05 -8 g 2011-05-05 21:33:30 -9 h 2011-05-05 22:32:10 -DROP TABLE ta_l2; - -create table with partition test -DROP TABLE IF EXISTS ta_l2; -CREATE TABLE ta_l2 ( -a INT, -b CHAR(1), -c DATETIME, -PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_HA_AS_P_2_1 -INSERT INTO ta_l2 (a, b, c) VALUES -(1, 'a', '2008-08-01 10:21:39'), -(2, 'b', '2000-01-01 00:00:00'), -(3, 'e', '2007-06-04 20:03:11'), -(4, 'd', '2003-11-30 05:01:03'), -(5, 'c', '2001-12-31 23:59:59'); - -select test -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-01 10:21:39 -2 b 2000-01-01 00:00:00 -3 e 2007-06-04 20:03:11 -4 d 2003-11-30 05:01:03 -5 c 2001-12-31 23:59:59 - -fail-over test -SHOW GLOBAL STATUS LIKE 'Spider_mon_table_cache_version%'; -Variable_name Value -Spider_mon_table_cache_version 1 -Spider_mon_table_cache_version_req 1 -INSERT INTO ta_l2 (a, b, c) VALUES -(6, 'e', '2011-05-05 20:04:05'); -ERROR HY000: Table 'SYSTEM.ta_r2' get a problem -SELECT db_name, table_name, link_id, link_status FROM mysql.spider_tables -ORDER BY db_name, table_name, link_id; -db_name table_name link_id link_status -auto_test_local ta_l2#P#pt1 0 1 -auto_test_local ta_l2#P#pt1 1 1 -auto_test_local ta_l2#P#pt2 0 3 -auto_test_local ta_l2#P#pt2 1 1 -SELECT db_name, table_name, link_id FROM mysql.spider_link_failed_log; -db_name table_name link_id -auto_test_local ta_l2#P#pt2 1 -auto_test_local ta_l2#P#pt2 0 -SHOW GLOBAL STATUS LIKE 'Spider_mon_table_cache_version%'; -Variable_name Value -Spider_mon_table_cache_version 1 -Spider_mon_table_cache_version_req 1 -INSERT INTO ta_l2 (a, b, c) VALUES -(6, 'e', '2011-05-05 20:04:05'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-01 10:21:39 -3 e 2007-06-04 20:03:11 -5 c 2001-12-31 23:59:59 -6 e 2011-05-05 20:04:05 - -recovery test -ALTER TABLE ta_l2 -PARTITION BY KEY(a) ( -PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', -PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001", lst "1 0"' - ); -SELECT db_name, table_name, link_id, link_status FROM mysql.spider_tables -ORDER BY db_name, table_name, link_id; -db_name table_name link_id link_status -auto_test_local ta_l2#P#pt1 0 1 -auto_test_local ta_l2#P#pt1 1 1 -auto_test_local ta_l2#P#pt2 0 1 -auto_test_local ta_l2#P#pt2 1 1 -INSERT INTO ta_l2 (a, b, c) VALUES -(8, 'g', '2011-05-05 21:33:30'), -(9, 'h', '2011-05-05 22:32:10'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-01 10:21:39 -3 e 2007-06-04 20:03:11 -5 c 2001-12-31 23:59:59 -8 g 2011-05-05 21:33:30 -9 h 2011-05-05 22:32:10 -DROP TABLE ta_l2; - -deinit -DROP DATABASE IF EXISTS auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -DROP DATABASE IF EXISTS auto_test_remote3; -DROP DATABASE IF EXISTS auto_test_local; -DROP DATABASE IF EXISTS auto_test_local; -DROP DATABASE IF EXISTS auto_test_local; -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -end of test diff --git a/storage/spider/mysql-test/spider/oracle/r/spider3_fixes.result b/storage/spider/mysql-test/spider/oracle/r/spider3_fixes.result deleted file mode 100644 index 418f8bb31a8..00000000000 --- a/storage/spider/mysql-test/spider/oracle/r/spider3_fixes.result +++ /dev/null @@ -1,194 +0,0 @@ -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 -for slave1_1 - -drop and create databases -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -CREATE DATABASE auto_test_remote; -USE auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -CREATE DATABASE auto_test_remote2; -USE auto_test_remote2; - -test select 1 -SELECT 1; -1 -1 - -3.1 -auto_increment -DROP TABLE IF EXISTS t1, t2; -CREATE TABLE t1 ( -id int(11) NOT NULL AUTO_INCREMENT, -PRIMARY KEY (id) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_INCREMENT1_1 -CREATE TABLE t2 ( -id int(11) NOT NULL AUTO_INCREMENT, -PRIMARY KEY (id) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_INCREMENT1_1 -MASTER_1_AUTO_INCREMENT_INCREMENT2 -MASTER_1_AUTO_INCREMENT_OFFSET2 -spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_1"\'; exception when others then null; end;', '', 'srv "s_2_1"') -1 -spider_direct_sql('CREATE SEQUENCE "seq_t1_1" START WITH 2 INCREMENT BY 4', '', 'srv "s_2_1"') -1 -spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_2"\'; exception when others then null; end;', '', 'srv "s_2_2"') -1 -spider_direct_sql('CREATE SEQUENCE "seq_t1_2" START WITH 3 INCREMENT BY 4', '', 'srv "s_2_2"') -1 -spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_1"\'; exception when others then null; end;', '', 'srv "s_2_1"') -1 -spider_direct_sql('CREATE SEQUENCE "seq_t1_1" START WITH 2 INCREMENT BY 4', '', 'srv "s_2_1"') -1 -spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_2"\'; exception when others then null; end;', '', 'srv "s_2_2"') -1 -spider_direct_sql('CREATE SEQUENCE "seq_t1_2" START WITH 3 INCREMENT BY 4', '', 'srv "s_2_2"') -1 -INSERT INTO t1 () VALUES (); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -777 -SELECT MAX(id) FROM t1; -MAX(id) -777 -INSERT INTO t2 () VALUES (); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -1554 -SELECT MAX(id) FROM t2; -MAX(id) -1554 -MASTER_1_AUTO_INCREMENT_OFFSET3 -INSERT INTO t1 (id) VALUES (null); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -1555 -SELECT MAX(id) FROM t1; -MAX(id) -1555 -MASTER_1_AUTO_INCREMENT_OFFSET4 -INSERT INTO t2 (id) VALUES (null); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -2331 -SELECT MAX(id) FROM t2; -MAX(id) -2331 -MASTER_1_AUTO_INCREMENT_OFFSET3 -INSERT INTO t1 () VALUES (),(),(),(); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -2332 -SELECT id FROM t1 ORDER BY id; -id -777 -1554 -1555 -2331 -2332 -3109 -3886 -4663 -MASTER_1_AUTO_INCREMENT_OFFSET4 -INSERT INTO t2 () VALUES (),(),(),(); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -5439 -SELECT id FROM t2 ORDER BY id; -id -777 -1554 -1555 -2331 -2332 -3109 -3886 -4663 -5439 -6216 -6993 -7770 -TRUNCATE TABLE t1; -TRUNCATE TABLE t2; -INSERT INTO t1 () VALUES (),(),(),(); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -777 -SELECT id FROM t1 ORDER BY id; -id -777 -1554 -2331 -3108 -INSERT INTO t2 () VALUES (),(),(),(); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -3885 -SELECT id FROM t2 ORDER BY id; -id -777 -1554 -2331 -3108 -3885 -4662 -5439 -6216 -SET INSERT_ID=5000; -MASTER_1_AUTO_INCREMENT_OFFSET3 -INSERT INTO t1 () VALUES (); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -5000 -SELECT MAX(id) FROM t1; -MAX(id) -6216 -MASTER_1_AUTO_INCREMENT_OFFSET4 -INSERT INTO t2 () VALUES (); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -6993 -SELECT MAX(id) FROM t2; -MAX(id) -6993 -INSERT INTO t1 (id) VALUES (10000); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -6993 -SELECT MAX(id) FROM t1; -MAX(id) -10000 -INSERT INTO t2 (id) VALUES (1000); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -6993 -SELECT MAX(id) FROM t2; -MAX(id) -10000 - -deinit -DROP DATABASE IF EXISTS auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -for slave1_1 -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -end of test diff --git a/storage/spider/mysql-test/spider/oracle/r/spider3_fixes_part.result b/storage/spider/mysql-test/spider/oracle/r/spider3_fixes_part.result deleted file mode 100644 index accb4607027..00000000000 --- a/storage/spider/mysql-test/spider/oracle/r/spider3_fixes_part.result +++ /dev/null @@ -1,192 +0,0 @@ -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 -for slave1_1 - -drop and create databases -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -CREATE DATABASE auto_test_remote; -USE auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -CREATE DATABASE auto_test_remote2; -USE auto_test_remote2; - -test select 1 -SELECT 1; -1 -1 -auto_increment with partition -DROP TABLE IF EXISTS t1, t2; -CREATE TABLE t1 ( -id int(11) NOT NULL AUTO_INCREMENT, -PRIMARY KEY (id) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_INCREMENT1_P_1 -CREATE TABLE t2 ( -id int(11) NOT NULL AUTO_INCREMENT, -PRIMARY KEY (id) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_INCREMENT1_P_1 -MASTER_1_AUTO_INCREMENT_INCREMENT2 -MASTER_1_AUTO_INCREMENT_OFFSET2 -spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_1"\'; exception when others then null; end;', '', 'srv "s_2_1"') -1 -spider_direct_sql('CREATE SEQUENCE "seq_t1_1" START WITH 2 INCREMENT BY 4', '', 'srv "s_2_1"') -1 -spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_2"\'; exception when others then null; end;', '', 'srv "s_2_2"') -1 -spider_direct_sql('CREATE SEQUENCE "seq_t1_2" START WITH 3 INCREMENT BY 4', '', 'srv "s_2_2"') -1 -spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_1"\'; exception when others then null; end;', '', 'srv "s_2_1"') -1 -spider_direct_sql('CREATE SEQUENCE "seq_t1_1" START WITH 2 INCREMENT BY 4', '', 'srv "s_2_1"') -1 -spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_2"\'; exception when others then null; end;', '', 'srv "s_2_2"') -1 -spider_direct_sql('CREATE SEQUENCE "seq_t1_2" START WITH 3 INCREMENT BY 4', '', 'srv "s_2_2"') -1 -INSERT INTO t1 () VALUES (); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -777 -SELECT MAX(id) FROM t1; -MAX(id) -777 -INSERT INTO t2 () VALUES (); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -1554 -SELECT MAX(id) FROM t2; -MAX(id) -1554 -MASTER_1_AUTO_INCREMENT_OFFSET3 -INSERT INTO t1 (id) VALUES (null); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -778 -SELECT MAX(id) FROM t1; -MAX(id) -1554 -MASTER_1_AUTO_INCREMENT_OFFSET4 -INSERT INTO t2 (id) VALUES (null); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -2331 -SELECT MAX(id) FROM t2; -MAX(id) -2331 -MASTER_1_AUTO_INCREMENT_OFFSET3 -INSERT INTO t1 () VALUES (),(),(),(); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -1555 -SELECT id FROM t1 ORDER BY id; -id -777 -778 -1554 -1555 -2331 -2332 -3109 -3886 -MASTER_1_AUTO_INCREMENT_OFFSET4 -INSERT INTO t2 () VALUES (),(),(),(); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -3108 -SELECT id FROM t2 ORDER BY id; -id -777 -778 -1554 -1555 -2331 -2332 -3108 -3109 -3885 -3886 -4662 -5439 -TRUNCATE TABLE t1; -TRUNCATE TABLE t2; -INSERT INTO t1 () VALUES (),(),(),(); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -777 -SELECT id FROM t1 ORDER BY id; -id -777 -1554 -2331 -3108 -INSERT INTO t2 () VALUES (),(),(),(); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -3885 -SELECT id FROM t2 ORDER BY id; -id -777 -1554 -2331 -3108 -3885 -4662 -5439 -6216 -SET INSERT_ID=5000; -MASTER_1_AUTO_INCREMENT_OFFSET3 -INSERT INTO t1 () VALUES (); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -5000 -SELECT MAX(id) FROM t1; -MAX(id) -6216 -MASTER_1_AUTO_INCREMENT_OFFSET4 -INSERT INTO t2 () VALUES (); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -6993 -SELECT MAX(id) FROM t2; -MAX(id) -6993 -INSERT INTO t1 (id) VALUES (10000); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -6993 -SELECT MAX(id) FROM t1; -MAX(id) -10000 -INSERT INTO t2 (id) VALUES (1000); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -6993 -SELECT MAX(id) FROM t2; -MAX(id) -10000 - -deinit -DROP DATABASE IF EXISTS auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -for slave1_1 -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -end of test diff --git a/storage/spider/mysql-test/spider/oracle/r/spider_fixes.result b/storage/spider/mysql-test/spider/oracle/r/spider_fixes.result deleted file mode 100644 index 85efde74061..00000000000 --- a/storage/spider/mysql-test/spider/oracle/r/spider_fixes.result +++ /dev/null @@ -1,552 +0,0 @@ -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 -for slave1_1 - -drop and create databases -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -CREATE DATABASE auto_test_remote; -USE auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -CREATE DATABASE auto_test_remote2; -USE auto_test_remote2; - -test select 1 -SELECT 1; -1 -1 - -create table and insert -DROP TABLE IF EXISTS tb_l; -CREATE TABLE tb_l ( -a INT, -b CHAR(1), -c DATETIME, -PRIMARY KEY(a) -) MASTER_1_ENGINE2 MASTER_1_CHARSET2 -INSERT INTO tb_l (a, b, c) VALUES -(1, 'a', '2008-08-01 10:21:39'), -(2, 'b', '2000-01-01 00:00:00'), -(3, 'e', '2007-06-04 20:03:11'), -(4, 'd', '2003-11-30 05:01:03'), -(5, 'c', '2001-12-31 23:59:59'); -DROP TABLE IF EXISTS ta_l; -CREATE TABLE ta_l ( -PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_2_1 -INSERT INTO ta_l SELECT a, b, c FROM tb_l; - -2.13 -select table with "order by desc" and "<" -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l -WHERE a < 5 ORDER BY a DESC LIMIT 3; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -4 d 2003-11-30 05:01:03 -3 e 2007-06-04 20:03:11 -2 b 2000-01-01 00:00:00 - -select table with "order by desc" and "<=" -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l -WHERE a <= 5 ORDER BY a DESC LIMIT 3; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -5 c 2001-12-31 23:59:59 -4 d 2003-11-30 05:01:03 -3 e 2007-06-04 20:03:11 - -2.14 -update table with range scan and split_read -UPDATE ta_l SET c = '2000-02-02 00:00:00' WHERE a > 1; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-01 10:21:39 -2 b 2000-02-02 00:00:00 -3 e 2000-02-02 00:00:00 -4 d 2000-02-02 00:00:00 -5 c 2000-02-02 00:00:00 - -2.15 -select table with range scan -TRUNCATE TABLE ta_l; -DROP TABLE IF EXISTS ta_l; -CREATE TABLE ta_l ( -a int(11) NOT NULL DEFAULT '0', -b char(1) DEFAULT NULL, -c datetime DEFAULT NULL, -PRIMARY KEY (a, b, c) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT5_2_1 -INSERT INTO ta_l SELECT a, b, c FROM tb_l; -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a = 4 AND b >= 'b' -AND c = '2003-11-30 05:01:03'; -a b c -4 d 2003-11-30 05:01:03 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a = 4 AND b > 'b' -AND c = '2003-11-30 05:01:03'; -a b c -4 d 2003-11-30 05:01:03 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a >= 4 AND b = 'd' -AND c = '2003-11-30 05:01:03'; -a b c -4 d 2003-11-30 05:01:03 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a > 4 AND b = 'c' -AND c = '2001-12-31 23:59:59'; -a b c -5 c 2001-12-31 23:59:59 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a = 4 AND b <= 'd' -AND c = '2003-11-30 05:01:03'; -a b c -4 d 2003-11-30 05:01:03 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a = 4 AND b < 'e' -AND c = '2003-11-30 05:01:03'; -a b c -4 d 2003-11-30 05:01:03 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a <= 4 AND b = 'b' -AND c = '2000-01-01 00:00:00'; -a b c -2 b 2000-01-01 00:00:00 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a < 4 AND b = 'b' -AND c = '2000-01-01 00:00:00'; -a b c -2 b 2000-01-01 00:00:00 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a = 4 AND b >= 'b' -AND b <= 'd' AND c = '2003-11-30 05:01:03'; -a b c -4 d 2003-11-30 05:01:03 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a = 4 AND b > 'b' -AND b < 'e' AND c = '2003-11-30 05:01:03'; -a b c -4 d 2003-11-30 05:01:03 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a <= 4 AND a >= 1 -AND b >= 'b' AND c = '2003-11-30 05:01:03'; -a b c -4 d 2003-11-30 05:01:03 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a < 4 AND a > 1 -AND b >= 'b' AND c = '2000-01-01 00:00:00'; -a b c -2 b 2000-01-01 00:00:00 - -2.16 -auto_increment insert with trigger -CREATE TABLE ta_l_auto_inc ( -a INT AUTO_INCREMENT, -b CHAR(1) DEFAULT 'c', -c DATETIME DEFAULT '1999-10-10 10:10:10', -PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT3_2_1 -CREATE TABLE tc_l ( -a INT, -b CHAR(1), -c DATETIME, -PRIMARY KEY(a) -) MASTER_1_ENGINE2 MASTER_1_CHARSET2 -CREATE TRIGGER ins_ta_l_auto_inc AFTER INSERT ON ta_l_auto_inc FOR EACH ROW BEGIN INSERT INTO tc_l (a, b, c) VALUES (NEW.a, NEW.b, NEW.c); END;; -INSERT INTO ta_l_auto_inc (a, b, c) VALUES -(NULL, 's', '2008-12-31 20:59:59'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM tc_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 s 2008-12-31 20:59:59 - -2.17 -engine-condition-pushdown with "or" and joining -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l WHERE a = 1 OR a IN (SELECT a FROM tb_l); -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-01 10:21:39 -2 b 2000-01-01 00:00:00 -3 e 2007-06-04 20:03:11 -4 d 2003-11-30 05:01:03 -5 c 2001-12-31 23:59:59 - -2.23 -index merge -CREATE TABLE ta_l_int ( -a INT AUTO_INCREMENT, -b INT DEFAULT 10, -c INT DEFAULT 11, -PRIMARY KEY(a), -KEY idx1(b), -KEY idx2(c) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT4_2_1 -INSERT INTO ta_l_int (a, b, c) VALUES (1, 2, 3); -INSERT INTO ta_l_int (a, b, c) SELECT a + 1, b + 1, c + 1 FROM ta_l_int; -INSERT INTO ta_l_int (a, b, c) SELECT a + 2, b + 2, c + 2 FROM ta_l_int; -INSERT INTO ta_l_int (a, b, c) SELECT a + 4, b + 4, c + 4 FROM ta_l_int; -INSERT INTO ta_l_int (a, b, c) SELECT a + 8, b + 8, c + 8 FROM ta_l_int; -SELECT a, b, c FROM ta_l_int force index(primary, idx1, idx2) -WHERE a = 5 OR b = 5 OR c = 5 ORDER BY a; -a b c -3 4 5 -4 5 6 -5 6 7 - -2.24 -index scan update without PK -DROP TABLE IF EXISTS ta_l_int; -CREATE TABLE ta_l_int ( -a INT NOT NULL, -b INT DEFAULT 10, -c INT DEFAULT 11, -KEY idx1(b), -KEY idx2(c) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT4_2_1 -SELECT a, b, c FROM ta_l_int ORDER BY a; -a b c -1 2 3 -2 3 4 -3 4 5 -4 5 6 -5 6 7 -6 7 8 -7 8 9 -8 9 10 -9 10 11 -10 11 12 -11 12 13 -12 13 14 -13 14 15 -14 15 16 -15 16 17 -16 17 18 -INSERT INTO ta_l_int (a, b, c) VALUES (0, 2, 3); -INSERT INTO ta_l_int (a, b, c) VALUES (18, 2, 3); -UPDATE ta_l_int SET c = 4 WHERE b = 2; -SELECT a, b, c FROM ta_l_int ORDER BY a; -a b c -0 2 4 -1 2 4 -2 3 4 -3 4 5 -4 5 6 -5 6 7 -6 7 8 -7 8 9 -8 9 10 -9 10 11 -10 11 12 -11 12 13 -12 13 14 -13 14 15 -14 15 16 -15 16 17 -16 17 18 -18 2 4 - -2.25 -direct order limit -SHOW GLOBAL STATUS LIKE 'Spider_direct_order_limit%'; -Variable_name Value -Spider_direct_order_limit 0 -SELECT a, b, c FROM ta_l_int ORDER BY a LIMIT 3; -a b c -1 2 4 -2 3 4 -3 4 5 -SHOW GLOBAL STATUS LIKE 'Spider_direct_order_limit%'; -Variable_name Value -Spider_direct_order_limit 0 - -2.26 -lock tables -DROP TABLE IF EXISTS t1; -DROP TABLE IF EXISTS t2; -CREATE TABLE t1 ( -id int(11) NOT NULL, -PRIMARY KEY (id) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_LOCK1 -CREATE TABLE t2 ( -id int(11) NOT NULL, -PRIMARY KEY (id) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_LOCK2 -LOCK TABLES t1 READ, t2 READ; -UNLOCK TABLES; - -auto_increment -DROP TABLE IF EXISTS t1; -CREATE TABLE t1 ( -id int(11) NOT NULL AUTO_INCREMENT, -PRIMARY KEY (id) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_INCREMENT1_1 -MASTER_1_AUTO_INCREMENT_INCREMENT2 -MASTER_1_AUTO_INCREMENT_OFFSET2 -spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_1"\'; exception when others then null; end;', '', 'srv "s_2_1"') -1 -spider_direct_sql('CREATE SEQUENCE "seq_t1_1" START WITH 2 INCREMENT BY 4', '', 'srv "s_2_1"') -1 -spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_2"\'; exception when others then null; end;', '', 'srv "s_2_2"') -1 -spider_direct_sql('CREATE SEQUENCE "seq_t1_2" START WITH 3 INCREMENT BY 4', '', 'srv "s_2_2"') -1 -spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_1"\'; exception when others then null; end;', '', 'srv "s_2_1"') -1 -spider_direct_sql('CREATE SEQUENCE "seq_t1_1" START WITH 2 INCREMENT BY 4', '', 'srv "s_2_1"') -1 -spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_2"\'; exception when others then null; end;', '', 'srv "s_2_2"') -1 -spider_direct_sql('CREATE SEQUENCE "seq_t1_2" START WITH 3 INCREMENT BY 4', '', 'srv "s_2_2"') -1 -INSERT INTO t1 () VALUES (); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -777 -SELECT MAX(id) FROM t1; -MAX(id) -777 -INSERT INTO t1 () VALUES (); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -1554 -SELECT MAX(id) FROM t1; -MAX(id) -1554 -INSERT INTO t1 (id) VALUES (null); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -2331 -SELECT MAX(id) FROM t1; -MAX(id) -2331 -INSERT INTO t1 (id) VALUES (null); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -3108 -SELECT MAX(id) FROM t1; -MAX(id) -3108 -INSERT INTO t1 () VALUES (),(),(),(); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -3885 -SELECT id FROM t1 ORDER BY id; -id -777 -1554 -2331 -3108 -3885 -4662 -5439 -6216 -SET INSERT_ID=5000; -INSERT INTO t1 () VALUES (); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -5000 -SELECT MAX(id) FROM t1; -MAX(id) -6216 -INSERT INTO t1 (id) VALUES (10000); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -5000 -SELECT MAX(id) FROM t1; -MAX(id) -10000 -INSERT INTO t1 (id) VALUES (1000); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -5000 -SELECT MAX(id) FROM t1; -MAX(id) -10000 - -read only -DROP TABLE IF EXISTS t1; -CREATE TABLE t1 ( -id int(11) NOT NULL, -PRIMARY KEY (id) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_READONLY1_1 -SELECT id FROM t1 ORDER BY id; -id -777 -1000 -1554 -2331 -3108 -3885 -4662 -5000 -5439 -6216 -10000 -INSERT INTO t1 (id) VALUES (1); -ERROR HY000: Table 'auto_test_local.t1' is read only -UPDATE t1 SET id = 4 WHERE id = 777; -ERROR HY000: Table 'auto_test_local.t1' is read only -DELETE FROM t1 WHERE id = 777; -ERROR HY000: Table 'auto_test_local.t1' is read only -DELETE FROM t1; -ERROR HY000: Table 'auto_test_local.t1' is read only -TRUNCATE t1; -ERROR HY000: Table 'auto_test_local.t1' is read only - -2.27 -error mode -DROP TABLE IF EXISTS t1; -CREATE TABLE t1 ( -id int(11) NOT NULL, -PRIMARY KEY (id) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_ERROR_MODE1_1 -SELECT id FROM t1 ORDER BY id; -id -Warnings: -Error 12712 Error from Oracle -1 942 ORA-00942: ??????????????? - -Error 12712 Oracle error -Error 12712 Error from Oracle -1 942 ORA-00942: ??????????????? - -Error 12712 Oracle error -INSERT INTO t1 (id) VALUES (1); -Warnings: -Error 12712 Error from Oracle -1 942 ORA-00942: ??????????????? - -Error 12712 Oracle error -DELETE FROM t1; -Warnings: -Error 12712 Error from Oracle -1 942 ORA-00942: ??????????????? - -Error 12712 Oracle error -TRUNCATE t1; -Warnings: -Error 12712 Error from Oracle -1 942 ORA-00942: ??????????????? - -Error 12712 Oracle error - -3.0 -is null -DROP TABLE IF EXISTS t1; -CREATE TABLE t1 ( -a VARCHAR(255), -b VARCHAR(255), -c VARCHAR(255), -KEY idx1(a,b), -KEY idx2(b), -PRIMARY KEY(c) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_TEXT_KEY1_1 -insert into t1 values (null, null, '2048'); -insert into t1 values ('1', '1', '1'); -insert into t1 select a + 1, b + 1, c + 1 from t1; -insert into t1 select a + 2, b + 2, c + 2 from t1; -insert into t1 select a + 4, b + 4, c + 4 from t1; -insert into t1 select a + 8, b + 8, c + 8 from t1; -insert into t1 select a + 16, b + 16, c + 16 from t1; -insert into t1 select a + 32, b + 32, c + 32 from t1; -insert into t1 select a + 64, b + 64, c + 64 from t1; -insert into t1 select a + 128, b + 128, c + 128 from t1; -insert into t1 select a + 256, b + 256, c + 256 from t1; -insert into t1 select a + 512, b + 512, c + 512 from t1; -flush tables; -select a from t1 where a is null order by a limit 30; -a -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -select b from t1 where b is null order by b limit 30; -b -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL - -direct_order_limit -TRUNCATE TABLE t1; -insert into t1 values ('1', '1', '1'); -insert into t1 select a + 1, b + 1, c + 1 from t1; -insert into t1 select a + 2, b + 2, c + 2 from t1; -insert into t1 select a + 4, b + 4, c + 4 from t1; -insert into t1 select a + 8, b + 8, c + 8 from t1; -insert into t1 select a + 16, b + 16, c + 16 from t1; -insert into t1 select a, b + 32, c + 32 from t1; -insert into t1 select a, b + 64, c + 64 from t1; -insert into t1 select a, b + 128, c + 128 from t1; -flush tables; -select a, b, c from t1 where a = '10' and b <> '100' order by c desc limit 5; -a b c -10 74 74 -10 42 42 -10 234 234 -10 202 202 -10 170 170 -select a, c from t1 where a = '10' order by b desc limit 5; -a c -10 74 -10 42 -10 234 -10 202 -10 170 - -deinit -DROP DATABASE IF EXISTS auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -for slave1_1 -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -end of test diff --git a/storage/spider/mysql-test/spider/oracle/r/spider_fixes_part.result b/storage/spider/mysql-test/spider/oracle/r/spider_fixes_part.result deleted file mode 100644 index 9abe8558416..00000000000 --- a/storage/spider/mysql-test/spider/oracle/r/spider_fixes_part.result +++ /dev/null @@ -1,199 +0,0 @@ -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 -for slave1_1 - -drop and create databases -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -CREATE DATABASE auto_test_remote; -USE auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -CREATE DATABASE auto_test_remote2; -USE auto_test_remote2; - -test select 1 -SELECT 1; -1 -1 -DROP TABLE IF EXISTS tb_l; -CREATE TABLE tb_l ( -a INT, -b CHAR(1), -c DATETIME, -PRIMARY KEY(a) -) MASTER_1_ENGINE2 MASTER_1_CHARSET2 -INSERT INTO tb_l (a, b, c) VALUES -(1, 'a', '2008-08-01 10:21:39'), -(2, 'b', '2000-01-01 00:00:00'), -(3, 'e', '2007-06-04 20:03:11'), -(4, 'd', '2003-11-30 05:01:03'), -(5, 'c', '2001-12-31 23:59:59'); - -2.17 -partition with sort -CREATE TABLE ta_l2 ( -a INT, -b CHAR(1), -c DATETIME, -PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_COMMENT2_P_2_1 -INSERT INTO ta_l2 SELECT a, b, c FROM tb_l; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 WHERE a > 1 -ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -2 b 2000-01-01 00:00:00 -3 e 2007-06-04 20:03:11 -4 d 2003-11-30 05:01:03 -5 c 2001-12-31 23:59:59 - -2.23 -partition update with moving partition -DROP TABLE IF EXISTS ta_l2; -CREATE TABLE ta_l2 ( -a INT, -b CHAR(1), -c DATETIME, -PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_COMMENT2_P_2_1 -INSERT INTO ta_l2 (a, b, c) VALUES (3, 'B', '2010-09-26 00:00:00'); -UPDATE ta_l2 SET a = 4 WHERE a = 3; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -4 B 2010-09-26 00:00:00 -index merge with partition -DROP TABLE IF EXISTS ta_l_int; -CREATE TABLE ta_l_int ( -a INT AUTO_INCREMENT, -b INT DEFAULT 10, -c INT DEFAULT 11, -PRIMARY KEY(a), -KEY idx1(b), -KEY idx2(c) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT3_P_2_1 -INSERT INTO ta_l_int (a, b, c) VALUES (1, 2, 3); -INSERT INTO ta_l_int (a, b, c) SELECT a + 1, b + 1, c + 1 FROM ta_l_int; -INSERT INTO ta_l_int (a, b, c) SELECT a + 2, b + 2, c + 2 FROM ta_l_int; -INSERT INTO ta_l_int (a, b, c) SELECT a + 4, b + 4, c + 4 FROM ta_l_int; -INSERT INTO ta_l_int (a, b, c) SELECT a + 8, b + 8, c + 8 FROM ta_l_int; -SELECT a, b, c FROM ta_l_int force index(primary, idx1, idx2) -WHERE a = 5 OR b = 5 OR c = 5 ORDER BY a; -a b c -3 4 5 -4 5 6 -5 6 7 - -2.26 -auto_increment with partition -DROP TABLE IF EXISTS t1; -CREATE TABLE t1 ( -id int(11) NOT NULL AUTO_INCREMENT, -PRIMARY KEY (id) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_INCREMENT1_P_1 -MASTER_1_AUTO_INCREMENT_INCREMENT2 -MASTER_1_AUTO_INCREMENT_OFFSET2 -spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_1"\'; exception when others then null; end;', '', 'srv "s_2_1"') -1 -spider_direct_sql('CREATE SEQUENCE "seq_t1_1" START WITH 2 INCREMENT BY 4', '', 'srv "s_2_1"') -1 -spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_2"\'; exception when others then null; end;', '', 'srv "s_2_2"') -1 -spider_direct_sql('CREATE SEQUENCE "seq_t1_2" START WITH 3 INCREMENT BY 4', '', 'srv "s_2_2"') -1 -spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_1"\'; exception when others then null; end;', '', 'srv "s_2_1"') -1 -spider_direct_sql('CREATE SEQUENCE "seq_t1_1" START WITH 2 INCREMENT BY 4', '', 'srv "s_2_1"') -1 -spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_2"\'; exception when others then null; end;', '', 'srv "s_2_2"') -1 -spider_direct_sql('CREATE SEQUENCE "seq_t1_2" START WITH 3 INCREMENT BY 4', '', 'srv "s_2_2"') -1 -INSERT INTO t1 () VALUES (); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -777 -SELECT MAX(id) FROM t1; -MAX(id) -777 -INSERT INTO t1 () VALUES (); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -1554 -SELECT MAX(id) FROM t1; -MAX(id) -1554 -INSERT INTO t1 (id) VALUES (null); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -2331 -SELECT MAX(id) FROM t1; -MAX(id) -2331 -INSERT INTO t1 (id) VALUES (null); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -3108 -SELECT MAX(id) FROM t1; -MAX(id) -3108 -INSERT INTO t1 () VALUES (),(),(),(); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -3885 -SELECT id FROM t1 ORDER BY id; -id -777 -1554 -2331 -3108 -3885 -4662 -5439 -6216 -SET INSERT_ID=5000; -INSERT INTO t1 () VALUES (); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -5000 -SELECT MAX(id) FROM t1; -MAX(id) -6216 -INSERT INTO t1 (id) VALUES (10000); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -5000 -SELECT MAX(id) FROM t1; -MAX(id) -10000 -INSERT INTO t1 (id) VALUES (1000); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -5000 -SELECT MAX(id) FROM t1; -MAX(id) -10000 - -deinit -DROP DATABASE IF EXISTS auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -for slave1_1 -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -end of test diff --git a/storage/spider/mysql-test/spider/oracle/r/vp_fixes.result b/storage/spider/mysql-test/spider/oracle/r/vp_fixes.result deleted file mode 100644 index 15dd29aa4d3..00000000000 --- a/storage/spider/mysql-test/spider/oracle/r/vp_fixes.result +++ /dev/null @@ -1,80 +0,0 @@ -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -drop and create databases -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -CREATE DATABASE auto_test_remote; -USE auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -CREATE DATABASE auto_test_remote2; -USE auto_test_remote2; - -test select 1 -SELECT 1; -1 -1 - -create table and insert -DROP TABLE IF EXISTS tb_l; -CREATE TABLE tb_l ( -a INT, -b CHAR(1), -c DATETIME, -PRIMARY KEY(a) -) MASTER_1_ENGINE2 MASTER_1_CHARSET2 -INSERT INTO tb_l (a, b, c) VALUES -(1, 'a', '2008-08-01 10:21:39'), -(2, 'b', '2000-01-01 00:00:00'), -(3, 'e', '2007-06-04 20:03:11'), -(4, 'd', '2003-11-30 05:01:03'), -(5, 'c', '2001-12-31 23:59:59'); -DROP TABLE IF EXISTS ta_l; -CREATE TABLE ta_l ( -PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_2_1 -INSERT INTO ta_l SELECT a, b, c FROM tb_l; - -0.9 -create different primary key table -CREATE TABLE ta_l_int ( -a INT DEFAULT 10, -b INT AUTO_INCREMENT, -c INT DEFAULT 11, -PRIMARY KEY(b) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT4_2_1 -INSERT INTO ta_l_int (a, b, c) VALUES (2, NULL, 3); -create un-correspond primary key table -DROP TABLE IF EXISTS ta_l_int; -CREATE TABLE ta_l_int ( -a INT DEFAULT 10, -b INT DEFAULT 12, -c INT DEFAULT 11, -PRIMARY KEY(c) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT4_2_1 -INSERT INTO ta_l_int (a, b, c) VALUES (2, NULL, 3); - -deinit -DROP DATABASE IF EXISTS auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -end of test diff --git a/storage/spider/mysql-test/spider/oracle/t/basic_sql.test b/storage/spider/mysql-test/spider/oracle/t/basic_sql.test deleted file mode 100644 index 9cf4ce99dc3..00000000000 --- a/storage/spider/mysql-test/spider/oracle/t/basic_sql.test +++ /dev/null @@ -1,2699 +0,0 @@ -# This test tests by executing basic SQL ---disable_warnings ---disable_query_log ---disable_result_log ---source test_init.inc ---enable_result_log ---enable_query_log - ---echo ---echo drop and create databases ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - CREATE DATABASE auto_test_remote; - USE auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; - CREATE DATABASE auto_test_remote2; - USE auto_test_remote2; -} ---enable_warnings - ---echo ---echo test select 1 ---connection master_1 -SELECT 1; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - SELECT 1; - --connection child2_2 - SELECT 1; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo create table select test -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_TABLES; - echo CHILD2_1_CREATE_TABLES; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 ---disable_warnings -DROP TABLE IF EXISTS tb_l; ---enable_warnings ---disable_query_log -echo CREATE TABLE tb_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) MASTER_1_ENGINE2 MASTER_1_CHARSET2; -eval CREATE TABLE tb_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) $MASTER_1_ENGINE2 $MASTER_1_CHARSET2; ---enable_query_log -INSERT INTO tb_l (a, b, c) VALUES - (1, 'a', '2008-08-01 10:21:39'), - (2, 'b', '2000-01-01 00:00:00'), - (3, 'e', '2007-06-04 20:03:11'), - (4, 'd', '2003-11-30 05:01:03'), - (5, 'c', '2001-12-31 23:59:59'); ---disable_warnings -DROP TABLE IF EXISTS ta_l; ---enable_warnings ---disable_query_log -echo CREATE TABLE ta_l ( - PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_2_1 -SELECT a, b, c FROM tb_l; -if ($MASTER_1_MERGE) -{ - --error ER_WRONG_OBJECT - eval CREATE TABLE ta_l ( - PRIMARY KEY(a) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_2_1 - SELECT a, b, c FROM tb_l; - eval CREATE TABLE ta_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_2_1; - INSERT INTO ta_l SELECT a, b, c FROM tb_l; -} -if (!$MASTER_1_MERGE) -{ - eval CREATE TABLE ta_l ( - PRIMARY KEY(a) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_2_1 - SELECT a, b, c FROM tb_l; -} ---enable_query_log -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%insert %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo create table ignore select test -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 ---disable_warnings -DROP TABLE IF EXISTS ta_l; -DROP TABLE IF EXISTS tb_l; ---enable_warnings ---disable_query_log -echo CREATE TABLE tb_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) MASTER_1_ENGINE2 MASTER_1_CHARSET2; -eval CREATE TABLE tb_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) $MASTER_1_ENGINE2 $MASTER_1_CHARSET2; ---enable_query_log -INSERT INTO tb_l (a, b, c) VALUES - (1, 'f', '2008-07-01 10:21:39'), - (2, 'g', '2000-02-01 00:00:00'), - (3, 'j', '2007-05-04 20:03:11'), - (4, 'i', '2003-10-30 05:01:03'), - (5, 'h', '2001-10-31 23:59:59'); ---disable_query_log -echo CREATE TABLE ta_l ( - PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_2_1 -IGNORE SELECT a, b, c FROM tb_l; -if ($MASTER_1_MERGE) -{ - --error ER_WRONG_OBJECT - eval CREATE TABLE ta_l ( - PRIMARY KEY(a) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_2_1 - IGNORE SELECT a, b, c FROM tb_l; - eval CREATE TABLE ta_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_2_1; - INSERT IGNORE INTO ta_l SELECT a, b, c FROM tb_l; -} -if (!$MASTER_1_MERGE) -{ - eval CREATE TABLE ta_l ( - PRIMARY KEY(a) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_2_1 - IGNORE SELECT a, b, c FROM tb_l; -} ---enable_query_log -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%insert %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo create table ignore select test -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 ---disable_warnings -DROP TABLE IF EXISTS ta_l; ---enable_warnings ---disable_query_log -echo CREATE TABLE ta_l ( - PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_2_1 -REPLACE SELECT a, b, c FROM tb_l; -if ($MASTER_1_MERGE) -{ - --error ER_WRONG_OBJECT - eval CREATE TABLE ta_l ( - PRIMARY KEY(a) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_2_1 - REPLACE SELECT a, b, c FROM tb_l; - eval CREATE TABLE ta_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_2_1; - REPLACE INTO ta_l SELECT a, b, c FROM tb_l; -} -if (!$MASTER_1_MERGE) -{ - eval CREATE TABLE ta_l ( - PRIMARY KEY(a) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_2_1 - REPLACE SELECT a, b, c FROM tb_l; -} ---enable_query_log -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%replace %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo create no index table -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_TABLES3; - echo CHILD2_1_CREATE_TABLES3; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES3; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES3; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 ---disable_warnings -DROP TABLE IF EXISTS ta_l_no_idx; ---enable_warnings ---disable_query_log -echo CREATE TABLE ta_l_no_idx -MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT2_2_1 -SELECT a, b, c FROM tb_l; -if ($MASTER_1_NEEDPK) -{ - --error ER_REQUIRES_PRIMARY_KEY - eval CREATE TABLE ta_l_no_idx - $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT2_2_1 - SELECT a, b, c FROM tb_l; - eval CREATE TABLE ta_l_no_idx ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT2_2_1; - INSERT INTO ta_l_no_idx SELECT a, b, c FROM tb_l; -} -if (!$MASTER_1_NEEDPK) -{ - if ($MASTER_1_MERGE) - { - --error ER_WRONG_OBJECT - eval CREATE TABLE ta_l_no_idx - $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT2_2_1 - SELECT a, b, c FROM tb_l; - eval CREATE TABLE ta_l_no_idx ( - a INT, - b CHAR(1), - c DATETIME - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT2_2_1; - INSERT INTO ta_l_no_idx SELECT a, b, c FROM tb_l; - } - if (!$MASTER_1_MERGE) - { - eval CREATE TABLE ta_l_no_idx - $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT2_2_1 - SELECT a, b, c FROM tb_l; - } -} ---enable_query_log -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%insert %'; - } - eval $CHILD2_1_SELECT_TABLES3; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l_no_idx ORDER BY a; - ---echo ---echo select table -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo select table shared mode -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a -LOCK IN SHARE MODE; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo select table for update -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a -FOR UPDATE; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo select table join -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a.a, a.b, date_format(b.c, '%Y-%m-%d %H:%i:%s') FROM ta_l a, tb_l b -WHERE a.a = b.a ORDER BY a.a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo select table straight_join -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT STRAIGHT_JOIN a.a, a.b, date_format(b.c, '%Y-%m-%d %H:%i:%s') -FROM ta_l a, tb_l b WHERE a.a = b.a ORDER BY a.a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo select sql_small_result -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT SQL_SMALL_RESULT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l -ORDER BY a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo select sql_big_result -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT SQL_BIG_RESULT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l -ORDER BY a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo select sql_buffer_result -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT SQL_BUFFER_RESULT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l -ORDER BY a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo select sql_cache -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT SQL_CACHE a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l -ORDER BY a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo select sql_no_cache -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT SQL_NO_CACHE a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l -ORDER BY a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo select sql_calc_found_rows -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT SQL_CALC_FOUND_ROWS a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l -ORDER BY a LIMIT 4; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT found_rows(); - ---echo ---echo select high_priority -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT HIGH_PRIORITY a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l -ORDER BY a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo select distinct -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT DISTINCT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l -ORDER BY a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo select count -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT count(*) FROM ta_l ORDER BY a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo select table join not use index -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a.a, a.b, date_format(a.c, '%Y-%m-%d %H:%i:%s') FROM tb_l a WHERE -EXISTS (SELECT * FROM ta_l b WHERE b.b = a.b) ORDER BY a.a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo select using pushdown -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a.a, a.b, date_format(a.c, '%Y-%m-%d %H:%i:%s') FROM ta_l a WHERE -a.b = 'g' ORDER BY a.a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo select using index and pushdown -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a.a, a.b, date_format(a.c, '%Y-%m-%d %H:%i:%s') FROM ta_l a WHERE -a.a > 0 AND a.b = 'g' ORDER BY a.a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo insert ---connection master_1 -TRUNCATE TABLE ta_l; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -INSERT INTO ta_l (a, b, c) VALUES (2, 'e', '2008-01-01 23:59:59'); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'insert %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo insert select ---connection master_1 -TRUNCATE TABLE ta_l; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -INSERT INTO ta_l (a, b, c) SELECT a, b, c FROM tb_l; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'insert %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo insert select a ---connection master_1 -TRUNCATE TABLE ta_l; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -INSERT INTO ta_l (a, b, c) VALUES ((SELECT a FROM tb_l ORDER BY a LIMIT 1), -'e', '2008-01-01 23:59:59'); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'insert %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo insert low_priority ---connection master_1 -TRUNCATE TABLE ta_l; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -INSERT LOW_PRIORITY INTO ta_l (a, b, c) values (2, 'e', '2008-01-01 23:59:59'); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'insert %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo insert high_priority ---connection master_1 -TRUNCATE TABLE ta_l; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -INSERT HIGH_PRIORITY INTO ta_l (a, b, c) VALUES (2, 'e', -'2008-01-01 23:59:59'); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'insert %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo insert ignore -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -INSERT IGNORE INTO ta_l (a, b, c) VALUES (2, 'd', '2009-02-02 01:01:01'); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'insert %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo insert update (insert) ---connection master_1 -TRUNCATE TABLE ta_l; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -INSERT INTO ta_l (a, b, c) VALUES (2, 'e', '2008-01-01 23:59:59') ON DUPLICATE -KEY UPDATE b = 'f', c = '2005-08-08 11:11:11'; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'insert %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%update %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%delete %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo insert update (update) -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -INSERT INTO ta_l (a, b, c) VALUES (2, 'e', '2008-01-01 23:59:59') ON DUPLICATE -KEY UPDATE b = 'f', c = '2005-08-08 11:11:11'; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'insert %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%update %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%delete %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo replace ---connection master_1 -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (2, 'e', '2008-01-01 23:59:59'); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -REPLACE INTO ta_l (a, b, c) VALUES (2, 'f', '2008-02-02 02:02:02'); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'replace %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'insert %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'update %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo replace select -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -REPLACE INTO ta_l (a, b, c) SELECT a, b, c FROM tb_l; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'replace %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'insert %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'update %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo replace select a -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -REPLACE INTO ta_l (a, b, c) VALUES ((SELECT a FROM tb_l ORDER BY a LIMIT 1), -'e', '2008-01-01 23:59:59'); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'replace %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'insert %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'update %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo replace low_priority -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -REPLACE LOW_PRIORITY INTO ta_l (a, b, c) VALUES (3, 'g', -'2009-03-03 03:03:03'); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'replace %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'insert %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'update %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo update -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (1, 'e', '2008-01-01 23:59:59'), -(2, 'e', '2008-01-01 23:59:59'); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -UPDATE ta_l SET b = 'f', c = '2008-02-02 02:02:02' WHERE a = 2; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'update %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo update select -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -UPDATE ta_l SET b = 'g', c = '2009-03-03 03:03:03' WHERE a IN (SELECT a FROM -tb_l); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'update %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo update select a -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -UPDATE ta_l SET b = 'h', c = '2010-04-04 04:04:04' WHERE a = (SELECT a FROM -tb_l ORDER BY a LIMIT 1); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'update %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo update join -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -UPDATE ta_l a, tb_l b SET a.b = b.b, a.c = b.c WHERE a.a = b.a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'update %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo update join a -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -UPDATE ta_l a, tb_l b SET a.b = 'g', a.c = '2009-03-03 03:03:03' WHERE -a.a = b.a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'update %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo update low_priority -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -UPDATE LOW_PRIORITY ta_l SET b = 'f', c = '2008-02-02 02:02:02' WHERE a = 2; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'update %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo update ignore -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -UPDATE IGNORE ta_l SET a = 1, b = 'g', c = '2009-03-03 03:03:03' WHERE a = 2; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'update %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo update pushdown -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -update ta_l set b = 'j', c = '2009-03-03 03:03:03' where b = 'f'; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'update %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo update index pushdown -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -UPDATE ta_l SET b = 'g', c = '2009-03-03 03:03:03' WHERE a > 0 AND b = 'j'; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'update %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo delete -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (1, 'e', '2008-01-01 23:59:59'), -(2, 'e', '2008-01-01 23:59:59'), (3, 'e', '2008-01-01 23:59:59'), -(4, 'e', '2008-01-01 23:59:59'), (5, 'e', '2008-01-01 23:59:59'), -(6, 'e', '2008-01-01 23:59:59'), (7, 'e', '2008-01-01 23:59:59'), -(8, 'e', '2008-01-01 23:59:59'), (9, 'e', '2008-01-01 23:59:59'), -(10, 'j', '2008-01-01 23:59:59'); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -DELETE FROM ta_l WHERE a = 2; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'delete %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo delete all -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -DELETE FROM ta_l; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'delete %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo delete select -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (1, 'e', '2008-01-01 23:59:59'), -(2, 'e', '2008-01-01 23:59:59'), (3, 'e', '2008-01-01 23:59:59'), -(4, 'e', '2008-01-01 23:59:59'), (5, 'e', '2008-01-01 23:59:59'), -(6, 'e', '2008-01-01 23:59:59'), (7, 'e', '2008-01-01 23:59:59'), -(8, 'e', '2008-01-01 23:59:59'), (9, 'e', '2008-01-01 23:59:59'), -(10, 'j', '2008-01-01 23:59:59'); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -DELETE FROM ta_l WHERE a IN (SELECT a FROM tb_l); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'delete %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo delete select a -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (1, 'e', '2008-01-01 23:59:59'), -(2, 'e', '2008-01-01 23:59:59'), (3, 'e', '2008-01-01 23:59:59'), -(4, 'e', '2008-01-01 23:59:59'), (5, 'e', '2008-01-01 23:59:59'), -(6, 'e', '2008-01-01 23:59:59'), (7, 'e', '2008-01-01 23:59:59'), -(8, 'e', '2008-01-01 23:59:59'), (9, 'e', '2008-01-01 23:59:59'), -(10, 'j', '2008-01-01 23:59:59'); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -DELETE FROM ta_l WHERE a = (SELECT a FROM tb_l ORDER BY a LIMIT 1); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'delete %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo delete join -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (1, 'e', '2008-01-01 23:59:59'), -(2, 'e', '2008-01-01 23:59:59'), (3, 'e', '2008-01-01 23:59:59'), -(4, 'e', '2008-01-01 23:59:59'), (5, 'e', '2008-01-01 23:59:59'), -(6, 'e', '2008-01-01 23:59:59'), (7, 'e', '2008-01-01 23:59:59'), -(8, 'e', '2008-01-01 23:59:59'), (9, 'e', '2008-01-01 23:59:59'), -(10, 'j', '2008-01-01 23:59:59'); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -DELETE a FROM ta_l a, (SELECT a FROM tb_l ORDER BY a) b WHERE a.a = b.a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'delete %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo delete low_priority -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (1, 'e', '2008-01-01 23:59:59'), -(2, 'e', '2008-01-01 23:59:59'), (3, 'e', '2008-01-01 23:59:59'), -(4, 'e', '2008-01-01 23:59:59'), (5, 'e', '2008-01-01 23:59:59'), -(6, 'e', '2008-01-01 23:59:59'), (7, 'e', '2008-01-01 23:59:59'), -(8, 'e', '2008-01-01 23:59:59'), (9, 'e', '2008-01-01 23:59:59'), -(10, 'j', '2008-01-01 23:59:59'); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -DELETE LOW_PRIORITY FROM ta_l WHERE a = 2; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'delete %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo delete ignore -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (1, 'e', '2008-01-01 23:59:59'), -(2, 'e', '2008-01-01 23:59:59'), (3, 'e', '2008-01-01 23:59:59'), -(4, 'e', '2008-01-01 23:59:59'), (5, 'e', '2008-01-01 23:59:59'), -(6, 'e', '2008-01-01 23:59:59'), (7, 'e', '2008-01-01 23:59:59'), -(8, 'e', '2008-01-01 23:59:59'), (9, 'e', '2008-01-01 23:59:59'), -(10, 'j', '2008-01-01 23:59:59'); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -DELETE IGNORE FROM ta_l WHERE a = 2; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'delete %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo delete quick -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (1, 'e', '2008-01-01 23:59:59'), -(2, 'e', '2008-01-01 23:59:59'), (3, 'e', '2008-01-01 23:59:59'), -(4, 'e', '2008-01-01 23:59:59'), (5, 'e', '2008-01-01 23:59:59'), -(6, 'e', '2008-01-01 23:59:59'), (7, 'e', '2008-01-01 23:59:59'), -(8, 'e', '2008-01-01 23:59:59'), (9, 'e', '2008-01-01 23:59:59'), -(10, 'j', '2008-01-01 23:59:59'); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -DELETE QUICK FROM ta_l WHERE a = 2; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'delete %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo delete pushdown -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (1, 'e', '2008-01-01 23:59:59'), -(2, 'e', '2008-01-01 23:59:59'), (3, 'e', '2008-01-01 23:59:59'), -(4, 'e', '2008-01-01 23:59:59'), (5, 'e', '2008-01-01 23:59:59'), -(6, 'e', '2008-01-01 23:59:59'), (7, 'e', '2008-01-01 23:59:59'), -(8, 'e', '2008-01-01 23:59:59'), (9, 'e', '2008-01-01 23:59:59'), -(10, 'j', '2008-01-01 23:59:59'); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -DELETE FROM ta_l WHERE b = 'e'; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'delete %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo delete index pushdown -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (1, 'e', '2008-01-01 23:59:59'), -(2, 'e', '2008-01-01 23:59:59'), (3, 'e', '2008-01-01 23:59:59'), -(4, 'e', '2008-01-01 23:59:59'), (5, 'e', '2008-01-01 23:59:59'), -(6, 'e', '2008-01-01 23:59:59'), (7, 'e', '2008-01-01 23:59:59'), -(8, 'e', '2008-01-01 23:59:59'), (9, 'e', '2008-01-01 23:59:59'), -(10, 'j', '2008-01-01 23:59:59'); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -DELETE FROM ta_l WHERE a > 0 AND b = 'e'; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'delete %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo truncate -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -TRUNCATE TABLE ta_l; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'truncate %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo deinit ---disable_warnings ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; -} ---disable_query_log ---disable_result_log ---source test_deinit.inc ---enable_result_log ---enable_query_log ---enable_warnings ---echo ---echo end of test diff --git a/storage/spider/mysql-test/spider/oracle/t/basic_sql_part.test b/storage/spider/mysql-test/spider/oracle/t/basic_sql_part.test deleted file mode 100644 index 1bb18358d5d..00000000000 --- a/storage/spider/mysql-test/spider/oracle/t/basic_sql_part.test +++ /dev/null @@ -1,571 +0,0 @@ -# This test tests by executing basic SQL ---disable_warnings ---disable_query_log ---disable_result_log ---source test_init.inc ---enable_result_log ---enable_query_log -if (!$HAVE_PARTITION) -{ - --disable_query_log - --disable_result_log - --source test_deinit.inc - --enable_result_log - --enable_query_log - --enable_warnings - skip Test requires partitioning; -} - ---echo ---echo drop and create databases ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - CREATE DATABASE auto_test_remote; - USE auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; - CREATE DATABASE auto_test_remote2; - USE auto_test_remote2; -} ---enable_warnings - ---echo ---echo test select 1 ---connection master_1 -SELECT 1; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - SELECT 1; - --connection child2_2 - SELECT 1; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---connection master_1 ---disable_warnings -DROP TABLE IF EXISTS tb_l; ---enable_warnings ---disable_query_log -echo CREATE TABLE tb_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) MASTER_1_ENGINE2 MASTER_1_CHARSET2; -eval CREATE TABLE tb_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) $MASTER_1_ENGINE2 $MASTER_1_CHARSET2; ---enable_query_log -INSERT INTO tb_l (a, b, c) VALUES - (1, 'f', '2008-07-01 10:21:39'), - (2, 'g', '2000-02-01 00:00:00'), - (3, 'j', '2007-05-04 20:03:11'), - (4, 'i', '2003-10-30 05:01:03'), - (5, 'h', '2001-10-31 23:59:59'); - ---echo ---echo create table with partition and select test -if ($HAVE_PARTITION) -{ - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_2_DROP_TABLES; - echo CHILD2_2_CREATE_TABLES; - } - --disable_warnings - eval $CHILD2_2_DROP_TABLES; - --enable_warnings - eval $CHILD2_2_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_TABLES2; - echo CHILD2_1_CREATE_TABLES2; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES2; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES2; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - --disable_query_log - echo CREATE TABLE ta_l2 ( - PRIMARY KEY(a) - ) MASTER_1_ENGINE MASTER_1_COMMENT_P_2_1 - SELECT a, b, c FROM tb_l; - if ($MASTER_1_MERGE) - { - --error ER_WRONG_OBJECT - eval CREATE TABLE ta_l2 ( - PRIMARY KEY(a) - ) $MASTER_1_ENGINE $MASTER_1_COMMENT_P_2_1 - SELECT a, b, c FROM tb_l; - eval CREATE TABLE ta_l2 ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) - ) $MASTER_1_ENGINE $MASTER_1_COMMENT_P_2_1; - INSERT INTO ta_l2 SELECT a, b, c FROM tb_l; - } - if (!$MASTER_1_MERGE) - { - eval CREATE TABLE ta_l2 ( - PRIMARY KEY(a) - ) $MASTER_1_ENGINE $MASTER_1_COMMENT_P_2_1 - SELECT a, b, c FROM tb_l; - } - --enable_query_log - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%insert %'; - } - eval $CHILD2_2_SELECT_TABLES; - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%insert %'; - } - eval $CHILD2_1_SELECT_TABLES2; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -} - ---echo ---echo select partition using pushdown -if ($HAVE_PARTITION) -{ - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - SELECT a.a, a.b, date_format(a.c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 a WHERE - a.b = 'g' ORDER BY a.a; - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } -} - ---echo ---echo select partition using index pushdown -if ($HAVE_PARTITION) -{ - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - SELECT a.a, a.b, date_format(a.c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 a WHERE - a.a > 0 AND a.b = 'g' ORDER BY a.a; - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } -} - ---echo ---echo update partition pushdown -if ($HAVE_PARTITION) -{ - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - UPDATE ta_l2 SET b = 'e', c = '2009-03-03 03:03:03' WHERE b = 'j'; - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'update %'; - } - eval $CHILD2_2_SELECT_TABLES; - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'update %'; - } - eval $CHILD2_1_SELECT_TABLES2; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -} - ---echo ---echo update partition index pushdown -if ($HAVE_PARTITION) -{ - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - UPDATE ta_l2 SET b = 'j', c = '2009-03-03 03:03:03' WHERE a > 0 AND b = 'e'; - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'update %'; - } - eval $CHILD2_2_SELECT_TABLES; - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'update %'; - } - eval $CHILD2_1_SELECT_TABLES2; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -} - ---echo ---echo delete partition pushdown -if ($HAVE_PARTITION) -{ - TRUNCATE TABLE ta_l2; - INSERT INTO ta_l2 SELECT a, b, c FROM tb_l; - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - DELETE FROM ta_l2 WHERE b = 'g'; - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'delete %'; - } - eval $CHILD2_2_SELECT_TABLES; - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'delete %'; - } - eval $CHILD2_1_SELECT_TABLES2; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -} - ---echo ---echo delete partition index pushdown -if ($HAVE_PARTITION) -{ - TRUNCATE TABLE ta_l2; - INSERT INTO ta_l2 SELECT a, b, c FROM tb_l; - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - DELETE FROM ta_l2 WHERE a > 0 AND b = 'g'; - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'delete %'; - } - eval $CHILD2_2_SELECT_TABLES; - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'delete %'; - } - eval $CHILD2_1_SELECT_TABLES2; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -} - ---echo ---echo deinit ---disable_warnings ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; -} ---disable_query_log ---disable_result_log ---source test_deinit.inc ---enable_result_log ---enable_query_log ---enable_warnings ---echo ---echo end of test diff --git a/storage/spider/mysql-test/spider/oracle/t/connect_child2_1.inc b/storage/spider/mysql-test/spider/oracle/t/connect_child2_1.inc deleted file mode 100644 index cd9b0c9ca9b..00000000000 --- a/storage/spider/mysql-test/spider/oracle/t/connect_child2_1.inc +++ /dev/null @@ -1 +0,0 @@ ---connect (child2_1, localhost, root, , , $CHILD2_1_MYPORT, $CHILD2_1_MYSOCK) diff --git a/storage/spider/mysql-test/spider/oracle/t/connect_child2_2.inc b/storage/spider/mysql-test/spider/oracle/t/connect_child2_2.inc deleted file mode 100644 index e145f66b630..00000000000 --- a/storage/spider/mysql-test/spider/oracle/t/connect_child2_2.inc +++ /dev/null @@ -1 +0,0 @@ ---connect (child2_2, localhost, root, , , $CHILD2_2_MYPORT, $CHILD2_2_MYSOCK) diff --git a/storage/spider/mysql-test/spider/oracle/t/connect_child2_3.inc b/storage/spider/mysql-test/spider/oracle/t/connect_child2_3.inc deleted file mode 100644 index d356348d8ea..00000000000 --- a/storage/spider/mysql-test/spider/oracle/t/connect_child2_3.inc +++ /dev/null @@ -1 +0,0 @@ ---connect (child2_3, localhost, root, , , $CHILD2_3_MYPORT, $CHILD2_3_MYSOCK) diff --git a/storage/spider/mysql-test/spider/oracle/t/connect_child3_1.inc b/storage/spider/mysql-test/spider/oracle/t/connect_child3_1.inc deleted file mode 100644 index 03e5c188c89..00000000000 --- a/storage/spider/mysql-test/spider/oracle/t/connect_child3_1.inc +++ /dev/null @@ -1 +0,0 @@ ---connect (child3_1, localhost, root, , , $CHILD3_1_MYPORT, $CHILD3_1_MYSOCK) diff --git a/storage/spider/mysql-test/spider/oracle/t/connect_child3_2.inc b/storage/spider/mysql-test/spider/oracle/t/connect_child3_2.inc deleted file mode 100644 index d62a7ada824..00000000000 --- a/storage/spider/mysql-test/spider/oracle/t/connect_child3_2.inc +++ /dev/null @@ -1 +0,0 @@ ---connect (child3_2, localhost, root, , , $CHILD3_2_MYPORT, $CHILD3_2_MYSOCK) diff --git a/storage/spider/mysql-test/spider/oracle/t/connect_child3_3.inc b/storage/spider/mysql-test/spider/oracle/t/connect_child3_3.inc deleted file mode 100644 index fb49f5bfdac..00000000000 --- a/storage/spider/mysql-test/spider/oracle/t/connect_child3_3.inc +++ /dev/null @@ -1 +0,0 @@ ---connect (child3_3, localhost, root, , , $CHILD3_3_MYPORT, $CHILD3_3_MYSOCK) diff --git a/storage/spider/mysql-test/spider/oracle/t/connect_master_1.inc b/storage/spider/mysql-test/spider/oracle/t/connect_master_1.inc deleted file mode 100644 index 0c129ce5775..00000000000 --- a/storage/spider/mysql-test/spider/oracle/t/connect_master_1.inc +++ /dev/null @@ -1 +0,0 @@ ---connect (master_1, localhost, root, , , $MASTER_1_MYPORT, $MASTER_1_MYSOCK) diff --git a/storage/spider/mysql-test/spider/oracle/t/connect_slave1_1.inc b/storage/spider/mysql-test/spider/oracle/t/connect_slave1_1.inc deleted file mode 100644 index 45a822743e0..00000000000 --- a/storage/spider/mysql-test/spider/oracle/t/connect_slave1_1.inc +++ /dev/null @@ -1 +0,0 @@ ---connect (slave1_1, localhost, root, , , $SLAVE1_1_MYPORT, $SLAVE1_1_MYSOCK) diff --git a/storage/spider/mysql-test/spider/oracle/t/direct_aggregate.test b/storage/spider/mysql-test/spider/oracle/t/direct_aggregate.test deleted file mode 100644 index 5c0c37f483d..00000000000 --- a/storage/spider/mysql-test/spider/oracle/t/direct_aggregate.test +++ /dev/null @@ -1,179 +0,0 @@ ---disable_warnings ---disable_query_log ---disable_result_log ---source test_init.inc ---enable_result_log ---enable_query_log - ---echo ---echo drop and create databases ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - CREATE DATABASE auto_test_remote; - USE auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; - CREATE DATABASE auto_test_remote2; - USE auto_test_remote2; -} ---enable_warnings - ---echo ---echo test select 1 ---connection master_1 -SELECT 1; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - SELECT 1; - --connection child2_2 - SELECT 1; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo create table select test -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_TABLES; - echo CHILD2_1_CREATE_TABLES; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 ---disable_warnings -DROP TABLE IF EXISTS ta_l; ---enable_warnings ---disable_query_log -echo CREATE TABLE ta_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_2_1; -eval CREATE TABLE ta_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_2_1; ---enable_query_log -INSERT INTO ta_l (a, b, c) VALUES - (1, 'a', '2008-08-01 10:21:39'), - (2, 'b', '2000-01-01 00:00:00'), - (3, 'e', '2007-06-04 20:03:11'), - (4, 'd', '2003-11-30 05:01:03'), - (5, 'c', '2001-12-31 23:59:59'); - ---echo ---echo direct_aggregating test -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -eval $MASTER_1_CHECK_DIRECT_AGGREGATE_STATUS; -SELECT COUNT(*) FROM ta_l; -eval $MASTER_1_CHECK_DIRECT_AGGREGATE_STATUS; -SELECT MAX(a) FROM ta_l; -eval $MASTER_1_CHECK_DIRECT_AGGREGATE_STATUS; -SELECT MIN(a) FROM ta_l; -eval $MASTER_1_CHECK_DIRECT_AGGREGATE_STATUS; -SELECT MAX(a) FROM ta_l WHERE a < 5; -eval $MASTER_1_CHECK_DIRECT_AGGREGATE_STATUS; -SELECT MIN(a) FROM ta_l WHERE a > 1; -eval $MASTER_1_CHECK_DIRECT_AGGREGATE_STATUS; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%handler %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo deinit ---disable_warnings ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; -} ---disable_query_log ---disable_result_log ---source test_deinit.inc ---enable_result_log ---enable_query_log ---enable_warnings ---echo ---echo end of test diff --git a/storage/spider/mysql-test/spider/oracle/t/direct_aggregate_part.test b/storage/spider/mysql-test/spider/oracle/t/direct_aggregate_part.test deleted file mode 100644 index cb0b55e9788..00000000000 --- a/storage/spider/mysql-test/spider/oracle/t/direct_aggregate_part.test +++ /dev/null @@ -1,192 +0,0 @@ ---disable_warnings ---disable_query_log ---disable_result_log ---source test_init.inc ---enable_result_log ---enable_query_log -if (!$HAVE_PARTITION) -{ - --disable_query_log - --disable_result_log - --source test_deinit.inc - --enable_result_log - --enable_query_log - --enable_warnings - skip Test requires partitioning; -} - ---echo ---echo drop and create databases ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - CREATE DATABASE auto_test_remote; - USE auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; - CREATE DATABASE auto_test_remote2; - USE auto_test_remote2; -} ---enable_warnings - ---echo ---echo test select 1 ---connection master_1 -SELECT 1; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - SELECT 1; - --connection child2_2 - SELECT 1; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo with partition test -if ($HAVE_PARTITION) -{ - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_2_DROP_TABLES; - echo CHILD2_2_CREATE_TABLES; - } - --disable_warnings - eval $CHILD2_2_DROP_TABLES; - --enable_warnings - eval $CHILD2_2_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_TABLES2; - echo CHILD2_1_CREATE_TABLES2; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES2; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES2; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - --disable_query_log - echo CREATE TABLE ta_l2 ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) - ) MASTER_1_ENGINE MASTER_1_COMMENT2_P_2_1; - eval CREATE TABLE ta_l2 ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) - ) $MASTER_1_ENGINE $MASTER_1_COMMENT2_P_2_1; - INSERT INTO ta_l2 (a, b, c) VALUES - (1, 'a', '2008-08-01 10:21:39'), - (2, 'b', '2000-01-01 00:00:00'), - (3, 'e', '2007-06-04 20:03:11'), - (4, 'd', '2003-11-30 05:01:03'), - (5, 'c', '2001-12-31 23:59:59'); - --enable_query_log - eval $MASTER_1_CHECK_DIRECT_AGGREGATE_STATUS; - SELECT COUNT(*) FROM ta_l2; - eval $MASTER_1_CHECK_DIRECT_AGGREGATE_STATUS; - SELECT MAX(a) FROM ta_l2; - eval $MASTER_1_CHECK_DIRECT_AGGREGATE_STATUS; - SELECT MIN(a) FROM ta_l2; - eval $MASTER_1_CHECK_DIRECT_AGGREGATE_STATUS; - SELECT MAX(a) FROM ta_l2 WHERE a < 5; - eval $MASTER_1_CHECK_DIRECT_AGGREGATE_STATUS; - SELECT MIN(a) FROM ta_l2 WHERE a > 1; - eval $MASTER_1_CHECK_DIRECT_AGGREGATE_STATUS; - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%handler %'; - } - eval $CHILD2_2_SELECT_TABLES; - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%handler %'; - } - eval $CHILD2_1_SELECT_TABLES2; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } -} - ---echo ---echo deinit ---disable_warnings ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; -} ---disable_query_log ---disable_result_log ---source test_deinit.inc ---enable_result_log ---enable_query_log ---enable_warnings ---echo ---echo end of test diff --git a/storage/spider/mysql-test/spider/oracle/t/direct_update.test b/storage/spider/mysql-test/spider/oracle/t/direct_update.test deleted file mode 100644 index 94f27e2859c..00000000000 --- a/storage/spider/mysql-test/spider/oracle/t/direct_update.test +++ /dev/null @@ -1,198 +0,0 @@ ---disable_warnings ---disable_query_log ---disable_result_log ---source test_init.inc ---enable_result_log ---enable_query_log - ---echo ---echo drop and create databases ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - CREATE DATABASE auto_test_remote; - USE auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; - CREATE DATABASE auto_test_remote2; - USE auto_test_remote2; -} ---enable_warnings - ---echo ---echo test select 1 ---connection master_1 -SELECT 1; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - SELECT 1; - --connection child2_2 - SELECT 1; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo create table select test -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_TABLES; - echo CHILD2_1_CREATE_TABLES; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 ---disable_warnings -DROP TABLE IF EXISTS ta_l; ---enable_warnings ---disable_query_log -echo CREATE TABLE ta_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_2_1; -eval CREATE TABLE ta_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_2_1; ---enable_query_log -INSERT INTO ta_l (a, b, c) VALUES - (1, 'a', '2008-08-01 10:21:39'), - (2, 'b', '2000-01-01 00:00:00'), - (3, 'e', '2007-06-04 20:03:11'), - (4, 'd', '2003-11-30 05:01:03'), - (5, 'c', '2001-12-31 23:59:59'); - ---echo ---echo direct_updating test -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -eval $MASTER_1_CHECK_DIRECT_UPDATE_STATUS; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; ---echo update all rows with function -UPDATE ta_l SET c = ADDDATE(c, 1); -eval $MASTER_1_CHECK_DIRECT_UPDATE_STATUS; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; ---echo update by primary key -UPDATE ta_l SET b = 'x' WHERE a = 3; -eval $MASTER_1_CHECK_DIRECT_UPDATE_STATUS; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; ---echo update by a column without index -UPDATE ta_l SET c = '2011-10-17' WHERE b = 'x'; -eval $MASTER_1_CHECK_DIRECT_UPDATE_STATUS; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; ---echo update by primary key with order and limit -UPDATE ta_l SET c = ADDDATE(c, 1) WHERE a < 4 ORDER BY b DESC LIMIT 1; -eval $MASTER_1_CHECK_DIRECT_UPDATE_STATUS; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; ---echo delete by primary key with order and limit -DELETE FROM ta_l WHERE a < 4 ORDER BY c LIMIT 1; -eval $MASTER_1_CHECK_DIRECT_DELETE_STATUS; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; ---echo delete by a column without index -DELETE FROM ta_l WHERE b = 'c'; -eval $MASTER_1_CHECK_DIRECT_DELETE_STATUS; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; ---echo delete by primary key -DELETE FROM ta_l WHERE a = 3; -eval $MASTER_1_CHECK_DIRECT_DELETE_STATUS; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%handler %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo deinit ---disable_warnings ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; -} ---disable_query_log ---disable_result_log ---source test_deinit.inc ---enable_result_log ---enable_query_log ---enable_warnings ---echo ---echo end of test diff --git a/storage/spider/mysql-test/spider/oracle/t/direct_update_part.test b/storage/spider/mysql-test/spider/oracle/t/direct_update_part.test deleted file mode 100644 index e8f1882594c..00000000000 --- a/storage/spider/mysql-test/spider/oracle/t/direct_update_part.test +++ /dev/null @@ -1,211 +0,0 @@ ---disable_warnings ---disable_query_log ---disable_result_log ---source test_init.inc ---enable_result_log ---enable_query_log -if (!$HAVE_PARTITION) -{ - --disable_query_log - --disable_result_log - --source test_deinit.inc - --enable_result_log - --enable_query_log - --enable_warnings - skip Test requires partitioning; -} - ---echo ---echo drop and create databases ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - CREATE DATABASE auto_test_remote; - USE auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; - CREATE DATABASE auto_test_remote2; - USE auto_test_remote2; -} ---enable_warnings - ---echo ---echo test select 1 ---connection master_1 -SELECT 1; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - SELECT 1; - --connection child2_2 - SELECT 1; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo with partition test -if ($HAVE_PARTITION) -{ - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_2_DROP_TABLES; - echo CHILD2_2_CREATE_TABLES; - } - --disable_warnings - eval $CHILD2_2_DROP_TABLES; - --enable_warnings - eval $CHILD2_2_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_TABLES2; - echo CHILD2_1_CREATE_TABLES2; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES2; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES2; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - --disable_query_log - echo CREATE TABLE ta_l2 ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) - ) MASTER_1_ENGINE MASTER_1_COMMENT2_P_2_1; - eval CREATE TABLE ta_l2 ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) - ) $MASTER_1_ENGINE $MASTER_1_COMMENT2_P_2_1; - INSERT INTO ta_l2 (a, b, c) VALUES - (1, 'a', '2008-08-01 10:21:39'), - (2, 'b', '2000-01-01 00:00:00'), - (3, 'e', '2007-06-04 20:03:11'), - (4, 'd', '2003-11-30 05:01:03'), - (5, 'c', '2001-12-31 23:59:59'); - --enable_query_log - eval $MASTER_1_CHECK_DIRECT_UPDATE_STATUS; - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; - --echo update all rows with function - UPDATE ta_l2 SET c = ADDDATE(c, 1); - eval $MASTER_1_CHECK_DIRECT_UPDATE_STATUS; - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; - --echo update by primary key - UPDATE ta_l2 SET b = 'x' WHERE a = 3; - eval $MASTER_1_CHECK_DIRECT_UPDATE_STATUS; - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; - --echo update by a column without index - UPDATE ta_l2 SET c = '2011-10-17' WHERE b = 'x'; - eval $MASTER_1_CHECK_DIRECT_UPDATE_STATUS; - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; - --echo update by primary key with order and limit - UPDATE ta_l2 SET c = ADDDATE(c, 1) WHERE a < 4 ORDER BY b DESC LIMIT 1; - eval $MASTER_1_CHECK_DIRECT_UPDATE_STATUS; - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; - --echo delete by primary key with order and limit - DELETE FROM ta_l2 WHERE a < 4 ORDER BY c LIMIT 1; - eval $MASTER_1_CHECK_DIRECT_DELETE_STATUS; - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; - --echo delete by a column without index - DELETE FROM ta_l2 WHERE b = 'c'; - eval $MASTER_1_CHECK_DIRECT_DELETE_STATUS; - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; - --echo delete by primary key - DELETE FROM ta_l2 WHERE a = 3; - eval $MASTER_1_CHECK_DIRECT_DELETE_STATUS; - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%handler %'; - } - eval $CHILD2_2_SELECT_TABLES; - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%handler %'; - } - eval $CHILD2_1_SELECT_TABLES2; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } -} - ---echo ---echo deinit ---disable_warnings ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; -} ---disable_query_log ---disable_result_log ---source test_deinit.inc ---enable_result_log ---enable_query_log ---enable_warnings ---echo ---echo end of test diff --git a/storage/spider/mysql-test/spider/oracle/t/function.test b/storage/spider/mysql-test/spider/oracle/t/function.test deleted file mode 100644 index 2472e774782..00000000000 --- a/storage/spider/mysql-test/spider/oracle/t/function.test +++ /dev/null @@ -1,253 +0,0 @@ -# This test tests for using functions ---disable_warnings ---disable_query_log ---disable_result_log ---source test_init.inc ---enable_result_log ---enable_query_log - ---echo ---echo drop and create databases ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - CREATE DATABASE auto_test_remote; - USE auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; - CREATE DATABASE auto_test_remote2; - USE auto_test_remote2; -} ---enable_warnings - ---echo ---echo test select 1 ---connection master_1 -SELECT 1; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - SELECT 1; - --connection child2_2 - SELECT 1; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo in() -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_result_log - } - --disable_query_log - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - echo CHILD2_1_DROP_TEXT_PK_TABLES1; - echo CHILD2_1_CREATE_TEXT_PK_TABLES1; - } - --disable_warnings - eval $CHILD2_1_DROP_TEXT_PK_TABLES1; - --enable_warnings - eval $CHILD2_1_CREATE_TEXT_PK_TABLES1; - --enable_query_log - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_result_log - } -} ---connection master_1 ---disable_query_log -echo CREATE TABLE t1 ( - a VARCHAR(255), - PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET3 MASTER_1_COMMENT_TEXT_PK1_1; -eval CREATE TABLE t1 ( - a VARCHAR(255), - PRIMARY KEY(a) -) $MASTER_1_ENGINE $MASTER_1_CHARSET3 $MASTER_1_COMMENT_TEXT_PK1_1; ---enable_query_log -insert into t1 values ('1'); -insert into t1 select a + 1 from t1; -insert into t1 select a + 2 from t1; -insert into t1 select a + 4 from t1; -insert into t1 select a + 8 from t1; -insert into t1 select a + 16 from t1; -insert into t1 select a + 32 from t1; -insert into t1 select a + 64 from t1; -insert into t1 select a + 128 from t1; -insert into t1 select a + 256 from t1; -insert into t1 select a + 512 from t1; -flush tables; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -select a from t1 where a in ('15', '120'); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_1_SELECT_TEXT_PK_TABLES1; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo date_sub() -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_TABLES; - echo CHILD2_1_CREATE_TABLES; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 ---disable_warnings -DROP TABLE IF EXISTS ta_l; ---enable_warnings ---disable_query_log -echo CREATE TABLE ta_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_2_1; -eval CREATE TABLE ta_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_2_1; ---enable_query_log -INSERT INTO ta_l (a, b, c) VALUES - (1, 'a', '2008-08-01 10:21:39'), - (2, 'b', '2000-01-01 00:00:00'), - (3, 'e', '2007-06-04 20:03:11'), - (4, 'd', '2003-11-30 05:01:03'), - (5, 'c', '2001-12-31 23:59:59'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -UPDATE ta_l SET c = DATE_SUB(c, INTERVAL 1 YEAR); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -UPDATE ta_l SET c = DATE_ADD(c, INTERVAL 1 QUARTER); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -UPDATE ta_l SET c = DATE_SUB(c, INTERVAL 1 MONTH); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -UPDATE ta_l SET c = DATE_ADD(c, INTERVAL 1 WEEK); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -UPDATE ta_l SET c = DATE_SUB(c, INTERVAL 1 DAY); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -UPDATE ta_l SET c = DATE_ADD(c, INTERVAL 1 HOUR); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -UPDATE ta_l SET c = DATE_SUB(c, INTERVAL 1 MINUTE); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -UPDATE ta_l SET c = DATE_ADD(c, INTERVAL 1 SECOND); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%update %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo deinit ---disable_warnings ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; -} ---disable_query_log ---disable_result_log ---source test_deinit.inc ---enable_result_log ---enable_query_log ---enable_warnings ---echo ---echo end of test diff --git a/storage/spider/mysql-test/spider/oracle/t/ha.test b/storage/spider/mysql-test/spider/oracle/t/ha.test deleted file mode 100644 index c36b7363a6d..00000000000 --- a/storage/spider/mysql-test/spider/oracle/t/ha.test +++ /dev/null @@ -1,878 +0,0 @@ -# This test tests for ha features -if ($USE_HA_TEST) -{ ---disable_warnings ---disable_query_log ---disable_result_log ---source test_init.inc ---source ha_test_init.inc ---enable_result_log ---enable_query_log - ---echo ---echo drop and create databases ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - CREATE DATABASE auto_test_remote; - USE auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; - CREATE DATABASE auto_test_remote2; - USE auto_test_remote2; - --connection child2_3 - DROP DATABASE IF EXISTS auto_test_remote3; - CREATE DATABASE auto_test_remote3; - USE auto_test_remote3; -} -if ($USE_CHILD_GROUP3) -{ - --connection child3_1 - DROP DATABASE IF EXISTS auto_test_local; - CREATE DATABASE auto_test_local; - USE auto_test_local; - --connection child3_2 - DROP DATABASE IF EXISTS auto_test_local; - CREATE DATABASE auto_test_local; - USE auto_test_local; - --connection child3_3 - DROP DATABASE IF EXISTS auto_test_local; - CREATE DATABASE auto_test_local; - USE auto_test_local; -} ---enable_warnings - ---echo ---echo test select 1 ---connection master_1 -SELECT 1; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - SELECT 1; - --connection child2_2 - SELECT 1; - --connection child2_3 - SELECT 1; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} -if ($USE_CHILD_GROUP3) -{ - if (!$OUTPUT_CHILD_GROUP3) - { - --disable_query_log - --disable_result_log - } - --connection child3_1 - SELECT 1; - --connection child3_2 - SELECT 1; - --connection child3_3 - SELECT 1; - if (!$OUTPUT_CHILD_GROUP3) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo create table test -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_TABLES; - echo CHILD2_1_CREATE_TABLES; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_2 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_2_DROP_TABLES; - echo CHILD2_2_CREATE_TABLES; - } - --disable_warnings - eval $CHILD2_2_DROP_TABLES; - --enable_warnings - eval $CHILD2_2_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} -if ($USE_CHILD_GROUP3) -{ - if (!$OUTPUT_CHILD_GROUP3) - { - --disable_query_log - --disable_result_log - } - --connection child3_1 - --disable_warnings - eval $CHILD3_1_DROP_TABLES_HA_2_1; - --enable_warnings - eval $CHILD3_1_CREATE_TABLES_HA_2_1; - --connection child3_2 - --disable_warnings - eval $CHILD3_2_DROP_TABLES_HA_2_1; - --enable_warnings - eval $CHILD3_2_CREATE_TABLES_HA_2_1; - --connection child3_3 - --disable_warnings - eval $CHILD3_3_DROP_TABLES_HA_2_1; - --enable_warnings - eval $CHILD3_3_CREATE_TABLES_HA_2_1; - if (!$OUTPUT_CHILD_GROUP3) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 ---disable_warnings -DROP TABLE IF EXISTS ta_l; ---enable_warnings ---disable_query_log -echo CREATE TABLE ta_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_HA_2_1; -eval CREATE TABLE ta_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_HA_2_1; ---enable_query_log -INSERT INTO ta_l (a, b, c) VALUES - (1, 'a', '2008-08-01 10:21:39'), - (2, 'b', '2000-01-01 00:00:00'), - (3, 'e', '2007-06-04 20:03:11'), - (4, 'd', '2003-11-30 05:01:03'), - (5, 'c', '2001-12-31 23:59:59'); - ---echo ---echo select test -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_1_SELECT_TABLES; - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_2_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo fail-over test -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_2 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_2_HA_DROP_TABLES; - } - --disable_warnings - eval $CHILD2_2_HA_DROP_TABLES; - --enable_warnings - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -eval $MASTER_1_CHECK_HA_STATUS; ---error 12511 -INSERT INTO ta_l (a, b, c) VALUES - (6, 'e', '2011-05-05 20:04:05'); -eval $MASTER_1_CHECK_LINK_STATUS; -eval $MASTER_1_CHECK_LINK_FAILED_LOG; -eval $MASTER_1_CHECK_HA_STATUS; -INSERT INTO ta_l (a, b, c) VALUES - (6, 'e', '2011-05-05 20:04:05'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} -if ($USE_CHILD_GROUP3) -{ - if (!$OUTPUT_CHILD_GROUP3) - { - --disable_query_log - --disable_result_log - } - --connection child3_1 - eval $CHILD3_1_CHECK_LINK_STATUS; - eval $CHILD3_1_CHECK_LINK_FAILED_LOG; - --connection child3_2 - eval $CHILD3_2_CHECK_LINK_STATUS; - eval $CHILD3_2_CHECK_LINK_FAILED_LOG; - --connection child3_3 - eval $CHILD3_3_CHECK_LINK_STATUS; - eval $CHILD3_3_CHECK_LINK_FAILED_LOG; - if (!$OUTPUT_CHILD_GROUP3) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo recovery test -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_2 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_2_HA_CREATE_TABLES; - } - eval $CHILD2_2_HA_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} -if ($USE_CHILD_GROUP3) -{ - if (!$OUTPUT_CHILD_GROUP3) - { - --disable_query_log - --disable_result_log - } - --connection child3_1 - eval $CHILD3_1_SET_RECOVERY_STATUS_2_1; - eval $CHILD3_1_CHECK_LINK_STATUS; - --connection child3_2 - eval $CHILD3_2_SET_RECOVERY_STATUS_2_1; - eval $CHILD3_2_CHECK_LINK_STATUS; - --connection child3_3 - eval $CHILD3_3_SET_RECOVERY_STATUS_2_1; - eval $CHILD3_3_CHECK_LINK_STATUS; - if (!$OUTPUT_CHILD_GROUP3) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -eval $MASTER_1_SET_RECOVERY_STATUS_2_1; -eval $MASTER_1_CHECK_LINK_STATUS; -eval $MASTER_1_COPY_TABLES_2_1; -if ($USE_CHILD_GROUP3) -{ - if (!$OUTPUT_CHILD_GROUP3) - { - --disable_query_log - --disable_result_log - } - --connection child3_1 - eval $CHILD3_1_SET_OK_STATUS_2_1; - eval $CHILD3_1_CHECK_LINK_STATUS; - --connection child3_2 - eval $CHILD3_2_SET_OK_STATUS_2_1; - eval $CHILD3_2_CHECK_LINK_STATUS; - --connection child3_3 - eval $CHILD3_3_SET_OK_STATUS_2_1; - eval $CHILD3_3_CHECK_LINK_STATUS; - if (!$OUTPUT_CHILD_GROUP3) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -eval $MASTER_1_SET_OK_STATUS_2_1; -eval $MASTER_1_CHECK_LINK_STATUS; -INSERT INTO ta_l (a, b, c) VALUES - (8, 'g', '2011-05-05 21:33:30'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -DROP TABLE ta_l; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_1_SELECT_TABLES; - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_2_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} -if ($USE_CHILD_GROUP3) -{ - if (!$OUTPUT_CHILD_GROUP3) - { - --disable_query_log - --disable_result_log - } - --connection child3_1 - --disable_warnings - eval $CHILD3_1_DROP_TABLES_HA_2_1; - --enable_warnings - --connection child3_2 - --disable_warnings - eval $CHILD3_2_DROP_TABLES_HA_2_1; - --enable_warnings - --connection child3_3 - --disable_warnings - eval $CHILD3_3_DROP_TABLES_HA_2_1; - --enable_warnings - if (!$OUTPUT_CHILD_GROUP3) - { - --enable_query_log - --enable_result_log - } -} - ---connection master_1 -eval $MASTER_1_CHANGE_HA_MON; - ---echo ---echo active standby test ---echo create table test -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_TABLES; - echo CHILD2_1_CREATE_TABLES; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_2 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_2_DROP_TABLES; - echo CHILD2_2_CREATE_TABLES; - } - --disable_warnings - eval $CHILD2_2_DROP_TABLES; - --enable_warnings - eval $CHILD2_2_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} -if ($USE_CHILD_GROUP3) -{ - if (!$OUTPUT_CHILD_GROUP3) - { - --disable_query_log - --disable_result_log - } - --connection child3_1 - --disable_warnings - eval $CHILD3_1_DROP_TABLES_HA_2_1; - --enable_warnings - eval $CHILD3_1_CREATE_TABLES_HA_AS_2_1; - --connection child3_2 - --disable_warnings - eval $CHILD3_2_DROP_TABLES_HA_2_1; - --enable_warnings - eval $CHILD3_2_CREATE_TABLES_HA_AS_2_1; - --connection child3_3 - --disable_warnings - eval $CHILD3_3_DROP_TABLES_HA_2_1; - --enable_warnings - eval $CHILD3_3_CREATE_TABLES_HA_AS_2_1; - if (!$OUTPUT_CHILD_GROUP3) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 ---disable_warnings -DROP TABLE IF EXISTS ta_l; ---enable_warnings ---disable_query_log -echo CREATE TABLE ta_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_HA_AS_2_1; -eval CREATE TABLE ta_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_HA_AS_2_1; ---enable_query_log -INSERT INTO ta_l (a, b, c) VALUES - (1, 'a', '2008-08-01 10:21:39'), - (2, 'b', '2000-01-01 00:00:00'), - (3, 'e', '2007-06-04 20:03:11'), - (4, 'd', '2003-11-30 05:01:03'), - (5, 'c', '2001-12-31 23:59:59'); - ---echo ---echo select test -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_1_SELECT_TABLES; - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_2_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo fail-over test -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_HA_AS_DROP_TABLES; - } - --disable_warnings - eval $CHILD2_1_HA_AS_DROP_TABLES; - --enable_warnings - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -eval $MASTER_1_CHECK_HA_STATUS; ---error 12511 -INSERT INTO ta_l (a, b, c) VALUES - (6, 'e', '2011-05-05 20:04:05'); -eval $MASTER_1_CHECK_LINK_STATUS; -eval $MASTER_1_CHECK_LINK_FAILED_LOG; -eval $MASTER_1_CHECK_HA_STATUS; -INSERT INTO ta_l (a, b, c) VALUES - (6, 'e', '2011-05-05 20:04:05'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_2_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} -if ($USE_CHILD_GROUP3) -{ - if (!$OUTPUT_CHILD_GROUP3) - { - --disable_query_log - --disable_result_log - } - --connection child3_1 - eval $CHILD3_1_CHECK_LINK_STATUS; - eval $CHILD3_1_CHECK_LINK_FAILED_LOG; - --connection child3_2 - eval $CHILD3_2_CHECK_LINK_STATUS; - eval $CHILD3_2_CHECK_LINK_FAILED_LOG; - --connection child3_3 - eval $CHILD3_3_CHECK_LINK_STATUS; - eval $CHILD3_3_CHECK_LINK_FAILED_LOG; - if (!$OUTPUT_CHILD_GROUP3) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo recovery test -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_HA_AS_CREATE_TABLES; - } - eval $CHILD2_1_HA_AS_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} -if ($USE_CHILD_GROUP3) -{ - if (!$OUTPUT_CHILD_GROUP3) - { - --disable_query_log - --disable_result_log - } - --connection child3_1 - eval $CHILD3_1_SET_OK_STATUS_AS_2_1; - eval $CHILD3_1_CHECK_LINK_STATUS; - --connection child3_2 - eval $CHILD3_2_SET_OK_STATUS_AS_2_1; - eval $CHILD3_2_CHECK_LINK_STATUS; - --connection child3_3 - eval $CHILD3_3_SET_OK_STATUS_AS_2_1; - eval $CHILD3_3_CHECK_LINK_STATUS; - if (!$OUTPUT_CHILD_GROUP3) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -eval $MASTER_1_SET_OK_STATUS_AS_2_1; -eval $MASTER_1_CHECK_LINK_STATUS; -INSERT INTO ta_l (a, b, c) VALUES - (8, 'g', '2011-05-05 21:33:30'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -DROP TABLE ta_l; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_1_SELECT_TABLES; - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_2_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} -if ($USE_CHILD_GROUP3) -{ - if (!$OUTPUT_CHILD_GROUP3) - { - --disable_query_log - --disable_result_log - } - --connection child3_1 - --disable_warnings - eval $CHILD3_1_DROP_TABLES_HA_2_1; - --enable_warnings - --connection child3_2 - --disable_warnings - eval $CHILD3_2_DROP_TABLES_HA_2_1; - --enable_warnings - --connection child3_3 - --disable_warnings - eval $CHILD3_3_DROP_TABLES_HA_2_1; - --enable_warnings - if (!$OUTPUT_CHILD_GROUP3) - { - --enable_query_log - --enable_result_log - } -} - ---connection master_1 -eval $MASTER_1_CHANGE_HA_MON; - ---echo ---echo deinit ---disable_warnings ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; - --connection child2_3 - DROP DATABASE IF EXISTS auto_test_remote3; -} -if ($USE_CHILD_GROUP3) -{ - --connection child3_1 - DROP DATABASE IF EXISTS auto_test_local; - --connection child3_2 - DROP DATABASE IF EXISTS auto_test_local; - --connection child3_3 - DROP DATABASE IF EXISTS auto_test_local; -} ---disable_query_log ---disable_result_log ---source ha_test_deinit.inc ---source test_deinit.inc ---enable_result_log ---enable_query_log ---enable_warnings -} ---echo ---echo end of test diff --git a/storage/spider/mysql-test/spider/oracle/t/ha_part.test b/storage/spider/mysql-test/spider/oracle/t/ha_part.test deleted file mode 100644 index 33fe9850b68..00000000000 --- a/storage/spider/mysql-test/spider/oracle/t/ha_part.test +++ /dev/null @@ -1,1017 +0,0 @@ -# This test tests for ha features -if ($USE_HA_TEST) -{ ---disable_warnings ---disable_query_log ---disable_result_log ---source test_init.inc ---source ha_test_init.inc ---enable_result_log ---enable_query_log -if (!$HAVE_PARTITION) -{ - --disable_query_log - --disable_result_log - --source ha_test_deinit.inc - --source test_deinit.inc - --enable_result_log - --enable_query_log - --enable_warnings - skip Test requires partitioning; -} - ---echo ---echo drop and create databases ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - CREATE DATABASE auto_test_remote; - USE auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; - CREATE DATABASE auto_test_remote2; - USE auto_test_remote2; - --connection child2_3 - DROP DATABASE IF EXISTS auto_test_remote3; - CREATE DATABASE auto_test_remote3; - USE auto_test_remote3; -} -if ($USE_CHILD_GROUP3) -{ - --connection child3_1 - DROP DATABASE IF EXISTS auto_test_local; - CREATE DATABASE auto_test_local; - USE auto_test_local; - --connection child3_2 - DROP DATABASE IF EXISTS auto_test_local; - CREATE DATABASE auto_test_local; - USE auto_test_local; - --connection child3_3 - DROP DATABASE IF EXISTS auto_test_local; - CREATE DATABASE auto_test_local; - USE auto_test_local; -} ---enable_warnings - ---echo ---echo test select 1 ---connection master_1 -SELECT 1; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - SELECT 1; - --connection child2_2 - SELECT 1; - --connection child2_3 - SELECT 1; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} -if ($USE_CHILD_GROUP3) -{ - if (!$OUTPUT_CHILD_GROUP3) - { - --disable_query_log - --disable_result_log - } - --connection child3_1 - SELECT 1; - --connection child3_2 - SELECT 1; - --connection child3_3 - SELECT 1; - if (!$OUTPUT_CHILD_GROUP3) - { - --enable_query_log - --enable_result_log - } -} - -if ($HAVE_PARTITION) -{ - --echo - --echo create table with partition test - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_TABLES; - echo CHILD2_1_DROP_TABLES2; - echo CHILD2_1_CREATE_TABLES; - echo CHILD2_1_CREATE_TABLES2; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES; - eval $CHILD2_1_DROP_TABLES2; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES; - eval $CHILD2_1_CREATE_TABLES2; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_2 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_2_DROP_TABLES; - echo CHILD2_2_CREATE_TABLES; - } - --disable_warnings - eval $CHILD2_2_DROP_TABLES; - --enable_warnings - eval $CHILD2_2_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_3 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_3_DROP_TABLES; - echo CHILD2_3_CREATE_TABLES; - } - --disable_warnings - eval $CHILD2_3_DROP_TABLES; - --enable_warnings - eval $CHILD2_3_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - if ($USE_CHILD_GROUP3) - { - if (!$OUTPUT_CHILD_GROUP3) - { - --disable_query_log - --disable_result_log - } - --connection child3_1 - --disable_warnings - eval $CHILD3_1_DROP_TABLES_HA_P_2_1; - --enable_warnings - eval $CHILD3_1_CREATE_TABLES_HA_P_2_1; - --connection child3_2 - --disable_warnings - eval $CHILD3_2_DROP_TABLES_HA_P_2_1; - --enable_warnings - eval $CHILD3_2_CREATE_TABLES_HA_P_2_1; - --connection child3_3 - --disable_warnings - eval $CHILD3_3_DROP_TABLES_HA_P_2_1; - --enable_warnings - eval $CHILD3_3_CREATE_TABLES_HA_P_2_1; - if (!$OUTPUT_CHILD_GROUP3) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - --disable_warnings - DROP TABLE IF EXISTS ta_l2; - --enable_warnings - --disable_query_log - echo CREATE TABLE ta_l2 ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) - ) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_HA_P_2_1; - eval CREATE TABLE ta_l2 ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_HA_P_2_1; - --enable_query_log - INSERT INTO ta_l2 (a, b, c) VALUES - (1, 'a', '2008-08-01 10:21:39'), - (2, 'b', '2000-01-01 00:00:00'), - (3, 'e', '2007-06-04 20:03:11'), - (4, 'd', '2003-11-30 05:01:03'), - (5, 'c', '2001-12-31 23:59:59'); - - --echo - --echo select test - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_3 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_1_SELECT_TABLES; - eval $CHILD2_1_SELECT_TABLES2; - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_2_SELECT_TABLES; - --connection child2_3 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_3_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - - --echo - --echo fail-over test - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_3 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_3_HA_DROP_TABLES; - } - --disable_warnings - eval $CHILD2_3_HA_DROP_TABLES; - --enable_warnings - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - eval $MASTER_1_CHECK_HA_STATUS; - --error 12511 - INSERT INTO ta_l2 (a, b, c) VALUES - (6, 'e', '2011-05-05 20:04:05'); - eval $MASTER_1_CHECK_LINK_STATUS; - eval $MASTER_1_CHECK_LINK_FAILED_LOG; - eval $MASTER_1_CHECK_HA_STATUS; - INSERT INTO ta_l2 (a, b, c) VALUES - (6, 'e', '2011-05-05 20:04:05'); - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_1_SELECT_TABLES; - eval $CHILD2_1_SELECT_TABLES2; - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_2_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - if ($USE_CHILD_GROUP3) - { - if (!$OUTPUT_CHILD_GROUP3) - { - --disable_query_log - --disable_result_log - } - --connection child3_1 - eval $CHILD3_1_CHECK_LINK_STATUS; - eval $CHILD3_1_CHECK_LINK_FAILED_LOG; - --connection child3_2 - eval $CHILD3_2_CHECK_LINK_STATUS; - eval $CHILD3_2_CHECK_LINK_FAILED_LOG; - --connection child3_3 - eval $CHILD3_3_CHECK_LINK_STATUS; - eval $CHILD3_3_CHECK_LINK_FAILED_LOG; - if (!$OUTPUT_CHILD_GROUP3) - { - --enable_query_log - --enable_result_log - } - } - - --echo - --echo recovery test - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_3 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_3_HA_CREATE_TABLES; - } - eval $CHILD2_3_HA_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - if ($USE_CHILD_GROUP3) - { - if (!$OUTPUT_CHILD_GROUP3) - { - --disable_query_log - --disable_result_log - } - --connection child3_1 - eval $CHILD3_1_SET_RECOVERY_STATUS_P_2_1; - eval $CHILD3_1_CHECK_LINK_STATUS; - --connection child3_2 - eval $CHILD3_2_SET_RECOVERY_STATUS_P_2_1; - eval $CHILD3_2_CHECK_LINK_STATUS; - --connection child3_3 - eval $CHILD3_3_SET_RECOVERY_STATUS_P_2_1; - eval $CHILD3_3_CHECK_LINK_STATUS; - if (!$OUTPUT_CHILD_GROUP3) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - eval $MASTER_1_SET_RECOVERY_STATUS_P_2_1; - eval $MASTER_1_CHECK_LINK_STATUS; - eval $MASTER_1_COPY_TABLES_P_2_1; - if ($USE_CHILD_GROUP3) - { - if (!$OUTPUT_CHILD_GROUP3) - { - --disable_query_log - --disable_result_log - } - --connection child3_1 - eval $CHILD3_1_SET_OK_STATUS_P_2_1; - eval $CHILD3_1_CHECK_LINK_STATUS; - --connection child3_2 - eval $CHILD3_2_SET_OK_STATUS_P_2_1; - eval $CHILD3_2_CHECK_LINK_STATUS; - --connection child3_3 - eval $CHILD3_3_SET_OK_STATUS_P_2_1; - eval $CHILD3_3_CHECK_LINK_STATUS; - if (!$OUTPUT_CHILD_GROUP3) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - eval $MASTER_1_SET_OK_STATUS_P_2_1; - eval $MASTER_1_CHECK_LINK_STATUS; - INSERT INTO ta_l2 (a, b, c) VALUES - (8, 'g', '2011-05-05 21:33:30'), - (9, 'h', '2011-05-05 22:32:10'); - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; - DROP TABLE ta_l2; - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_1_SELECT_TABLES; - eval $CHILD2_1_SELECT_TABLES2; - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_2_SELECT_TABLES; - --connection child2_3 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_3_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - if ($USE_CHILD_GROUP3) - { - if (!$OUTPUT_CHILD_GROUP3) - { - --disable_query_log - --disable_result_log - } - --connection child3_1 - --disable_warnings - eval $CHILD3_1_DROP_TABLES_HA_P_2_1; - --enable_warnings - --connection child3_2 - --disable_warnings - eval $CHILD3_2_DROP_TABLES_HA_P_2_1; - --enable_warnings - --connection child3_3 - --disable_warnings - eval $CHILD3_3_DROP_TABLES_HA_P_2_1; - --enable_warnings - if (!$OUTPUT_CHILD_GROUP3) - { - --enable_query_log - --enable_result_log - } - } -} - -if ($HAVE_PARTITION) -{ - --echo - --echo create table with partition test - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_TABLES; - echo CHILD2_1_DROP_TABLES2; - echo CHILD2_1_CREATE_TABLES; - echo CHILD2_1_CREATE_TABLES2; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES; - eval $CHILD2_1_DROP_TABLES2; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES; - eval $CHILD2_1_CREATE_TABLES2; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_2 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_2_DROP_TABLES; - echo CHILD2_2_CREATE_TABLES; - } - --disable_warnings - eval $CHILD2_2_DROP_TABLES; - --enable_warnings - eval $CHILD2_2_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_3 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_3_DROP_TABLES; - echo CHILD2_3_CREATE_TABLES; - } - --disable_warnings - eval $CHILD2_3_DROP_TABLES; - --enable_warnings - eval $CHILD2_3_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - if ($USE_CHILD_GROUP3) - { - if (!$OUTPUT_CHILD_GROUP3) - { - --disable_query_log - --disable_result_log - } - --connection child3_1 - --disable_warnings - eval $CHILD3_1_DROP_TABLES_HA_P_2_1; - --enable_warnings - eval $CHILD3_1_CREATE_TABLES_HA_AS_P_2_1; - --connection child3_2 - --disable_warnings - eval $CHILD3_2_DROP_TABLES_HA_P_2_1; - --enable_warnings - eval $CHILD3_2_CREATE_TABLES_HA_AS_P_2_1; - --connection child3_3 - --disable_warnings - eval $CHILD3_3_DROP_TABLES_HA_P_2_1; - --enable_warnings - eval $CHILD3_3_CREATE_TABLES_HA_AS_P_2_1; - if (!$OUTPUT_CHILD_GROUP3) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - --disable_warnings - DROP TABLE IF EXISTS ta_l2; - --enable_warnings - --disable_query_log - echo CREATE TABLE ta_l2 ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) - ) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_HA_AS_P_2_1; - eval CREATE TABLE ta_l2 ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_HA_AS_P_2_1; - --enable_query_log - INSERT INTO ta_l2 (a, b, c) VALUES - (1, 'a', '2008-08-01 10:21:39'), - (2, 'b', '2000-01-01 00:00:00'), - (3, 'e', '2007-06-04 20:03:11'), - (4, 'd', '2003-11-30 05:01:03'), - (5, 'c', '2001-12-31 23:59:59'); - - --echo - --echo select test - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_3 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_1_SELECT_TABLES; - eval $CHILD2_1_SELECT_TABLES2; - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_2_SELECT_TABLES; - --connection child2_3 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_3_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - - --echo - --echo fail-over test - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_HA_AS_DROP_TABLES2; - } - --disable_warnings - eval $CHILD2_1_HA_AS_DROP_TABLES2; - --enable_warnings - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_3 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - eval $MASTER_1_CHECK_HA_STATUS; - --error 12511 - INSERT INTO ta_l2 (a, b, c) VALUES - (6, 'e', '2011-05-05 20:04:05'); - eval $MASTER_1_CHECK_LINK_STATUS; - eval $MASTER_1_CHECK_LINK_FAILED_LOG; - eval $MASTER_1_CHECK_HA_STATUS; - INSERT INTO ta_l2 (a, b, c) VALUES - (6, 'e', '2011-05-05 20:04:05'); - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_1_SELECT_TABLES; - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_2_SELECT_TABLES; - --connection child2_3 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_3_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - if ($USE_CHILD_GROUP3) - { - if (!$OUTPUT_CHILD_GROUP3) - { - --disable_query_log - --disable_result_log - } - --connection child3_1 - eval $CHILD3_1_CHECK_LINK_STATUS; - eval $CHILD3_1_CHECK_LINK_FAILED_LOG; - --connection child3_2 - eval $CHILD3_2_CHECK_LINK_STATUS; - eval $CHILD3_2_CHECK_LINK_FAILED_LOG; - --connection child3_3 - eval $CHILD3_3_CHECK_LINK_STATUS; - eval $CHILD3_3_CHECK_LINK_FAILED_LOG; - if (!$OUTPUT_CHILD_GROUP3) - { - --enable_query_log - --enable_result_log - } - } - - --echo - --echo recovery test - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_HA_AS_CREATE_TABLES2; - } - eval $CHILD2_1_HA_AS_CREATE_TABLES2; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_3 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - if ($USE_CHILD_GROUP3) - { - if (!$OUTPUT_CHILD_GROUP3) - { - --disable_query_log - --disable_result_log - } - --connection child3_1 - eval $CHILD3_1_SET_OK_STATUS_AS_P_2_1; - eval $CHILD3_1_CHECK_LINK_STATUS; - --connection child3_2 - eval $CHILD3_2_SET_OK_STATUS_AS_P_2_1; - eval $CHILD3_2_CHECK_LINK_STATUS; - --connection child3_3 - eval $CHILD3_3_SET_OK_STATUS_AS_P_2_1; - eval $CHILD3_3_CHECK_LINK_STATUS; - if (!$OUTPUT_CHILD_GROUP3) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - eval $MASTER_1_SET_OK_STATUS_AS_P_2_1; - eval $MASTER_1_CHECK_LINK_STATUS; - INSERT INTO ta_l2 (a, b, c) VALUES - (8, 'g', '2011-05-05 21:33:30'), - (9, 'h', '2011-05-05 22:32:10'); - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; - DROP TABLE ta_l2; - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_1_SELECT_TABLES; - eval $CHILD2_1_SELECT_TABLES2; - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_2_SELECT_TABLES; - --connection child2_3 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_3_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - if ($USE_CHILD_GROUP3) - { - if (!$OUTPUT_CHILD_GROUP3) - { - --disable_query_log - --disable_result_log - } - --connection child3_1 - --disable_warnings - eval $CHILD3_1_DROP_TABLES_HA_P_2_1; - --enable_warnings - --connection child3_2 - --disable_warnings - eval $CHILD3_2_DROP_TABLES_HA_P_2_1; - --enable_warnings - --connection child3_3 - --disable_warnings - eval $CHILD3_3_DROP_TABLES_HA_P_2_1; - --enable_warnings - if (!$OUTPUT_CHILD_GROUP3) - { - --enable_query_log - --enable_result_log - } - } -} - ---echo ---echo deinit ---disable_warnings ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; - --connection child2_3 - DROP DATABASE IF EXISTS auto_test_remote3; -} -if ($USE_CHILD_GROUP3) -{ - --connection child3_1 - DROP DATABASE IF EXISTS auto_test_local; - --connection child3_2 - DROP DATABASE IF EXISTS auto_test_local; - --connection child3_3 - DROP DATABASE IF EXISTS auto_test_local; -} ---disable_query_log ---disable_result_log ---source ha_test_deinit.inc ---source test_deinit.inc ---enable_result_log ---enable_query_log ---enable_warnings -} ---echo ---echo end of test diff --git a/storage/spider/mysql-test/spider/oracle/t/ha_test_deinit.inc b/storage/spider/mysql-test/spider/oracle/t/ha_test_deinit.inc deleted file mode 100644 index 53d0409d066..00000000000 --- a/storage/spider/mysql-test/spider/oracle/t/ha_test_deinit.inc +++ /dev/null @@ -1,30 +0,0 @@ -# get connection and exist engine test ---echo for master_1 ---connection master_1 ---source ../include/ha_deinit_master_1.inc ---echo for child2 -if ($USE_CHILD_GROUP2) -{ - --echo child2_1 - --connection child2_1 - --source ../include/ha_deinit_child2_1.inc - --echo child2_2 - --connection child2_2 - --source ../include/ha_deinit_child2_2.inc - --echo child2_3 - --connection child2_3 - --source ../include/ha_deinit_child2_3.inc -} ---echo for child3 -if ($USE_CHILD_GROUP3) -{ - --echo child3_1 - --connection child3_1 - --source ../include/ha_deinit_child3_1.inc - --echo child3_2 - --connection child3_2 - --source ../include/ha_deinit_child3_2.inc - --echo child3_3 - --connection child3_3 - --source ../include/ha_deinit_child3_3.inc -} diff --git a/storage/spider/mysql-test/spider/oracle/t/ha_test_init.inc b/storage/spider/mysql-test/spider/oracle/t/ha_test_init.inc deleted file mode 100644 index 70576ab16dc..00000000000 --- a/storage/spider/mysql-test/spider/oracle/t/ha_test_init.inc +++ /dev/null @@ -1,30 +0,0 @@ -# get connection and exist engine test ---echo for master_1 ---connection master_1 ---source ../include/ha_init_master_1.inc ---echo for child2 -if ($USE_CHILD_GROUP2) -{ - --echo child2_1 - --connection child2_1 - --source ../include/ha_init_child2_1.inc - --echo child2_2 - --connection child2_2 - --source ../include/ha_init_child2_2.inc - --echo child2_3 - --connection child2_3 - --source ../include/ha_init_child2_3.inc -} ---echo for child3 -if ($USE_CHILD_GROUP3) -{ - --echo child3_1 - --connection child3_1 - --source ../include/ha_init_child3_1.inc - --echo child3_2 - --connection child3_2 - --source ../include/ha_init_child3_2.inc - --echo child3_3 - --connection child3_3 - --source ../include/ha_init_child3_3.inc -} diff --git a/storage/spider/mysql-test/spider/oracle/t/have_engine.inc b/storage/spider/mysql-test/spider/oracle/t/have_engine.inc deleted file mode 100644 index 64bef7499cb..00000000000 --- a/storage/spider/mysql-test/spider/oracle/t/have_engine.inc +++ /dev/null @@ -1,7 +0,0 @@ -if (!`SELECT count(*) FROM information_schema.engines WHERE - (support = 'YES' OR support = 'DEFAULT') AND - engine = '$TEST_ENGINE_TYPE'`) -{ - SELECT engine, support FROM information_schema.engines; - --let $SKIP_REASON= "Need $TEST_ENGINE_TYPE engine" -} diff --git a/storage/spider/mysql-test/spider/oracle/t/have_func.inc b/storage/spider/mysql-test/spider/oracle/t/have_func.inc deleted file mode 100644 index e0823e73fc8..00000000000 --- a/storage/spider/mysql-test/spider/oracle/t/have_func.inc +++ /dev/null @@ -1,5 +0,0 @@ -if (!`SELECT count(*) FROM mysql.func WHERE name = '$TEST_FUNC_NAME'`) -{ - SELECT name FROM mysql.func; - --let $SKIP_REASON= "Need $TEST_FUNC_NAME function" -} diff --git a/storage/spider/mysql-test/spider/oracle/t/have_partition.inc b/storage/spider/mysql-test/spider/oracle/t/have_partition.inc deleted file mode 100644 index b6e699475db..00000000000 --- a/storage/spider/mysql-test/spider/oracle/t/have_partition.inc +++ /dev/null @@ -1,7 +0,0 @@ -let $HAVE_PARTITION= 0; -if (`SELECT count(*) FROM information_schema.plugins WHERE - plugin_status = 'ACTIVE' AND - plugin_name = 'partition'`) -{ - let $HAVE_PARTITION= 1; -} diff --git a/storage/spider/mysql-test/spider/oracle/t/have_trigger.inc b/storage/spider/mysql-test/spider/oracle/t/have_trigger.inc deleted file mode 100644 index 32de484b388..00000000000 --- a/storage/spider/mysql-test/spider/oracle/t/have_trigger.inc +++ /dev/null @@ -1,2 +0,0 @@ -let $HAVE_TRIGGER= `SELECT COUNT(*) FROM information_schema.tables - WHERE TABLE_SCHEMA = 'information_schema' AND TABLE_NAME = 'TRIGGERS'`; diff --git a/storage/spider/mysql-test/spider/oracle/t/hs_test_deinit.inc b/storage/spider/mysql-test/spider/oracle/t/hs_test_deinit.inc deleted file mode 100644 index 7ec2e981fd2..00000000000 --- a/storage/spider/mysql-test/spider/oracle/t/hs_test_deinit.inc +++ /dev/null @@ -1,17 +0,0 @@ -# get connection and exist engine test ---echo for master_1 ---connection master_1 ---source ../include/hs_deinit_master_1.inc ---echo for child2 -if ($USE_CHILD_GROUP2) -{ - --echo child2_1 - --connection child2_1 - --source ../include/hs_deinit_child2_1.inc - --echo child2_2 - --connection child2_2 - --source ../include/hs_deinit_child2_2.inc - --echo child2_3 - --connection child2_3 - --source ../include/hs_deinit_child2_3.inc -} diff --git a/storage/spider/mysql-test/spider/oracle/t/hs_test_init.inc b/storage/spider/mysql-test/spider/oracle/t/hs_test_init.inc deleted file mode 100644 index 831bf479524..00000000000 --- a/storage/spider/mysql-test/spider/oracle/t/hs_test_init.inc +++ /dev/null @@ -1,17 +0,0 @@ -# get connection and exist engine test ---echo for master_1 ---connection master_1 ---source ../include/hs_init_master_1.inc ---echo for child2 -if ($USE_CHILD_GROUP2) -{ - --echo child2_1 - --connection child2_1 - --source ../include/hs_init_child2_1.inc - --echo child2_2 - --connection child2_2 - --source ../include/hs_init_child2_2.inc - --echo child2_3 - --connection child2_3 - --source ../include/hs_init_child2_3.inc -} diff --git a/storage/spider/mysql-test/spider/oracle/t/slave_test_deinit.inc b/storage/spider/mysql-test/spider/oracle/t/slave_test_deinit.inc deleted file mode 100644 index e9d99b7a960..00000000000 --- a/storage/spider/mysql-test/spider/oracle/t/slave_test_deinit.inc +++ /dev/null @@ -1,6 +0,0 @@ -# get connection and exist engine test ---echo for slave1_1 ---connection slave1_1 -STOP SLAVE; ---source ../include/deinit_slave1_1.inc ---disconnect slave1_1 diff --git a/storage/spider/mysql-test/spider/oracle/t/slave_test_init.inc b/storage/spider/mysql-test/spider/oracle/t/slave_test_init.inc deleted file mode 100644 index 739d88970c5..00000000000 --- a/storage/spider/mysql-test/spider/oracle/t/slave_test_init.inc +++ /dev/null @@ -1,44 +0,0 @@ -# get connection and exist engine test ---echo for slave1_1 ---source connect_slave1_1.inc ---connection slave1_1 -SET SESSION sql_log_bin= 0; ---let $SLAVE1_1_SERVER_ID=`SELECT @@global.server_id` ---let $TEST_ENGINE_TYPE= $SLAVE1_1_ENGINE_TYPE ---source have_partition.inc ---source have_trigger.inc ---source ../include/init_slave1_1.inc ---source have_engine.inc ---let $SLAVE1_1_SLAVE_STATUS=`SHOW SLAVE STATUS` -if (!$SLAVE1_1_SLAVE_STATUS) -{ - eval CHANGE MASTER TO - MASTER_HOST = '127.0.0.1', - MASTER_USER = 'root', - MASTER_PASSWORD = '', - MASTER_PORT = $MASTER_1_MYPORT - ; -} -START SLAVE; ---connection master_1 -call mtr.add_suppression("Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT"); ---connection slave1_1 -call mtr.add_suppression("Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT"); -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - call mtr.add_suppression("Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT"); - --connection child2_2 - call mtr.add_suppression("Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT"); - --connection child2_3 - call mtr.add_suppression("Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT"); -} -if ($USE_CHILD_GROUP3) -{ - --connection child3_1 - call mtr.add_suppression("Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT"); - --connection child3_2 - call mtr.add_suppression("Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT"); - --connection child3_3 - call mtr.add_suppression("Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT"); -} diff --git a/storage/spider/mysql-test/spider/oracle/t/spider3_fixes.test b/storage/spider/mysql-test/spider/oracle/t/spider3_fixes.test deleted file mode 100644 index 962abbad19f..00000000000 --- a/storage/spider/mysql-test/spider/oracle/t/spider3_fixes.test +++ /dev/null @@ -1,292 +0,0 @@ -# This test tests for Spider 3.0's bug fixes -source include/have_log_bin.inc; ---disable_warnings ---disable_query_log ---disable_result_log ---source test_init.inc ---source slave_test_init.inc ---enable_result_log ---enable_query_log - ---echo ---echo drop and create databases ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -if ($USE_REPLICATION) -{ - --connection slave1_1 - DROP DATABASE IF EXISTS auto_test_local; - CREATE DATABASE auto_test_local; - USE auto_test_local; -} -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - CREATE DATABASE auto_test_remote; - USE auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; - CREATE DATABASE auto_test_remote2; - USE auto_test_remote2; -} ---enable_warnings - ---echo ---echo test select 1 ---connection master_1 -SELECT 1; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - SELECT 1; - --connection child2_2 - SELECT 1; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - - ---echo ---echo 3.1 ---echo auto_increment -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_INCREMENT_TABLES1; - echo CHILD2_1_CREATE_INCREMENT_TABLES1; - echo CHILD2_1_AUTO_INCREMENT_INCREMENT2; - echo CHILD2_1_AUTO_INCREMENT_OFFSET2; - } - --disable_warnings - eval $CHILD2_1_DROP_INCREMENT_TABLES1; - --enable_warnings - eval $CHILD2_1_CREATE_INCREMENT_TABLES1; - eval $CHILD2_1_AUTO_INCREMENT_INCREMENT2; - eval $CHILD2_1_AUTO_INCREMENT_OFFSET2; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -if ($USE_REPLICATION) -{ - save_master_pos; - --connection slave1_1 - sync_with_master; - --connection master_1 - --disable_query_log - SET SESSION sql_log_bin= 0; - --enable_query_log -} ---disable_warnings -DROP TABLE IF EXISTS t1, t2; ---enable_warnings ---disable_query_log -echo CREATE TABLE t1 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_INCREMENT1_1; -echo CREATE TABLE t2 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_INCREMENT1_1; -echo MASTER_1_AUTO_INCREMENT_INCREMENT2; -echo MASTER_1_AUTO_INCREMENT_OFFSET2; -eval CREATE TABLE t1 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) -) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_INCREMENT1_1; -eval CREATE TABLE t2 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) -) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_INCREMENT1_1; -eval $MASTER_1_AUTO_INCREMENT_INCREMENT2; -eval $MASTER_1_AUTO_INCREMENT_OFFSET2; -if ($USE_REPLICATION) -{ - SET SESSION sql_log_bin= 1; - --connection slave1_1 - --disable_warnings - DROP TABLE IF EXISTS t1, t2; - --enable_warnings - echo CREATE TABLE t1 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) - ) SLAVE1_1_ENGINE SLAVE1_1_CHARSET SLAVE1_1_COMMENT_INCREMENT1_1; - echo CREATE TABLE t2 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) - ) SLAVE1_1_ENGINE SLAVE1_1_CHARSET SLAVE1_1_COMMENT_INCREMENT1_1; - eval CREATE TABLE t1 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) - ) $SLAVE1_1_ENGINE $SLAVE1_1_CHARSET $SLAVE1_1_COMMENT_INCREMENT1_1; - eval CREATE TABLE t2 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) - ) $SLAVE1_1_ENGINE $SLAVE1_1_CHARSET $SLAVE1_1_COMMENT_INCREMENT1_1; - --connection master_1 -} ---enable_query_log -INSERT INTO t1 () VALUES (); -SELECT LAST_INSERT_ID(); -SELECT MAX(id) FROM t1; -INSERT INTO t2 () VALUES (); -SELECT LAST_INSERT_ID(); -SELECT MAX(id) FROM t2; ---disable_query_log -echo MASTER_1_AUTO_INCREMENT_OFFSET3; -eval $MASTER_1_AUTO_INCREMENT_OFFSET3; ---enable_query_log -INSERT INTO t1 (id) VALUES (null); -SELECT LAST_INSERT_ID(); -SELECT MAX(id) FROM t1; ---disable_query_log -echo MASTER_1_AUTO_INCREMENT_OFFSET4; -eval $MASTER_1_AUTO_INCREMENT_OFFSET4; ---enable_query_log -INSERT INTO t2 (id) VALUES (null); -SELECT LAST_INSERT_ID(); -SELECT MAX(id) FROM t2; ---disable_query_log -echo MASTER_1_AUTO_INCREMENT_OFFSET3; -eval $MASTER_1_AUTO_INCREMENT_OFFSET3; ---enable_query_log -INSERT INTO t1 () VALUES (),(),(),(); -SELECT LAST_INSERT_ID(); -SELECT id FROM t1 ORDER BY id; ---disable_query_log -echo MASTER_1_AUTO_INCREMENT_OFFSET4; -eval $MASTER_1_AUTO_INCREMENT_OFFSET4; ---enable_query_log -INSERT INTO t2 () VALUES (),(),(),(); -SELECT LAST_INSERT_ID(); -SELECT id FROM t2 ORDER BY id; -TRUNCATE TABLE t1; -TRUNCATE TABLE t2; -INSERT INTO t1 () VALUES (),(),(),(); -SELECT LAST_INSERT_ID(); -SELECT id FROM t1 ORDER BY id; -INSERT INTO t2 () VALUES (),(),(),(); -SELECT LAST_INSERT_ID(); -SELECT id FROM t2 ORDER BY id; -SET INSERT_ID=5000; ---disable_query_log -echo MASTER_1_AUTO_INCREMENT_OFFSET3; -eval $MASTER_1_AUTO_INCREMENT_OFFSET3; ---enable_query_log -INSERT INTO t1 () VALUES (); -SELECT LAST_INSERT_ID(); -SELECT MAX(id) FROM t1; ---disable_query_log -echo MASTER_1_AUTO_INCREMENT_OFFSET4; -eval $MASTER_1_AUTO_INCREMENT_OFFSET4; ---enable_query_log -INSERT INTO t2 () VALUES (); -SELECT LAST_INSERT_ID(); -SELECT MAX(id) FROM t2; -INSERT INTO t1 (id) VALUES (10000); -SELECT LAST_INSERT_ID(); -SELECT MAX(id) FROM t1; -INSERT INTO t2 (id) VALUES (1000); -SELECT LAST_INSERT_ID(); -SELECT MAX(id) FROM t2; -if ($USE_REPLICATION) -{ - save_master_pos; - --connection slave1_1 - sync_with_master; - SELECT id FROM t1 ORDER BY id; - --connection master_1 - --disable_query_log - SET SESSION sql_log_bin= 0; - --enable_query_log -} -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%insert %'; - } - eval $CHILD2_1_SELECT_INCREMENT_TABLES1; - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_AUTO_INCREMENT_INCREMENT1; - echo CHILD2_1_AUTO_INCREMENT_OFFSET1; - } - eval $CHILD2_1_AUTO_INCREMENT_INCREMENT1; - eval $CHILD2_1_AUTO_INCREMENT_OFFSET1; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - - ---echo ---echo deinit ---disable_warnings ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -if ($USE_REPLICATION) -{ - --connection slave1_1 - DROP DATABASE IF EXISTS auto_test_local; -} -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; -} ---disable_query_log ---disable_result_log ---source slave_test_deinit.inc ---source test_deinit.inc ---enable_result_log ---enable_query_log ---enable_warnings ---echo ---echo end of test diff --git a/storage/spider/mysql-test/spider/oracle/t/spider3_fixes_part.test b/storage/spider/mysql-test/spider/oracle/t/spider3_fixes_part.test deleted file mode 100644 index c609108ca9e..00000000000 --- a/storage/spider/mysql-test/spider/oracle/t/spider3_fixes_part.test +++ /dev/null @@ -1,345 +0,0 @@ -# This test tests for Spider 3.0's bug fixes -source include/have_log_bin.inc; ---disable_warnings ---disable_query_log ---disable_result_log ---source test_init.inc ---source slave_test_init.inc ---enable_result_log ---enable_query_log -if (!$HAVE_PARTITION) -{ - --disable_query_log - --disable_result_log - --source slave_test_deinit.inc - --source test_deinit.inc - --enable_result_log - --enable_query_log - --enable_warnings - skip Test requires partitioning; -} - ---echo ---echo drop and create databases ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -if ($USE_REPLICATION) -{ - --connection slave1_1 - DROP DATABASE IF EXISTS auto_test_local; - CREATE DATABASE auto_test_local; - USE auto_test_local; -} -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - CREATE DATABASE auto_test_remote; - USE auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; - CREATE DATABASE auto_test_remote2; - USE auto_test_remote2; -} ---enable_warnings - ---echo ---echo test select 1 ---connection master_1 -SELECT 1; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - SELECT 1; - --connection child2_2 - SELECT 1; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - - ---echo auto_increment with partition -if ($HAVE_PARTITION) -{ - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_INCREMENT_TABLES1; - echo CHILD2_1_CREATE_INCREMENT_TABLES1; - echo CHILD2_1_AUTO_INCREMENT_INCREMENT2; - echo CHILD2_1_AUTO_INCREMENT_OFFSET2; - } - --disable_warnings - eval $CHILD2_1_DROP_INCREMENT_TABLES1; - --enable_warnings - eval $CHILD2_1_CREATE_INCREMENT_TABLES1; - eval $CHILD2_1_AUTO_INCREMENT_INCREMENT2; - eval $CHILD2_1_AUTO_INCREMENT_OFFSET2; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_2 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_2_DROP_INCREMENT_TABLES1; - echo CHILD2_2_CREATE_INCREMENT_TABLES1; - echo CHILD2_2_AUTO_INCREMENT_INCREMENT2; - echo CHILD2_2_AUTO_INCREMENT_OFFSET2; - } - --disable_warnings - eval $CHILD2_2_DROP_INCREMENT_TABLES1; - --enable_warnings - eval $CHILD2_2_CREATE_INCREMENT_TABLES1; - eval $CHILD2_2_AUTO_INCREMENT_INCREMENT2; - eval $CHILD2_2_AUTO_INCREMENT_OFFSET2; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - if ($USE_REPLICATION) - { - save_master_pos; - --connection slave1_1 - sync_with_master; - --connection master_1 - --disable_query_log - SET SESSION sql_log_bin= 0; - --enable_query_log - } - --disable_warnings - DROP TABLE IF EXISTS t1, t2; - --enable_warnings - --disable_query_log - echo CREATE TABLE t1 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) - ) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_INCREMENT1_P_1; - echo CREATE TABLE t2 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) - ) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_INCREMENT1_P_1; - echo MASTER_1_AUTO_INCREMENT_INCREMENT2; - echo MASTER_1_AUTO_INCREMENT_OFFSET2; - eval CREATE TABLE t1 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_INCREMENT1_P_1; - eval CREATE TABLE t2 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_INCREMENT1_P_1; - eval $MASTER_1_AUTO_INCREMENT_INCREMENT2; - eval $MASTER_1_AUTO_INCREMENT_OFFSET2; - if ($USE_REPLICATION) - { - SET SESSION sql_log_bin= 1; - --connection slave1_1 - --disable_warnings - DROP TABLE IF EXISTS t1, t2; - --enable_warnings - echo CREATE TABLE t1 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) - ) SLAVE1_1_ENGINE SLAVE1_1_CHARSET SLAVE1_1_COMMENT_INCREMENT1_P_1; - echo CREATE TABLE t2 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) - ) SLAVE1_1_ENGINE SLAVE1_1_CHARSET SLAVE1_1_COMMENT_INCREMENT1_P_1; - eval CREATE TABLE t1 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) - ) $SLAVE1_1_ENGINE $SLAVE1_1_CHARSET $SLAVE1_1_COMMENT_INCREMENT1_P_1; - eval CREATE TABLE t2 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) - ) $SLAVE1_1_ENGINE $SLAVE1_1_CHARSET $SLAVE1_1_COMMENT_INCREMENT1_P_1; - --connection master_1 - } - --enable_query_log - INSERT INTO t1 () VALUES (); - SELECT LAST_INSERT_ID(); - SELECT MAX(id) FROM t1; - INSERT INTO t2 () VALUES (); - SELECT LAST_INSERT_ID(); - SELECT MAX(id) FROM t2; - --disable_query_log - echo MASTER_1_AUTO_INCREMENT_OFFSET3; - eval $MASTER_1_AUTO_INCREMENT_OFFSET3; - --enable_query_log - INSERT INTO t1 (id) VALUES (null); - SELECT LAST_INSERT_ID(); - SELECT MAX(id) FROM t1; - --disable_query_log - echo MASTER_1_AUTO_INCREMENT_OFFSET4; - eval $MASTER_1_AUTO_INCREMENT_OFFSET4; - --enable_query_log - INSERT INTO t2 (id) VALUES (null); - SELECT LAST_INSERT_ID(); - SELECT MAX(id) FROM t2; - --disable_query_log - echo MASTER_1_AUTO_INCREMENT_OFFSET3; - eval $MASTER_1_AUTO_INCREMENT_OFFSET3; - --enable_query_log - INSERT INTO t1 () VALUES (),(),(),(); - SELECT LAST_INSERT_ID(); - SELECT id FROM t1 ORDER BY id; - --disable_query_log - echo MASTER_1_AUTO_INCREMENT_OFFSET4; - eval $MASTER_1_AUTO_INCREMENT_OFFSET4; - --enable_query_log - INSERT INTO t2 () VALUES (),(),(),(); - SELECT LAST_INSERT_ID(); - SELECT id FROM t2 ORDER BY id; - TRUNCATE TABLE t1; - TRUNCATE TABLE t2; - INSERT INTO t1 () VALUES (),(),(),(); - SELECT LAST_INSERT_ID(); - SELECT id FROM t1 ORDER BY id; - INSERT INTO t2 () VALUES (),(),(),(); - SELECT LAST_INSERT_ID(); - SELECT id FROM t2 ORDER BY id; - SET INSERT_ID=5000; - --disable_query_log - echo MASTER_1_AUTO_INCREMENT_OFFSET3; - eval $MASTER_1_AUTO_INCREMENT_OFFSET3; - --enable_query_log - INSERT INTO t1 () VALUES (); - SELECT LAST_INSERT_ID(); - SELECT MAX(id) FROM t1; - --disable_query_log - echo MASTER_1_AUTO_INCREMENT_OFFSET4; - eval $MASTER_1_AUTO_INCREMENT_OFFSET4; - --enable_query_log - INSERT INTO t2 () VALUES (); - SELECT LAST_INSERT_ID(); - SELECT MAX(id) FROM t2; - INSERT INTO t1 (id) VALUES (10000); - SELECT LAST_INSERT_ID(); - SELECT MAX(id) FROM t1; - INSERT INTO t2 (id) VALUES (1000); - SELECT LAST_INSERT_ID(); - SELECT MAX(id) FROM t2; - if ($USE_REPLICATION) - { - save_master_pos; - --connection slave1_1 - sync_with_master; - SELECT id FROM t1 ORDER BY id; - --connection master_1 - --disable_query_log - SET SESSION sql_log_bin= 0; - --enable_query_log - } - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%insert %'; - } - eval $CHILD2_1_SELECT_INCREMENT_TABLES1; - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_AUTO_INCREMENT_INCREMENT1; - echo CHILD2_1_AUTO_INCREMENT_OFFSET1; - } - eval $CHILD2_1_AUTO_INCREMENT_INCREMENT1; - eval $CHILD2_1_AUTO_INCREMENT_OFFSET1; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%insert %'; - } - eval $CHILD2_2_SELECT_INCREMENT_TABLES1; - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_2_AUTO_INCREMENT_INCREMENT1; - echo CHILD2_2_AUTO_INCREMENT_OFFSET1; - } - eval $CHILD2_2_AUTO_INCREMENT_INCREMENT1; - eval $CHILD2_2_AUTO_INCREMENT_OFFSET1; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } -} - - ---echo ---echo deinit ---disable_warnings ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -if ($USE_REPLICATION) -{ - --connection slave1_1 - DROP DATABASE IF EXISTS auto_test_local; -} -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; -} ---disable_query_log ---disable_result_log ---source slave_test_deinit.inc ---source test_deinit.inc ---enable_result_log ---enable_query_log ---enable_warnings ---echo ---echo end of test diff --git a/storage/spider/mysql-test/spider/oracle/t/spider_fixes.test b/storage/spider/mysql-test/spider/oracle/t/spider_fixes.test deleted file mode 100644 index d0158c7dc0b..00000000000 --- a/storage/spider/mysql-test/spider/oracle/t/spider_fixes.test +++ /dev/null @@ -1,1419 +0,0 @@ -# This test tests for Spider's bug fixes -source include/have_log_bin.inc; ---disable_warnings ---disable_query_log ---disable_result_log ---source test_init.inc ---source slave_test_init.inc ---enable_result_log ---enable_query_log - ---echo ---echo drop and create databases ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -if ($USE_REPLICATION) -{ - --connection slave1_1 - DROP DATABASE IF EXISTS auto_test_local; - CREATE DATABASE auto_test_local; - USE auto_test_local; -} -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - CREATE DATABASE auto_test_remote; - USE auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; - CREATE DATABASE auto_test_remote2; - USE auto_test_remote2; -} ---enable_warnings - ---echo ---echo test select 1 ---connection master_1 -SELECT 1; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - SELECT 1; - --connection child2_2 - SELECT 1; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo create table and insert -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_TABLES; - echo CHILD2_1_CREATE_TABLES; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 ---disable_warnings -DROP TABLE IF EXISTS tb_l; ---enable_warnings ---disable_query_log -echo CREATE TABLE tb_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) MASTER_1_ENGINE2 MASTER_1_CHARSET2; -eval CREATE TABLE tb_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) $MASTER_1_ENGINE2 $MASTER_1_CHARSET2; ---enable_query_log -INSERT INTO tb_l (a, b, c) VALUES - (1, 'a', '2008-08-01 10:21:39'), - (2, 'b', '2000-01-01 00:00:00'), - (3, 'e', '2007-06-04 20:03:11'), - (4, 'd', '2003-11-30 05:01:03'), - (5, 'c', '2001-12-31 23:59:59'); ---disable_warnings -DROP TABLE IF EXISTS ta_l; ---enable_warnings ---disable_query_log -echo CREATE TABLE ta_l ( - PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_2_1; -eval CREATE TABLE ta_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_2_1; ---enable_query_log -INSERT INTO ta_l SELECT a, b, c FROM tb_l; - ---echo ---echo 2.13 ---echo select table with "order by desc" and "<" -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l -WHERE a < 5 ORDER BY a DESC LIMIT 3; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo select table with "order by desc" and "<=" -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l -WHERE a <= 5 ORDER BY a DESC LIMIT 3; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo 2.14 ---echo update table with range scan and split_read -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -UPDATE ta_l SET c = '2000-02-02 00:00:00' WHERE a > 1; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo 2.15 ---echo select table with range scan -TRUNCATE TABLE ta_l; ---disable_warnings -DROP TABLE IF EXISTS ta_l; ---enable_warnings -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_TABLES6; - echo CHILD2_1_CREATE_TABLES6; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES6; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES6; - --enable_query_log - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_result_log - } -} ---connection master_1 ---disable_query_log -echo CREATE TABLE ta_l ( - a int(11) NOT NULL DEFAULT '0', - b char(1) DEFAULT NULL, - c datetime DEFAULT NULL, - PRIMARY KEY (a, b, c) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT5_2_1; -eval CREATE TABLE ta_l ( - a int(11) NOT NULL DEFAULT '0', - b char(1) DEFAULT NULL, - c datetime DEFAULT NULL, - PRIMARY KEY (a, b, c) -) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT5_2_1; ---enable_query_log -INSERT INTO ta_l SELECT a, b, c FROM tb_l; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a = 4 AND b >= 'b' -AND c = '2003-11-30 05:01:03'; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a = 4 AND b > 'b' -AND c = '2003-11-30 05:01:03'; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a >= 4 AND b = 'd' -AND c = '2003-11-30 05:01:03'; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a > 4 AND b = 'c' -AND c = '2001-12-31 23:59:59'; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a = 4 AND b <= 'd' -AND c = '2003-11-30 05:01:03'; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a = 4 AND b < 'e' -AND c = '2003-11-30 05:01:03'; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a <= 4 AND b = 'b' -AND c = '2000-01-01 00:00:00'; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a < 4 AND b = 'b' -AND c = '2000-01-01 00:00:00'; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a = 4 AND b >= 'b' -AND b <= 'd' AND c = '2003-11-30 05:01:03'; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a = 4 AND b > 'b' -AND b < 'e' AND c = '2003-11-30 05:01:03'; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a <= 4 AND a >= 1 -AND b >= 'b' AND c = '2003-11-30 05:01:03'; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a < 4 AND a > 1 -AND b >= 'b' AND c = '2000-01-01 00:00:00'; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo 2.16 ---echo auto_increment insert with trigger -if ($HAVE_TRIGGER) -{ - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_result_log - } - --disable_query_log - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - echo CHILD2_1_DROP_TABLES4; - echo CHILD2_1_CREATE_TABLES4; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES4; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES4; - --enable_query_log - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_result_log - } - } - --connection master_1 - --disable_query_log - echo CREATE TABLE ta_l_auto_inc ( - a INT AUTO_INCREMENT, - b CHAR(1) DEFAULT 'c', - c DATETIME DEFAULT '1999-10-10 10:10:10', - PRIMARY KEY(a) - ) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT3_2_1; - eval CREATE TABLE ta_l_auto_inc ( - a INT AUTO_INCREMENT, - b CHAR(1) DEFAULT 'c', - c DATETIME DEFAULT '1999-10-10 10:10:10', - PRIMARY KEY(a) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT3_2_1; - echo CREATE TABLE tc_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) - ) MASTER_1_ENGINE2 MASTER_1_CHARSET2; - eval CREATE TABLE tc_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) - ) $MASTER_1_ENGINE2 $MASTER_1_CHARSET2; - --enable_query_log - --eval CREATE TRIGGER ins_ta_l_auto_inc AFTER INSERT ON ta_l_auto_inc FOR EACH ROW BEGIN INSERT INTO tc_l (a, b, c) VALUES (NEW.a, NEW.b, NEW.c); END; - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - INSERT INTO ta_l_auto_inc (a, b, c) VALUES - (NULL, 's', '2008-12-31 20:59:59'); - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%insert %'; - } - eval $CHILD2_1_SELECT_TABLES4; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM tc_l ORDER BY a; -} - ---echo ---echo 2.17 ---echo engine-condition-pushdown with "or" and joining -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l WHERE a = 1 OR a IN (SELECT a FROM tb_l); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo 2.23 ---echo index merge -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_result_log - } - --disable_query_log - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - echo CHILD2_1_DROP_TABLES5; - echo CHILD2_1_CREATE_TABLES5; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES5; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES5; - --enable_query_log - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_result_log - } -} ---connection master_1 ---disable_query_log -echo CREATE TABLE ta_l_int ( - a INT AUTO_INCREMENT, - b INT DEFAULT 10, - c INT DEFAULT 11, - PRIMARY KEY(a), - KEY idx1(b), - KEY idx2(c) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT4_2_1; -eval CREATE TABLE ta_l_int ( - a INT AUTO_INCREMENT, - b INT DEFAULT 10, - c INT DEFAULT 11, - PRIMARY KEY(a), - KEY idx1(b), - KEY idx2(c) -) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT4_2_1; ---enable_query_log -INSERT INTO ta_l_int (a, b, c) VALUES (1, 2, 3); -INSERT INTO ta_l_int (a, b, c) SELECT a + 1, b + 1, c + 1 FROM ta_l_int; -INSERT INTO ta_l_int (a, b, c) SELECT a + 2, b + 2, c + 2 FROM ta_l_int; -INSERT INTO ta_l_int (a, b, c) SELECT a + 4, b + 4, c + 4 FROM ta_l_int; -INSERT INTO ta_l_int (a, b, c) SELECT a + 8, b + 8, c + 8 FROM ta_l_int; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, c FROM ta_l_int force index(primary, idx1, idx2) -WHERE a = 5 OR b = 5 OR c = 5 ORDER BY a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo 2.24 ---echo index scan update without PK ---connection master_1 ---disable_warnings -DROP TABLE IF EXISTS ta_l_int; ---enable_warnings ---disable_query_log -echo CREATE TABLE ta_l_int ( - a INT NOT NULL, - b INT DEFAULT 10, - c INT DEFAULT 11, - KEY idx1(b), - KEY idx2(c) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT4_2_1; -if ($MASTER_1_NEEDPK) -{ - --error ER_REQUIRES_PRIMARY_KEY - eval CREATE TABLE ta_l_int ( - a INT NOT NULL, - b INT DEFAULT 10, - c INT DEFAULT 11, - KEY idx1(b), - KEY idx2(c) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT4_2_1; - eval CREATE TABLE ta_l_int ( - a INT NOT NULL, - b INT DEFAULT 10, - c INT DEFAULT 11, - PRIMARY KEY(a), - KEY idx1(b), - KEY idx2(c) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT4_2_1; -} -if (!$MASTER_1_NEEDPK) -{ - eval CREATE TABLE ta_l_int ( - a INT NOT NULL, - b INT DEFAULT 10, - c INT DEFAULT 11, - KEY idx1(b), - KEY idx2(c) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT4_2_1; -} ---enable_query_log -SELECT a, b, c FROM ta_l_int ORDER BY a; -INSERT INTO ta_l_int (a, b, c) VALUES (0, 2, 3); -INSERT INTO ta_l_int (a, b, c) VALUES (18, 2, 3); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -UPDATE ta_l_int SET c = 4 WHERE b = 2; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%update %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, c FROM ta_l_int ORDER BY a; - - ---echo ---echo 2.25 ---echo direct order limit ---connection master_1 -eval $MASTER_1_CHECK_DIRECT_ORDER_LIMIT_STATUS; -SELECT a, b, c FROM ta_l_int ORDER BY a LIMIT 3; -eval $MASTER_1_CHECK_DIRECT_ORDER_LIMIT_STATUS; - - ---echo ---echo 2.26 ---echo lock tables -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_LOCK_TABLES1; - echo CHILD2_1_DROP_LOCK_TABLES2; - echo CHILD2_1_CREATE_LOCK_TABLES1; - echo CHILD2_1_CREATE_LOCK_TABLES2; - } - --disable_warnings - eval $CHILD2_1_DROP_LOCK_TABLES1; - eval $CHILD2_1_DROP_LOCK_TABLES2; - --enable_warnings - eval $CHILD2_1_CREATE_LOCK_TABLES1; - eval $CHILD2_1_CREATE_LOCK_TABLES2; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_2 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_2_DROP_LOCK_TABLES1; - echo CHILD2_2_DROP_LOCK_TABLES2; - echo CHILD2_2_CREATE_LOCK_TABLES1; - echo CHILD2_2_CREATE_LOCK_TABLES2; - } - --disable_warnings - eval $CHILD2_2_DROP_LOCK_TABLES1; - eval $CHILD2_2_DROP_LOCK_TABLES2; - --enable_warnings - eval $CHILD2_2_CREATE_LOCK_TABLES1; - eval $CHILD2_2_CREATE_LOCK_TABLES2; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 ---disable_warnings -DROP TABLE IF EXISTS t1; -DROP TABLE IF EXISTS t2; ---enable_warnings ---disable_query_log -echo CREATE TABLE t1 ( - id int(11) NOT NULL, - PRIMARY KEY (id) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_LOCK1; -eval CREATE TABLE t1 ( - id int(11) NOT NULL, - PRIMARY KEY (id) -) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_LOCK1; -echo CREATE TABLE t2 ( - id int(11) NOT NULL, - PRIMARY KEY (id) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_LOCK2; -eval CREATE TABLE t2 ( - id int(11) NOT NULL, - PRIMARY KEY (id) -) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_LOCK2; ---enable_query_log -LOCK TABLES t1 READ, t2 READ; -UNLOCK TABLES; - - ---echo ---echo auto_increment -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_INCREMENT_TABLES1; - echo CHILD2_1_CREATE_INCREMENT_TABLES1; - echo CHILD2_1_AUTO_INCREMENT_INCREMENT2; - echo CHILD2_1_AUTO_INCREMENT_OFFSET2; - } - --disable_warnings - eval $CHILD2_1_DROP_INCREMENT_TABLES1; - --enable_warnings - eval $CHILD2_1_CREATE_INCREMENT_TABLES1; - eval $CHILD2_1_AUTO_INCREMENT_INCREMENT2; - eval $CHILD2_1_AUTO_INCREMENT_OFFSET2; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -if ($USE_REPLICATION) -{ - save_master_pos; - --connection slave1_1 - sync_with_master; - --connection master_1 - --disable_query_log - SET SESSION sql_log_bin= 0; - --enable_query_log -} ---disable_warnings -DROP TABLE IF EXISTS t1; ---enable_warnings ---disable_query_log -echo CREATE TABLE t1 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_INCREMENT1_1; -echo MASTER_1_AUTO_INCREMENT_INCREMENT2; -echo MASTER_1_AUTO_INCREMENT_OFFSET2; -eval CREATE TABLE t1 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) -) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_INCREMENT1_1; -eval $MASTER_1_AUTO_INCREMENT_INCREMENT2; -eval $MASTER_1_AUTO_INCREMENT_OFFSET2; -if ($USE_REPLICATION) -{ - SET SESSION sql_log_bin= 1; - --connection slave1_1 - --disable_warnings - DROP TABLE IF EXISTS t1; - --enable_warnings - echo CREATE TABLE t1 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) - ) SLAVE1_1_ENGINE SLAVE1_1_CHARSET SLAVE1_1_COMMENT_INCREMENT1_1; - eval CREATE TABLE t1 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) - ) $SLAVE1_1_ENGINE $SLAVE1_1_CHARSET $SLAVE1_1_COMMENT_INCREMENT1_1; - --connection master_1 -} ---enable_query_log -INSERT INTO t1 () VALUES (); -SELECT LAST_INSERT_ID(); -SELECT MAX(id) FROM t1; -INSERT INTO t1 () VALUES (); -SELECT LAST_INSERT_ID(); -SELECT MAX(id) FROM t1; -INSERT INTO t1 (id) VALUES (null); -SELECT LAST_INSERT_ID(); -SELECT MAX(id) FROM t1; -INSERT INTO t1 (id) VALUES (null); -SELECT LAST_INSERT_ID(); -SELECT MAX(id) FROM t1; -INSERT INTO t1 () VALUES (),(),(),(); -SELECT LAST_INSERT_ID(); -SELECT id FROM t1 ORDER BY id; -SET INSERT_ID=5000; -INSERT INTO t1 () VALUES (); -SELECT LAST_INSERT_ID(); -SELECT MAX(id) FROM t1; -INSERT INTO t1 (id) VALUES (10000); -SELECT LAST_INSERT_ID(); -SELECT MAX(id) FROM t1; -INSERT INTO t1 (id) VALUES (1000); -SELECT LAST_INSERT_ID(); -SELECT MAX(id) FROM t1; -if ($USE_REPLICATION) -{ - save_master_pos; - --connection slave1_1 - sync_with_master; - SELECT id FROM t1 ORDER BY id; - --connection master_1 - --disable_query_log - SET SESSION sql_log_bin= 0; - --enable_query_log -} -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%insert %'; - } - eval $CHILD2_1_SELECT_INCREMENT_TABLES1; - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_AUTO_INCREMENT_INCREMENT1; - echo CHILD2_1_AUTO_INCREMENT_OFFSET1; - } - eval $CHILD2_1_AUTO_INCREMENT_INCREMENT1; - eval $CHILD2_1_AUTO_INCREMENT_OFFSET1; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - - ---echo ---echo read only -let $MASTER_1_ENGINE_IS_SPIDER= - `SELECT IF('$MASTER_1_ENGINE_TYPE' = 'Spider' OR - '$MASTER_1_HIDDEN_ENGINE_TYPE' = 'Spider', 1, 0)`; -if ($MASTER_1_ENGINE_IS_SPIDER) -{ - --connection master_1 - --disable_warnings - DROP TABLE IF EXISTS t1; - --enable_warnings - --disable_query_log - echo CREATE TABLE t1 ( - id int(11) NOT NULL, - PRIMARY KEY (id) - ) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_READONLY1_1; - eval CREATE TABLE t1 ( - id int(11) NOT NULL, - PRIMARY KEY (id) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_READONLY1_1; - --let $MIN_VAL= `SELECT MIN(id) FROM t1` - --enable_query_log - SELECT id FROM t1 ORDER BY id; - --error 12518 - INSERT INTO t1 (id) VALUES (1); - --error 12518 - eval UPDATE t1 SET id = 4 WHERE id = $MIN_VAL; - --error 12518 - eval DELETE FROM t1 WHERE id = $MIN_VAL; - --error 12518 - DELETE FROM t1; - --error 12518 - TRUNCATE t1; -} -if (!$MASTER_1_ENGINE_IS_SPIDER) -{ - --echo skipped -} - - ---echo ---echo 2.27 ---echo error mode -if ($MASTER_1_ENGINE_IS_SPIDER) -{ - --connection master_1 - --disable_warnings - DROP TABLE IF EXISTS t1; - --enable_warnings - --disable_query_log - echo CREATE TABLE t1 ( - id int(11) NOT NULL, - PRIMARY KEY (id) - ) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_ERROR_MODE1_1; - eval CREATE TABLE t1 ( - id int(11) NOT NULL, - PRIMARY KEY (id) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_ERROR_MODE1_1; - --enable_query_log - SELECT id FROM t1 ORDER BY id; - INSERT INTO t1 (id) VALUES (1); - DELETE FROM t1; - TRUNCATE t1; -} -if (!$MASTER_1_ENGINE_IS_SPIDER) -{ - --echo skipped -} - - ---echo ---echo 3.0 ---echo is null -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_result_log - } - --disable_query_log - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - echo CHILD2_1_DROP_TEXT_KEY_TABLES1; - echo CHILD2_1_CREATE_TEXT_KEY_TABLES1; - } - --disable_warnings - eval $CHILD2_1_DROP_TEXT_KEY_TABLES1; - --enable_warnings - eval $CHILD2_1_CREATE_TEXT_KEY_TABLES1; - --enable_query_log - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_result_log - } -} ---connection master_1 ---disable_warnings -DROP TABLE IF EXISTS t1; ---enable_warnings ---disable_query_log -echo CREATE TABLE t1 ( - a VARCHAR(255), - b VARCHAR(255), - c VARCHAR(255), - KEY idx1(a,b), - KEY idx2(b), - PRIMARY KEY(c) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_TEXT_KEY1_1; -eval CREATE TABLE t1 ( - a VARCHAR(255), - b VARCHAR(255), - c VARCHAR(255), - KEY idx1(a,b), - KEY idx2(b), - PRIMARY KEY(c) -) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_TEXT_KEY1_1; ---enable_query_log -insert into t1 values (null, null, '2048'); -insert into t1 values ('1', '1', '1'); -insert into t1 select a + 1, b + 1, c + 1 from t1; -insert into t1 select a + 2, b + 2, c + 2 from t1; -insert into t1 select a + 4, b + 4, c + 4 from t1; -insert into t1 select a + 8, b + 8, c + 8 from t1; -insert into t1 select a + 16, b + 16, c + 16 from t1; -insert into t1 select a + 32, b + 32, c + 32 from t1; -insert into t1 select a + 64, b + 64, c + 64 from t1; -insert into t1 select a + 128, b + 128, c + 128 from t1; -insert into t1 select a + 256, b + 256, c + 256 from t1; -insert into t1 select a + 512, b + 512, c + 512 from t1; -flush tables; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -select a from t1 where a is null order by a limit 30; -select b from t1 where b is null order by b limit 30; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_1_SELECT_TEXT_PK_TABLES1; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - - ---echo ---echo direct_order_limit ---connection master_1 -TRUNCATE TABLE t1; -insert into t1 values ('1', '1', '1'); -insert into t1 select a + 1, b + 1, c + 1 from t1; -insert into t1 select a + 2, b + 2, c + 2 from t1; -insert into t1 select a + 4, b + 4, c + 4 from t1; -insert into t1 select a + 8, b + 8, c + 8 from t1; -insert into t1 select a + 16, b + 16, c + 16 from t1; -insert into t1 select a, b + 32, c + 32 from t1; -insert into t1 select a, b + 64, c + 64 from t1; -insert into t1 select a, b + 128, c + 128 from t1; -flush tables; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -select a, b, c from t1 where a = '10' and b <> '100' order by c desc limit 5; -select a, c from t1 where a = '10' order by b desc limit 5; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_1_SELECT_TEXT_PK_TABLES1; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - - ---echo ---echo deinit ---disable_warnings ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -if ($USE_REPLICATION) -{ - --connection slave1_1 - DROP DATABASE IF EXISTS auto_test_local; -} -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; -} ---disable_query_log ---disable_result_log ---source slave_test_deinit.inc ---source test_deinit.inc ---enable_result_log ---enable_query_log ---enable_warnings ---echo ---echo end of test diff --git a/storage/spider/mysql-test/spider/oracle/t/spider_fixes_part.test b/storage/spider/mysql-test/spider/oracle/t/spider_fixes_part.test deleted file mode 100644 index 3053b0008e7..00000000000 --- a/storage/spider/mysql-test/spider/oracle/t/spider_fixes_part.test +++ /dev/null @@ -1,645 +0,0 @@ -# This test tests for Spider's bug fixes -source include/have_log_bin.inc; ---disable_warnings ---disable_query_log ---disable_result_log ---source test_init.inc ---source slave_test_init.inc ---enable_result_log ---enable_query_log -if (!$HAVE_PARTITION) -{ - --disable_query_log - --disable_result_log - --source slave_test_deinit.inc - --source test_deinit.inc - --enable_result_log - --enable_query_log - --enable_warnings - skip Test requires partitioning; -} - ---echo ---echo drop and create databases ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -if ($USE_REPLICATION) -{ - --connection slave1_1 - DROP DATABASE IF EXISTS auto_test_local; - CREATE DATABASE auto_test_local; - USE auto_test_local; -} -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - CREATE DATABASE auto_test_remote; - USE auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; - CREATE DATABASE auto_test_remote2; - USE auto_test_remote2; -} ---enable_warnings - ---echo ---echo test select 1 ---connection master_1 -SELECT 1; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - SELECT 1; - --connection child2_2 - SELECT 1; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---connection master_1 ---disable_warnings -DROP TABLE IF EXISTS tb_l; ---enable_warnings ---disable_query_log -echo CREATE TABLE tb_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) MASTER_1_ENGINE2 MASTER_1_CHARSET2; -eval CREATE TABLE tb_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) $MASTER_1_ENGINE2 $MASTER_1_CHARSET2; ---enable_query_log -INSERT INTO tb_l (a, b, c) VALUES - (1, 'a', '2008-08-01 10:21:39'), - (2, 'b', '2000-01-01 00:00:00'), - (3, 'e', '2007-06-04 20:03:11'), - (4, 'd', '2003-11-30 05:01:03'), - (5, 'c', '2001-12-31 23:59:59'); - ---echo ---echo 2.17 ---echo partition with sort -if ($HAVE_PARTITION) -{ - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_2_DROP_TABLES; - echo CHILD2_2_CREATE_TABLES; - } - --disable_warnings - eval $CHILD2_2_DROP_TABLES; - --enable_warnings - eval $CHILD2_2_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_TABLES2; - echo CHILD2_1_CREATE_TABLES2; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES2; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES2; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - --disable_query_log - echo CREATE TABLE ta_l2 ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) - ) MASTER_1_ENGINE MASTER_1_COMMENT2_P_2_1; - eval CREATE TABLE ta_l2 ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) - ) $MASTER_1_ENGINE $MASTER_1_COMMENT2_P_2_1; - --enable_query_log - INSERT INTO ta_l2 SELECT a, b, c FROM tb_l; - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 WHERE a > 1 - ORDER BY a; - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_2_SELECT_TABLES; - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_1_SELECT_TABLES2; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } -} - ---echo ---echo 2.23 ---echo partition update with moving partition -if ($HAVE_PARTITION) -{ - --connection master_1 - --disable_warnings - DROP TABLE IF EXISTS ta_l2; - --enable_warnings - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_2_DROP_TABLES; - echo CHILD2_2_CREATE_TABLES; - } - --disable_warnings - eval $CHILD2_2_DROP_TABLES; - --enable_warnings - eval $CHILD2_2_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_TABLES2; - echo CHILD2_1_CREATE_TABLES2; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES2; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES2; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - --disable_query_log - echo CREATE TABLE ta_l2 ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) - ) MASTER_1_ENGINE MASTER_1_COMMENT2_P_2_1; - eval CREATE TABLE ta_l2 ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) - ) $MASTER_1_ENGINE $MASTER_1_COMMENT2_P_2_1; - --enable_query_log - INSERT INTO ta_l2 (a, b, c) VALUES (3, 'B', '2010-09-26 00:00:00'); - UPDATE ta_l2 SET a = 4 WHERE a = 3; - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2; - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%insert %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%update %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%delete %'; - } - eval $CHILD2_2_SELECT_TABLES; - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%insert %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%update %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%delete %'; - } - eval $CHILD2_1_SELECT_TABLES2; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } -} - ---echo index merge with partition -if ($HAVE_PARTITION) -{ - --connection master_1 - --disable_warnings - DROP TABLE IF EXISTS ta_l_int; - --enable_warnings - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_result_log - } - --disable_query_log - --connection child2_2 - if ($OUTPUT_CHILD_GROUP2) - { - echo CHILD2_2_DROP_TABLES5; - echo CHILD2_2_CREATE_TABLES5; - } - --disable_warnings - eval $CHILD2_2_DROP_TABLES5; - --enable_warnings - eval $CHILD2_2_CREATE_TABLES5; - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - echo CHILD2_1_DROP_TABLES5; - echo CHILD2_1_CREATE_TABLES5; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES5; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES5; - --enable_query_log - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_result_log - } - } - --connection master_1 - --disable_query_log - echo CREATE TABLE ta_l_int ( - a INT AUTO_INCREMENT, - b INT DEFAULT 10, - c INT DEFAULT 11, - PRIMARY KEY(a), - KEY idx1(b), - KEY idx2(c) - ) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT3_P_2_1; - eval CREATE TABLE ta_l_int ( - a INT AUTO_INCREMENT, - b INT DEFAULT 10, - c INT DEFAULT 11, - PRIMARY KEY(a), - KEY idx1(b), - KEY idx2(c) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT3_P_2_1; - --enable_query_log - INSERT INTO ta_l_int (a, b, c) VALUES (1, 2, 3); - INSERT INTO ta_l_int (a, b, c) SELECT a + 1, b + 1, c + 1 FROM ta_l_int; - INSERT INTO ta_l_int (a, b, c) SELECT a + 2, b + 2, c + 2 FROM ta_l_int; - INSERT INTO ta_l_int (a, b, c) SELECT a + 4, b + 4, c + 4 FROM ta_l_int; - INSERT INTO ta_l_int (a, b, c) SELECT a + 8, b + 8, c + 8 FROM ta_l_int; - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - SELECT a, b, c FROM ta_l_int force index(primary, idx1, idx2) - WHERE a = 5 OR b = 5 OR c = 5 ORDER BY a; - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } -} - - ---echo ---echo 2.26 ---echo auto_increment with partition -if ($HAVE_PARTITION) -{ - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_INCREMENT_TABLES1; - echo CHILD2_1_CREATE_INCREMENT_TABLES1; - echo CHILD2_1_AUTO_INCREMENT_INCREMENT2; - echo CHILD2_1_AUTO_INCREMENT_OFFSET2; - } - --disable_warnings - eval $CHILD2_1_DROP_INCREMENT_TABLES1; - --enable_warnings - eval $CHILD2_1_CREATE_INCREMENT_TABLES1; - eval $CHILD2_1_AUTO_INCREMENT_INCREMENT2; - eval $CHILD2_1_AUTO_INCREMENT_OFFSET2; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_2 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_2_DROP_INCREMENT_TABLES1; - echo CHILD2_2_CREATE_INCREMENT_TABLES1; - echo CHILD2_2_AUTO_INCREMENT_INCREMENT2; - echo CHILD2_2_AUTO_INCREMENT_OFFSET2; - } - --disable_warnings - eval $CHILD2_2_DROP_INCREMENT_TABLES1; - --enable_warnings - eval $CHILD2_2_CREATE_INCREMENT_TABLES1; - eval $CHILD2_2_AUTO_INCREMENT_INCREMENT2; - eval $CHILD2_2_AUTO_INCREMENT_OFFSET2; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - if ($USE_REPLICATION) - { - save_master_pos; - --connection slave1_1 - sync_with_master; - --connection master_1 - --disable_query_log - SET SESSION sql_log_bin= 0; - --enable_query_log - } - --disable_warnings - DROP TABLE IF EXISTS t1; - --enable_warnings - --disable_query_log - echo CREATE TABLE t1 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) - ) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_INCREMENT1_P_1; - echo MASTER_1_AUTO_INCREMENT_INCREMENT2; - echo MASTER_1_AUTO_INCREMENT_OFFSET2; - eval CREATE TABLE t1 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_INCREMENT1_P_1; - eval $MASTER_1_AUTO_INCREMENT_INCREMENT2; - eval $MASTER_1_AUTO_INCREMENT_OFFSET2; - if ($USE_REPLICATION) - { - SET SESSION sql_log_bin= 1; - --connection slave1_1 - --disable_warnings - DROP TABLE IF EXISTS t1; - --enable_warnings - echo CREATE TABLE t1 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) - ) SLAVE1_1_ENGINE SLAVE1_1_CHARSET SLAVE1_1_COMMENT_INCREMENT1_P_1; - eval CREATE TABLE t1 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) - ) $SLAVE1_1_ENGINE $SLAVE1_1_CHARSET $SLAVE1_1_COMMENT_INCREMENT1_P_1; - --connection master_1 - } - --enable_query_log - INSERT INTO t1 () VALUES (); - SELECT LAST_INSERT_ID(); - SELECT MAX(id) FROM t1; - INSERT INTO t1 () VALUES (); - SELECT LAST_INSERT_ID(); - SELECT MAX(id) FROM t1; - INSERT INTO t1 (id) VALUES (null); - SELECT LAST_INSERT_ID(); - SELECT MAX(id) FROM t1; - INSERT INTO t1 (id) VALUES (null); - SELECT LAST_INSERT_ID(); - SELECT MAX(id) FROM t1; - INSERT INTO t1 () VALUES (),(),(),(); - SELECT LAST_INSERT_ID(); - SELECT id FROM t1 ORDER BY id; - SET INSERT_ID=5000; - INSERT INTO t1 () VALUES (); - SELECT LAST_INSERT_ID(); - SELECT MAX(id) FROM t1; - INSERT INTO t1 (id) VALUES (10000); - SELECT LAST_INSERT_ID(); - SELECT MAX(id) FROM t1; - INSERT INTO t1 (id) VALUES (1000); - SELECT LAST_INSERT_ID(); - SELECT MAX(id) FROM t1; - if ($USE_REPLICATION) - { - save_master_pos; - --connection slave1_1 - sync_with_master; - SELECT id FROM t1 ORDER BY id; - --connection master_1 - --disable_query_log - SET SESSION sql_log_bin= 0; - --enable_query_log - } - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%insert %'; - } - eval $CHILD2_1_SELECT_INCREMENT_TABLES1; - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_AUTO_INCREMENT_INCREMENT1; - echo CHILD2_1_AUTO_INCREMENT_OFFSET1; - } - eval $CHILD2_1_AUTO_INCREMENT_INCREMENT1; - eval $CHILD2_1_AUTO_INCREMENT_OFFSET1; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%insert %'; - } - eval $CHILD2_2_SELECT_INCREMENT_TABLES1; - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_2_AUTO_INCREMENT_INCREMENT1; - echo CHILD2_2_AUTO_INCREMENT_OFFSET1; - } - eval $CHILD2_2_AUTO_INCREMENT_INCREMENT1; - eval $CHILD2_2_AUTO_INCREMENT_OFFSET1; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } -} - - ---echo ---echo deinit ---disable_warnings ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -if ($USE_REPLICATION) -{ - --connection slave1_1 - DROP DATABASE IF EXISTS auto_test_local; -} -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; -} ---disable_query_log ---disable_result_log ---source slave_test_deinit.inc ---source test_deinit.inc ---enable_result_log ---enable_query_log ---enable_warnings ---echo ---echo end of test diff --git a/storage/spider/mysql-test/spider/oracle/t/test_deinit.inc b/storage/spider/mysql-test/spider/oracle/t/test_deinit.inc deleted file mode 100644 index 989bde26d3c..00000000000 --- a/storage/spider/mysql-test/spider/oracle/t/test_deinit.inc +++ /dev/null @@ -1,37 +0,0 @@ -# get connection and exist engine test ---echo for master_1 ---connection master_1 ---source ../include/deinit_master_1.inc ---disconnect master_1 ---echo for child2 -if ($USE_CHILD_GROUP2) -{ - --echo child2_1 - --connection child2_1 - --source ../include/deinit_child2_1.inc - --disconnect child2_1 - --echo child2_2 - --connection child2_2 - --source ../include/deinit_child2_2.inc - --disconnect child2_2 - --echo child2_3 - --connection child2_3 - --source ../include/deinit_child2_3.inc - --disconnect child2_3 -} ---echo for child3 -if ($USE_CHILD_GROUP3) -{ - --echo child3_1 - --connection child3_1 - --source ../include/deinit_child3_1.inc - --disconnect child3_1 - --echo child3_2 - --connection child3_2 - --source ../include/deinit_child3_2.inc - --disconnect child3_2 - --echo child3_3 - --connection child3_3 - --source ../include/deinit_child3_3.inc - --disconnect child3_3 -} diff --git a/storage/spider/mysql-test/spider/oracle/t/test_init.inc b/storage/spider/mysql-test/spider/oracle/t/test_init.inc deleted file mode 100644 index f2cd6c0269f..00000000000 --- a/storage/spider/mysql-test/spider/oracle/t/test_init.inc +++ /dev/null @@ -1,74 +0,0 @@ -# get connection and exist engine test ---echo for master_1 ---source connect_master_1.inc ---connection master_1 -CALL mtr.add_suppression("unknown variable"); -SET SESSION sql_log_bin= 0; ---let $MASTER_1_SERVER_ID=`SELECT @@global.server_id` ---let $TEST_ENGINE_TYPE= $MASTER_1_ENGINE_TYPE ---source have_partition.inc ---source have_trigger.inc ---source ../include/init_master_1.inc ---source have_engine.inc ---echo for child2 -if ($USE_CHILD_GROUP2) -{ - --echo child2_1 - --source connect_child2_1.inc - --connection child2_1 - CALL mtr.add_suppression("unknown variable *"); - SET SESSION sql_log_bin= 0; - --let $CHILD2_1_SERVER_ID=`SELECT @@global.server_id` - --let $TEST_ENGINE_TYPE= $CHILD2_1_ENGINE_TYPE - --source ../include/init_child2_1.inc - --source have_engine.inc - --echo child2_2 - --source connect_child2_2.inc - --connection child2_2 - CALL mtr.add_suppression("unknown variable *"); - SET SESSION sql_log_bin= 0; - --let $CHILD2_2_SERVER_ID=`SELECT @@global.server_id` - --let $TEST_ENGINE_TYPE= $CHILD2_2_ENGINE_TYPE - --source ../include/init_child2_2.inc - --source have_engine.inc - --echo child2_3 - --source connect_child2_3.inc - --connection child2_3 - CALL mtr.add_suppression("unknown variable *"); - SET SESSION sql_log_bin= 0; - --let $CHILD2_3_SERVER_ID=`SELECT @@global.server_id` - --let $TEST_ENGINE_TYPE= $CHILD2_3_ENGINE_TYPE - --source ../include/init_child2_3.inc - --source have_engine.inc -} ---echo for child3 -if ($USE_CHILD_GROUP3) -{ - --echo child3_1 - --source connect_child3_1.inc - --connection child3_1 - CALL mtr.add_suppression("unknown variable *"); - SET SESSION sql_log_bin= 0; - --let $CHILD3_1_SERVER_ID=`SELECT @@global.server_id` - --let $TEST_ENGINE_TYPE= $CHILD3_1_ENGINE_TYPE - --source ../include/init_child3_1.inc - --source have_engine.inc - --echo child3_2 - --source connect_child3_2.inc - --connection child3_2 - CALL mtr.add_suppression("unknown variable *"); - SET SESSION sql_log_bin= 0; - --let $CHILD3_2_SERVER_ID=`SELECT @@global.server_id` - --let $TEST_ENGINE_TYPE= $CHILD3_2_ENGINE_TYPE - --source ../include/init_child3_2.inc - --source have_engine.inc - --echo child3_3 - --source connect_child3_3.inc - --connection child3_3 - CALL mtr.add_suppression("unknown variable *"); - SET SESSION sql_log_bin= 0; - --let $CHILD3_3_SERVER_ID=`SELECT @@global.server_id` - --let $TEST_ENGINE_TYPE= $CHILD3_3_ENGINE_TYPE - --source ../include/init_child3_3.inc - --source have_engine.inc -} diff --git a/storage/spider/mysql-test/spider/oracle/t/vp_fixes.test b/storage/spider/mysql-test/spider/oracle/t/vp_fixes.test deleted file mode 100644 index 2c3e1523611..00000000000 --- a/storage/spider/mysql-test/spider/oracle/t/vp_fixes.test +++ /dev/null @@ -1,335 +0,0 @@ -# This test tests for VP's bug fixes ---disable_warnings ---disable_query_log ---disable_result_log ---source test_init.inc ---enable_result_log ---enable_query_log - ---echo ---echo drop and create databases ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - CREATE DATABASE auto_test_remote; - USE auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; - CREATE DATABASE auto_test_remote2; - USE auto_test_remote2; -} ---enable_warnings - ---echo ---echo test select 1 ---connection master_1 -SELECT 1; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - SELECT 1; - --connection child2_2 - SELECT 1; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo create table and insert -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_TABLES; - echo CHILD2_1_CREATE_TABLES; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 ---disable_warnings -DROP TABLE IF EXISTS tb_l; ---enable_warnings ---disable_query_log -echo CREATE TABLE tb_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) MASTER_1_ENGINE2 MASTER_1_CHARSET2; -eval CREATE TABLE tb_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) $MASTER_1_ENGINE2 $MASTER_1_CHARSET2; ---enable_query_log -INSERT INTO tb_l (a, b, c) VALUES - (1, 'a', '2008-08-01 10:21:39'), - (2, 'b', '2000-01-01 00:00:00'), - (3, 'e', '2007-06-04 20:03:11'), - (4, 'd', '2003-11-30 05:01:03'), - (5, 'c', '2001-12-31 23:59:59'); ---disable_warnings -DROP TABLE IF EXISTS ta_l; ---enable_warnings ---disable_query_log -echo CREATE TABLE ta_l ( - PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_2_1; -eval CREATE TABLE ta_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_2_1; ---enable_query_log -INSERT INTO ta_l SELECT a, b, c FROM tb_l; - ---echo ---echo 0.9 ---echo create different primary key table -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_result_log - } - --disable_query_log - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - echo CHILD2_1_DROP_TABLES5; - echo CHILD2_1_CREATE_TABLES5; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES5; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES5; - --enable_query_log - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_result_log - } -} ---connection master_1 ---disable_query_log -echo CREATE TABLE ta_l_int ( - a INT DEFAULT 10, - b INT AUTO_INCREMENT, - c INT DEFAULT 11, - PRIMARY KEY(b) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT4_2_1; -eval CREATE TABLE ta_l_int ( - a INT DEFAULT 10, - b INT AUTO_INCREMENT, - c INT DEFAULT 11, - PRIMARY KEY(b) -) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT4_2_1; ---enable_query_log -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 ---let $MASTER_1_IS_VP= `SELECT IF('$MASTER_1_ENGINE_TYPE' = 'VP', 1, 0)` -if ($MASTER_1_IS_VP) -{ - --error 14514 - INSERT INTO ta_l_int (a, b, c) VALUES (2, NULL, 3); -} -if (!$MASTER_1_IS_VP) -{ - INSERT INTO ta_l_int (a, b, c) VALUES (2, NULL, 3); - --disable_query_log - --disable_result_log - TRUNCATE TABLE ta_l_int; - --enable_query_log - --enable_result_log -} -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%insert %'; - } - eval $CHILD2_1_SELECT_TABLES5; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo create un-correspond primary key table ---connection master_1 ---disable_warnings -DROP TABLE IF EXISTS ta_l_int; ---enable_warnings -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_result_log - } - --disable_query_log - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - echo CHILD2_1_DROP_TABLES5; - echo CHILD2_1_CREATE_TABLES5; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES5; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES5; - --enable_query_log - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_result_log - } -} ---connection master_1 ---disable_query_log -echo CREATE TABLE ta_l_int ( - a INT DEFAULT 10, - b INT DEFAULT 12, - c INT DEFAULT 11, - PRIMARY KEY(c) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT4_2_1; -eval CREATE TABLE ta_l_int ( - a INT DEFAULT 10, - b INT DEFAULT 12, - c INT DEFAULT 11, - PRIMARY KEY(c) -) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT4_2_1; ---enable_query_log -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -if ($MASTER_1_IS_VP) -{ - --error 14514 - INSERT INTO ta_l_int (a, b, c) VALUES (2, NULL, 3); -} -if (!$MASTER_1_IS_VP) -{ - INSERT INTO ta_l_int (a, b, c) VALUES (2, NULL, 3); - --disable_query_log - --disable_result_log - TRUNCATE TABLE ta_l_int; - --enable_query_log - --enable_result_log -} -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%insert %'; - } - eval $CHILD2_1_SELECT_TABLES5; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo deinit ---disable_warnings ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; -} ---disable_query_log ---disable_result_log ---source test_deinit.inc ---enable_result_log ---enable_query_log ---enable_warnings ---echo ---echo end of test diff --git a/storage/spider/mysql-test/spider/oracle2/include/deinit_child2_1.inc b/storage/spider/mysql-test/spider/oracle2/include/deinit_child2_1.inc deleted file mode 100644 index e69de29bb2d..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/include/deinit_child2_1.inc +++ /dev/null diff --git a/storage/spider/mysql-test/spider/oracle2/include/deinit_child2_2.inc b/storage/spider/mysql-test/spider/oracle2/include/deinit_child2_2.inc deleted file mode 100644 index e69de29bb2d..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/include/deinit_child2_2.inc +++ /dev/null diff --git a/storage/spider/mysql-test/spider/oracle2/include/deinit_child2_3.inc b/storage/spider/mysql-test/spider/oracle2/include/deinit_child2_3.inc deleted file mode 100644 index e69de29bb2d..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/include/deinit_child2_3.inc +++ /dev/null diff --git a/storage/spider/mysql-test/spider/oracle2/include/deinit_child3_1.inc b/storage/spider/mysql-test/spider/oracle2/include/deinit_child3_1.inc deleted file mode 100644 index 74c8efa90aa..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/include/deinit_child3_1.inc +++ /dev/null @@ -1,3 +0,0 @@ ---let $TEST_ENGINE_TYPE= $CHILD3_1_ENGINE_TYPE ---let $INIT_TEST_ENGINE= $INIT_CHILD3_1_ENGINE ---source ../../include/deinit_engine.inc diff --git a/storage/spider/mysql-test/spider/oracle2/include/deinit_child3_2.inc b/storage/spider/mysql-test/spider/oracle2/include/deinit_child3_2.inc deleted file mode 100644 index f42a980ad23..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/include/deinit_child3_2.inc +++ /dev/null @@ -1,3 +0,0 @@ ---let $TEST_ENGINE_TYPE= $CHILD3_2_ENGINE_TYPE ---let $INIT_TEST_ENGINE= $INIT_CHILD3_2_ENGINE ---source ../../include/deinit_engine.inc diff --git a/storage/spider/mysql-test/spider/oracle2/include/deinit_child3_3.inc b/storage/spider/mysql-test/spider/oracle2/include/deinit_child3_3.inc deleted file mode 100644 index 0696fb991cf..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/include/deinit_child3_3.inc +++ /dev/null @@ -1,3 +0,0 @@ ---let $TEST_ENGINE_TYPE= $CHILD3_3_ENGINE_TYPE ---let $INIT_TEST_ENGINE= $INIT_CHILD3_3_ENGINE ---source ../../include/deinit_engine.inc diff --git a/storage/spider/mysql-test/spider/oracle2/include/deinit_master_1.inc b/storage/spider/mysql-test/spider/oracle2/include/deinit_master_1.inc deleted file mode 100644 index c19e376d10a..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/include/deinit_master_1.inc +++ /dev/null @@ -1 +0,0 @@ ---source ../../include/deinit_spider.inc diff --git a/storage/spider/mysql-test/spider/oracle2/include/deinit_slave1_1.inc b/storage/spider/mysql-test/spider/oracle2/include/deinit_slave1_1.inc deleted file mode 100644 index e69de29bb2d..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/include/deinit_slave1_1.inc +++ /dev/null diff --git a/storage/spider/mysql-test/spider/oracle2/include/ha_deinit_child2_1.inc b/storage/spider/mysql-test/spider/oracle2/include/ha_deinit_child2_1.inc deleted file mode 100644 index e69de29bb2d..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/include/ha_deinit_child2_1.inc +++ /dev/null diff --git a/storage/spider/mysql-test/spider/oracle2/include/ha_deinit_child2_2.inc b/storage/spider/mysql-test/spider/oracle2/include/ha_deinit_child2_2.inc deleted file mode 100644 index e69de29bb2d..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/include/ha_deinit_child2_2.inc +++ /dev/null diff --git a/storage/spider/mysql-test/spider/oracle2/include/ha_deinit_child2_3.inc b/storage/spider/mysql-test/spider/oracle2/include/ha_deinit_child2_3.inc deleted file mode 100644 index e69de29bb2d..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/include/ha_deinit_child2_3.inc +++ /dev/null diff --git a/storage/spider/mysql-test/spider/oracle2/include/ha_deinit_child3_1.inc b/storage/spider/mysql-test/spider/oracle2/include/ha_deinit_child3_1.inc deleted file mode 100644 index c19e376d10a..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/include/ha_deinit_child3_1.inc +++ /dev/null @@ -1 +0,0 @@ ---source ../../include/deinit_spider.inc diff --git a/storage/spider/mysql-test/spider/oracle2/include/ha_deinit_child3_2.inc b/storage/spider/mysql-test/spider/oracle2/include/ha_deinit_child3_2.inc deleted file mode 100644 index c19e376d10a..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/include/ha_deinit_child3_2.inc +++ /dev/null @@ -1 +0,0 @@ ---source ../../include/deinit_spider.inc diff --git a/storage/spider/mysql-test/spider/oracle2/include/ha_deinit_child3_3.inc b/storage/spider/mysql-test/spider/oracle2/include/ha_deinit_child3_3.inc deleted file mode 100644 index c19e376d10a..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/include/ha_deinit_child3_3.inc +++ /dev/null @@ -1 +0,0 @@ ---source ../../include/deinit_spider.inc diff --git a/storage/spider/mysql-test/spider/oracle2/include/ha_deinit_master_1.inc b/storage/spider/mysql-test/spider/oracle2/include/ha_deinit_master_1.inc deleted file mode 100644 index e69de29bb2d..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/include/ha_deinit_master_1.inc +++ /dev/null diff --git a/storage/spider/mysql-test/spider/oracle2/include/ha_init_child2_1.inc b/storage/spider/mysql-test/spider/oracle2/include/ha_init_child2_1.inc deleted file mode 100644 index 2684829408d..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/include/ha_init_child2_1.inc +++ /dev/null @@ -1,8 +0,0 @@ -let $CHILD2_1_HA_AS_DROP_TABLES= - $CHILD2_1_DROP_TABLES; -let $CHILD2_1_HA_AS_CREATE_TABLES= - $CHILD2_1_CREATE_TABLES; -let $CHILD2_1_HA_AS_DROP_TABLES2= - $CHILD2_1_DROP_TABLES2; -let $CHILD2_1_HA_AS_CREATE_TABLES2= - $CHILD2_1_CREATE_TABLES2; diff --git a/storage/spider/mysql-test/spider/oracle2/include/ha_init_child2_2.inc b/storage/spider/mysql-test/spider/oracle2/include/ha_init_child2_2.inc deleted file mode 100644 index 205eaa6fe35..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/include/ha_init_child2_2.inc +++ /dev/null @@ -1,4 +0,0 @@ -let $CHILD2_2_HA_DROP_TABLES= - $CHILD2_2_DROP_TABLES; -let $CHILD2_2_HA_CREATE_TABLES= - $CHILD2_2_CREATE_TABLES; diff --git a/storage/spider/mysql-test/spider/oracle2/include/ha_init_child2_3.inc b/storage/spider/mysql-test/spider/oracle2/include/ha_init_child2_3.inc deleted file mode 100644 index 55cb858372c..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/include/ha_init_child2_3.inc +++ /dev/null @@ -1,4 +0,0 @@ -let $CHILD2_3_HA_DROP_TABLES= - $CHILD2_3_DROP_TABLES; -let $CHILD2_3_HA_CREATE_TABLES= - $CHILD2_3_CREATE_TABLES; diff --git a/storage/spider/mysql-test/spider/oracle2/include/ha_init_child3_1.inc b/storage/spider/mysql-test/spider/oracle2/include/ha_init_child3_1.inc deleted file mode 100644 index 8357f0bdbc2..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/include/ha_init_child3_1.inc +++ /dev/null @@ -1,140 +0,0 @@ ---let $CHILD3_1_ENGINE_TYPE=Spider ---let $CHILD3_1_ENGINE=ENGINE=Spider ---source ../include/init_spider.inc -eval INSERT INTO mysql.spider_link_mon_servers -(db_name, table_name, link_id, sid, server, scheme, host, port, socket, - username, password, ssl_ca, ssl_capath, ssl_cert, ssl_cipher, ssl_key, - ssl_verify_server_cert, default_file, default_group) VALUES -('%auto_test_local%', '%ta_l%', '%', $CHILD3_1_SERVER_ID, 's_3_1', NULL, NULL, - NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, NULL, NULL), -('%auto_test_local%', '%ta_l%', '%', $CHILD3_2_SERVER_ID, 's_3_2', NULL, NULL, - NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, NULL, NULL), -('%auto_test_local%', '%ta_l%', '%', $CHILD3_3_SERVER_ID, 's_3_3', NULL, NULL, - NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, NULL, NULL); -let $CHILD3_1_CHECK_LINK_STATUS= - SELECT db_name, table_name, link_id, link_status FROM mysql.spider_tables - ORDER BY db_name, table_name, link_id; -let $CHILD3_1_CHECK_LINK_FAILED_LOG= - SELECT db_name, table_name, link_id FROM mysql.spider_link_failed_log; -let $CHILD3_1_SET_RECOVERY_STATUS_2_1= - ALTER TABLE ta_l - CONNECTION='host "localhost", user "root", password "", - msi "$CHILD3_1_SERVER_ID", mkd "2", - database "auto_test_remote auto_test_remote2", lst "0 2"'; -let $CHILD3_1_SET_OK_STATUS_2_1= - ALTER TABLE ta_l - CONNECTION='host "localhost", user "root", password "", - msi "$CHILD3_1_SERVER_ID", mkd "2", - database "auto_test_remote auto_test_remote2", lst "0 1"'; -let $CHILD3_1_SET_OK_STATUS_AS_2_1= - ALTER TABLE ta_l - CONNECTION='host "localhost", user "root", password "", - msi "$CHILD3_1_SERVER_ID", mkd "2", alc "1", - database "auto_test_remote auto_test_remote2", lst "1 0"'; - -let $CHILD3_1_DROP_TABLES_HA_2_1= - DROP TABLE IF EXISTS ta_l; -if ($VERSION_COMPILE_OS_WIN) -{ - let $CHILD3_1_CREATE_TABLES_HA_2_1= - CREATE TABLE ta_l ( - a INT DEFAULT 10, - b CHAR(1) DEFAULT 'c', - c DATETIME DEFAULT '1999-10-10 10:10:10', - PRIMARY KEY(a) - ) $CHILD3_1_ENGINE $CHILD3_1_CHARSET - COMMENT='port "$CHILD2_1_MYPORT $CHILD2_2_MYPORT", table "ta_r ta_r3"' - CONNECTION='host "localhost", user "root", password "", - msi "$CHILD3_1_SERVER_ID", mkd "2", - database "auto_test_remote auto_test_remote2"'; - let $CHILD3_1_CREATE_TABLES_HA_AS_2_1= - CREATE TABLE ta_l ( - a INT DEFAULT 10, - b CHAR(1) DEFAULT 'c', - c DATETIME DEFAULT '1999-10-10 10:10:10', - PRIMARY KEY(a) - ) $CHILD3_1_ENGINE $CHILD3_1_CHARSET - COMMENT='port "$CHILD2_1_MYPORT $CHILD2_2_MYPORT", table "ta_r ta_r3"' - CONNECTION='host "localhost", user "root", password "", - msi "$CHILD3_1_SERVER_ID", mkd "2", alc "1", - database "auto_test_remote auto_test_remote2"'; -} -if (!$VERSION_COMPILE_OS_WIN) -{ - let $CHILD3_1_CREATE_TABLES_HA_2_1= - CREATE TABLE ta_l ( - a INT DEFAULT 10, - b CHAR(1) DEFAULT 'c', - c DATETIME DEFAULT '1999-10-10 10:10:10', - PRIMARY KEY(a) - ) $CHILD3_1_ENGINE $CHILD3_1_CHARSET - COMMENT='socket "$CHILD2_1_MYSOCK $CHILD2_2_MYSOCK", table "ta_r ta_r3"' - CONNECTION='host "localhost", user "root", password "", - msi "$CHILD3_1_SERVER_ID", mkd "2", - database "auto_test_remote auto_test_remote2"'; - let $CHILD3_1_CREATE_TABLES_HA_AS_2_1= - CREATE TABLE ta_l ( - a INT DEFAULT 10, - b CHAR(1) DEFAULT 'c', - c DATETIME DEFAULT '1999-10-10 10:10:10', - PRIMARY KEY(a) - ) $CHILD3_1_ENGINE $CHILD3_1_CHARSET - COMMENT='socket "$CHILD2_1_MYSOCK $CHILD2_2_MYSOCK", table "ta_r ta_r3"' - CONNECTION='host "localhost", user "root", password "", - msi "$CHILD3_1_SERVER_ID", mkd "2", alc "1", - database "auto_test_remote auto_test_remote2"'; -} -let $CHILD3_1_DROP_TABLES_HA_P_2_1= - DROP TABLE IF EXISTS ta_l2; -let $CHILD3_1_CREATE_TABLES_HA_P_2_1= - CREATE TABLE ta_l2 ( - a INT DEFAULT 10, - b CHAR(1) DEFAULT 'c', - c DATETIME DEFAULT '1999-10-10 10:10:10', - PRIMARY KEY(a) - ) $CHILD3_1_ENGINE $CHILD3_1_CHARSET - COMMENT='msi "$CHILD3_1_SERVER_ID", mkd "2"' - PARTITION BY KEY(a) ( - PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', - PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001"' - ); -let $CHILD3_1_CREATE_TABLES_HA_AS_P_2_1= - CREATE TABLE ta_l2 ( - a INT DEFAULT 10, - b CHAR(1) DEFAULT 'c', - c DATETIME DEFAULT '1999-10-10 10:10:10', - PRIMARY KEY(a) - ) $CHILD3_1_ENGINE $CHILD3_1_CHARSET - COMMENT='msi "$CHILD3_1_SERVER_ID", mkd "2", alc "1"' - PARTITION BY KEY(a) ( - PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', - PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001"' - ); -let $CHILD3_1_SET_RECOVERY_STATUS_P_2_1= - ALTER TABLE ta_l2 - PARTITION BY KEY(a) ( - PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', - PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001", lst "0 2"' - ); -let $CHILD3_1_SET_OK_STATUS_P_2_1= - ALTER TABLE ta_l2 - PARTITION BY KEY(a) ( - PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', - PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001", lst "0 1"' - ); -let $CHILD3_1_SET_OK_STATUS_AS_P_2_1= - ALTER TABLE ta_l2 - PARTITION BY KEY(a) ( - PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', - PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001", lst "1 0"' - ); diff --git a/storage/spider/mysql-test/spider/oracle2/include/ha_init_child3_2.inc b/storage/spider/mysql-test/spider/oracle2/include/ha_init_child3_2.inc deleted file mode 100644 index 3ffcec24f51..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/include/ha_init_child3_2.inc +++ /dev/null @@ -1,140 +0,0 @@ ---let $CHILD3_2_ENGINE_TYPE=Spider ---let $CHILD3_2_ENGINE=ENGINE=Spider ---source ../include/init_spider.inc -eval INSERT INTO mysql.spider_link_mon_servers -(db_name, table_name, link_id, sid, server, scheme, host, port, socket, - username, password, ssl_ca, ssl_capath, ssl_cert, ssl_cipher, ssl_key, - ssl_verify_server_cert, default_file, default_group) VALUES -('%auto_test_local%', '%ta_l%', '%', $CHILD3_1_SERVER_ID, 's_3_1', NULL, NULL, - NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, NULL, NULL), -('%auto_test_local%', '%ta_l%', '%', $CHILD3_2_SERVER_ID, 's_3_2', NULL, NULL, - NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, NULL, NULL), -('%auto_test_local%', '%ta_l%', '%', $CHILD3_3_SERVER_ID, 's_3_3', NULL, NULL, - NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, NULL, NULL); -let $CHILD3_2_CHECK_LINK_STATUS= - SELECT db_name, table_name, link_id, link_status FROM mysql.spider_tables - ORDER BY db_name, table_name, link_id; -let $CHILD3_2_CHECK_LINK_FAILED_LOG= - SELECT db_name, table_name, link_id FROM mysql.spider_link_failed_log; -let $CHILD3_2_SET_RECOVERY_STATUS_2_1= - ALTER TABLE ta_l - CONNECTION='host "localhost", user "root", password "", - msi "$CHILD3_1_SERVER_ID", mkd "2", - database "auto_test_remote auto_test_remote2", lst "0 2"'; -let $CHILD3_2_SET_OK_STATUS_2_1= - ALTER TABLE ta_l - CONNECTION='host "localhost", user "root", password "", - msi "$CHILD3_1_SERVER_ID", mkd "2", - database "auto_test_remote auto_test_remote2", lst "0 1"'; -let $CHILD3_2_SET_OK_STATUS_AS_2_1= - ALTER TABLE ta_l - CONNECTION='host "localhost", user "root", password "", - msi "$CHILD3_1_SERVER_ID", mkd "2", alc "1", - database "auto_test_remote auto_test_remote2", lst "1 0"'; - -let $CHILD3_2_DROP_TABLES_HA_2_1= - DROP TABLE IF EXISTS ta_l; -if ($VERSION_COMPILE_OS_WIN) -{ - let $CHILD3_2_CREATE_TABLES_HA_2_1= - CREATE TABLE ta_l ( - a INT DEFAULT 10, - b CHAR(1) DEFAULT 'c', - c DATETIME DEFAULT '1999-10-10 10:10:10', - PRIMARY KEY(a) - ) $CHILD3_2_ENGINE $CHILD3_2_CHARSET - COMMENT='port "$CHILD2_1_MYPORT $CHILD2_2_MYPORT", table "ta_r ta_r3"' - CONNECTION='host "localhost", user "root", password "", - msi "$CHILD3_1_SERVER_ID", mkd "2", - database "auto_test_remote auto_test_remote2"'; - let $CHILD3_2_CREATE_TABLES_HA_AS_2_1= - CREATE TABLE ta_l ( - a INT DEFAULT 10, - b CHAR(1) DEFAULT 'c', - c DATETIME DEFAULT '1999-10-10 10:10:10', - PRIMARY KEY(a) - ) $CHILD3_2_ENGINE $CHILD3_2_CHARSET - COMMENT='port "$CHILD2_1_MYPORT $CHILD2_2_MYPORT", table "ta_r ta_r3"' - CONNECTION='host "localhost", user "root", password "", - msi "$CHILD3_1_SERVER_ID", mkd "2", alc "1", - database "auto_test_remote auto_test_remote2"'; -} -if (!$VERSION_COMPILE_OS_WIN) -{ - let $CHILD3_2_CREATE_TABLES_HA_2_1= - CREATE TABLE ta_l ( - a INT DEFAULT 10, - b CHAR(1) DEFAULT 'c', - c DATETIME DEFAULT '1999-10-10 10:10:10', - PRIMARY KEY(a) - ) $CHILD3_2_ENGINE $CHILD3_2_CHARSET - COMMENT='socket "$CHILD2_1_MYSOCK $CHILD2_2_MYSOCK", table "ta_r ta_r3"' - CONNECTION='host "localhost", user "root", password "", - msi "$CHILD3_1_SERVER_ID", mkd "2", - database "auto_test_remote auto_test_remote2"'; - let $CHILD3_2_CREATE_TABLES_HA_AS_2_1= - CREATE TABLE ta_l ( - a INT DEFAULT 10, - b CHAR(1) DEFAULT 'c', - c DATETIME DEFAULT '1999-10-10 10:10:10', - PRIMARY KEY(a) - ) $CHILD3_2_ENGINE $CHILD3_2_CHARSET - COMMENT='socket "$CHILD2_1_MYSOCK $CHILD2_2_MYSOCK", table "ta_r ta_r3"' - CONNECTION='host "localhost", user "root", password "", - msi "$CHILD3_1_SERVER_ID", mkd "2", alc "1", - database "auto_test_remote auto_test_remote2"'; -} -let $CHILD3_2_DROP_TABLES_HA_P_2_1= - DROP TABLE IF EXISTS ta_l2; -let $CHILD3_2_CREATE_TABLES_HA_P_2_1= - CREATE TABLE ta_l2 ( - a INT DEFAULT 10, - b CHAR(1) DEFAULT 'c', - c DATETIME DEFAULT '1999-10-10 10:10:10', - PRIMARY KEY(a) - ) $CHILD3_2_ENGINE $CHILD3_2_CHARSET - COMMENT='msi "$CHILD3_1_SERVER_ID", mkd "2"' - PARTITION BY KEY(a) ( - PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', - PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001"' - ); -let $CHILD3_2_CREATE_TABLES_HA_AS_P_2_1= - CREATE TABLE ta_l2 ( - a INT DEFAULT 10, - b CHAR(1) DEFAULT 'c', - c DATETIME DEFAULT '1999-10-10 10:10:10', - PRIMARY KEY(a) - ) $CHILD3_2_ENGINE $CHILD3_2_CHARSET - COMMENT='msi "$CHILD3_1_SERVER_ID", mkd "2", alc "1"' - PARTITION BY KEY(a) ( - PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', - PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001"' - ); -let $CHILD3_2_SET_RECOVERY_STATUS_P_2_1= - ALTER TABLE ta_l2 - PARTITION BY KEY(a) ( - PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', - PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001", lst "0 2"' - ); -let $CHILD3_2_SET_OK_STATUS_P_2_1= - ALTER TABLE ta_l2 - PARTITION BY KEY(a) ( - PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', - PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001", lst "0 1"' - ); -let $CHILD3_2_SET_OK_STATUS_AS_P_2_1= - ALTER TABLE ta_l2 - PARTITION BY KEY(a) ( - PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', - PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001", lst "1 0"' - ); diff --git a/storage/spider/mysql-test/spider/oracle2/include/ha_init_child3_3.inc b/storage/spider/mysql-test/spider/oracle2/include/ha_init_child3_3.inc deleted file mode 100644 index 67bd00109f5..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/include/ha_init_child3_3.inc +++ /dev/null @@ -1,140 +0,0 @@ ---let $CHILD3_3_ENGINE_TYPE=Spider ---let $CHILD3_3_ENGINE=ENGINE=Spider ---source ../include/init_spider.inc -eval INSERT INTO mysql.spider_link_mon_servers -(db_name, table_name, link_id, sid, server, scheme, host, port, socket, - username, password, ssl_ca, ssl_capath, ssl_cert, ssl_cipher, ssl_key, - ssl_verify_server_cert, default_file, default_group) VALUES -('%auto_test_local%', '%ta_l%', '%', $CHILD3_1_SERVER_ID, 's_3_1', NULL, NULL, - NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, NULL, NULL), -('%auto_test_local%', '%ta_l%', '%', $CHILD3_2_SERVER_ID, 's_3_2', NULL, NULL, - NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, NULL, NULL), -('%auto_test_local%', '%ta_l%', '%', $CHILD3_3_SERVER_ID, 's_3_3', NULL, NULL, - NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, NULL, NULL); -let $CHILD3_3_CHECK_LINK_STATUS= - SELECT db_name, table_name, link_id, link_status FROM mysql.spider_tables - ORDER BY db_name, table_name, link_id; -let $CHILD3_3_CHECK_LINK_FAILED_LOG= - SELECT db_name, table_name, link_id FROM mysql.spider_link_failed_log; -let $CHILD3_3_SET_RECOVERY_STATUS_2_1= - ALTER TABLE ta_l - CONNECTION='host "localhost", user "root", password "", - msi "$CHILD3_1_SERVER_ID", mkd "2", - database "auto_test_remote auto_test_remote2", lst "0 2"'; -let $CHILD3_3_SET_OK_STATUS_2_1= - ALTER TABLE ta_l - CONNECTION='host "localhost", user "root", password "", - msi "$CHILD3_1_SERVER_ID", mkd "2", - database "auto_test_remote auto_test_remote2", lst "0 1"'; -let $CHILD3_3_SET_OK_STATUS_AS_2_1= - ALTER TABLE ta_l - CONNECTION='host "localhost", user "root", password "", - msi "$CHILD3_1_SERVER_ID", mkd "2", alc "1", - database "auto_test_remote auto_test_remote2", lst "1 0"'; - -let $CHILD3_3_DROP_TABLES_HA_2_1= - DROP TABLE IF EXISTS ta_l; -if ($VERSION_COMPILE_OS_WIN) -{ - let $CHILD3_3_CREATE_TABLES_HA_2_1= - CREATE TABLE ta_l ( - a INT DEFAULT 10, - b CHAR(1) DEFAULT 'c', - c DATETIME DEFAULT '1999-10-10 10:10:10', - PRIMARY KEY(a) - ) $CHILD3_3_ENGINE $CHILD3_3_CHARSET - COMMENT='port "$CHILD2_1_MYPORT $CHILD2_2_MYPORT", table "ta_r ta_r3"' - CONNECTION='host "localhost", user "root", password "", - msi "$CHILD3_1_SERVER_ID", mkd "2", - database "auto_test_remote auto_test_remote2"'; - let $CHILD3_3_CREATE_TABLES_HA_AS_2_1= - CREATE TABLE ta_l ( - a INT DEFAULT 10, - b CHAR(1) DEFAULT 'c', - c DATETIME DEFAULT '1999-10-10 10:10:10', - PRIMARY KEY(a) - ) $CHILD3_3_ENGINE $CHILD3_3_CHARSET - COMMENT='port "$CHILD2_1_MYPORT $CHILD2_2_MYPORT", table "ta_r ta_r3"' - CONNECTION='host "localhost", user "root", password "", - msi "$CHILD3_1_SERVER_ID", mkd "2", alc "1", - database "auto_test_remote auto_test_remote2"'; -} -if (!$VERSION_COMPILE_OS_WIN) -{ - let $CHILD3_3_CREATE_TABLES_HA_2_1= - CREATE TABLE ta_l ( - a INT DEFAULT 10, - b CHAR(1) DEFAULT 'c', - c DATETIME DEFAULT '1999-10-10 10:10:10', - PRIMARY KEY(a) - ) $CHILD3_3_ENGINE $CHILD3_3_CHARSET - COMMENT='socket "$CHILD2_1_MYSOCK $CHILD2_2_MYSOCK", table "ta_r ta_r3"' - CONNECTION='host "localhost", user "root", password "", - msi "$CHILD3_1_SERVER_ID", mkd "2", - database "auto_test_remote auto_test_remote2"'; - let $CHILD3_3_CREATE_TABLES_HA_AS_2_1= - CREATE TABLE ta_l ( - a INT DEFAULT 10, - b CHAR(1) DEFAULT 'c', - c DATETIME DEFAULT '1999-10-10 10:10:10', - PRIMARY KEY(a) - ) $CHILD3_3_ENGINE $CHILD3_3_CHARSET - COMMENT='socket "$CHILD2_1_MYSOCK $CHILD2_2_MYSOCK", table "ta_r ta_r3"' - CONNECTION='host "localhost", user "root", password "", - msi "$CHILD3_1_SERVER_ID", mkd "2", alc "1", - database "auto_test_remote auto_test_remote2"'; -} -let $CHILD3_3_DROP_TABLES_HA_P_2_1= - DROP TABLE IF EXISTS ta_l2; -let $CHILD3_3_CREATE_TABLES_HA_P_2_1= - CREATE TABLE ta_l2 ( - a INT DEFAULT 10, - b CHAR(1) DEFAULT 'c', - c DATETIME DEFAULT '1999-10-10 10:10:10', - PRIMARY KEY(a) - ) $CHILD3_3_ENGINE $CHILD3_3_CHARSET - COMMENT='msi "$CHILD3_1_SERVER_ID", mkd "2"' - PARTITION BY KEY(a) ( - PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', - PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001"' - ); -let $CHILD3_3_CREATE_TABLES_HA_AS_P_2_1= - CREATE TABLE ta_l2 ( - a INT DEFAULT 10, - b CHAR(1) DEFAULT 'c', - c DATETIME DEFAULT '1999-10-10 10:10:10', - PRIMARY KEY(a) - ) $CHILD3_3_ENGINE $CHILD3_3_CHARSET - COMMENT='msi "$CHILD3_1_SERVER_ID", mkd "2", alc "1"' - PARTITION BY KEY(a) ( - PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', - PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001"' - ); -let $CHILD3_3_SET_RECOVERY_STATUS_P_2_1= - ALTER TABLE ta_l2 - PARTITION BY KEY(a) ( - PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', - PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001", lst "0 2"' - ); -let $CHILD3_3_SET_OK_STATUS_P_2_1= - ALTER TABLE ta_l2 - PARTITION BY KEY(a) ( - PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', - PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001", lst "0 1"' - ); -let $CHILD3_3_SET_OK_STATUS_AS_P_2_1= - ALTER TABLE ta_l2 - PARTITION BY KEY(a) ( - PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', - PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001", lst "1 0"' - ); diff --git a/storage/spider/mysql-test/spider/oracle2/include/ha_init_master_1.inc b/storage/spider/mysql-test/spider/oracle2/include/ha_init_master_1.inc deleted file mode 100644 index 8ace39ab641..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/include/ha_init_master_1.inc +++ /dev/null @@ -1,109 +0,0 @@ -eval INSERT INTO mysql.spider_link_mon_servers -(db_name, table_name, link_id, sid, server, scheme, host, port, socket, - username, password, ssl_ca, ssl_capath, ssl_cert, ssl_cipher, ssl_key, - ssl_verify_server_cert, default_file, default_group) VALUES -('%auto_test_local%', '%ta_l%', '%', $CHILD3_1_SERVER_ID, 's_3_1', NULL, NULL, - NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, NULL, NULL), -('%auto_test_local%', '%ta_l%', '%', $CHILD3_2_SERVER_ID, 's_3_2', NULL, NULL, - NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, NULL, NULL), -('%auto_test_local%', '%ta_l%', '%', $CHILD3_3_SERVER_ID, 's_3_3', NULL, NULL, - NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, NULL, NULL); -let $MASTER_1_CHECK_LINK_STATUS= - SELECT db_name, table_name, link_id, link_status FROM mysql.spider_tables - ORDER BY db_name, table_name, link_id; -let $MASTER_1_CHECK_LINK_FAILED_LOG= - SELECT db_name, table_name, link_id FROM mysql.spider_link_failed_log; -let $MASTER_1_SET_RECOVERY_STATUS_2_1= - ALTER TABLE ta_l - CONNECTION='host "$ORACLE_HOST", user "$ORACLE_USER", - password "$ORACLE_PASSWORD", msi "$CHILD3_1_SERVER_ID", mkd "2", - database "$ORACLE_DATABASE", lst "0 2"'; -let $MASTER_1_SET_OK_STATUS_2_1= - ALTER TABLE ta_l - CONNECTION='host "$ORACLE_HOST", user "$ORACLE_USER", - password "$ORACLE_PASSWORD", msi "$CHILD3_1_SERVER_ID", mkd "2", - database "$ORACLE_DATABASE", lst "0 1"'; -let $MASTER_1_SET_OK_STATUS_AS_2_1= - ALTER TABLE ta_l - CONNECTION='host "$ORACLE_HOST", user "$ORACLE_USER", - password "$ORACLE_PASSWORD", msi "$CHILD3_1_SERVER_ID", mkd "2", alc "1", - database "$ORACLE_DATABASE", lst "1 0"'; -let $MASTER_1_COPY_TABLES_2_1= - SELECT spider_copy_tables('ta_l', '0', '1'); - -if ($VERSION_COMPILE_OS_WIN) -{ - let $MASTER_1_COMMENT_HA_2_1= - COMMENT='port "$CHILD2_1_MYPORT $CHILD2_2_MYPORT", table "ta_r ta_r3", - wrapper "oracle"' - CONNECTION='host "$ORACLE_HOST", user "$ORACLE_USER", - password "$ORACLE_PASSWORD", msi "$CHILD3_1_SERVER_ID", mkd "2", - database "$ORACLE_DATABASE"'; - let $MASTER_1_COMMENT_HA_AS_2_1= - COMMENT='port "$CHILD2_1_MYPORT $CHILD2_2_MYPORT", table "ta_r ta_r3", - wrapper "oracle"' - CONNECTION='host "$ORACLE_HOST", user "$ORACLE_USER", - password "$ORACLE_PASSWORD", msi "$CHILD3_1_SERVER_ID", mkd "2", alc "1", - database "$ORACLE_DATABASE"'; -} -if (!$VERSION_COMPILE_OS_WIN) -{ - let $MASTER_1_COMMENT_HA_2_1= - COMMENT='socket "$CHILD2_1_MYSOCK $CHILD2_2_MYSOCK", table "ta_r ta_r3", - wrapper "oracle"' - CONNECTION='host "$ORACLE_HOST", user "$ORACLE_USER", - password "$ORACLE_PASSWORD", msi "$CHILD3_1_SERVER_ID", mkd "2", - database "$ORACLE_DATABASE"'; - let $MASTER_1_COMMENT_HA_AS_2_1= - COMMENT='socket "$CHILD2_1_MYSOCK $CHILD2_2_MYSOCK", table "ta_r ta_r3", - wrapper "oracle"' - CONNECTION='host "$ORACLE_HOST", user "$ORACLE_USER", - password "$ORACLE_PASSWORD", msi "$CHILD3_1_SERVER_ID", mkd "2", alc "1", - database "$ORACLE_DATABASE"'; -} -let $MASTER_1_COMMENT_HA_P_2_1= - COMMENT='msi "$CHILD3_1_SERVER_ID", mkd "2"' - PARTITION BY KEY(a) ( - PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', - PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001"' - ); -let $MASTER_1_COMMENT_HA_AS_P_2_1= - COMMENT='msi "$CHILD3_1_SERVER_ID", mkd "2", alc "1"' - PARTITION BY KEY(a) ( - PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', - PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001"' - ); -let $MASTER_1_SET_RECOVERY_STATUS_P_2_1= - ALTER TABLE ta_l2 - PARTITION BY KEY(a) ( - PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', - PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001", lst "0 2"' - ); -let $MASTER_1_SET_OK_STATUS_P_2_1= - ALTER TABLE ta_l2 - PARTITION BY KEY(a) ( - PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', - PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001", lst "0 1"' - ); -let $MASTER_1_SET_OK_STATUS_AS_P_2_1= - ALTER TABLE ta_l2 - PARTITION BY KEY(a) ( - PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', - PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001", lst "1 0"' - ); -let $MASTER_1_COPY_TABLES_P_2_1= - SELECT spider_copy_tables('ta_l2#P#pt2', '0', '1'); -let $MASTER_1_CHECK_HA_STATUS= - SHOW GLOBAL STATUS LIKE 'Spider_mon_table_cache_version%'; -let $MASTER_1_CHANGE_HA_MON= - SELECT spider_flush_table_mon_cache(); diff --git a/storage/spider/mysql-test/spider/oracle2/include/hs_deinit_child2_1.inc b/storage/spider/mysql-test/spider/oracle2/include/hs_deinit_child2_1.inc deleted file mode 100644 index e69de29bb2d..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/include/hs_deinit_child2_1.inc +++ /dev/null diff --git a/storage/spider/mysql-test/spider/oracle2/include/hs_deinit_child2_2.inc b/storage/spider/mysql-test/spider/oracle2/include/hs_deinit_child2_2.inc deleted file mode 100644 index e69de29bb2d..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/include/hs_deinit_child2_2.inc +++ /dev/null diff --git a/storage/spider/mysql-test/spider/oracle2/include/hs_deinit_child2_3.inc b/storage/spider/mysql-test/spider/oracle2/include/hs_deinit_child2_3.inc deleted file mode 100644 index e69de29bb2d..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/include/hs_deinit_child2_3.inc +++ /dev/null diff --git a/storage/spider/mysql-test/spider/oracle2/include/hs_deinit_master_1.inc b/storage/spider/mysql-test/spider/oracle2/include/hs_deinit_master_1.inc deleted file mode 100644 index e69de29bb2d..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/include/hs_deinit_master_1.inc +++ /dev/null diff --git a/storage/spider/mysql-test/spider/oracle2/include/hs_init_child2_1.inc b/storage/spider/mysql-test/spider/oracle2/include/hs_init_child2_1.inc deleted file mode 100644 index f3f92a61e6f..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/include/hs_init_child2_1.inc +++ /dev/null @@ -1,24 +0,0 @@ -let $CHILD2_1_HS_DROP_TABLES= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "hs_r"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"'); -let $CHILD2_1_HS_CREATE_TABLES= - SELECT spider_direct_sql('CREATE TABLE "hs_r" ( - "a" INT DEFAULT 10, - "b" CHAR(1) DEFAULT \'c\', - "c" DATE DEFAULT TO_DATE(\'1999-10-10 10:10:10\', \'YYYY-MM-DD HH24:MI:SS\'), - "d" INT DEFAULT 11, - CONSTRAINT "pk_s_2_1_hs_r" PRIMARY KEY("a") - )', '', 'srv "s_2_1"'); -let $CHILD2_1_HS_SELECT_TABLES= - SELECT spider_direct_sql('SELECT "a", "b", TO_CHAR("c", \'YYYY-MM-DD HH24:MI:SS\'), "d" FROM "hs_r" ORDER BY "a"', '', 'srv "s_2_1"'); -let $CHILD2_1_HS_DROP_TABLES2= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "hs_r2"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"'); -let $CHILD2_1_HS_CREATE_TABLES2= - SELECT spider_direct_sql('CREATE TABLE "hs_r2" ( - "a" INT DEFAULT 10, - "b" CHAR(1) DEFAULT \'c\', - "c" DATE DEFAULT TO_DATE(\'1999-10-10 10:10:10\', \'YYYY-MM-DD HH24:MI:SS\'), - "d" INT DEFAULT 11, - CONSTRAINT "pk_s_2_1_hs_r2" PRIMARY KEY("a") - )', '', 'srv "s_2_1"'); -let $CHILD2_1_HS_SELECT_TABLES2= - SELECT spider_direct_sql('SELECT "a", "b", TO_CHAR("c", \'YYYY-MM-DD HH24:MI:SS\'), "d" FROM "hs_r2" ORDER BY "a"', '', 'srv "s_2_1"'); diff --git a/storage/spider/mysql-test/spider/oracle2/include/hs_init_child2_2.inc b/storage/spider/mysql-test/spider/oracle2/include/hs_init_child2_2.inc deleted file mode 100644 index 4bd8d49c17c..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/include/hs_init_child2_2.inc +++ /dev/null @@ -1,12 +0,0 @@ -let $CHILD2_2_HS_DROP_TABLES= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "hs_r3"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_2"'); -let $CHILD2_2_HS_CREATE_TABLES= - SELECT spider_direct_sql('CREATE TABLE "hs_r3" ( - "a" INT DEFAULT 10, - "b" CHAR(1) DEFAULT \'c\', - "c" DATE DEFAULT TO_DATE(\'1999-10-10 10:10:10\', \'YYYY-MM-DD HH24:MI:SS\'), - "d" INT DEFAULT 11, - CONSTRAINT "pk_s_2_2_hs_r3" PRIMARY KEY("a") - )', '', 'srv "s_2_2"'); -let $CHILD2_2_HS_SELECT_TABLES= - SELECT spider_direct_sql('SELECT "a", "b", TO_CHAR("c", \'YYYY-MM-DD HH24:MI:SS\'), "d" FROM "hs_r3" ORDER BY "a"', '', 'srv "s_2_2"'); diff --git a/storage/spider/mysql-test/spider/oracle2/include/hs_init_child2_3.inc b/storage/spider/mysql-test/spider/oracle2/include/hs_init_child2_3.inc deleted file mode 100644 index e69de29bb2d..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/include/hs_init_child2_3.inc +++ /dev/null diff --git a/storage/spider/mysql-test/spider/oracle2/include/hs_init_master_1.inc b/storage/spider/mysql-test/spider/oracle2/include/hs_init_master_1.inc deleted file mode 100644 index 0ff5e2a10d9..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/include/hs_init_master_1.inc +++ /dev/null @@ -1,12 +0,0 @@ -let $MASTER_1_HS_COMMENT_TMP= - COMMENT=''; -let $MASTER_1_HS_COMMENT_2_1= - COMMENT='srv "s_2_1", table "hs_r", uhr "1", uhw "1", hrp "$CHILD2_1_HSRPORT", hwp "$CHILD2_1_HSWPORT"'; -let $MASTER_1_HS_COMMENT_P_2_1= - COMMENT='uhr "1", uhw "1"' - PARTITION BY RANGE(a) ( - PARTITION pt1 VALUES LESS THAN (4) - COMMENT='srv "s_2_1", table "hs_r2", hrp "$CHILD2_1_HSRPORT", hwp "$CHILD2_1_HSWPORT"', - PARTITION pt2 VALUES LESS THAN MAXVALUE - COMMENT='srv "s_2_2", table "hs_r3", hrp "$CHILD2_2_HSRPORT", hwp "$CHILD2_2_HSWPORT"' - ); diff --git a/storage/spider/mysql-test/spider/oracle2/include/init_child2_1.inc b/storage/spider/mysql-test/spider/oracle2/include/init_child2_1.inc deleted file mode 100644 index c24736eefca..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/include/init_child2_1.inc +++ /dev/null @@ -1,192 +0,0 @@ ---connection master_1 -SELECT spider_direct_sql('ALTER SESSION SET NLS_DATE_FORMAT=\'YYYY-MM-DD HH24:MI:SS\'', '', 'srv "s_2_1"'); -SELECT spider_direct_sql('ALTER SESSION SET NLS_TIME_FORMAT=\'HH24:MI:SSXFF\'', '', 'srv "s_2_1"'); -SELECT spider_direct_sql('ALTER SESSION SET NLS_TIMESTAMP_FORMAT=\'YYYY-MM-DD HH24:MI:SSXFF\'', '', 'srv "s_2_1"'); -let $CHILD2_1_DROP_TABLES= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "ta_r"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"'); -let $CHILD2_1_CREATE_TABLES= - SELECT spider_direct_sql('CREATE TABLE "ta_r" ( - "a" INT DEFAULT 10, - "b" CHAR(1) DEFAULT \'c\', - "c" DATE DEFAULT TO_DATE(\'1999-10-10 10:10:10\', \'YYYY-MM-DD HH24:MI:SS\'), - CONSTRAINT "pk_s_2_1_ta_r" PRIMARY KEY("a") - )', '', 'srv "s_2_1"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE INDEX "idx1" ON "ta_r"("b")', '', 'srv "s_2_1"'); -let $CHILD2_1_SELECT_TABLES= - SELECT spider_direct_sql('SELECT "a", "b", TO_CHAR("c", \'YYYY-MM-DD HH24:MI:SS\') FROM "ta_r" ORDER BY "a"', '', 'srv "s_2_1"'); -let $CHILD2_1_DROP_TABLES2= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "ta_r2"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"'); -let $CHILD2_1_CREATE_TABLES2= - SELECT spider_direct_sql('CREATE TABLE "ta_r2" ( - "a" INT DEFAULT 10, - "b" CHAR(1) DEFAULT \'c\', - "c" DATE DEFAULT TO_DATE(\'1999-10-10 10:10:10\', \'YYYY-MM-DD HH24:MI:SS\'), - CONSTRAINT "pk_s_2_1_ta_r2" PRIMARY KEY("a") - )', '', 'srv "s_2_1"'); -let $CHILD2_1_SELECT_TABLES2= - SELECT spider_direct_sql('SELECT "a", "b", TO_CHAR("c", \'YYYY-MM-DD HH24:MI:SS\') FROM "ta_r2" ORDER BY "a"', '', 'srv "s_2_1"'); -let $CHILD2_1_DROP_TABLES3= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "ta_r_no_idx"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"'); -let $CHILD2_1_CREATE_TABLES3= - SELECT spider_direct_sql('CREATE TABLE "ta_r_no_idx" ( - "a" INT DEFAULT 10, - "b" CHAR(1) DEFAULT \'c\', - "c" DATE DEFAULT TO_DATE(\'1999-10-10 10:10:10\', \'YYYY-MM-DD HH24:MI:SS\') - )', '', 'srv "s_2_1"'); -let $CHILD2_1_SELECT_TABLES3= - SELECT spider_direct_sql('SELECT "a", "b", TO_CHAR("c", \'YYYY-MM-DD HH24:MI:SS\') FROM "ta_r_no_idx" ORDER BY "a"', '', 'srv "s_2_1"'); -let $CHILD2_1_DROP_TABLES4= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "ta_r_auto_inc"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"'); -let $CHILD2_1_CREATE_TABLES4= - SELECT spider_direct_sql('CREATE TABLE "ta_r_auto_inc" ( - "a" INT DEFAULT 10, - "b" CHAR(1) DEFAULT \'c\', - "c" DATE DEFAULT TO_DATE(\'1999-10-10 10:10:10\', \'YYYY-MM-DD HH24:MI:SS\'), - CONSTRAINT "pk_s_2_1_ta_r_auto_inc" PRIMARY KEY("a") - )', '', 'srv "s_2_1"'); -let $CHILD2_1_SELECT_TABLES4= - SELECT spider_direct_sql('SELECT "a", "b", TO_CHAR("c", \'YYYY-MM-DD HH24:MI:SS\') FROM "ta_r_auto_inc" - ORDER BY "a"', '', 'srv "s_2_1"'); -let $CHILD2_1_DROP_TABLES5= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "s_2_1_ta_r_int"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"'); -let $CHILD2_1_CREATE_TABLES5= - SELECT spider_direct_sql('CREATE TABLE "s_2_1_ta_r_int" ( - "a" INT DEFAULT 3, - "b" INT DEFAULT 10, - "c" INT DEFAULT 11, - CONSTRAINT "pk_s_2_1_ta_r_int" PRIMARY KEY("a") - )', '', 'srv "s_2_1"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE INDEX "idx1_s_2_1_ta_r_int" ON "s_2_1_ta_r_int"("b")', '', 'srv "s_2_1"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE INDEX "idx2_s_2_1_ta_r_int" ON "s_2_1_ta_r_int"("c")', '', 'srv "s_2_1"'); -let $CHILD2_1_SELECT_TABLES5= - SELECT spider_direct_sql('SELECT "a", "b", "c" FROM "s_2_1_ta_r_int" ORDER BY "a"', '', 'srv "s_2_1"'); -let $CHILD2_1_DROP_TABLES6= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "ta_r_3"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"'); -let $CHILD2_1_CREATE_TABLES6= - SELECT spider_direct_sql('CREATE TABLE "ta_r_3" ( - "a" INT DEFAULT 10, - "b" CHAR(1) DEFAULT \'c\', - "c" DATE DEFAULT TO_DATE(\'1999-10-10 10:10:10\', \'YYYY-MM-DD HH24:MI:SS\') - )', '', 'srv "s_2_1"'); -let $CHILD2_1_SELECT_TABLES6= - SELECT spider_direct_sql('SELECT "a", "b", TO_CHAR("c", \'YYYY-MM-DD HH24:MI:SS\') FROM "ta_r_3" ORDER BY "a"', '', 'srv "s_2_1"'); -let $CHILD2_1_DROP_FT_TABLES= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "ft_r"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"'); -let $CHILD2_1_CREATE_FT_TABLES= - SELECT spider_direct_sql('CREATE TABLE "ft_r" ( - "a" INT DEFAULT 0, - "b" TEXT, - "c" TEXT, - "d" TEXT, - CONSTRAINT "pk_s_2_1_ft_r" PRIMARY KEY("a"), - FULLTEXT INDEX "ft_idx1"("b"), - FULLTEXT INDEX "ft_idx2"("c") - )', '', 'srv "s_2_1"'); -let $CHILD2_1_SELECT_FT_TABLES= - SELECT spider_direct_sql('SELECT "a", "b", "c", "d" FROM "ft_r" ORDER BY "a"', '', 'srv "s_2_1"'); -let $CHILD2_1_DROP_FT_TABLES2= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "ft_r2"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"'); -let $CHILD2_1_CREATE_FT_TABLES2= - SELECT spider_direct_sql('CREATE TABLE "ft_r2" ( - "a" INT DEFAULT 0, - "b" TEXT, - "c" TEXT, - "d" TEXT, - CONSTRAINT "pk_s_2_1_ft_r2" PRIMARY KEY("a"), - FULLTEXT INDEX "ft_idx1"("b"), - FULLTEXT INDEX "ft_idx2"("c") - )', '', 'srv "s_2_1"'); -let $CHILD2_1_SELECT_FT_TABLES2= - SELECT spider_direct_sql('SELECT "a", "b", "c", "d" FROM "ft_r2" ORDER BY "a"', '', 'srv "s_2_1"'); -let $CHILD2_1_DROP_GM_TABLES= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "gm_r"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"'); -let $CHILD2_1_CREATE_GM_TABLES= - SELECT spider_direct_sql('CREATE TABLE "gm_r" ( - "a" INT DEFAULT 0, - "b" GEOMETRY NOT NULL, - "c" GEOMETRY NOT NULL, - CONSTRAINT "pk_s_2_1_gm_r" PRIMARY KEY("a"), - SPATIAL INDEX "sp_idx1"("b"), - SPATIAL INDEX "sp_idx2"("c") - )', '', 'srv "s_2_1"'); -let $CHILD2_1_SELECT_GM_TABLES= - SELECT spider_direct_sql('SELECT "a", "b", "c" FROM "gm_r" ORDER BY "a"', '', 'srv "s_2_1"'); -let $CHILD2_1_DROP_GM_TABLES2= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "gm_r2"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"'); -let $CHILD2_1_CREATE_GM_TABLES2= - SELECT spider_direct_sql('CREATE TABLE "gm_r2" ( - "a" INT DEFAULT 0, - "b" GEOMETRY NOT NULL, - "c" GEOMETRY NOT NULL, - CONSTRAINT "pk_s_2_1_gm_r2" PRIMARY KEY("a"), - SPATIAL INDEX "sp_idx1"("b"), - SPATIAL INDEX "sp_idx2"("c") - )', '', 'srv "s_2_1"'); -let $CHILD2_1_SELECT_GM_TABLES2= - SELECT spider_direct_sql('SELECT "a", "b", "c" FROM "gm_r2" ORDER BY "a"', '', 'srv "s_2_1"'); -let $CHILD2_1_DROP_LOCK_TABLES1= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "t1_1"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"'); -let $CHILD2_1_CREATE_LOCK_TABLES1= - SELECT spider_direct_sql('CREATE TABLE "t1_1" ( - "id" INT NOT NULL, - CONSTRAINT "pk_s_2_1_t1_1" PRIMARY KEY ("id") - )', '', 'srv "s_2_1"'); -let $CHILD2_1_DROP_LOCK_TABLES2= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "t2_2"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"'); -let $CHILD2_1_CREATE_LOCK_TABLES2= - SELECT spider_direct_sql('CREATE TABLE "t2_2" ( - "id" INT NOT NULL, - CONSTRAINT "pk_s_2_1_t2_2" PRIMARY KEY ("id") - )', '', 'srv "s_2_1"'); -let $CHILD2_1_DROP_INCREMENT_TABLES1= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "t1_1"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"'); -let $CHILD2_1_CREATE_INCREMENT_TABLES1= - SELECT spider_direct_sql('CREATE TABLE "t1_1" ( - "id" INT NOT NULL, - CONSTRAINT "pk_s_2_1_t1_1" PRIMARY KEY ("id") - )', '', 'srv "s_2_1"'); -let $CHILD2_1_SELECT_INCREMENT_TABLES1= - SELECT spider_direct_sql('SELECT "id" FROM "t1_1" ORDER BY "id"', '', 'srv "s_2_1"'); -let $CHILD2_1_DROP_TEXT_PK_TABLES1= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "t1"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"'); -let $CHILD2_1_CREATE_TEXT_PK_TABLES1= - SELECT spider_direct_sql('CREATE TABLE "t1" ( - "a" VARCHAR(255), - CONSTRAINT "pk_s_2_1_t1" PRIMARY KEY ("a") - )', '', 'srv "s_2_1"'); -let $CHILD2_1_SELECT_TEXT_PK_TABLES1= - SELECT spider_direct_sql('SELECT "a" FROM "t1" ORDER BY "a"', '', 'srv "s_2_1"'); -let $CHILD2_1_DROP_TEXT_KEY_TABLES1= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "t1"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"'); -let $CHILD2_1_CREATE_TEXT_KEY_TABLES1= - SELECT spider_direct_sql('CREATE TABLE "t1" ( - "a" VARCHAR(255), - "b" VARCHAR(255), - "c" VARCHAR(255), - CONSTRAINT "pk_s_2_1_t1" PRIMARY KEY ("c") - )', '', 'srv "s_2_1"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE INDEX "idx1_t1" ON "t1"("a","b")', '', 'srv "s_2_1"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE INDEX "idx2_t1" ON "t1"("b")', '', 'srv "s_2_1"'); -let $CHILD2_1_SELECT_TEXT_KEY_TABLES1= - SELECT spider_direct_sql('SELECT "a", "b", "c" FROM "t1" ORDER BY "c"', '', 'srv "s_2_1"'); -let $CHILD2_1_AUTO_INCREMENT_INCREMENT1= - SELECT spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_1"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE SEQUENCE "seq_t1_1" START WITH 1 INCREMENT BY 1', '', 'srv "s_2_1"'); -let $CHILD2_1_AUTO_INCREMENT_INCREMENT2= - SELECT spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_1"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE SEQUENCE "seq_t1_1" START WITH 2 INCREMENT BY 4', '', 'srv "s_2_1"'); -let $CHILD2_1_AUTO_INCREMENT_OFFSET1= - SELECT spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_1"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE SEQUENCE "seq_t1_1" START WITH 1 INCREMENT BY 1', '', 'srv "s_2_1"'); -let $CHILD2_1_AUTO_INCREMENT_OFFSET2= - SELECT spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_1"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE SEQUENCE "seq_t1_1" START WITH 2 INCREMENT BY 4', '', 'srv "s_2_1"'); diff --git a/storage/spider/mysql-test/spider/oracle2/include/init_child2_2.inc b/storage/spider/mysql-test/spider/oracle2/include/init_child2_2.inc deleted file mode 100644 index fd4497c0b59..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/include/init_child2_2.inc +++ /dev/null @@ -1,94 +0,0 @@ ---connection master_1 -SELECT spider_direct_sql('ALTER SESSION SET NLS_DATE_FORMAT=\'YYYY-MM-DD HH24:MI:SS\'', '', 'srv "s_2_2"'); -SELECT spider_direct_sql('ALTER SESSION SET NLS_TIME_FORMAT=\'HH24:MI:SSXFF\'', '', 'srv "s_2_2"'); -SELECT spider_direct_sql('ALTER SESSION SET NLS_TIMESTAMP_FORMAT=\'YYYY-MM-DD HH24:MI:SSXFF\'', '', 'srv "s_2_2"'); -let $CHILD2_2_DROP_TABLES= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "ta_r3"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_2"'); -let $CHILD2_2_CREATE_TABLES= - SELECT spider_direct_sql('CREATE TABLE "ta_r3" ( - "a" INT DEFAULT 10, - "b" CHAR(1) DEFAULT \'c\', - "c" DATE DEFAULT TO_DATE(\'1999-10-10 10:10:10\', \'YYYY-MM-DD HH24:MI:SS\'), - CONSTRAINT "pk_s_2_2_ta_r3" PRIMARY KEY("a") - )', '', 'srv "s_2_2"'); -let $CHILD2_2_DROP_TABLES5= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "s_2_2_ta_r_int"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_2"'); -let $CHILD2_2_CREATE_TABLES5= - SELECT spider_direct_sql('CREATE TABLE "s_2_2_ta_r_int" ( - "a" INT DEFAULT 3, - "b" INT DEFAULT 10, - "c" INT DEFAULT 11, - CONSTRAINT "pk_s_2_2_ta_r_int" PRIMARY KEY("a") - )', '', 'srv "s_2_2"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE INDEX "idx1_s_2_2_ta_r_int" ON "s_2_2_ta_r_int"("b")', '', 'srv "s_2_2"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE INDEX "idx2_s_2_2_ta_r_int" ON "s_2_2_ta_r_int"("c")', '', 'srv "s_2_2"'); -let $CHILD2_2_SELECT_TABLES= - SELECT spider_direct_sql('SELECT "a", "b", TO_CHAR("c", \'YYYY-MM-DD HH24:MI:SS\') FROM "ta_r3" ORDER BY "a"', '', 'srv "s_2_2"'); -let $CHILD2_2_DROP_FT_TABLES= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "ft_r3"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_2"'); -let $CHILD2_2_CREATE_FT_TABLES= - SELECT spider_direct_sql('CREATE TABLE "ft_r3" ( - "a" INT DEFAULT 0, - "b" TEXT, - "c" TEXT, - "d" TEXT, - CONSTRAINT "pk_s_2_2_ft_r3" PRIMARY KEY("a"), - FULLTEXT INDEX "ft_idx1"("b"), - FULLTEXT INDEX "ft_idx2"("c") - )', '', 'srv "s_2_2"'); -let $CHILD2_2_SELECT_FT_TABLES= - SELECT spider_direct_sql('SELECT "a", "b", "c", "d" FROM "ft_r3" ORDER BY "a"', '', 'srv "s_2_2"'); -let $CHILD2_2_DROP_GM_TABLES= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "gm_r3"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_2"'); -let $CHILD2_2_CREATE_GM_TABLES= - SELECT spider_direct_sql('CREATE TABLE "gm_r3" ( - "a" INT DEFAULT 0, - "b" GEOMETRY NOT NULL, - "c" GEOMETRY NOT NULL, - CONSTRAINT "pk_s_2_2_gm_r3" PRIMARY KEY("a"), - SPATIAL INDEX "sp_idx1"("b"), - SPATIAL INDEX "sp_idx2"("c") - )', '', 'srv "s_2_2"'); -let $CHILD2_2_SELECT_GM_TABLES= - SELECT spider_direct_sql('SELECT "a", "b", "c" FROM "gm_r3" ORDER BY "a"', '', 'srv "s_2_2"'); -let $CHILD2_2_DROP_LOCK_TABLES1= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "t1_2"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_2"'); -let $CHILD2_2_CREATE_LOCK_TABLES1= - SELECT spider_direct_sql('CREATE TABLE "t1_2" ( - "id" INT NOT NULL, - CONSTRAINT "pk_s_2_2_t1_2" PRIMARY KEY ("id") - )', '', 'srv "s_2_2"'); -let $CHILD2_2_DROP_LOCK_TABLES2= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "t2_1"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_2"'); -let $CHILD2_2_CREATE_LOCK_TABLES2= - SELECT spider_direct_sql('CREATE TABLE "t2_1" ( - "id" INT NOT NULL, - CONSTRAINT "pk_s_2_2_t2_1" PRIMARY KEY ("id") - )', '', 'srv "s_2_2"'); -let $CHILD2_2_DROP_INCREMENT_TABLES1= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "t1_2"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_2"'); -let $CHILD2_2_CREATE_INCREMENT_TABLES1= - SELECT spider_direct_sql('CREATE TABLE "t1_2" ( - "id" INT NOT NULL, - CONSTRAINT "pk_s_2_2_t1_2" PRIMARY KEY ("id") - )', '', 'srv "s_2_2"'); -let $CHILD2_2_SELECT_INCREMENT_TABLES1= - SELECT spider_direct_sql('SELECT "id" FROM "t1_2" ORDER BY "id"', '', 'srv "s_2_2"'); -let $CHILD2_2_AUTO_INCREMENT_INCREMENT1= - SELECT spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_2"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_2"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE SEQUENCE "seq_t1_2" START WITH 1 INCREMENT BY 1', '', 'srv "s_2_2"'); -let $CHILD2_2_AUTO_INCREMENT_INCREMENT2= - SELECT spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_2"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_2"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE SEQUENCE "seq_t1_2" START WITH 3 INCREMENT BY 4', '', 'srv "s_2_2"'); -let $CHILD2_2_AUTO_INCREMENT_OFFSET1= - SELECT spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_2"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_2"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE SEQUENCE "seq_t1_2" START WITH 1 INCREMENT BY 1', '', 'srv "s_2_2"'); -let $CHILD2_2_AUTO_INCREMENT_OFFSET2= - SELECT spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_2"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_2"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE SEQUENCE "seq_t1_2" START WITH 3 INCREMENT BY 4', '', 'srv "s_2_2"'); diff --git a/storage/spider/mysql-test/spider/oracle2/include/init_child2_3.inc b/storage/spider/mysql-test/spider/oracle2/include/init_child2_3.inc deleted file mode 100644 index e16dfeffd81..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/include/init_child2_3.inc +++ /dev/null @@ -1,15 +0,0 @@ ---connection master_1 -SELECT spider_direct_sql('ALTER SESSION SET NLS_DATE_FORMAT=\'YYYY-MM-DD HH24:MI:SS\'', '', 'srv "s_2_3"'); -SELECT spider_direct_sql('ALTER SESSION SET NLS_TIME_FORMAT=\'HH24:MI:SSXFF\'', '', 'srv "s_2_3"'); -SELECT spider_direct_sql('ALTER SESSION SET NLS_TIMESTAMP_FORMAT=\'YYYY-MM-DD HH24:MI:SSXFF\'', '', 'srv "s_2_3"'); -let $CHILD2_3_DROP_TABLES= - SELECT spider_direct_sql('begin execute immediate \'DROP TABLE "ta_r4"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_3"'); -let $CHILD2_3_CREATE_TABLES= - SELECT spider_direct_sql('CREATE TABLE "ta_r4" ( - "a" INT DEFAULT 10, - "b" CHAR(1) DEFAULT \'c\', - "c" DATE DEFAULT TO_DATE(\'1999-10-10 10:10:10\', \'YYYY-MM-DD HH24:MI:SS\'), - CONSTRAINT "pk_s_2_3_ta_r4" PRIMARY KEY("a") - )', '', 'srv "s_2_3"'); -let $CHILD2_3_SELECT_TABLES= - SELECT spider_direct_sql('SELECT "a", "b", TO_CHAR("c", \'YYYY-MM-DD HH24:MI:SS\') FROM "ta_r4" ORDER BY "a"', '', 'srv "s_2_3"'); diff --git a/storage/spider/mysql-test/spider/oracle2/include/init_child3_1.inc b/storage/spider/mysql-test/spider/oracle2/include/init_child3_1.inc deleted file mode 100644 index d2d308cbefe..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/include/init_child3_1.inc +++ /dev/null @@ -1,3 +0,0 @@ ---let $TEST_ENGINE_TYPE= $CHILD3_1_ENGINE_TYPE ---source ../../include/init_engine.inc ---let $INIT_CHILD3_1_ENGINE= $INIT_TEST_ENGINE diff --git a/storage/spider/mysql-test/spider/oracle2/include/init_child3_2.inc b/storage/spider/mysql-test/spider/oracle2/include/init_child3_2.inc deleted file mode 100644 index 3fbe1bd55bb..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/include/init_child3_2.inc +++ /dev/null @@ -1,3 +0,0 @@ ---let $TEST_ENGINE_TYPE= $CHILD3_2_ENGINE_TYPE ---source ../../include/init_engine.inc ---let $INIT_CHILD3_2_ENGINE= $INIT_TEST_ENGINE diff --git a/storage/spider/mysql-test/spider/oracle2/include/init_child3_3.inc b/storage/spider/mysql-test/spider/oracle2/include/init_child3_3.inc deleted file mode 100644 index 3c7aaa8af84..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/include/init_child3_3.inc +++ /dev/null @@ -1,3 +0,0 @@ ---let $TEST_ENGINE_TYPE= $CHILD3_3_ENGINE_TYPE ---source ../../include/init_engine.inc ---let $INIT_CHILD3_3_ENGINE= $INIT_TEST_ENGINE diff --git a/storage/spider/mysql-test/spider/oracle2/include/init_master_1.inc b/storage/spider/mysql-test/spider/oracle2/include/init_master_1.inc deleted file mode 100644 index 00c6f544992..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/include/init_master_1.inc +++ /dev/null @@ -1,150 +0,0 @@ ---source ../include/init_spider.inc -SET spider_direct_order_limit= 10000; -SET spider_init_sql_alloc_size= 1; -SET spider_conn_recycle_mode= 2; -let $MASTER_1_COMMENT_2_1= - COMMENT='database "$ORACLE_DATABASE", table "ta_r", wrapper "oracle", - pk_name "pk_s_2_1_ta_r"' - CONNECTION='host "$ORACLE_HOST", port "$ORACLE_PORT", user "$ORACLE_USER", - password "$ORACLE_PASSWORD"'; -let $MASTER_1_COMMENT2_2_1= - COMMENT='database "$ORACLE_DATABASE", table "ta_r_no_idx", wrapper "oracle", - pk_name "pk_s_2_1_ta_r_no_idx"' - CONNECTION='host "$ORACLE_HOST", port "$ORACLE_PORT", user "$ORACLE_USER", - password "$ORACLE_PASSWORD", prt "2000000"'; -let $MASTER_1_COMMENT_P_2_1= - COMMENT='table "ta_r3"' - PARTITION BY KEY(a) ( - PARTITION pt1 COMMENT='srv "s_2_1", table "ta_r2", - priority "1000", pk_name "pk_s_2_1_ta_r2"', - PARTITION pt2 COMMENT='srv "s_2_2", priority "1000001", - pk_name "pk_s_2_2_ta_r3"' - ); -let $MASTER_1_COMMENT2_P_2_1= - COMMENT='table "ta_r3"' - PARTITION BY RANGE(a) ( - PARTITION pt1 VALUES LESS THAN (4) COMMENT='srv "s_2_1", - table "ta_r2", priority "1000", pk_name "pk_s_2_1_ta_r2"', - PARTITION pt2 VALUES LESS THAN MAXVALUE - COMMENT='srv "s_2_2", priority "1000001", pk_name "pk_s_2_2_ta_r3"' - ); -let $MASTER_1_COMMENT3_2_1= - COMMENT='database "$ORACLE_DATABASE", table "ta_r_auto_inc", - wrapper "oracle"' - CONNECTION='host "$ORACLE_HOST", port "$ORACLE_PORT", user "$ORACLE_USER", - password "$ORACLE_PASSWORD", pk_name "pk_s_2_1_ta_r_auto_inc"'; -let $MASTER_1_COMMENT3_P_2_1= - COMMENT='table "s_2_1_ta_r_int"' - PARTITION BY LIST(MOD(a, 2)) ( - PARTITION pt1 VALUES IN (0) - COMMENT='srv "s_2_1", priority "1000", pk_name "pk_s_2_1_ta_r_int"', - PARTITION pt2 VALUES IN (1) - COMMENT='srv "s_2_2", priority "1000001", pk_name "pk_s_2_2_ta_r_int", - table "s_2_2_ta_r_int"' - ); -let $MASTER_1_COMMENT4_2_1= - COMMENT='database "$ORACLE_DATABASE", table "s_2_1_ta_r_int", - wrapper "oracle"' - CONNECTION='host "$ORACLE_HOST", port "$ORACLE_PORT", user "$ORACLE_USER", - password "$ORACLE_PASSWORD", pk_name "pk_s_2_1_ta_r_int"'; -let $MASTER_1_COMMENT5_2_1= - COMMENT='database "$ORACLE_DATABASE", table "ta_r_3", wrapper "oracle"' - CONNECTION='host "$ORACLE_HOST", port "$ORACLE_PORT", user "$ORACLE_USER", - password "$ORACLE_PASSWORD", pk_name "pk_s_2_1_ta_r_3"'; -let $MASTER_1_COMMENT_FT_2_1= - COMMENT='database "$ORACLE_DATABASE", table "ft_r", wrapper "oracle"' - CONNECTION='host "$ORACLE_HOST", port "$ORACLE_PORT", user "$ORACLE_USER", - password "$ORACLE_PASSWORD", pk_name "pk_s_2_1_ft_r"'; -let $MASTER_1_COMMENT2_FT_P_2_1= - COMMENT='table "ft_r3"' - PARTITION BY RANGE(a) ( - PARTITION pt1 VALUES LESS THAN (4) COMMENT='srv "s_2_1", - table "ft_r2", priority "1000", pk_name "pk_s_2_1_ft_r2"', - PARTITION pt2 VALUES LESS THAN MAXVALUE - COMMENT='srv "s_2_2", priority "1000001", pk_name "pk_s_2_2_ft_r3"' - ); -let $MASTER_1_COMMENT_GM_2_1= - COMMENT='srv "s_2_1", table "gm_r", pk_name "pk_s_2_1_gm_r"'; -let $MASTER_1_COMMENT2_GM_P_2_1= - COMMENT='table "gm_r3"' - PARTITION BY RANGE(a) ( - PARTITION pt1 VALUES LESS THAN (4) COMMENT='srv "s_2_1", - table "gm_r2", priority "1000", pk_name "pk_s_2_1_gm_r2"', - PARTITION pt2 VALUES LESS THAN MAXVALUE - COMMENT='srv "s_2_2", priority "1000001", pk_name "pk_s_2_2_gm_r3"' - ); -let $MASTER_1_COMMENT_LOCK1= - COMMENT 'tbl "t1_1 t1_2", srv "s_2_1 s_2_2", - pk_name "pk_s_2_1_t1_1 pk_s_2_2_t1_2"'; -let $MASTER_1_COMMENT_LOCK2= - COMMENT 'tbl "t2_1 t2_2", srv "s_2_2 s_2_1", - pk_name "pk_s_2_2_t2_1 pk_s_2_1_t2_2"'; -let $MASTER_1_COMMENT_INCREMENT1_1= - COMMENT 'aim "2", sqn "seq_t1_1", tbl "t1_1", srv "s_2_1", - pk_name "pk_s_2_1_t1_1"'; -let $MASTER_1_COMMENT_INCREMENT1_P_1= - COMMENT 'aim "2"' - PARTITION BY LIST(MOD(id, 2)) ( - PARTITION pt1 VALUES IN (0) - COMMENT='sqn "seq_t1_1", tbl "t1_1", srv "s_2_1", pk_name "pk_s_2_1_t1_1"', - PARTITION pt2 VALUES IN (1) - COMMENT='sqn "seq_t1_2", tbl "t1_2", srv "s_2_2", pk_name "pk_s_2_2_t1_2"' - ); -let $MASTER_1_COMMENT_READONLY1_1= - COMMENT 'read_only_mode "1", tbl "t1_1", srv "s_2_1", - pk_name "pk_s_2_1_t1_1"'; -let $MASTER_1_COMMENT_ERROR_MODE1_1= - COMMENT 'erm "1", ewm "1", tbl "ter1_1", srv "s_2_1", - pk_name "pk_s_2_1_ter1_1"'; -let $MASTER_1_COMMENT_TEXT_PK1_1= - COMMENT 'tbl "t1", srv "s_2_1", pk_name "pk_s_2_1_t1"'; -let $MASTER_1_COMMENT_TEXT_KEY1_1= - COMMENT 'tbl "t1", srv "s_2_1", pk_name "pk_s_2_1_t1"'; -let $MASTER_1_CHECK_DIRECT_UPDATE_STATUS= - SHOW GLOBAL STATUS LIKE 'Spider_direct_update%'; -let $MASTER_1_CHECK_DIRECT_DELETE_STATUS= - SHOW GLOBAL STATUS LIKE 'Spider_direct_delete%'; -let $MASTER_1_CHECK_DIRECT_ORDER_LIMIT_STATUS= - SHOW GLOBAL STATUS LIKE 'Spider_direct_order_limit%'; -let $MASTER_1_CHECK_DIRECT_AGGREGATE_STATUS= - SHOW GLOBAL STATUS LIKE 'Spider_direct_aggregate%'; -let $MASTER_1_AUTO_INCREMENT_INCREMENT1= - SET SESSION AUTO_INCREMENT_INCREMENT = 1 $STR_SEMICOLON - SELECT spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_1"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE SEQUENCE "seq_t1_1" START WITH 1 INCREMENT BY 1', '', 'srv "s_2_1"') - $STR_SEMICOLON - SELECT spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_2"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_2"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE SEQUENCE "seq_t1_2" START WITH 1 INCREMENT BY 1', '', 'srv "s_2_2"'); -let $MASTER_1_AUTO_INCREMENT_INCREMENT2= - SET SESSION AUTO_INCREMENT_INCREMENT = 777 $STR_SEMICOLON - SELECT spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_1"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE SEQUENCE "seq_t1_1" START WITH 2 INCREMENT BY 4', '', 'srv "s_2_1"') - $STR_SEMICOLON - SELECT spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_2"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_2"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE SEQUENCE "seq_t1_2" START WITH 3 INCREMENT BY 4', '', 'srv "s_2_2"'); -let $MASTER_1_AUTO_INCREMENT_OFFSET1= - SET SESSION AUTO_INCREMENT_OFFSET = 1 $STR_SEMICOLON - SELECT spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_1"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE SEQUENCE "seq_t1_1" START WITH 1 INCREMENT BY 1', '', 'srv "s_2_1"') - $STR_SEMICOLON - SELECT spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_2"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_2"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE SEQUENCE "seq_t1_2" START WITH 1 INCREMENT BY 1', '', 'srv "s_2_2"'); -let $MASTER_1_AUTO_INCREMENT_OFFSET2= - SET SESSION AUTO_INCREMENT_OFFSET = 777 $STR_SEMICOLON - SELECT spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_1"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_1"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE SEQUENCE "seq_t1_1" START WITH 2 INCREMENT BY 4', '', 'srv "s_2_1"') - $STR_SEMICOLON - SELECT spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_2"\'$STR_SEMICOLON exception when others then null$STR_SEMICOLON end$STR_SEMICOLON', '', 'srv "s_2_2"') - $STR_SEMICOLON - SELECT spider_direct_sql('CREATE SEQUENCE "seq_t1_2" START WITH 3 INCREMENT BY 4', '', 'srv "s_2_2"'); -let $MASTER_1_AUTO_INCREMENT_OFFSET3= - SET SESSION AUTO_INCREMENT_OFFSET = 1; -let $MASTER_1_AUTO_INCREMENT_OFFSET4= - SET SESSION AUTO_INCREMENT_OFFSET = 777; diff --git a/storage/spider/mysql-test/spider/oracle2/include/init_slave1_1.inc b/storage/spider/mysql-test/spider/oracle2/include/init_slave1_1.inc deleted file mode 100644 index 73c3c6b9ef2..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/include/init_slave1_1.inc +++ /dev/null @@ -1,10 +0,0 @@ -let $SLAVE1_1_COMMENT_INCREMENT1_1= - COMMENT ''; -let $SLAVE1_1_COMMENT_INCREMENT1_P_1= - COMMENT '' - PARTITION BY LIST(MOD(id, 2)) ( - PARTITION pt1 VALUES IN (0) - COMMENT='', - PARTITION pt2 VALUES IN (1) - COMMENT='' - ); diff --git a/storage/spider/mysql-test/spider/oracle2/include/init_spider.inc b/storage/spider/mysql-test/spider/oracle2/include/init_spider.inc deleted file mode 100644 index ff9ac9aee29..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/include/init_spider.inc +++ /dev/null @@ -1,105 +0,0 @@ ---source ../../include/init_spider.inc -let $VERSION_COMPILE_OS_WIN= - `SELECT IF(@@version_compile_os like 'Win%', 1, 0)`; -if ($VERSION_COMPILE_OS_WIN) -{ - eval DROP SERVER s_2_1; - eval CREATE SERVER s_2_1 FOREIGN DATA WRAPPER oracle OPTIONS ( - HOST '$ORACLE_HOST', - DATABASE '$ORACLE_DATABASE', - USER '$ORACLE_USER', - PASSWORD '$ORACLE_PASSWORD', - PORT $ORACLE_PORT - ); - eval DROP SERVER s_2_2; - eval CREATE SERVER s_2_2 FOREIGN DATA WRAPPER oracle OPTIONS ( - HOST '$ORACLE_HOST', - DATABASE '$ORACLE_DATABASE', - USER '$ORACLE_USER', - PASSWORD '$ORACLE_PASSWORD', - PORT $ORACLE_PORT - ); - eval DROP SERVER s_2_3; - eval CREATE SERVER s_2_3 FOREIGN DATA WRAPPER oracle OPTIONS ( - HOST '$ORACLE_HOST', - DATABASE '$ORACLE_DATABASE', - USER '$ORACLE_USER', - PASSWORD '$ORACLE_PASSWORD', - PORT $ORACLE_PORT - ); - eval DROP SERVER s_3_1; - eval CREATE SERVER s_3_1 FOREIGN DATA WRAPPER mysql OPTIONS ( - HOST 'localhost', - DATABASE 'auto_test_local', - USER 'root', - PASSWORD '', - PORT $CHILD3_1_MYPORT - ); - eval DROP SERVER s_3_2; - eval CREATE SERVER s_3_2 FOREIGN DATA WRAPPER mysql OPTIONS ( - HOST 'localhost', - DATABASE 'auto_test_local', - USER 'root', - PASSWORD '', - PORT $CHILD3_2_MYPORT - ); - eval DROP SERVER s_3_3; - eval CREATE SERVER s_3_3 FOREIGN DATA WRAPPER mysql OPTIONS ( - HOST 'localhost', - DATABASE 'auto_test_local', - USER 'root', - PASSWORD '', - PORT $CHILD2_3_MYPORT - ); -} -if (!$VERSION_COMPILE_OS_WIN) -{ - eval DROP SERVER s_2_1; - eval CREATE SERVER s_2_1 FOREIGN DATA WRAPPER oracle OPTIONS ( - HOST '$ORACLE_HOST', - DATABASE '$ORACLE_DATABASE', - USER '$ORACLE_USER', - PASSWORD '$ORACLE_PASSWORD', - PORT $ORACLE_PORT - ); - eval DROP SERVER s_2_2; - eval CREATE SERVER s_2_2 FOREIGN DATA WRAPPER oracle OPTIONS ( - HOST '$ORACLE_HOST', - DATABASE '$ORACLE_DATABASE', - USER '$ORACLE_USER', - PASSWORD '$ORACLE_PASSWORD', - PORT $ORACLE_PORT - ); - eval DROP SERVER s_2_3; - eval CREATE SERVER s_2_3 FOREIGN DATA WRAPPER oracle OPTIONS ( - HOST '$ORACLE_HOST', - DATABASE '$ORACLE_DATABASE', - USER '$ORACLE_USER', - PASSWORD '$ORACLE_PASSWORD', - PORT $ORACLE_PORT - ); - eval DROP SERVER s_3_1; - eval CREATE SERVER s_3_1 FOREIGN DATA WRAPPER mysql OPTIONS ( - HOST 'localhost', - DATABASE 'auto_test_local', - USER 'root', - PASSWORD '', - SOCKET '$CHILD3_1_MYSOCK' - ); - eval DROP SERVER s_3_2; - eval CREATE SERVER s_3_2 FOREIGN DATA WRAPPER mysql OPTIONS ( - HOST 'localhost', - DATABASE 'auto_test_local', - USER 'root', - PASSWORD '', - SOCKET '$CHILD3_2_MYSOCK' - ); - eval DROP SERVER s_3_3; - eval CREATE SERVER s_3_3 FOREIGN DATA WRAPPER mysql OPTIONS ( - HOST 'localhost', - DATABASE 'auto_test_local', - USER 'root', - PASSWORD '', - SOCKET '$CHILD3_3_MYSOCK' - ); -} diff --git a/storage/spider/mysql-test/spider/oracle2/my.cnf b/storage/spider/mysql-test/spider/oracle2/my.cnf deleted file mode 100644 index efa05c8e8b0..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/my.cnf +++ /dev/null @@ -1,146 +0,0 @@ -# Use default setting for mysqld processes -!include include/default_mysqld.cnf - -[mysqld.1.1] -log-bin= master-bin -loose_handlersocket_port= 20000 -loose_handlersocket_port_wr= 20001 -loose_handlersocket_threads= 2 -loose_handlersocket_threads_wr= 1 -loose_handlersocket_support_merge_table= 0 -loose_handlersocket_direct_update_mode= 2 -loose_handlersocket_unlimited_boundary= 65536 -loose_handlersocket_bulk_insert= 0 -loose_handlersocket_bulk_insert_timeout= 0 -loose_handlersocket_general_log= 1 -loose_handlersocket_timeout= 30 -loose_handlersocket_close_table_interval=2 -open_files_limit= 4096 -loose_partition= 1 - -[mysqld.3.1] -loose_partition= 1 - -[mysqld.3.2] -loose_partition= 1 - -[mysqld.3.3] -loose_partition= 1 - -[mysqld.4.1] -loose_partition= 1 - - -[ENV] -USE_GEOMETRY_TEST= 0 -USE_FULLTEXT_TEST= 0 -USE_HA_TEST= 1 -USE_GENERAL_LOG= 1 -USE_REPLICATION= 0 -MASTER_1_MYPORT= @mysqld.1.1.port -MASTER_1_HSRPORT= 20000 -MASTER_1_HSWPORT= 20001 -MASTER_1_MYSOCK= @mysqld.1.1.socket -MASTER_1_ENGINE_TYPE= Spider -#MASTER_1_ENGINE_TYPE= MyISAM -MASTER_1_ENGINE= ENGINE=Spider -MASTER_1_CHARSET= DEFAULT CHARSET=utf8 -MASTER_1_ENGINE2= ENGINE=MyISAM -MASTER_1_CHARSET2= DEFAULT CHARSET=utf8 -MASTER_1_CHARSET3= DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci -SLAVE1_1_MYPORT= @mysqld.4.1.port -SLAVE1_1_MYSOCK= @mysqld.4.1.socket -SLAVE1_1_ENGINE_TYPE= MyISAM -SLAVE1_1_ENGINE= ENGINE=MyISAM -SLAVE1_1_CHARSET= DEFAULT CHARSET=utf8 -USE_CHILD_GROUP2= 1 -OUTPUT_CHILD_GROUP2= 0 -CHILD2_1_MYPORT= @mysqld.1.1.port -CHILD2_1_MYSOCK= @mysqld.1.1.socket -CHILD2_1_ENGINE_TYPE= InnoDB -CHILD2_1_ENGINE= ENGINE=InnoDB -CHILD2_1_CHARSET= DEFAULT CHARSET=utf8 -CHILD2_1_CHARSET2= DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci -CHILD2_2_MYPORT= @mysqld.1.1.port -CHILD2_2_MYSOCK= @mysqld.1.1.socket -CHILD2_2_ENGINE_TYPE= InnoDB -CHILD2_2_ENGINE= ENGINE=InnoDB -CHILD2_2_CHARSET= DEFAULT CHARSET=utf8 -CHILD2_3_MYPORT= @mysqld.1.1.port -CHILD2_3_MYSOCK= @mysqld.1.1.socket -CHILD2_3_ENGINE_TYPE= InnoDB -CHILD2_3_ENGINE= ENGINE=InnoDB -CHILD2_3_CHARSET= DEFAULT CHARSET=utf8 -CHILD2_1_FT_MYPORT= @mysqld.1.1.port -CHILD2_1_FT_MYSOCK= @mysqld.1.1.socket -CHILD2_1_FT_ENGINE_TYPE= MyISAM -CHILD2_1_FT_ENGINE= ENGINE=MyISAM -CHILD2_1_FT_CHARSET= DEFAULT CHARSET=utf8 -CHILD2_2_FT_MYPORT= @mysqld.1.1.port -CHILD2_2_FT_MYSOCK= @mysqld.1.1.socket -CHILD2_2_FT_ENGINE_TYPE= MyISAM -CHILD2_2_FT_ENGINE= ENGINE=MyISAM -CHILD2_2_FT_CHARSET= DEFAULT CHARSET=utf8 -CHILD2_1_GM_MYPORT= @mysqld.1.1.port -CHILD2_1_GM_MYSOCK= @mysqld.1.1.socket -CHILD2_1_GM_ENGINE_TYPE= MyISAM -CHILD2_1_GM_ENGINE= ENGINE=MyISAM -CHILD2_1_GM_CHARSET= DEFAULT CHARSET=utf8 -CHILD2_2_GM_MYPORT= @mysqld.1.1.port -CHILD2_2_GM_MYSOCK= @mysqld.1.1.socket -CHILD2_2_GM_ENGINE_TYPE= MyISAM -CHILD2_2_GM_ENGINE= ENGINE=MyISAM -CHILD2_2_GM_CHARSET= DEFAULT CHARSET=utf8 -USE_CHILD_GROUP3= 1 -OUTPUT_CHILD_GROUP3= 0 -CHILD3_1_MYPORT= @mysqld.3.1.port -CHILD3_1_MYSOCK= @mysqld.3.1.socket -CHILD3_1_ENGINE_TYPE= InnoDB -CHILD3_1_ENGINE= ENGINE=InnoDB -CHILD3_1_CHARSET= DEFAULT CHARSET=utf8 -CHILD3_2_MYPORT= @mysqld.3.2.port -CHILD3_2_MYSOCK= @mysqld.3.2.socket -CHILD3_2_ENGINE_TYPE= InnoDB -CHILD3_2_ENGINE= ENGINE=InnoDB -CHILD3_2_CHARSET= DEFAULT CHARSET=utf8 -CHILD3_3_MYPORT= @mysqld.3.3.port -CHILD3_3_MYSOCK= @mysqld.3.3.socket -CHILD3_3_ENGINE_TYPE= InnoDB -CHILD3_3_ENGINE= ENGINE=InnoDB -CHILD3_3_CHARSET= DEFAULT CHARSET=utf8 -ORACLE_HOST= xe -ORACLE_PORT= 1521 -ORACLE_USER= system -ORACLE_PASSWORD= oracle -ORACLE_DATABASE= SYSTEM - -STR_SEMICOLON= ; - -#The followings are set in include/init_xxx.inc files -# MASTER_1_COMMENT_2_1 -# MASTER_1_COMMENT2_2_1 -# MASTER_1_COMMENT3_2_1 -# MASTER_1_COMMENT4_2_1 -# MASTER_1_COMMENT5_2_1 -# MASTER_1_COMMENT_P_2_1 -# CHILD2_1_DROP_TABLES -# CHILD2_1_CREATE_TABLES -# CHILD2_1_SELECT_TABLES -# CHILD2_1_DROP_TABLES2 -# CHILD2_1_CREATE_TABLES2 -# CHILD2_1_SELECT_TABLES2 -# CHILD2_1_DROP_TABLES3 -# CHILD2_1_CREATE_TABLES3 -# CHILD2_1_SELECT_TABLES3 -# CHILD2_1_DROP_TABLES4 -# CHILD2_1_CREATE_TABLES4 -# CHILD2_1_SELECT_TABLES4 -# CHILD2_1_DROP_TABLES5 -# CHILD2_1_CREATE_TABLES5 -# CHILD2_1_SELECT_TABLES5 -# CHILD2_1_DROP_TABLES6 -# CHILD2_1_CREATE_TABLES6 -# CHILD2_1_SELECT_TABLES6 -# CHILD2_2_DROP_TABLES -# CHILD2_2_CREATE_TABLES -# CHILD2_2_SELECT_TABLES diff --git a/storage/spider/mysql-test/spider/oracle2/r/basic_sql.result b/storage/spider/mysql-test/spider/oracle2/r/basic_sql.result deleted file mode 100644 index 1e9fe78acea..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/r/basic_sql.result +++ /dev/null @@ -1,634 +0,0 @@ -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -drop and create databases -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -CREATE DATABASE auto_test_remote; -USE auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -CREATE DATABASE auto_test_remote2; -USE auto_test_remote2; - -test select 1 -SELECT 1; -1 -1 - -create table select test -DROP TABLE IF EXISTS tb_l; -CREATE TABLE tb_l ( -a INT, -b CHAR(1), -c DATETIME, -PRIMARY KEY(a) -) MASTER_1_ENGINE2 MASTER_1_CHARSET2 -INSERT INTO tb_l (a, b, c) VALUES -(1, 'a', '2008-08-01 10:21:39'), -(2, 'b', '2000-01-01 00:00:00'), -(3, 'e', '2007-06-04 20:03:11'), -(4, 'd', '2003-11-30 05:01:03'), -(5, 'c', '2001-12-31 23:59:59'); -DROP TABLE IF EXISTS ta_l; -CREATE TABLE ta_l ( -PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_2_1 -SELECT a, b, c FROM tb_l -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-01 10:21:39 -2 b 2000-01-01 00:00:00 -3 e 2007-06-04 20:03:11 -4 d 2003-11-30 05:01:03 -5 c 2001-12-31 23:59:59 - -create table ignore select test -DROP TABLE IF EXISTS ta_l; -DROP TABLE IF EXISTS tb_l; -CREATE TABLE tb_l ( -a INT, -b CHAR(1), -c DATETIME, -PRIMARY KEY(a) -) MASTER_1_ENGINE2 MASTER_1_CHARSET2 -INSERT INTO tb_l (a, b, c) VALUES -(1, 'f', '2008-07-01 10:21:39'), -(2, 'g', '2000-02-01 00:00:00'), -(3, 'j', '2007-05-04 20:03:11'), -(4, 'i', '2003-10-30 05:01:03'), -(5, 'h', '2001-10-31 23:59:59'); -CREATE TABLE ta_l ( -PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_2_1 -IGNORE SELECT a, b, c FROM tb_l -Warnings: -Warning 1062 Duplicate entry '1' for key 'PRIMARY' -Warning 1062 Duplicate entry '2' for key 'PRIMARY' -Warning 1062 Duplicate entry '3' for key 'PRIMARY' -Warning 1062 Duplicate entry '4' for key 'PRIMARY' -Warning 1062 Duplicate entry '5' for key 'PRIMARY' -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-01 10:21:39 -2 b 2000-01-01 00:00:00 -3 e 2007-06-04 20:03:11 -4 d 2003-11-30 05:01:03 -5 c 2001-12-31 23:59:59 - -create table ignore select test -DROP TABLE IF EXISTS ta_l; -CREATE TABLE ta_l ( -PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_2_1 -REPLACE SELECT a, b, c FROM tb_l -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -create no index table -DROP TABLE IF EXISTS ta_l_no_idx; -CREATE TABLE ta_l_no_idx -MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT2_2_1 -SELECT a, b, c FROM tb_l -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l_no_idx ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -select table -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -select table shared mode -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a -LOCK IN SHARE MODE; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -select table for update -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a -FOR UPDATE; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -select table join -SELECT a.a, a.b, date_format(b.c, '%Y-%m-%d %H:%i:%s') FROM ta_l a, tb_l b -WHERE a.a = b.a ORDER BY a.a; -a b date_format(b.c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -select table straight_join -SELECT STRAIGHT_JOIN a.a, a.b, date_format(b.c, '%Y-%m-%d %H:%i:%s') -FROM ta_l a, tb_l b WHERE a.a = b.a ORDER BY a.a; -a b date_format(b.c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -select sql_small_result -SELECT SQL_SMALL_RESULT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l -ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -select sql_big_result -SELECT SQL_BIG_RESULT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l -ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -select sql_buffer_result -SELECT SQL_BUFFER_RESULT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l -ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -select sql_cache -SELECT SQL_CACHE a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l -ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -select sql_no_cache -SELECT SQL_NO_CACHE a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l -ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -select sql_calc_found_rows -SELECT SQL_CALC_FOUND_ROWS a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l -ORDER BY a LIMIT 4; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -SELECT found_rows(); -found_rows() -5 - -select high_priority -SELECT HIGH_PRIORITY a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l -ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -select distinct -SELECT DISTINCT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l -ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -select count -SELECT count(*) FROM ta_l ORDER BY a; -count(*) -5 - -select table join not use index -SELECT a.a, a.b, date_format(a.c, '%Y-%m-%d %H:%i:%s') FROM tb_l a WHERE -EXISTS (SELECT * FROM ta_l b WHERE b.b = a.b) ORDER BY a.a; -a b date_format(a.c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -select using pushdown -SELECT a.a, a.b, date_format(a.c, '%Y-%m-%d %H:%i:%s') FROM ta_l a WHERE -a.b = 'g' ORDER BY a.a; -a b date_format(a.c, '%Y-%m-%d %H:%i:%s') -2 g 2000-02-01 00:00:00 - -select using index and pushdown -SELECT a.a, a.b, date_format(a.c, '%Y-%m-%d %H:%i:%s') FROM ta_l a WHERE -a.a > 0 AND a.b = 'g' ORDER BY a.a; -a b date_format(a.c, '%Y-%m-%d %H:%i:%s') -2 g 2000-02-01 00:00:00 - -insert -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (2, 'e', '2008-01-01 23:59:59'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -2 e 2008-01-01 23:59:59 - -insert select -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) SELECT a, b, c FROM tb_l; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -insert select a -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES ((SELECT a FROM tb_l ORDER BY a LIMIT 1), -'e', '2008-01-01 23:59:59'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 e 2008-01-01 23:59:59 - -insert low_priority -TRUNCATE TABLE ta_l; -INSERT LOW_PRIORITY INTO ta_l (a, b, c) values (2, 'e', '2008-01-01 23:59:59'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -2 e 2008-01-01 23:59:59 - -insert high_priority -TRUNCATE TABLE ta_l; -INSERT HIGH_PRIORITY INTO ta_l (a, b, c) VALUES (2, 'e', -'2008-01-01 23:59:59'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -2 e 2008-01-01 23:59:59 - -insert ignore -INSERT IGNORE INTO ta_l (a, b, c) VALUES (2, 'd', '2009-02-02 01:01:01'); -Warnings: -Warning 1062 Duplicate entry '2' for key 'PRIMARY' -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -2 e 2008-01-01 23:59:59 - -insert update (insert) -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (2, 'e', '2008-01-01 23:59:59') ON DUPLICATE -KEY UPDATE b = 'f', c = '2005-08-08 11:11:11'; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -2 e 2008-01-01 23:59:59 - -insert update (update) -INSERT INTO ta_l (a, b, c) VALUES (2, 'e', '2008-01-01 23:59:59') ON DUPLICATE -KEY UPDATE b = 'f', c = '2005-08-08 11:11:11'; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -2 f 2005-08-08 11:11:11 - -replace -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (2, 'e', '2008-01-01 23:59:59'); -REPLACE INTO ta_l (a, b, c) VALUES (2, 'f', '2008-02-02 02:02:02'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -2 f 2008-02-02 02:02:02 - -replace select -REPLACE INTO ta_l (a, b, c) SELECT a, b, c FROM tb_l; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -replace select a -REPLACE INTO ta_l (a, b, c) VALUES ((SELECT a FROM tb_l ORDER BY a LIMIT 1), -'e', '2008-01-01 23:59:59'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 e 2008-01-01 23:59:59 -2 g 2000-02-01 00:00:00 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -replace low_priority -REPLACE LOW_PRIORITY INTO ta_l (a, b, c) VALUES (3, 'g', -'2009-03-03 03:03:03'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 e 2008-01-01 23:59:59 -2 g 2000-02-01 00:00:00 -3 g 2009-03-03 03:03:03 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -update -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (1, 'e', '2008-01-01 23:59:59'), -(2, 'e', '2008-01-01 23:59:59'); -UPDATE ta_l SET b = 'f', c = '2008-02-02 02:02:02' WHERE a = 2; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 e 2008-01-01 23:59:59 -2 f 2008-02-02 02:02:02 - -update select -UPDATE ta_l SET b = 'g', c = '2009-03-03 03:03:03' WHERE a IN (SELECT a FROM -tb_l); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 g 2009-03-03 03:03:03 -2 g 2009-03-03 03:03:03 - -update select a -UPDATE ta_l SET b = 'h', c = '2010-04-04 04:04:04' WHERE a = (SELECT a FROM -tb_l ORDER BY a LIMIT 1); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 h 2010-04-04 04:04:04 -2 g 2009-03-03 03:03:03 - -update join -UPDATE ta_l a, tb_l b SET a.b = b.b, a.c = b.c WHERE a.a = b.a; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 - -update join a -UPDATE ta_l a, tb_l b SET a.b = 'g', a.c = '2009-03-03 03:03:03' WHERE -a.a = b.a; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 g 2009-03-03 03:03:03 -2 g 2009-03-03 03:03:03 - -update low_priority -UPDATE LOW_PRIORITY ta_l SET b = 'f', c = '2008-02-02 02:02:02' WHERE a = 2; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 g 2009-03-03 03:03:03 -2 f 2008-02-02 02:02:02 - -update ignore -UPDATE IGNORE ta_l SET a = 1, b = 'g', c = '2009-03-03 03:03:03' WHERE a = 2; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 g 2009-03-03 03:03:03 -2 f 2008-02-02 02:02:02 - -update pushdown -update ta_l set b = 'j', c = '2009-03-03 03:03:03' where b = 'f'; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 g 2009-03-03 03:03:03 -2 j 2009-03-03 03:03:03 - -update index pushdown -UPDATE ta_l SET b = 'g', c = '2009-03-03 03:03:03' WHERE a > 0 AND b = 'j'; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 g 2009-03-03 03:03:03 -2 g 2009-03-03 03:03:03 - -delete -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (1, 'e', '2008-01-01 23:59:59'), -(2, 'e', '2008-01-01 23:59:59'), (3, 'e', '2008-01-01 23:59:59'), -(4, 'e', '2008-01-01 23:59:59'), (5, 'e', '2008-01-01 23:59:59'), -(6, 'e', '2008-01-01 23:59:59'), (7, 'e', '2008-01-01 23:59:59'), -(8, 'e', '2008-01-01 23:59:59'), (9, 'e', '2008-01-01 23:59:59'), -(10, 'j', '2008-01-01 23:59:59'); -DELETE FROM ta_l WHERE a = 2; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 e 2008-01-01 23:59:59 -3 e 2008-01-01 23:59:59 -4 e 2008-01-01 23:59:59 -5 e 2008-01-01 23:59:59 -6 e 2008-01-01 23:59:59 -7 e 2008-01-01 23:59:59 -8 e 2008-01-01 23:59:59 -9 e 2008-01-01 23:59:59 -10 j 2008-01-01 23:59:59 - -delete all -DELETE FROM ta_l; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') - -delete select -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (1, 'e', '2008-01-01 23:59:59'), -(2, 'e', '2008-01-01 23:59:59'), (3, 'e', '2008-01-01 23:59:59'), -(4, 'e', '2008-01-01 23:59:59'), (5, 'e', '2008-01-01 23:59:59'), -(6, 'e', '2008-01-01 23:59:59'), (7, 'e', '2008-01-01 23:59:59'), -(8, 'e', '2008-01-01 23:59:59'), (9, 'e', '2008-01-01 23:59:59'), -(10, 'j', '2008-01-01 23:59:59'); -DELETE FROM ta_l WHERE a IN (SELECT a FROM tb_l); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -6 e 2008-01-01 23:59:59 -7 e 2008-01-01 23:59:59 -8 e 2008-01-01 23:59:59 -9 e 2008-01-01 23:59:59 -10 j 2008-01-01 23:59:59 - -delete select a -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (1, 'e', '2008-01-01 23:59:59'), -(2, 'e', '2008-01-01 23:59:59'), (3, 'e', '2008-01-01 23:59:59'), -(4, 'e', '2008-01-01 23:59:59'), (5, 'e', '2008-01-01 23:59:59'), -(6, 'e', '2008-01-01 23:59:59'), (7, 'e', '2008-01-01 23:59:59'), -(8, 'e', '2008-01-01 23:59:59'), (9, 'e', '2008-01-01 23:59:59'), -(10, 'j', '2008-01-01 23:59:59'); -DELETE FROM ta_l WHERE a = (SELECT a FROM tb_l ORDER BY a LIMIT 1); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -2 e 2008-01-01 23:59:59 -3 e 2008-01-01 23:59:59 -4 e 2008-01-01 23:59:59 -5 e 2008-01-01 23:59:59 -6 e 2008-01-01 23:59:59 -7 e 2008-01-01 23:59:59 -8 e 2008-01-01 23:59:59 -9 e 2008-01-01 23:59:59 -10 j 2008-01-01 23:59:59 - -delete join -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (1, 'e', '2008-01-01 23:59:59'), -(2, 'e', '2008-01-01 23:59:59'), (3, 'e', '2008-01-01 23:59:59'), -(4, 'e', '2008-01-01 23:59:59'), (5, 'e', '2008-01-01 23:59:59'), -(6, 'e', '2008-01-01 23:59:59'), (7, 'e', '2008-01-01 23:59:59'), -(8, 'e', '2008-01-01 23:59:59'), (9, 'e', '2008-01-01 23:59:59'), -(10, 'j', '2008-01-01 23:59:59'); -DELETE a FROM ta_l a, (SELECT a FROM tb_l ORDER BY a) b WHERE a.a = b.a; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -6 e 2008-01-01 23:59:59 -7 e 2008-01-01 23:59:59 -8 e 2008-01-01 23:59:59 -9 e 2008-01-01 23:59:59 -10 j 2008-01-01 23:59:59 - -delete low_priority -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (1, 'e', '2008-01-01 23:59:59'), -(2, 'e', '2008-01-01 23:59:59'), (3, 'e', '2008-01-01 23:59:59'), -(4, 'e', '2008-01-01 23:59:59'), (5, 'e', '2008-01-01 23:59:59'), -(6, 'e', '2008-01-01 23:59:59'), (7, 'e', '2008-01-01 23:59:59'), -(8, 'e', '2008-01-01 23:59:59'), (9, 'e', '2008-01-01 23:59:59'), -(10, 'j', '2008-01-01 23:59:59'); -DELETE LOW_PRIORITY FROM ta_l WHERE a = 2; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 e 2008-01-01 23:59:59 -3 e 2008-01-01 23:59:59 -4 e 2008-01-01 23:59:59 -5 e 2008-01-01 23:59:59 -6 e 2008-01-01 23:59:59 -7 e 2008-01-01 23:59:59 -8 e 2008-01-01 23:59:59 -9 e 2008-01-01 23:59:59 -10 j 2008-01-01 23:59:59 - -delete ignore -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (1, 'e', '2008-01-01 23:59:59'), -(2, 'e', '2008-01-01 23:59:59'), (3, 'e', '2008-01-01 23:59:59'), -(4, 'e', '2008-01-01 23:59:59'), (5, 'e', '2008-01-01 23:59:59'), -(6, 'e', '2008-01-01 23:59:59'), (7, 'e', '2008-01-01 23:59:59'), -(8, 'e', '2008-01-01 23:59:59'), (9, 'e', '2008-01-01 23:59:59'), -(10, 'j', '2008-01-01 23:59:59'); -DELETE IGNORE FROM ta_l WHERE a = 2; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 e 2008-01-01 23:59:59 -3 e 2008-01-01 23:59:59 -4 e 2008-01-01 23:59:59 -5 e 2008-01-01 23:59:59 -6 e 2008-01-01 23:59:59 -7 e 2008-01-01 23:59:59 -8 e 2008-01-01 23:59:59 -9 e 2008-01-01 23:59:59 -10 j 2008-01-01 23:59:59 - -delete quick -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (1, 'e', '2008-01-01 23:59:59'), -(2, 'e', '2008-01-01 23:59:59'), (3, 'e', '2008-01-01 23:59:59'), -(4, 'e', '2008-01-01 23:59:59'), (5, 'e', '2008-01-01 23:59:59'), -(6, 'e', '2008-01-01 23:59:59'), (7, 'e', '2008-01-01 23:59:59'), -(8, 'e', '2008-01-01 23:59:59'), (9, 'e', '2008-01-01 23:59:59'), -(10, 'j', '2008-01-01 23:59:59'); -DELETE QUICK FROM ta_l WHERE a = 2; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 e 2008-01-01 23:59:59 -3 e 2008-01-01 23:59:59 -4 e 2008-01-01 23:59:59 -5 e 2008-01-01 23:59:59 -6 e 2008-01-01 23:59:59 -7 e 2008-01-01 23:59:59 -8 e 2008-01-01 23:59:59 -9 e 2008-01-01 23:59:59 -10 j 2008-01-01 23:59:59 - -delete pushdown -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (1, 'e', '2008-01-01 23:59:59'), -(2, 'e', '2008-01-01 23:59:59'), (3, 'e', '2008-01-01 23:59:59'), -(4, 'e', '2008-01-01 23:59:59'), (5, 'e', '2008-01-01 23:59:59'), -(6, 'e', '2008-01-01 23:59:59'), (7, 'e', '2008-01-01 23:59:59'), -(8, 'e', '2008-01-01 23:59:59'), (9, 'e', '2008-01-01 23:59:59'), -(10, 'j', '2008-01-01 23:59:59'); -DELETE FROM ta_l WHERE b = 'e'; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -10 j 2008-01-01 23:59:59 - -delete index pushdown -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (1, 'e', '2008-01-01 23:59:59'), -(2, 'e', '2008-01-01 23:59:59'), (3, 'e', '2008-01-01 23:59:59'), -(4, 'e', '2008-01-01 23:59:59'), (5, 'e', '2008-01-01 23:59:59'), -(6, 'e', '2008-01-01 23:59:59'), (7, 'e', '2008-01-01 23:59:59'), -(8, 'e', '2008-01-01 23:59:59'), (9, 'e', '2008-01-01 23:59:59'), -(10, 'j', '2008-01-01 23:59:59'); -DELETE FROM ta_l WHERE a > 0 AND b = 'e'; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -10 j 2008-01-01 23:59:59 - -truncate -TRUNCATE TABLE ta_l; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') - -deinit -DROP DATABASE IF EXISTS auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -end of test diff --git a/storage/spider/mysql-test/spider/oracle2/r/basic_sql_part.result b/storage/spider/mysql-test/spider/oracle2/r/basic_sql_part.result deleted file mode 100644 index 9e1201c17c9..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/r/basic_sql_part.result +++ /dev/null @@ -1,121 +0,0 @@ -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -drop and create databases -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -CREATE DATABASE auto_test_remote; -USE auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -CREATE DATABASE auto_test_remote2; -USE auto_test_remote2; - -test select 1 -SELECT 1; -1 -1 -DROP TABLE IF EXISTS tb_l; -CREATE TABLE tb_l ( -a INT, -b CHAR(1), -c DATETIME, -PRIMARY KEY(a) -) MASTER_1_ENGINE2 MASTER_1_CHARSET2 -INSERT INTO tb_l (a, b, c) VALUES -(1, 'f', '2008-07-01 10:21:39'), -(2, 'g', '2000-02-01 00:00:00'), -(3, 'j', '2007-05-04 20:03:11'), -(4, 'i', '2003-10-30 05:01:03'), -(5, 'h', '2001-10-31 23:59:59'); - -create table with partition and select test -CREATE TABLE ta_l2 ( -PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_COMMENT_P_2_1 -SELECT a, b, c FROM tb_l -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -select partition using pushdown -SELECT a.a, a.b, date_format(a.c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 a WHERE -a.b = 'g' ORDER BY a.a; -a b date_format(a.c, '%Y-%m-%d %H:%i:%s') -2 g 2000-02-01 00:00:00 - -select partition using index pushdown -SELECT a.a, a.b, date_format(a.c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 a WHERE -a.a > 0 AND a.b = 'g' ORDER BY a.a; -a b date_format(a.c, '%Y-%m-%d %H:%i:%s') -2 g 2000-02-01 00:00:00 - -update partition pushdown -UPDATE ta_l2 SET b = 'e', c = '2009-03-03 03:03:03' WHERE b = 'j'; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 -3 e 2009-03-03 03:03:03 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -update partition index pushdown -UPDATE ta_l2 SET b = 'j', c = '2009-03-03 03:03:03' WHERE a > 0 AND b = 'e'; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -2 g 2000-02-01 00:00:00 -3 j 2009-03-03 03:03:03 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -delete partition pushdown -TRUNCATE TABLE ta_l2; -INSERT INTO ta_l2 SELECT a, b, c FROM tb_l; -DELETE FROM ta_l2 WHERE b = 'g'; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -delete partition index pushdown -TRUNCATE TABLE ta_l2; -INSERT INTO ta_l2 SELECT a, b, c FROM tb_l; -DELETE FROM ta_l2 WHERE a > 0 AND b = 'g'; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 f 2008-07-01 10:21:39 -3 j 2007-05-04 20:03:11 -4 i 2003-10-30 05:01:03 -5 h 2001-10-31 23:59:59 - -deinit -DROP DATABASE IF EXISTS auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -end of test diff --git a/storage/spider/mysql-test/spider/oracle2/r/direct_aggregate.result b/storage/spider/mysql-test/spider/oracle2/r/direct_aggregate.result deleted file mode 100644 index fe5752cff65..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/r/direct_aggregate.result +++ /dev/null @@ -1,91 +0,0 @@ -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -drop and create databases -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -CREATE DATABASE auto_test_remote; -USE auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -CREATE DATABASE auto_test_remote2; -USE auto_test_remote2; - -test select 1 -SELECT 1; -1 -1 - -create table select test -DROP TABLE IF EXISTS ta_l; -CREATE TABLE ta_l ( -a INT, -b CHAR(1), -c DATETIME, -PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_2_1 -INSERT INTO ta_l (a, b, c) VALUES -(1, 'a', '2008-08-01 10:21:39'), -(2, 'b', '2000-01-01 00:00:00'), -(3, 'e', '2007-06-04 20:03:11'), -(4, 'd', '2003-11-30 05:01:03'), -(5, 'c', '2001-12-31 23:59:59'); - -direct_aggregating test -SHOW GLOBAL STATUS LIKE 'Spider_direct_aggregate%'; -Variable_name Value -Spider_direct_aggregate 0 -SELECT COUNT(*) FROM ta_l; -COUNT(*) -5 -SHOW GLOBAL STATUS LIKE 'Spider_direct_aggregate%'; -Variable_name Value -Spider_direct_aggregate 1 -SELECT MAX(a) FROM ta_l; -MAX(a) -5 -SHOW GLOBAL STATUS LIKE 'Spider_direct_aggregate%'; -Variable_name Value -Spider_direct_aggregate 1 -SELECT MIN(a) FROM ta_l; -MIN(a) -1 -SHOW GLOBAL STATUS LIKE 'Spider_direct_aggregate%'; -Variable_name Value -Spider_direct_aggregate 1 -SELECT MAX(a) FROM ta_l WHERE a < 5; -MAX(a) -4 -SHOW GLOBAL STATUS LIKE 'Spider_direct_aggregate%'; -Variable_name Value -Spider_direct_aggregate 1 -SELECT MIN(a) FROM ta_l WHERE a > 1; -MIN(a) -2 -SHOW GLOBAL STATUS LIKE 'Spider_direct_aggregate%'; -Variable_name Value -Spider_direct_aggregate 1 - -deinit -DROP DATABASE IF EXISTS auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -end of test diff --git a/storage/spider/mysql-test/spider/oracle2/r/direct_aggregate_part.result b/storage/spider/mysql-test/spider/oracle2/r/direct_aggregate_part.result deleted file mode 100644 index 9bde4a1746a..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/r/direct_aggregate_part.result +++ /dev/null @@ -1,82 +0,0 @@ -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -drop and create databases -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -CREATE DATABASE auto_test_remote; -USE auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -CREATE DATABASE auto_test_remote2; -USE auto_test_remote2; - -test select 1 -SELECT 1; -1 -1 - -with partition test -CREATE TABLE ta_l2 ( -a INT, -b CHAR(1), -c DATETIME, -PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_COMMENT2_P_2_1 -SHOW GLOBAL STATUS LIKE 'Spider_direct_aggregate%'; -Variable_name Value -Spider_direct_aggregate 0 -SELECT COUNT(*) FROM ta_l2; -COUNT(*) -5 -SHOW GLOBAL STATUS LIKE 'Spider_direct_aggregate%'; -Variable_name Value -Spider_direct_aggregate 2 -SELECT MAX(a) FROM ta_l2; -MAX(a) -5 -SHOW GLOBAL STATUS LIKE 'Spider_direct_aggregate%'; -Variable_name Value -Spider_direct_aggregate 2 -SELECT MIN(a) FROM ta_l2; -MIN(a) -1 -SHOW GLOBAL STATUS LIKE 'Spider_direct_aggregate%'; -Variable_name Value -Spider_direct_aggregate 2 -SELECT MAX(a) FROM ta_l2 WHERE a < 5; -MAX(a) -4 -SHOW GLOBAL STATUS LIKE 'Spider_direct_aggregate%'; -Variable_name Value -Spider_direct_aggregate 2 -SELECT MIN(a) FROM ta_l2 WHERE a > 1; -MIN(a) -2 -SHOW GLOBAL STATUS LIKE 'Spider_direct_aggregate%'; -Variable_name Value -Spider_direct_aggregate 2 - -deinit -DROP DATABASE IF EXISTS auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -end of test diff --git a/storage/spider/mysql-test/spider/oracle2/r/direct_update.result b/storage/spider/mysql-test/spider/oracle2/r/direct_update.result deleted file mode 100644 index 3dc39d5f630..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/r/direct_update.result +++ /dev/null @@ -1,138 +0,0 @@ -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -drop and create databases -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -CREATE DATABASE auto_test_remote; -USE auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -CREATE DATABASE auto_test_remote2; -USE auto_test_remote2; - -test select 1 -SELECT 1; -1 -1 - -create table select test -DROP TABLE IF EXISTS ta_l; -CREATE TABLE ta_l ( -a INT, -b CHAR(1), -c DATETIME, -PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_2_1 -INSERT INTO ta_l (a, b, c) VALUES -(1, 'a', '2008-08-01 10:21:39'), -(2, 'b', '2000-01-01 00:00:00'), -(3, 'e', '2007-06-04 20:03:11'), -(4, 'd', '2003-11-30 05:01:03'), -(5, 'c', '2001-12-31 23:59:59'); - -direct_updating test -SHOW GLOBAL STATUS LIKE 'Spider_direct_update%'; -Variable_name Value -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-01 10:21:39 -2 b 2000-01-01 00:00:00 -3 e 2007-06-04 20:03:11 -4 d 2003-11-30 05:01:03 -5 c 2001-12-31 23:59:59 -update all rows with function -UPDATE ta_l SET c = ADDDATE(c, 1); -SHOW GLOBAL STATUS LIKE 'Spider_direct_update%'; -Variable_name Value -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-02 10:21:39 -2 b 2000-01-02 00:00:00 -3 e 2007-06-05 20:03:11 -4 d 2003-12-01 05:01:03 -5 c 2002-01-01 23:59:59 -update by primary key -UPDATE ta_l SET b = 'x' WHERE a = 3; -SHOW GLOBAL STATUS LIKE 'Spider_direct_update%'; -Variable_name Value -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-02 10:21:39 -2 b 2000-01-02 00:00:00 -3 x 2007-06-05 20:03:11 -4 d 2003-12-01 05:01:03 -5 c 2002-01-01 23:59:59 -update by a column without index -UPDATE ta_l SET c = '2011-10-17' WHERE b = 'x'; -SHOW GLOBAL STATUS LIKE 'Spider_direct_update%'; -Variable_name Value -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-02 10:21:39 -2 b 2000-01-02 00:00:00 -3 x 2011-10-17 00:00:00 -4 d 2003-12-01 05:01:03 -5 c 2002-01-01 23:59:59 -update by primary key with order and limit -UPDATE ta_l SET c = ADDDATE(c, 1) WHERE a < 4 ORDER BY b DESC LIMIT 1; -SHOW GLOBAL STATUS LIKE 'Spider_direct_update%'; -Variable_name Value -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-02 10:21:39 -2 b 2000-01-02 00:00:00 -3 x 2011-10-18 00:00:00 -4 d 2003-12-01 05:01:03 -5 c 2002-01-01 23:59:59 -delete by primary key with order and limit -DELETE FROM ta_l WHERE a < 4 ORDER BY c LIMIT 1; -SHOW GLOBAL STATUS LIKE 'Spider_direct_delete%'; -Variable_name Value -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-02 10:21:39 -3 x 2011-10-18 00:00:00 -4 d 2003-12-01 05:01:03 -5 c 2002-01-01 23:59:59 -delete by a column without index -DELETE FROM ta_l WHERE b = 'c'; -SHOW GLOBAL STATUS LIKE 'Spider_direct_delete%'; -Variable_name Value -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-02 10:21:39 -3 x 2011-10-18 00:00:00 -4 d 2003-12-01 05:01:03 -delete by primary key -DELETE FROM ta_l WHERE a = 3; -SHOW GLOBAL STATUS LIKE 'Spider_direct_delete%'; -Variable_name Value -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-02 10:21:39 -4 d 2003-12-01 05:01:03 - -deinit -DROP DATABASE IF EXISTS auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -end of test diff --git a/storage/spider/mysql-test/spider/oracle2/r/direct_update_part.result b/storage/spider/mysql-test/spider/oracle2/r/direct_update_part.result deleted file mode 100644 index 8a22c40a0da..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/r/direct_update_part.result +++ /dev/null @@ -1,129 +0,0 @@ -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -drop and create databases -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -CREATE DATABASE auto_test_remote; -USE auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -CREATE DATABASE auto_test_remote2; -USE auto_test_remote2; - -test select 1 -SELECT 1; -1 -1 - -with partition test -CREATE TABLE ta_l2 ( -a INT, -b CHAR(1), -c DATETIME, -PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_COMMENT2_P_2_1 -SHOW GLOBAL STATUS LIKE 'Spider_direct_update%'; -Variable_name Value -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-01 10:21:39 -2 b 2000-01-01 00:00:00 -3 e 2007-06-04 20:03:11 -4 d 2003-11-30 05:01:03 -5 c 2001-12-31 23:59:59 -update all rows with function -UPDATE ta_l2 SET c = ADDDATE(c, 1); -SHOW GLOBAL STATUS LIKE 'Spider_direct_update%'; -Variable_name Value -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-02 10:21:39 -2 b 2000-01-02 00:00:00 -3 e 2007-06-05 20:03:11 -4 d 2003-12-01 05:01:03 -5 c 2002-01-01 23:59:59 -update by primary key -UPDATE ta_l2 SET b = 'x' WHERE a = 3; -SHOW GLOBAL STATUS LIKE 'Spider_direct_update%'; -Variable_name Value -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-02 10:21:39 -2 b 2000-01-02 00:00:00 -3 x 2007-06-05 20:03:11 -4 d 2003-12-01 05:01:03 -5 c 2002-01-01 23:59:59 -update by a column without index -UPDATE ta_l2 SET c = '2011-10-17' WHERE b = 'x'; -SHOW GLOBAL STATUS LIKE 'Spider_direct_update%'; -Variable_name Value -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-02 10:21:39 -2 b 2000-01-02 00:00:00 -3 x 2011-10-17 00:00:00 -4 d 2003-12-01 05:01:03 -5 c 2002-01-01 23:59:59 -update by primary key with order and limit -UPDATE ta_l2 SET c = ADDDATE(c, 1) WHERE a < 4 ORDER BY b DESC LIMIT 1; -SHOW GLOBAL STATUS LIKE 'Spider_direct_update%'; -Variable_name Value -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-02 10:21:39 -2 b 2000-01-02 00:00:00 -3 x 2011-10-18 00:00:00 -4 d 2003-12-01 05:01:03 -5 c 2002-01-01 23:59:59 -delete by primary key with order and limit -DELETE FROM ta_l2 WHERE a < 4 ORDER BY c LIMIT 1; -SHOW GLOBAL STATUS LIKE 'Spider_direct_delete%'; -Variable_name Value -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-02 10:21:39 -3 x 2011-10-18 00:00:00 -4 d 2003-12-01 05:01:03 -5 c 2002-01-01 23:59:59 -delete by a column without index -DELETE FROM ta_l2 WHERE b = 'c'; -SHOW GLOBAL STATUS LIKE 'Spider_direct_delete%'; -Variable_name Value -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-02 10:21:39 -3 x 2011-10-18 00:00:00 -4 d 2003-12-01 05:01:03 -delete by primary key -DELETE FROM ta_l2 WHERE a = 3; -SHOW GLOBAL STATUS LIKE 'Spider_direct_delete%'; -Variable_name Value -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-02 10:21:39 -4 d 2003-12-01 05:01:03 - -deinit -DROP DATABASE IF EXISTS auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -end of test diff --git a/storage/spider/mysql-test/spider/oracle2/r/function.result b/storage/spider/mysql-test/spider/oracle2/r/function.result deleted file mode 100644 index 764c774514b..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/r/function.result +++ /dev/null @@ -1,149 +0,0 @@ -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -drop and create databases -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -CREATE DATABASE auto_test_remote; -USE auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -CREATE DATABASE auto_test_remote2; -USE auto_test_remote2; - -test select 1 -SELECT 1; -1 -1 - -in() -CREATE TABLE t1 ( -a VARCHAR(255), -PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET3 MASTER_1_COMMENT_TEXT_PK1_1 -insert into t1 values ('1'); -insert into t1 select a + 1 from t1; -insert into t1 select a + 2 from t1; -insert into t1 select a + 4 from t1; -insert into t1 select a + 8 from t1; -insert into t1 select a + 16 from t1; -insert into t1 select a + 32 from t1; -insert into t1 select a + 64 from t1; -insert into t1 select a + 128 from t1; -insert into t1 select a + 256 from t1; -insert into t1 select a + 512 from t1; -flush tables; -select a from t1 where a in ('15', '120'); -a -120 -15 - -date_sub() -DROP TABLE IF EXISTS ta_l; -CREATE TABLE ta_l ( -a INT, -b CHAR(1), -c DATETIME, -PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_2_1 -INSERT INTO ta_l (a, b, c) VALUES -(1, 'a', '2008-08-01 10:21:39'), -(2, 'b', '2000-01-01 00:00:00'), -(3, 'e', '2007-06-04 20:03:11'), -(4, 'd', '2003-11-30 05:01:03'), -(5, 'c', '2001-12-31 23:59:59'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-01 10:21:39 -2 b 2000-01-01 00:00:00 -3 e 2007-06-04 20:03:11 -4 d 2003-11-30 05:01:03 -5 c 2001-12-31 23:59:59 -UPDATE ta_l SET c = DATE_SUB(c, INTERVAL 1 YEAR); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2007-08-01 10:21:39 -2 b 1999-01-01 00:00:00 -3 e 2006-06-04 20:03:11 -4 d 2002-11-30 05:01:03 -5 c 2000-12-31 23:59:59 -UPDATE ta_l SET c = DATE_ADD(c, INTERVAL 1 QUARTER); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2007-11-01 10:21:39 -2 b 1999-04-01 00:00:00 -3 e 2006-09-04 20:03:11 -4 d 2003-02-28 05:01:03 -5 c 2001-03-31 23:59:59 -UPDATE ta_l SET c = DATE_SUB(c, INTERVAL 1 MONTH); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2007-10-01 10:21:39 -2 b 1999-03-01 00:00:00 -3 e 2006-08-04 20:03:11 -4 d 2003-01-28 05:01:03 -5 c 2001-02-28 23:59:59 -UPDATE ta_l SET c = DATE_ADD(c, INTERVAL 1 WEEK); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2007-10-08 10:21:39 -2 b 1999-03-08 00:00:00 -3 e 2006-08-11 20:03:11 -4 d 2003-02-04 05:01:03 -5 c 2001-03-07 23:59:59 -UPDATE ta_l SET c = DATE_SUB(c, INTERVAL 1 DAY); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2007-10-07 10:21:39 -2 b 1999-03-07 00:00:00 -3 e 2006-08-10 20:03:11 -4 d 2003-02-03 05:01:03 -5 c 2001-03-06 23:59:59 -UPDATE ta_l SET c = DATE_ADD(c, INTERVAL 1 HOUR); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2007-10-07 11:21:39 -2 b 1999-03-07 01:00:00 -3 e 2006-08-10 21:03:11 -4 d 2003-02-03 06:01:03 -5 c 2001-03-07 00:59:59 -UPDATE ta_l SET c = DATE_SUB(c, INTERVAL 1 MINUTE); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2007-10-07 11:20:39 -2 b 1999-03-07 00:59:00 -3 e 2006-08-10 21:02:11 -4 d 2003-02-03 06:00:03 -5 c 2001-03-07 00:58:59 -UPDATE ta_l SET c = DATE_ADD(c, INTERVAL 1 SECOND); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2007-10-07 11:20:40 -2 b 1999-03-07 00:59:01 -3 e 2006-08-10 21:02:12 -4 d 2003-02-03 06:00:04 -5 c 2001-03-07 00:59:00 - -deinit -DROP DATABASE IF EXISTS auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -end of test diff --git a/storage/spider/mysql-test/spider/oracle2/r/ha.result b/storage/spider/mysql-test/spider/oracle2/r/ha.result deleted file mode 100644 index 8ca64dec6df..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/r/ha.result +++ /dev/null @@ -1,240 +0,0 @@ -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -drop and create databases -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -CREATE DATABASE auto_test_remote; -USE auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -CREATE DATABASE auto_test_remote2; -USE auto_test_remote2; -DROP DATABASE IF EXISTS auto_test_remote3; -CREATE DATABASE auto_test_remote3; -USE auto_test_remote3; -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; - -test select 1 -SELECT 1; -1 -1 - -create table test -DROP TABLE IF EXISTS ta_l; -CREATE TABLE ta_l ( -a INT, -b CHAR(1), -c DATETIME, -PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_HA_2_1 -INSERT INTO ta_l (a, b, c) VALUES -(1, 'a', '2008-08-01 10:21:39'), -(2, 'b', '2000-01-01 00:00:00'), -(3, 'e', '2007-06-04 20:03:11'), -(4, 'd', '2003-11-30 05:01:03'), -(5, 'c', '2001-12-31 23:59:59'); - -select test -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-01 10:21:39 -2 b 2000-01-01 00:00:00 -3 e 2007-06-04 20:03:11 -4 d 2003-11-30 05:01:03 -5 c 2001-12-31 23:59:59 - -fail-over test -SHOW GLOBAL STATUS LIKE 'Spider_mon_table_cache_version%'; -Variable_name Value -Spider_mon_table_cache_version 0 -Spider_mon_table_cache_version_req 1 -INSERT INTO ta_l (a, b, c) VALUES -(6, 'e', '2011-05-05 20:04:05'); -ERROR HY000: Table 'SYSTEM.ta_r3' get a problem -SELECT db_name, table_name, link_id, link_status FROM mysql.spider_tables -ORDER BY db_name, table_name, link_id; -db_name table_name link_id link_status -auto_test_local ta_l 0 1 -auto_test_local ta_l 1 3 -SELECT db_name, table_name, link_id FROM mysql.spider_link_failed_log; -db_name table_name link_id -auto_test_local ta_l 1 -SHOW GLOBAL STATUS LIKE 'Spider_mon_table_cache_version%'; -Variable_name Value -Spider_mon_table_cache_version 1 -Spider_mon_table_cache_version_req 1 -INSERT INTO ta_l (a, b, c) VALUES -(6, 'e', '2011-05-05 20:04:05'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-01 10:21:39 -2 b 2000-01-01 00:00:00 -3 e 2007-06-04 20:03:11 -4 d 2003-11-30 05:01:03 -5 c 2001-12-31 23:59:59 -6 e 2011-05-05 20:04:05 - -recovery test -ALTER TABLE ta_l -CONNECTION='host "xe", user "system", - password "oracle", msi "2", mkd "2", - database "SYSTEM", lst "0 2"'; -SELECT db_name, table_name, link_id, link_status FROM mysql.spider_tables -ORDER BY db_name, table_name, link_id; -db_name table_name link_id link_status -auto_test_local ta_l 0 1 -auto_test_local ta_l 1 2 -SELECT spider_copy_tables('ta_l', '0', '1'); -spider_copy_tables('ta_l', '0', '1') -1 -ALTER TABLE ta_l -CONNECTION='host "xe", user "system", - password "oracle", msi "2", mkd "2", - database "SYSTEM", lst "0 1"'; -SELECT db_name, table_name, link_id, link_status FROM mysql.spider_tables -ORDER BY db_name, table_name, link_id; -db_name table_name link_id link_status -auto_test_local ta_l 0 1 -auto_test_local ta_l 1 1 -INSERT INTO ta_l (a, b, c) VALUES -(8, 'g', '2011-05-05 21:33:30'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-01 10:21:39 -2 b 2000-01-01 00:00:00 -3 e 2007-06-04 20:03:11 -4 d 2003-11-30 05:01:03 -5 c 2001-12-31 23:59:59 -6 e 2011-05-05 20:04:05 -8 g 2011-05-05 21:33:30 -DROP TABLE ta_l; -SELECT spider_flush_table_mon_cache(); -spider_flush_table_mon_cache() -1 - -active standby test -create table test -DROP TABLE IF EXISTS ta_l; -CREATE TABLE ta_l ( -a INT, -b CHAR(1), -c DATETIME, -PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_HA_AS_2_1 -INSERT INTO ta_l (a, b, c) VALUES -(1, 'a', '2008-08-01 10:21:39'), -(2, 'b', '2000-01-01 00:00:00'), -(3, 'e', '2007-06-04 20:03:11'), -(4, 'd', '2003-11-30 05:01:03'), -(5, 'c', '2001-12-31 23:59:59'); - -select test -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-01 10:21:39 -2 b 2000-01-01 00:00:00 -3 e 2007-06-04 20:03:11 -4 d 2003-11-30 05:01:03 -5 c 2001-12-31 23:59:59 - -fail-over test -SHOW GLOBAL STATUS LIKE 'Spider_mon_table_cache_version%'; -Variable_name Value -Spider_mon_table_cache_version 1 -Spider_mon_table_cache_version_req 2 -INSERT INTO ta_l (a, b, c) VALUES -(6, 'e', '2011-05-05 20:04:05'); -ERROR HY000: Table 'SYSTEM.ta_r' get a problem -SELECT db_name, table_name, link_id, link_status FROM mysql.spider_tables -ORDER BY db_name, table_name, link_id; -db_name table_name link_id link_status -auto_test_local ta_l 0 3 -auto_test_local ta_l 1 1 -SELECT db_name, table_name, link_id FROM mysql.spider_link_failed_log; -db_name table_name link_id -auto_test_local ta_l 1 -auto_test_local ta_l 0 -SHOW GLOBAL STATUS LIKE 'Spider_mon_table_cache_version%'; -Variable_name Value -Spider_mon_table_cache_version 2 -Spider_mon_table_cache_version_req 2 -INSERT INTO ta_l (a, b, c) VALUES -(6, 'e', '2011-05-05 20:04:05'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -6 e 2011-05-05 20:04:05 - -recovery test -ALTER TABLE ta_l -CONNECTION='host "xe", user "system", - password "oracle", msi "2", mkd "2", alc "1", - database "SYSTEM", lst "1 0"'; -SELECT db_name, table_name, link_id, link_status FROM mysql.spider_tables -ORDER BY db_name, table_name, link_id; -db_name table_name link_id link_status -auto_test_local ta_l 0 1 -auto_test_local ta_l 1 1 -INSERT INTO ta_l (a, b, c) VALUES -(8, 'g', '2011-05-05 21:33:30'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -8 g 2011-05-05 21:33:30 -DROP TABLE ta_l; -SELECT spider_flush_table_mon_cache(); -spider_flush_table_mon_cache() -1 - -deinit -DROP DATABASE IF EXISTS auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -DROP DATABASE IF EXISTS auto_test_remote3; -DROP DATABASE IF EXISTS auto_test_local; -DROP DATABASE IF EXISTS auto_test_local; -DROP DATABASE IF EXISTS auto_test_local; -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -end of test diff --git a/storage/spider/mysql-test/spider/oracle2/r/ha_part.result b/storage/spider/mysql-test/spider/oracle2/r/ha_part.result deleted file mode 100644 index e11b6f695e0..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/r/ha_part.result +++ /dev/null @@ -1,262 +0,0 @@ -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -drop and create databases -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -CREATE DATABASE auto_test_remote; -USE auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -CREATE DATABASE auto_test_remote2; -USE auto_test_remote2; -DROP DATABASE IF EXISTS auto_test_remote3; -CREATE DATABASE auto_test_remote3; -USE auto_test_remote3; -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; - -test select 1 -SELECT 1; -1 -1 - -create table with partition test -DROP TABLE IF EXISTS ta_l2; -CREATE TABLE ta_l2 ( -a INT, -b CHAR(1), -c DATETIME, -PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_HA_P_2_1 -INSERT INTO ta_l2 (a, b, c) VALUES -(1, 'a', '2008-08-01 10:21:39'), -(2, 'b', '2000-01-01 00:00:00'), -(3, 'e', '2007-06-04 20:03:11'), -(4, 'd', '2003-11-30 05:01:03'), -(5, 'c', '2001-12-31 23:59:59'); - -select test -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-01 10:21:39 -2 b 2000-01-01 00:00:00 -3 e 2007-06-04 20:03:11 -4 d 2003-11-30 05:01:03 -5 c 2001-12-31 23:59:59 - -fail-over test -SHOW GLOBAL STATUS LIKE 'Spider_mon_table_cache_version%'; -Variable_name Value -Spider_mon_table_cache_version 0 -Spider_mon_table_cache_version_req 1 -INSERT INTO ta_l2 (a, b, c) VALUES -(6, 'e', '2011-05-05 20:04:05'); -ERROR HY000: Table 'SYSTEM.ta_r4' get a problem -SELECT db_name, table_name, link_id, link_status FROM mysql.spider_tables -ORDER BY db_name, table_name, link_id; -db_name table_name link_id link_status -auto_test_local ta_l2#P#pt1 0 1 -auto_test_local ta_l2#P#pt1 1 1 -auto_test_local ta_l2#P#pt2 0 1 -auto_test_local ta_l2#P#pt2 1 3 -SELECT db_name, table_name, link_id FROM mysql.spider_link_failed_log; -db_name table_name link_id -auto_test_local ta_l2#P#pt2 1 -SHOW GLOBAL STATUS LIKE 'Spider_mon_table_cache_version%'; -Variable_name Value -Spider_mon_table_cache_version 1 -Spider_mon_table_cache_version_req 1 -INSERT INTO ta_l2 (a, b, c) VALUES -(6, 'e', '2011-05-05 20:04:05'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-01 10:21:39 -2 b 2000-01-01 00:00:00 -3 e 2007-06-04 20:03:11 -4 d 2003-11-30 05:01:03 -5 c 2001-12-31 23:59:59 -6 e 2011-05-05 20:04:05 - -recovery test -ALTER TABLE ta_l2 -PARTITION BY KEY(a) ( -PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', -PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001", lst "0 2"' - ); -SELECT db_name, table_name, link_id, link_status FROM mysql.spider_tables -ORDER BY db_name, table_name, link_id; -db_name table_name link_id link_status -auto_test_local ta_l2#P#pt1 0 1 -auto_test_local ta_l2#P#pt1 1 1 -auto_test_local ta_l2#P#pt2 0 1 -auto_test_local ta_l2#P#pt2 1 2 -SELECT spider_copy_tables('ta_l2#P#pt2', '0', '1'); -spider_copy_tables('ta_l2#P#pt2', '0', '1') -1 -ALTER TABLE ta_l2 -PARTITION BY KEY(a) ( -PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', -PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001", lst "0 1"' - ); -SELECT db_name, table_name, link_id, link_status FROM mysql.spider_tables -ORDER BY db_name, table_name, link_id; -db_name table_name link_id link_status -auto_test_local ta_l2#P#pt1 0 1 -auto_test_local ta_l2#P#pt1 1 1 -auto_test_local ta_l2#P#pt2 0 1 -auto_test_local ta_l2#P#pt2 1 1 -INSERT INTO ta_l2 (a, b, c) VALUES -(8, 'g', '2011-05-05 21:33:30'), -(9, 'h', '2011-05-05 22:32:10'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-01 10:21:39 -2 b 2000-01-01 00:00:00 -3 e 2007-06-04 20:03:11 -4 d 2003-11-30 05:01:03 -5 c 2001-12-31 23:59:59 -6 e 2011-05-05 20:04:05 -8 g 2011-05-05 21:33:30 -9 h 2011-05-05 22:32:10 -DROP TABLE ta_l2; - -create table with partition test -DROP TABLE IF EXISTS ta_l2; -CREATE TABLE ta_l2 ( -a INT, -b CHAR(1), -c DATETIME, -PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_HA_AS_P_2_1 -INSERT INTO ta_l2 (a, b, c) VALUES -(1, 'a', '2008-08-01 10:21:39'), -(2, 'b', '2000-01-01 00:00:00'), -(3, 'e', '2007-06-04 20:03:11'), -(4, 'd', '2003-11-30 05:01:03'), -(5, 'c', '2001-12-31 23:59:59'); - -select test -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-01 10:21:39 -2 b 2000-01-01 00:00:00 -3 e 2007-06-04 20:03:11 -4 d 2003-11-30 05:01:03 -5 c 2001-12-31 23:59:59 - -fail-over test -SHOW GLOBAL STATUS LIKE 'Spider_mon_table_cache_version%'; -Variable_name Value -Spider_mon_table_cache_version 1 -Spider_mon_table_cache_version_req 1 -INSERT INTO ta_l2 (a, b, c) VALUES -(6, 'e', '2011-05-05 20:04:05'); -ERROR HY000: Table 'SYSTEM.ta_r2' get a problem -SELECT db_name, table_name, link_id, link_status FROM mysql.spider_tables -ORDER BY db_name, table_name, link_id; -db_name table_name link_id link_status -auto_test_local ta_l2#P#pt1 0 1 -auto_test_local ta_l2#P#pt1 1 1 -auto_test_local ta_l2#P#pt2 0 3 -auto_test_local ta_l2#P#pt2 1 1 -SELECT db_name, table_name, link_id FROM mysql.spider_link_failed_log; -db_name table_name link_id -auto_test_local ta_l2#P#pt2 1 -auto_test_local ta_l2#P#pt2 0 -SHOW GLOBAL STATUS LIKE 'Spider_mon_table_cache_version%'; -Variable_name Value -Spider_mon_table_cache_version 1 -Spider_mon_table_cache_version_req 1 -INSERT INTO ta_l2 (a, b, c) VALUES -(6, 'e', '2011-05-05 20:04:05'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-01 10:21:39 -3 e 2007-06-04 20:03:11 -5 c 2001-12-31 23:59:59 -6 e 2011-05-05 20:04:05 - -recovery test -ALTER TABLE ta_l2 -PARTITION BY KEY(a) ( -PARTITION pt1 COMMENT='srv "s_2_1 s_2_2", tbl "ta_r ta_r3", - priority "1000"', -PARTITION pt2 COMMENT='srv "s_2_1 s_2_3", tbl "ta_r2 ta_r4", - priority "1000001", lst "1 0"' - ); -SELECT db_name, table_name, link_id, link_status FROM mysql.spider_tables -ORDER BY db_name, table_name, link_id; -db_name table_name link_id link_status -auto_test_local ta_l2#P#pt1 0 1 -auto_test_local ta_l2#P#pt1 1 1 -auto_test_local ta_l2#P#pt2 0 1 -auto_test_local ta_l2#P#pt2 1 1 -INSERT INTO ta_l2 (a, b, c) VALUES -(8, 'g', '2011-05-05 21:33:30'), -(9, 'h', '2011-05-05 22:32:10'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-01 10:21:39 -3 e 2007-06-04 20:03:11 -5 c 2001-12-31 23:59:59 -8 g 2011-05-05 21:33:30 -9 h 2011-05-05 22:32:10 -DROP TABLE ta_l2; - -deinit -DROP DATABASE IF EXISTS auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -DROP DATABASE IF EXISTS auto_test_remote3; -DROP DATABASE IF EXISTS auto_test_local; -DROP DATABASE IF EXISTS auto_test_local; -DROP DATABASE IF EXISTS auto_test_local; -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -end of test diff --git a/storage/spider/mysql-test/spider/oracle2/r/spider3_fixes.result b/storage/spider/mysql-test/spider/oracle2/r/spider3_fixes.result deleted file mode 100644 index dd6c8715648..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/r/spider3_fixes.result +++ /dev/null @@ -1,210 +0,0 @@ -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 -for slave1_1 - -drop and create databases -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -CREATE DATABASE auto_test_remote; -USE auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -CREATE DATABASE auto_test_remote2; -USE auto_test_remote2; - -test select 1 -SELECT 1; -1 -1 - -3.1 -auto_increment -DROP TABLE IF EXISTS t1, t2; -CREATE TABLE t1 ( -id int(11) NOT NULL AUTO_INCREMENT, -PRIMARY KEY (id) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_INCREMENT1_1 -CREATE TABLE t2 ( -id int(11) NOT NULL AUTO_INCREMENT, -PRIMARY KEY (id) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_INCREMENT1_1 -MASTER_1_AUTO_INCREMENT_INCREMENT2 -MASTER_1_AUTO_INCREMENT_OFFSET2 -spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_1"\'; exception when others then null; end;', '', 'srv "s_2_1"') -1 -spider_direct_sql('CREATE SEQUENCE "seq_t1_1" START WITH 2 INCREMENT BY 4', '', 'srv "s_2_1"') -1 -spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_2"\'; exception when others then null; end;', '', 'srv "s_2_2"') -1 -spider_direct_sql('CREATE SEQUENCE "seq_t1_2" START WITH 3 INCREMENT BY 4', '', 'srv "s_2_2"') -1 -spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_1"\'; exception when others then null; end;', '', 'srv "s_2_1"') -1 -spider_direct_sql('CREATE SEQUENCE "seq_t1_1" START WITH 2 INCREMENT BY 4', '', 'srv "s_2_1"') -1 -spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_2"\'; exception when others then null; end;', '', 'srv "s_2_2"') -1 -spider_direct_sql('CREATE SEQUENCE "seq_t1_2" START WITH 3 INCREMENT BY 4', '', 'srv "s_2_2"') -1 -INSERT INTO t1 () VALUES (); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -2 -SELECT MAX(id) FROM t1; -MAX(id) -2 -INSERT INTO t2 () VALUES (); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -6 -SELECT MAX(id) FROM t2; -MAX(id) -6 -MASTER_1_AUTO_INCREMENT_OFFSET3 -INSERT INTO t1 (id) VALUES (null); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -10 -SELECT MAX(id) FROM t1; -MAX(id) -10 -MASTER_1_AUTO_INCREMENT_OFFSET4 -INSERT INTO t2 (id) VALUES (null); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -14 -SELECT MAX(id) FROM t2; -MAX(id) -14 -MASTER_1_AUTO_INCREMENT_OFFSET3 -INSERT INTO t1 () VALUES (),(),(),(); -Warnings: -Note 12520 Binlog's auto-inc value is probably different from linked table's auto-inc value -Note 12520 Binlog's auto-inc value is probably different from linked table's auto-inc value -Note 12520 Binlog's auto-inc value is probably different from linked table's auto-inc value -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -18 -SELECT id FROM t1 ORDER BY id; -id -2 -6 -10 -14 -18 -22 -26 -30 -MASTER_1_AUTO_INCREMENT_OFFSET4 -INSERT INTO t2 () VALUES (),(),(),(); -Warnings: -Note 12520 Binlog's auto-inc value is probably different from linked table's auto-inc value -Note 12520 Binlog's auto-inc value is probably different from linked table's auto-inc value -Note 12520 Binlog's auto-inc value is probably different from linked table's auto-inc value -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -34 -SELECT id FROM t2 ORDER BY id; -id -2 -6 -10 -14 -18 -22 -26 -30 -34 -38 -42 -46 -TRUNCATE TABLE t1; -TRUNCATE TABLE t2; -INSERT INTO t1 () VALUES (),(),(),(); -Warnings: -Note 12520 Binlog's auto-inc value is probably different from linked table's auto-inc value -Note 12520 Binlog's auto-inc value is probably different from linked table's auto-inc value -Note 12520 Binlog's auto-inc value is probably different from linked table's auto-inc value -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -50 -SELECT id FROM t1 ORDER BY id; -id -50 -54 -58 -62 -INSERT INTO t2 () VALUES (),(),(),(); -Warnings: -Note 12520 Binlog's auto-inc value is probably different from linked table's auto-inc value -Note 12520 Binlog's auto-inc value is probably different from linked table's auto-inc value -Note 12520 Binlog's auto-inc value is probably different from linked table's auto-inc value -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -66 -SELECT id FROM t2 ORDER BY id; -id -50 -54 -58 -62 -66 -70 -74 -78 -SET INSERT_ID=5000; -MASTER_1_AUTO_INCREMENT_OFFSET3 -INSERT INTO t1 () VALUES (); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -82 -SELECT MAX(id) FROM t1; -MAX(id) -82 -MASTER_1_AUTO_INCREMENT_OFFSET4 -INSERT INTO t2 () VALUES (); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -86 -SELECT MAX(id) FROM t2; -MAX(id) -86 -INSERT INTO t1 (id) VALUES (10000); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -90 -SELECT MAX(id) FROM t1; -MAX(id) -90 -INSERT INTO t2 (id) VALUES (1000); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -94 -SELECT MAX(id) FROM t2; -MAX(id) -94 - -deinit -DROP DATABASE IF EXISTS auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -for slave1_1 -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -end of test diff --git a/storage/spider/mysql-test/spider/oracle2/r/spider3_fixes_part.result b/storage/spider/mysql-test/spider/oracle2/r/spider3_fixes_part.result deleted file mode 100644 index 38875214eb8..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/r/spider3_fixes_part.result +++ /dev/null @@ -1,208 +0,0 @@ -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 -for slave1_1 - -drop and create databases -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -CREATE DATABASE auto_test_remote; -USE auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -CREATE DATABASE auto_test_remote2; -USE auto_test_remote2; - -test select 1 -SELECT 1; -1 -1 -auto_increment with partition -DROP TABLE IF EXISTS t1, t2; -CREATE TABLE t1 ( -id int(11) NOT NULL AUTO_INCREMENT, -PRIMARY KEY (id) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_INCREMENT1_P_1 -CREATE TABLE t2 ( -id int(11) NOT NULL AUTO_INCREMENT, -PRIMARY KEY (id) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_INCREMENT1_P_1 -MASTER_1_AUTO_INCREMENT_INCREMENT2 -MASTER_1_AUTO_INCREMENT_OFFSET2 -spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_1"\'; exception when others then null; end;', '', 'srv "s_2_1"') -1 -spider_direct_sql('CREATE SEQUENCE "seq_t1_1" START WITH 2 INCREMENT BY 4', '', 'srv "s_2_1"') -1 -spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_2"\'; exception when others then null; end;', '', 'srv "s_2_2"') -1 -spider_direct_sql('CREATE SEQUENCE "seq_t1_2" START WITH 3 INCREMENT BY 4', '', 'srv "s_2_2"') -1 -spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_1"\'; exception when others then null; end;', '', 'srv "s_2_1"') -1 -spider_direct_sql('CREATE SEQUENCE "seq_t1_1" START WITH 2 INCREMENT BY 4', '', 'srv "s_2_1"') -1 -spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_2"\'; exception when others then null; end;', '', 'srv "s_2_2"') -1 -spider_direct_sql('CREATE SEQUENCE "seq_t1_2" START WITH 3 INCREMENT BY 4', '', 'srv "s_2_2"') -1 -INSERT INTO t1 () VALUES (); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -3 -SELECT MAX(id) FROM t1; -MAX(id) -3 -INSERT INTO t2 () VALUES (); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -7 -SELECT MAX(id) FROM t2; -MAX(id) -7 -MASTER_1_AUTO_INCREMENT_OFFSET3 -INSERT INTO t1 (id) VALUES (null); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -2 -SELECT MAX(id) FROM t1; -MAX(id) -7 -MASTER_1_AUTO_INCREMENT_OFFSET4 -INSERT INTO t2 (id) VALUES (null); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -6 -SELECT MAX(id) FROM t2; -MAX(id) -7 -MASTER_1_AUTO_INCREMENT_OFFSET3 -INSERT INTO t1 () VALUES (),(),(),(); -Warnings: -Note 12520 Binlog's auto-inc value is probably different from linked table's auto-inc value -Note 12520 Binlog's auto-inc value is probably different from linked table's auto-inc value -Note 12520 Binlog's auto-inc value is probably different from linked table's auto-inc value -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -10 -SELECT id FROM t1 ORDER BY id; -id -2 -3 -6 -7 -10 -11 -14 -15 -MASTER_1_AUTO_INCREMENT_OFFSET4 -INSERT INTO t2 () VALUES (),(),(),(); -Warnings: -Note 12520 Binlog's auto-inc value is probably different from linked table's auto-inc value -Note 12520 Binlog's auto-inc value is probably different from linked table's auto-inc value -Note 12520 Binlog's auto-inc value is probably different from linked table's auto-inc value -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -18 -SELECT id FROM t2 ORDER BY id; -id -2 -3 -6 -7 -10 -11 -14 -15 -18 -19 -22 -23 -TRUNCATE TABLE t1; -TRUNCATE TABLE t2; -INSERT INTO t1 () VALUES (),(),(),(); -Warnings: -Note 12520 Binlog's auto-inc value is probably different from linked table's auto-inc value -Note 12520 Binlog's auto-inc value is probably different from linked table's auto-inc value -Note 12520 Binlog's auto-inc value is probably different from linked table's auto-inc value -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -26 -SELECT id FROM t1 ORDER BY id; -id -26 -27 -30 -31 -INSERT INTO t2 () VALUES (),(),(),(); -Warnings: -Note 12520 Binlog's auto-inc value is probably different from linked table's auto-inc value -Note 12520 Binlog's auto-inc value is probably different from linked table's auto-inc value -Note 12520 Binlog's auto-inc value is probably different from linked table's auto-inc value -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -34 -SELECT id FROM t2 ORDER BY id; -id -26 -27 -30 -31 -34 -35 -38 -39 -SET INSERT_ID=5000; -MASTER_1_AUTO_INCREMENT_OFFSET3 -INSERT INTO t1 () VALUES (); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -42 -SELECT MAX(id) FROM t1; -MAX(id) -42 -MASTER_1_AUTO_INCREMENT_OFFSET4 -INSERT INTO t2 () VALUES (); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -43 -SELECT MAX(id) FROM t2; -MAX(id) -43 -INSERT INTO t1 (id) VALUES (10000); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -46 -SELECT MAX(id) FROM t1; -MAX(id) -46 -INSERT INTO t2 (id) VALUES (1000); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -50 -SELECT MAX(id) FROM t2; -MAX(id) -50 - -deinit -DROP DATABASE IF EXISTS auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -for slave1_1 -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -end of test diff --git a/storage/spider/mysql-test/spider/oracle2/r/spider_fixes.result b/storage/spider/mysql-test/spider/oracle2/r/spider_fixes.result deleted file mode 100644 index 5a41603c746..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/r/spider_fixes.result +++ /dev/null @@ -1,556 +0,0 @@ -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 -for slave1_1 - -drop and create databases -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -CREATE DATABASE auto_test_remote; -USE auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -CREATE DATABASE auto_test_remote2; -USE auto_test_remote2; - -test select 1 -SELECT 1; -1 -1 - -create table and insert -DROP TABLE IF EXISTS tb_l; -CREATE TABLE tb_l ( -a INT, -b CHAR(1), -c DATETIME, -PRIMARY KEY(a) -) MASTER_1_ENGINE2 MASTER_1_CHARSET2 -INSERT INTO tb_l (a, b, c) VALUES -(1, 'a', '2008-08-01 10:21:39'), -(2, 'b', '2000-01-01 00:00:00'), -(3, 'e', '2007-06-04 20:03:11'), -(4, 'd', '2003-11-30 05:01:03'), -(5, 'c', '2001-12-31 23:59:59'); -DROP TABLE IF EXISTS ta_l; -CREATE TABLE ta_l ( -PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_2_1 -INSERT INTO ta_l SELECT a, b, c FROM tb_l; - -2.13 -select table with "order by desc" and "<" -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l -WHERE a < 5 ORDER BY a DESC LIMIT 3; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -4 d 2003-11-30 05:01:03 -3 e 2007-06-04 20:03:11 -2 b 2000-01-01 00:00:00 - -select table with "order by desc" and "<=" -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l -WHERE a <= 5 ORDER BY a DESC LIMIT 3; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -5 c 2001-12-31 23:59:59 -4 d 2003-11-30 05:01:03 -3 e 2007-06-04 20:03:11 - -2.14 -update table with range scan and split_read -UPDATE ta_l SET c = '2000-02-02 00:00:00' WHERE a > 1; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-01 10:21:39 -2 b 2000-02-02 00:00:00 -3 e 2000-02-02 00:00:00 -4 d 2000-02-02 00:00:00 -5 c 2000-02-02 00:00:00 - -2.15 -select table with range scan -TRUNCATE TABLE ta_l; -DROP TABLE IF EXISTS ta_l; -CREATE TABLE ta_l ( -a int(11) NOT NULL DEFAULT '0', -b char(1) DEFAULT NULL, -c datetime DEFAULT NULL, -PRIMARY KEY (a, b, c) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT5_2_1 -INSERT INTO ta_l SELECT a, b, c FROM tb_l; -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a = 4 AND b >= 'b' -AND c = '2003-11-30 05:01:03'; -a b c -4 d 2003-11-30 05:01:03 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a = 4 AND b > 'b' -AND c = '2003-11-30 05:01:03'; -a b c -4 d 2003-11-30 05:01:03 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a >= 4 AND b = 'd' -AND c = '2003-11-30 05:01:03'; -a b c -4 d 2003-11-30 05:01:03 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a > 4 AND b = 'c' -AND c = '2001-12-31 23:59:59'; -a b c -5 c 2001-12-31 23:59:59 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a = 4 AND b <= 'd' -AND c = '2003-11-30 05:01:03'; -a b c -4 d 2003-11-30 05:01:03 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a = 4 AND b < 'e' -AND c = '2003-11-30 05:01:03'; -a b c -4 d 2003-11-30 05:01:03 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a <= 4 AND b = 'b' -AND c = '2000-01-01 00:00:00'; -a b c -2 b 2000-01-01 00:00:00 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a < 4 AND b = 'b' -AND c = '2000-01-01 00:00:00'; -a b c -2 b 2000-01-01 00:00:00 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a = 4 AND b >= 'b' -AND b <= 'd' AND c = '2003-11-30 05:01:03'; -a b c -4 d 2003-11-30 05:01:03 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a = 4 AND b > 'b' -AND b < 'e' AND c = '2003-11-30 05:01:03'; -a b c -4 d 2003-11-30 05:01:03 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a <= 4 AND a >= 1 -AND b >= 'b' AND c = '2003-11-30 05:01:03'; -a b c -4 d 2003-11-30 05:01:03 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a < 4 AND a > 1 -AND b >= 'b' AND c = '2000-01-01 00:00:00'; -a b c -2 b 2000-01-01 00:00:00 - -2.16 -auto_increment insert with trigger -CREATE TABLE ta_l_auto_inc ( -a INT AUTO_INCREMENT, -b CHAR(1) DEFAULT 'c', -c DATETIME DEFAULT '1999-10-10 10:10:10', -PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT3_2_1 -CREATE TABLE tc_l ( -a INT, -b CHAR(1), -c DATETIME, -PRIMARY KEY(a) -) MASTER_1_ENGINE2 MASTER_1_CHARSET2 -CREATE TRIGGER ins_ta_l_auto_inc AFTER INSERT ON ta_l_auto_inc FOR EACH ROW BEGIN INSERT INTO tc_l (a, b, c) VALUES (NEW.a, NEW.b, NEW.c); END;; -INSERT INTO ta_l_auto_inc (a, b, c) VALUES -(NULL, 's', '2008-12-31 20:59:59'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM tc_l ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 s 2008-12-31 20:59:59 - -2.17 -engine-condition-pushdown with "or" and joining -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l WHERE a = 1 OR a IN (SELECT a FROM tb_l); -a b date_format(c, '%Y-%m-%d %H:%i:%s') -1 a 2008-08-01 10:21:39 -2 b 2000-01-01 00:00:00 -3 e 2007-06-04 20:03:11 -4 d 2003-11-30 05:01:03 -5 c 2001-12-31 23:59:59 - -2.23 -index merge -CREATE TABLE ta_l_int ( -a INT AUTO_INCREMENT, -b INT DEFAULT 10, -c INT DEFAULT 11, -PRIMARY KEY(a), -KEY idx1(b), -KEY idx2(c) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT4_2_1 -INSERT INTO ta_l_int (a, b, c) VALUES (1, 2, 3); -INSERT INTO ta_l_int (a, b, c) SELECT a + 1, b + 1, c + 1 FROM ta_l_int; -INSERT INTO ta_l_int (a, b, c) SELECT a + 2, b + 2, c + 2 FROM ta_l_int; -INSERT INTO ta_l_int (a, b, c) SELECT a + 4, b + 4, c + 4 FROM ta_l_int; -INSERT INTO ta_l_int (a, b, c) SELECT a + 8, b + 8, c + 8 FROM ta_l_int; -SELECT a, b, c FROM ta_l_int force index(primary, idx1, idx2) -WHERE a = 5 OR b = 5 OR c = 5 ORDER BY a; -a b c -3 4 5 -4 5 6 -5 6 7 - -2.24 -index scan update without PK -DROP TABLE IF EXISTS ta_l_int; -CREATE TABLE ta_l_int ( -a INT NOT NULL, -b INT DEFAULT 10, -c INT DEFAULT 11, -KEY idx1(b), -KEY idx2(c) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT4_2_1 -SELECT a, b, c FROM ta_l_int ORDER BY a; -a b c -1 2 3 -2 3 4 -3 4 5 -4 5 6 -5 6 7 -6 7 8 -7 8 9 -8 9 10 -9 10 11 -10 11 12 -11 12 13 -12 13 14 -13 14 15 -14 15 16 -15 16 17 -16 17 18 -INSERT INTO ta_l_int (a, b, c) VALUES (0, 2, 3); -INSERT INTO ta_l_int (a, b, c) VALUES (18, 2, 3); -UPDATE ta_l_int SET c = 4 WHERE b = 2; -SELECT a, b, c FROM ta_l_int ORDER BY a; -a b c -0 2 4 -1 2 4 -2 3 4 -3 4 5 -4 5 6 -5 6 7 -6 7 8 -7 8 9 -8 9 10 -9 10 11 -10 11 12 -11 12 13 -12 13 14 -13 14 15 -14 15 16 -15 16 17 -16 17 18 -18 2 4 - -2.25 -direct order limit -SHOW GLOBAL STATUS LIKE 'Spider_direct_order_limit%'; -Variable_name Value -Spider_direct_order_limit 0 -SELECT a, b, c FROM ta_l_int ORDER BY a LIMIT 3; -a b c -1 2 4 -2 3 4 -3 4 5 -SHOW GLOBAL STATUS LIKE 'Spider_direct_order_limit%'; -Variable_name Value -Spider_direct_order_limit 0 - -2.26 -lock tables -DROP TABLE IF EXISTS t1; -DROP TABLE IF EXISTS t2; -CREATE TABLE t1 ( -id int(11) NOT NULL, -PRIMARY KEY (id) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_LOCK1 -CREATE TABLE t2 ( -id int(11) NOT NULL, -PRIMARY KEY (id) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_LOCK2 -LOCK TABLES t1 READ, t2 READ; -UNLOCK TABLES; - -auto_increment -DROP TABLE IF EXISTS t1; -CREATE TABLE t1 ( -id int(11) NOT NULL AUTO_INCREMENT, -PRIMARY KEY (id) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_INCREMENT1_1 -MASTER_1_AUTO_INCREMENT_INCREMENT2 -MASTER_1_AUTO_INCREMENT_OFFSET2 -spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_1"\'; exception when others then null; end;', '', 'srv "s_2_1"') -1 -spider_direct_sql('CREATE SEQUENCE "seq_t1_1" START WITH 2 INCREMENT BY 4', '', 'srv "s_2_1"') -1 -spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_2"\'; exception when others then null; end;', '', 'srv "s_2_2"') -1 -spider_direct_sql('CREATE SEQUENCE "seq_t1_2" START WITH 3 INCREMENT BY 4', '', 'srv "s_2_2"') -1 -spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_1"\'; exception when others then null; end;', '', 'srv "s_2_1"') -1 -spider_direct_sql('CREATE SEQUENCE "seq_t1_1" START WITH 2 INCREMENT BY 4', '', 'srv "s_2_1"') -1 -spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_2"\'; exception when others then null; end;', '', 'srv "s_2_2"') -1 -spider_direct_sql('CREATE SEQUENCE "seq_t1_2" START WITH 3 INCREMENT BY 4', '', 'srv "s_2_2"') -1 -INSERT INTO t1 () VALUES (); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -2 -SELECT MAX(id) FROM t1; -MAX(id) -2 -INSERT INTO t1 () VALUES (); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -6 -SELECT MAX(id) FROM t1; -MAX(id) -6 -INSERT INTO t1 (id) VALUES (null); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -10 -SELECT MAX(id) FROM t1; -MAX(id) -10 -INSERT INTO t1 (id) VALUES (null); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -14 -SELECT MAX(id) FROM t1; -MAX(id) -14 -INSERT INTO t1 () VALUES (),(),(),(); -Warnings: -Note 12520 Binlog's auto-inc value is probably different from linked table's auto-inc value -Note 12520 Binlog's auto-inc value is probably different from linked table's auto-inc value -Note 12520 Binlog's auto-inc value is probably different from linked table's auto-inc value -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -18 -SELECT id FROM t1 ORDER BY id; -id -2 -6 -10 -14 -18 -22 -26 -30 -SET INSERT_ID=5000; -INSERT INTO t1 () VALUES (); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -34 -SELECT MAX(id) FROM t1; -MAX(id) -34 -INSERT INTO t1 (id) VALUES (10000); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -38 -SELECT MAX(id) FROM t1; -MAX(id) -38 -INSERT INTO t1 (id) VALUES (1000); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -42 -SELECT MAX(id) FROM t1; -MAX(id) -42 - -read only -DROP TABLE IF EXISTS t1; -CREATE TABLE t1 ( -id int(11) NOT NULL, -PRIMARY KEY (id) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_READONLY1_1 -SELECT id FROM t1 ORDER BY id; -id -2 -6 -10 -14 -18 -22 -26 -30 -34 -38 -42 -INSERT INTO t1 (id) VALUES (1); -ERROR HY000: Table 'auto_test_local.t1' is read only -UPDATE t1 SET id = 4 WHERE id = 2; -ERROR HY000: Table 'auto_test_local.t1' is read only -DELETE FROM t1 WHERE id = 2; -ERROR HY000: Table 'auto_test_local.t1' is read only -DELETE FROM t1; -ERROR HY000: Table 'auto_test_local.t1' is read only -TRUNCATE t1; -ERROR HY000: Table 'auto_test_local.t1' is read only - -2.27 -error mode -DROP TABLE IF EXISTS t1; -CREATE TABLE t1 ( -id int(11) NOT NULL, -PRIMARY KEY (id) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_ERROR_MODE1_1 -SELECT id FROM t1 ORDER BY id; -id -Warnings: -Error 12712 Error from Oracle -1 942 ORA-00942: ??????????????? - -Error 12712 Oracle error -Error 12712 Error from Oracle -1 942 ORA-00942: ??????????????? - -Error 12712 Oracle error -INSERT INTO t1 (id) VALUES (1); -Warnings: -Error 12712 Error from Oracle -1 942 ORA-00942: ??????????????? - -Error 12712 Oracle error -DELETE FROM t1; -Warnings: -Error 12712 Error from Oracle -1 942 ORA-00942: ??????????????? - -Error 12712 Oracle error -TRUNCATE t1; -Warnings: -Error 12712 Error from Oracle -1 942 ORA-00942: ??????????????? - -Error 12712 Oracle error - -3.0 -is null -DROP TABLE IF EXISTS t1; -CREATE TABLE t1 ( -a VARCHAR(255), -b VARCHAR(255), -c VARCHAR(255), -KEY idx1(a,b), -KEY idx2(b), -PRIMARY KEY(c) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_TEXT_KEY1_1 -insert into t1 values (null, null, '2048'); -insert into t1 values ('1', '1', '1'); -insert into t1 select a + 1, b + 1, c + 1 from t1; -insert into t1 select a + 2, b + 2, c + 2 from t1; -insert into t1 select a + 4, b + 4, c + 4 from t1; -insert into t1 select a + 8, b + 8, c + 8 from t1; -insert into t1 select a + 16, b + 16, c + 16 from t1; -insert into t1 select a + 32, b + 32, c + 32 from t1; -insert into t1 select a + 64, b + 64, c + 64 from t1; -insert into t1 select a + 128, b + 128, c + 128 from t1; -insert into t1 select a + 256, b + 256, c + 256 from t1; -insert into t1 select a + 512, b + 512, c + 512 from t1; -flush tables; -select a from t1 where a is null order by a limit 30; -a -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -select b from t1 where b is null order by b limit 30; -b -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL -NULL - -direct_order_limit -TRUNCATE TABLE t1; -insert into t1 values ('1', '1', '1'); -insert into t1 select a + 1, b + 1, c + 1 from t1; -insert into t1 select a + 2, b + 2, c + 2 from t1; -insert into t1 select a + 4, b + 4, c + 4 from t1; -insert into t1 select a + 8, b + 8, c + 8 from t1; -insert into t1 select a + 16, b + 16, c + 16 from t1; -insert into t1 select a, b + 32, c + 32 from t1; -insert into t1 select a, b + 64, c + 64 from t1; -insert into t1 select a, b + 128, c + 128 from t1; -flush tables; -select a, b, c from t1 where a = '10' and b <> '100' order by c desc limit 5; -a b c -10 74 74 -10 42 42 -10 234 234 -10 202 202 -10 170 170 -select a, c from t1 where a = '10' order by b desc limit 5; -a c -10 74 -10 42 -10 234 -10 202 -10 170 - -deinit -DROP DATABASE IF EXISTS auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -for slave1_1 -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -end of test diff --git a/storage/spider/mysql-test/spider/oracle2/r/spider_fixes_part.result b/storage/spider/mysql-test/spider/oracle2/r/spider_fixes_part.result deleted file mode 100644 index 20a5ca1812b..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/r/spider_fixes_part.result +++ /dev/null @@ -1,203 +0,0 @@ -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 -for slave1_1 - -drop and create databases -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -CREATE DATABASE auto_test_remote; -USE auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -CREATE DATABASE auto_test_remote2; -USE auto_test_remote2; - -test select 1 -SELECT 1; -1 -1 -DROP TABLE IF EXISTS tb_l; -CREATE TABLE tb_l ( -a INT, -b CHAR(1), -c DATETIME, -PRIMARY KEY(a) -) MASTER_1_ENGINE2 MASTER_1_CHARSET2 -INSERT INTO tb_l (a, b, c) VALUES -(1, 'a', '2008-08-01 10:21:39'), -(2, 'b', '2000-01-01 00:00:00'), -(3, 'e', '2007-06-04 20:03:11'), -(4, 'd', '2003-11-30 05:01:03'), -(5, 'c', '2001-12-31 23:59:59'); - -2.17 -partition with sort -CREATE TABLE ta_l2 ( -a INT, -b CHAR(1), -c DATETIME, -PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_COMMENT2_P_2_1 -INSERT INTO ta_l2 SELECT a, b, c FROM tb_l; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 WHERE a > 1 -ORDER BY a; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -2 b 2000-01-01 00:00:00 -3 e 2007-06-04 20:03:11 -4 d 2003-11-30 05:01:03 -5 c 2001-12-31 23:59:59 - -2.23 -partition update with moving partition -DROP TABLE IF EXISTS ta_l2; -CREATE TABLE ta_l2 ( -a INT, -b CHAR(1), -c DATETIME, -PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_COMMENT2_P_2_1 -INSERT INTO ta_l2 (a, b, c) VALUES (3, 'B', '2010-09-26 00:00:00'); -UPDATE ta_l2 SET a = 4 WHERE a = 3; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2; -a b date_format(c, '%Y-%m-%d %H:%i:%s') -4 B 2010-09-26 00:00:00 -index merge with partition -DROP TABLE IF EXISTS ta_l_int; -CREATE TABLE ta_l_int ( -a INT AUTO_INCREMENT, -b INT DEFAULT 10, -c INT DEFAULT 11, -PRIMARY KEY(a), -KEY idx1(b), -KEY idx2(c) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT3_P_2_1 -INSERT INTO ta_l_int (a, b, c) VALUES (1, 2, 3); -INSERT INTO ta_l_int (a, b, c) SELECT a + 1, b + 1, c + 1 FROM ta_l_int; -INSERT INTO ta_l_int (a, b, c) SELECT a + 2, b + 2, c + 2 FROM ta_l_int; -INSERT INTO ta_l_int (a, b, c) SELECT a + 4, b + 4, c + 4 FROM ta_l_int; -INSERT INTO ta_l_int (a, b, c) SELECT a + 8, b + 8, c + 8 FROM ta_l_int; -SELECT a, b, c FROM ta_l_int force index(primary, idx1, idx2) -WHERE a = 5 OR b = 5 OR c = 5 ORDER BY a; -a b c -3 4 5 -4 5 6 -5 6 7 - -2.26 -auto_increment with partition -DROP TABLE IF EXISTS t1; -CREATE TABLE t1 ( -id int(11) NOT NULL AUTO_INCREMENT, -PRIMARY KEY (id) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_INCREMENT1_P_1 -MASTER_1_AUTO_INCREMENT_INCREMENT2 -MASTER_1_AUTO_INCREMENT_OFFSET2 -spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_1"\'; exception when others then null; end;', '', 'srv "s_2_1"') -1 -spider_direct_sql('CREATE SEQUENCE "seq_t1_1" START WITH 2 INCREMENT BY 4', '', 'srv "s_2_1"') -1 -spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_2"\'; exception when others then null; end;', '', 'srv "s_2_2"') -1 -spider_direct_sql('CREATE SEQUENCE "seq_t1_2" START WITH 3 INCREMENT BY 4', '', 'srv "s_2_2"') -1 -spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_1"\'; exception when others then null; end;', '', 'srv "s_2_1"') -1 -spider_direct_sql('CREATE SEQUENCE "seq_t1_1" START WITH 2 INCREMENT BY 4', '', 'srv "s_2_1"') -1 -spider_direct_sql('begin execute immediate \'DROP SEQUENCE "seq_t1_2"\'; exception when others then null; end;', '', 'srv "s_2_2"') -1 -spider_direct_sql('CREATE SEQUENCE "seq_t1_2" START WITH 3 INCREMENT BY 4', '', 'srv "s_2_2"') -1 -INSERT INTO t1 () VALUES (); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -3 -SELECT MAX(id) FROM t1; -MAX(id) -3 -INSERT INTO t1 () VALUES (); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -2 -SELECT MAX(id) FROM t1; -MAX(id) -3 -INSERT INTO t1 (id) VALUES (null); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -7 -SELECT MAX(id) FROM t1; -MAX(id) -7 -INSERT INTO t1 (id) VALUES (null); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -6 -SELECT MAX(id) FROM t1; -MAX(id) -7 -INSERT INTO t1 () VALUES (),(),(),(); -Warnings: -Note 12520 Binlog's auto-inc value is probably different from linked table's auto-inc value -Note 12520 Binlog's auto-inc value is probably different from linked table's auto-inc value -Note 12520 Binlog's auto-inc value is probably different from linked table's auto-inc value -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -10 -SELECT id FROM t1 ORDER BY id; -id -2 -3 -6 -7 -10 -11 -14 -15 -SET INSERT_ID=5000; -INSERT INTO t1 () VALUES (); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -18 -SELECT MAX(id) FROM t1; -MAX(id) -18 -INSERT INTO t1 (id) VALUES (10000); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -22 -SELECT MAX(id) FROM t1; -MAX(id) -22 -INSERT INTO t1 (id) VALUES (1000); -SELECT LAST_INSERT_ID(); -LAST_INSERT_ID() -26 -SELECT MAX(id) FROM t1; -MAX(id) -26 - -deinit -DROP DATABASE IF EXISTS auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -for slave1_1 -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -end of test diff --git a/storage/spider/mysql-test/spider/oracle2/r/vp_fixes.result b/storage/spider/mysql-test/spider/oracle2/r/vp_fixes.result deleted file mode 100644 index 15dd29aa4d3..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/r/vp_fixes.result +++ /dev/null @@ -1,80 +0,0 @@ -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -drop and create databases -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -CREATE DATABASE auto_test_remote; -USE auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -CREATE DATABASE auto_test_remote2; -USE auto_test_remote2; - -test select 1 -SELECT 1; -1 -1 - -create table and insert -DROP TABLE IF EXISTS tb_l; -CREATE TABLE tb_l ( -a INT, -b CHAR(1), -c DATETIME, -PRIMARY KEY(a) -) MASTER_1_ENGINE2 MASTER_1_CHARSET2 -INSERT INTO tb_l (a, b, c) VALUES -(1, 'a', '2008-08-01 10:21:39'), -(2, 'b', '2000-01-01 00:00:00'), -(3, 'e', '2007-06-04 20:03:11'), -(4, 'd', '2003-11-30 05:01:03'), -(5, 'c', '2001-12-31 23:59:59'); -DROP TABLE IF EXISTS ta_l; -CREATE TABLE ta_l ( -PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_2_1 -INSERT INTO ta_l SELECT a, b, c FROM tb_l; - -0.9 -create different primary key table -CREATE TABLE ta_l_int ( -a INT DEFAULT 10, -b INT AUTO_INCREMENT, -c INT DEFAULT 11, -PRIMARY KEY(b) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT4_2_1 -INSERT INTO ta_l_int (a, b, c) VALUES (2, NULL, 3); -create un-correspond primary key table -DROP TABLE IF EXISTS ta_l_int; -CREATE TABLE ta_l_int ( -a INT DEFAULT 10, -b INT DEFAULT 12, -c INT DEFAULT 11, -PRIMARY KEY(c) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT4_2_1 -INSERT INTO ta_l_int (a, b, c) VALUES (2, NULL, 3); - -deinit -DROP DATABASE IF EXISTS auto_test_local; -DROP DATABASE IF EXISTS auto_test_remote; -DROP DATABASE IF EXISTS auto_test_remote2; -for master_1 -for child2 -child2_1 -child2_2 -child2_3 -for child3 -child3_1 -child3_2 -child3_3 - -end of test diff --git a/storage/spider/mysql-test/spider/oracle2/t/basic_sql.test b/storage/spider/mysql-test/spider/oracle2/t/basic_sql.test deleted file mode 100644 index 9cf4ce99dc3..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/t/basic_sql.test +++ /dev/null @@ -1,2699 +0,0 @@ -# This test tests by executing basic SQL ---disable_warnings ---disable_query_log ---disable_result_log ---source test_init.inc ---enable_result_log ---enable_query_log - ---echo ---echo drop and create databases ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - CREATE DATABASE auto_test_remote; - USE auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; - CREATE DATABASE auto_test_remote2; - USE auto_test_remote2; -} ---enable_warnings - ---echo ---echo test select 1 ---connection master_1 -SELECT 1; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - SELECT 1; - --connection child2_2 - SELECT 1; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo create table select test -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_TABLES; - echo CHILD2_1_CREATE_TABLES; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 ---disable_warnings -DROP TABLE IF EXISTS tb_l; ---enable_warnings ---disable_query_log -echo CREATE TABLE tb_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) MASTER_1_ENGINE2 MASTER_1_CHARSET2; -eval CREATE TABLE tb_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) $MASTER_1_ENGINE2 $MASTER_1_CHARSET2; ---enable_query_log -INSERT INTO tb_l (a, b, c) VALUES - (1, 'a', '2008-08-01 10:21:39'), - (2, 'b', '2000-01-01 00:00:00'), - (3, 'e', '2007-06-04 20:03:11'), - (4, 'd', '2003-11-30 05:01:03'), - (5, 'c', '2001-12-31 23:59:59'); ---disable_warnings -DROP TABLE IF EXISTS ta_l; ---enable_warnings ---disable_query_log -echo CREATE TABLE ta_l ( - PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_2_1 -SELECT a, b, c FROM tb_l; -if ($MASTER_1_MERGE) -{ - --error ER_WRONG_OBJECT - eval CREATE TABLE ta_l ( - PRIMARY KEY(a) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_2_1 - SELECT a, b, c FROM tb_l; - eval CREATE TABLE ta_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_2_1; - INSERT INTO ta_l SELECT a, b, c FROM tb_l; -} -if (!$MASTER_1_MERGE) -{ - eval CREATE TABLE ta_l ( - PRIMARY KEY(a) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_2_1 - SELECT a, b, c FROM tb_l; -} ---enable_query_log -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%insert %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo create table ignore select test -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 ---disable_warnings -DROP TABLE IF EXISTS ta_l; -DROP TABLE IF EXISTS tb_l; ---enable_warnings ---disable_query_log -echo CREATE TABLE tb_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) MASTER_1_ENGINE2 MASTER_1_CHARSET2; -eval CREATE TABLE tb_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) $MASTER_1_ENGINE2 $MASTER_1_CHARSET2; ---enable_query_log -INSERT INTO tb_l (a, b, c) VALUES - (1, 'f', '2008-07-01 10:21:39'), - (2, 'g', '2000-02-01 00:00:00'), - (3, 'j', '2007-05-04 20:03:11'), - (4, 'i', '2003-10-30 05:01:03'), - (5, 'h', '2001-10-31 23:59:59'); ---disable_query_log -echo CREATE TABLE ta_l ( - PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_2_1 -IGNORE SELECT a, b, c FROM tb_l; -if ($MASTER_1_MERGE) -{ - --error ER_WRONG_OBJECT - eval CREATE TABLE ta_l ( - PRIMARY KEY(a) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_2_1 - IGNORE SELECT a, b, c FROM tb_l; - eval CREATE TABLE ta_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_2_1; - INSERT IGNORE INTO ta_l SELECT a, b, c FROM tb_l; -} -if (!$MASTER_1_MERGE) -{ - eval CREATE TABLE ta_l ( - PRIMARY KEY(a) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_2_1 - IGNORE SELECT a, b, c FROM tb_l; -} ---enable_query_log -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%insert %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo create table ignore select test -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 ---disable_warnings -DROP TABLE IF EXISTS ta_l; ---enable_warnings ---disable_query_log -echo CREATE TABLE ta_l ( - PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_2_1 -REPLACE SELECT a, b, c FROM tb_l; -if ($MASTER_1_MERGE) -{ - --error ER_WRONG_OBJECT - eval CREATE TABLE ta_l ( - PRIMARY KEY(a) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_2_1 - REPLACE SELECT a, b, c FROM tb_l; - eval CREATE TABLE ta_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_2_1; - REPLACE INTO ta_l SELECT a, b, c FROM tb_l; -} -if (!$MASTER_1_MERGE) -{ - eval CREATE TABLE ta_l ( - PRIMARY KEY(a) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_2_1 - REPLACE SELECT a, b, c FROM tb_l; -} ---enable_query_log -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%replace %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo create no index table -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_TABLES3; - echo CHILD2_1_CREATE_TABLES3; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES3; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES3; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 ---disable_warnings -DROP TABLE IF EXISTS ta_l_no_idx; ---enable_warnings ---disable_query_log -echo CREATE TABLE ta_l_no_idx -MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT2_2_1 -SELECT a, b, c FROM tb_l; -if ($MASTER_1_NEEDPK) -{ - --error ER_REQUIRES_PRIMARY_KEY - eval CREATE TABLE ta_l_no_idx - $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT2_2_1 - SELECT a, b, c FROM tb_l; - eval CREATE TABLE ta_l_no_idx ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT2_2_1; - INSERT INTO ta_l_no_idx SELECT a, b, c FROM tb_l; -} -if (!$MASTER_1_NEEDPK) -{ - if ($MASTER_1_MERGE) - { - --error ER_WRONG_OBJECT - eval CREATE TABLE ta_l_no_idx - $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT2_2_1 - SELECT a, b, c FROM tb_l; - eval CREATE TABLE ta_l_no_idx ( - a INT, - b CHAR(1), - c DATETIME - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT2_2_1; - INSERT INTO ta_l_no_idx SELECT a, b, c FROM tb_l; - } - if (!$MASTER_1_MERGE) - { - eval CREATE TABLE ta_l_no_idx - $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT2_2_1 - SELECT a, b, c FROM tb_l; - } -} ---enable_query_log -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%insert %'; - } - eval $CHILD2_1_SELECT_TABLES3; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l_no_idx ORDER BY a; - ---echo ---echo select table -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo select table shared mode -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a -LOCK IN SHARE MODE; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo select table for update -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a -FOR UPDATE; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo select table join -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a.a, a.b, date_format(b.c, '%Y-%m-%d %H:%i:%s') FROM ta_l a, tb_l b -WHERE a.a = b.a ORDER BY a.a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo select table straight_join -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT STRAIGHT_JOIN a.a, a.b, date_format(b.c, '%Y-%m-%d %H:%i:%s') -FROM ta_l a, tb_l b WHERE a.a = b.a ORDER BY a.a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo select sql_small_result -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT SQL_SMALL_RESULT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l -ORDER BY a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo select sql_big_result -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT SQL_BIG_RESULT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l -ORDER BY a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo select sql_buffer_result -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT SQL_BUFFER_RESULT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l -ORDER BY a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo select sql_cache -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT SQL_CACHE a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l -ORDER BY a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo select sql_no_cache -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT SQL_NO_CACHE a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l -ORDER BY a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo select sql_calc_found_rows -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT SQL_CALC_FOUND_ROWS a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l -ORDER BY a LIMIT 4; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT found_rows(); - ---echo ---echo select high_priority -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT HIGH_PRIORITY a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l -ORDER BY a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo select distinct -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT DISTINCT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l -ORDER BY a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo select count -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT count(*) FROM ta_l ORDER BY a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo select table join not use index -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a.a, a.b, date_format(a.c, '%Y-%m-%d %H:%i:%s') FROM tb_l a WHERE -EXISTS (SELECT * FROM ta_l b WHERE b.b = a.b) ORDER BY a.a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo select using pushdown -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a.a, a.b, date_format(a.c, '%Y-%m-%d %H:%i:%s') FROM ta_l a WHERE -a.b = 'g' ORDER BY a.a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo select using index and pushdown -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a.a, a.b, date_format(a.c, '%Y-%m-%d %H:%i:%s') FROM ta_l a WHERE -a.a > 0 AND a.b = 'g' ORDER BY a.a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo insert ---connection master_1 -TRUNCATE TABLE ta_l; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -INSERT INTO ta_l (a, b, c) VALUES (2, 'e', '2008-01-01 23:59:59'); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'insert %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo insert select ---connection master_1 -TRUNCATE TABLE ta_l; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -INSERT INTO ta_l (a, b, c) SELECT a, b, c FROM tb_l; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'insert %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo insert select a ---connection master_1 -TRUNCATE TABLE ta_l; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -INSERT INTO ta_l (a, b, c) VALUES ((SELECT a FROM tb_l ORDER BY a LIMIT 1), -'e', '2008-01-01 23:59:59'); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'insert %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo insert low_priority ---connection master_1 -TRUNCATE TABLE ta_l; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -INSERT LOW_PRIORITY INTO ta_l (a, b, c) values (2, 'e', '2008-01-01 23:59:59'); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'insert %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo insert high_priority ---connection master_1 -TRUNCATE TABLE ta_l; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -INSERT HIGH_PRIORITY INTO ta_l (a, b, c) VALUES (2, 'e', -'2008-01-01 23:59:59'); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'insert %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo insert ignore -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -INSERT IGNORE INTO ta_l (a, b, c) VALUES (2, 'd', '2009-02-02 01:01:01'); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'insert %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo insert update (insert) ---connection master_1 -TRUNCATE TABLE ta_l; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -INSERT INTO ta_l (a, b, c) VALUES (2, 'e', '2008-01-01 23:59:59') ON DUPLICATE -KEY UPDATE b = 'f', c = '2005-08-08 11:11:11'; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'insert %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%update %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%delete %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo insert update (update) -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -INSERT INTO ta_l (a, b, c) VALUES (2, 'e', '2008-01-01 23:59:59') ON DUPLICATE -KEY UPDATE b = 'f', c = '2005-08-08 11:11:11'; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'insert %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%update %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%delete %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo replace ---connection master_1 -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (2, 'e', '2008-01-01 23:59:59'); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -REPLACE INTO ta_l (a, b, c) VALUES (2, 'f', '2008-02-02 02:02:02'); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'replace %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'insert %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'update %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo replace select -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -REPLACE INTO ta_l (a, b, c) SELECT a, b, c FROM tb_l; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'replace %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'insert %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'update %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo replace select a -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -REPLACE INTO ta_l (a, b, c) VALUES ((SELECT a FROM tb_l ORDER BY a LIMIT 1), -'e', '2008-01-01 23:59:59'); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'replace %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'insert %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'update %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo replace low_priority -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -REPLACE LOW_PRIORITY INTO ta_l (a, b, c) VALUES (3, 'g', -'2009-03-03 03:03:03'); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'replace %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'insert %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'update %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo update -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (1, 'e', '2008-01-01 23:59:59'), -(2, 'e', '2008-01-01 23:59:59'); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -UPDATE ta_l SET b = 'f', c = '2008-02-02 02:02:02' WHERE a = 2; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'update %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo update select -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -UPDATE ta_l SET b = 'g', c = '2009-03-03 03:03:03' WHERE a IN (SELECT a FROM -tb_l); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'update %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo update select a -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -UPDATE ta_l SET b = 'h', c = '2010-04-04 04:04:04' WHERE a = (SELECT a FROM -tb_l ORDER BY a LIMIT 1); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'update %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo update join -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -UPDATE ta_l a, tb_l b SET a.b = b.b, a.c = b.c WHERE a.a = b.a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'update %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo update join a -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -UPDATE ta_l a, tb_l b SET a.b = 'g', a.c = '2009-03-03 03:03:03' WHERE -a.a = b.a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'update %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo update low_priority -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -UPDATE LOW_PRIORITY ta_l SET b = 'f', c = '2008-02-02 02:02:02' WHERE a = 2; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'update %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo update ignore -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -UPDATE IGNORE ta_l SET a = 1, b = 'g', c = '2009-03-03 03:03:03' WHERE a = 2; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'update %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo update pushdown -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -update ta_l set b = 'j', c = '2009-03-03 03:03:03' where b = 'f'; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'update %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo update index pushdown -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -UPDATE ta_l SET b = 'g', c = '2009-03-03 03:03:03' WHERE a > 0 AND b = 'j'; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'update %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo delete -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (1, 'e', '2008-01-01 23:59:59'), -(2, 'e', '2008-01-01 23:59:59'), (3, 'e', '2008-01-01 23:59:59'), -(4, 'e', '2008-01-01 23:59:59'), (5, 'e', '2008-01-01 23:59:59'), -(6, 'e', '2008-01-01 23:59:59'), (7, 'e', '2008-01-01 23:59:59'), -(8, 'e', '2008-01-01 23:59:59'), (9, 'e', '2008-01-01 23:59:59'), -(10, 'j', '2008-01-01 23:59:59'); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -DELETE FROM ta_l WHERE a = 2; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'delete %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo delete all -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -DELETE FROM ta_l; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'delete %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo delete select -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (1, 'e', '2008-01-01 23:59:59'), -(2, 'e', '2008-01-01 23:59:59'), (3, 'e', '2008-01-01 23:59:59'), -(4, 'e', '2008-01-01 23:59:59'), (5, 'e', '2008-01-01 23:59:59'), -(6, 'e', '2008-01-01 23:59:59'), (7, 'e', '2008-01-01 23:59:59'), -(8, 'e', '2008-01-01 23:59:59'), (9, 'e', '2008-01-01 23:59:59'), -(10, 'j', '2008-01-01 23:59:59'); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -DELETE FROM ta_l WHERE a IN (SELECT a FROM tb_l); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'delete %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo delete select a -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (1, 'e', '2008-01-01 23:59:59'), -(2, 'e', '2008-01-01 23:59:59'), (3, 'e', '2008-01-01 23:59:59'), -(4, 'e', '2008-01-01 23:59:59'), (5, 'e', '2008-01-01 23:59:59'), -(6, 'e', '2008-01-01 23:59:59'), (7, 'e', '2008-01-01 23:59:59'), -(8, 'e', '2008-01-01 23:59:59'), (9, 'e', '2008-01-01 23:59:59'), -(10, 'j', '2008-01-01 23:59:59'); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -DELETE FROM ta_l WHERE a = (SELECT a FROM tb_l ORDER BY a LIMIT 1); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'delete %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo delete join -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (1, 'e', '2008-01-01 23:59:59'), -(2, 'e', '2008-01-01 23:59:59'), (3, 'e', '2008-01-01 23:59:59'), -(4, 'e', '2008-01-01 23:59:59'), (5, 'e', '2008-01-01 23:59:59'), -(6, 'e', '2008-01-01 23:59:59'), (7, 'e', '2008-01-01 23:59:59'), -(8, 'e', '2008-01-01 23:59:59'), (9, 'e', '2008-01-01 23:59:59'), -(10, 'j', '2008-01-01 23:59:59'); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -DELETE a FROM ta_l a, (SELECT a FROM tb_l ORDER BY a) b WHERE a.a = b.a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'delete %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo delete low_priority -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (1, 'e', '2008-01-01 23:59:59'), -(2, 'e', '2008-01-01 23:59:59'), (3, 'e', '2008-01-01 23:59:59'), -(4, 'e', '2008-01-01 23:59:59'), (5, 'e', '2008-01-01 23:59:59'), -(6, 'e', '2008-01-01 23:59:59'), (7, 'e', '2008-01-01 23:59:59'), -(8, 'e', '2008-01-01 23:59:59'), (9, 'e', '2008-01-01 23:59:59'), -(10, 'j', '2008-01-01 23:59:59'); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -DELETE LOW_PRIORITY FROM ta_l WHERE a = 2; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'delete %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo delete ignore -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (1, 'e', '2008-01-01 23:59:59'), -(2, 'e', '2008-01-01 23:59:59'), (3, 'e', '2008-01-01 23:59:59'), -(4, 'e', '2008-01-01 23:59:59'), (5, 'e', '2008-01-01 23:59:59'), -(6, 'e', '2008-01-01 23:59:59'), (7, 'e', '2008-01-01 23:59:59'), -(8, 'e', '2008-01-01 23:59:59'), (9, 'e', '2008-01-01 23:59:59'), -(10, 'j', '2008-01-01 23:59:59'); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -DELETE IGNORE FROM ta_l WHERE a = 2; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'delete %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo delete quick -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (1, 'e', '2008-01-01 23:59:59'), -(2, 'e', '2008-01-01 23:59:59'), (3, 'e', '2008-01-01 23:59:59'), -(4, 'e', '2008-01-01 23:59:59'), (5, 'e', '2008-01-01 23:59:59'), -(6, 'e', '2008-01-01 23:59:59'), (7, 'e', '2008-01-01 23:59:59'), -(8, 'e', '2008-01-01 23:59:59'), (9, 'e', '2008-01-01 23:59:59'), -(10, 'j', '2008-01-01 23:59:59'); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -DELETE QUICK FROM ta_l WHERE a = 2; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'delete %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo delete pushdown -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (1, 'e', '2008-01-01 23:59:59'), -(2, 'e', '2008-01-01 23:59:59'), (3, 'e', '2008-01-01 23:59:59'), -(4, 'e', '2008-01-01 23:59:59'), (5, 'e', '2008-01-01 23:59:59'), -(6, 'e', '2008-01-01 23:59:59'), (7, 'e', '2008-01-01 23:59:59'), -(8, 'e', '2008-01-01 23:59:59'), (9, 'e', '2008-01-01 23:59:59'), -(10, 'j', '2008-01-01 23:59:59'); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -DELETE FROM ta_l WHERE b = 'e'; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'delete %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo delete index pushdown -TRUNCATE TABLE ta_l; -INSERT INTO ta_l (a, b, c) VALUES (1, 'e', '2008-01-01 23:59:59'), -(2, 'e', '2008-01-01 23:59:59'), (3, 'e', '2008-01-01 23:59:59'), -(4, 'e', '2008-01-01 23:59:59'), (5, 'e', '2008-01-01 23:59:59'), -(6, 'e', '2008-01-01 23:59:59'), (7, 'e', '2008-01-01 23:59:59'), -(8, 'e', '2008-01-01 23:59:59'), (9, 'e', '2008-01-01 23:59:59'), -(10, 'j', '2008-01-01 23:59:59'); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -DELETE FROM ta_l WHERE a > 0 AND b = 'e'; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'delete %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo truncate -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -TRUNCATE TABLE ta_l; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'truncate %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo deinit ---disable_warnings ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; -} ---disable_query_log ---disable_result_log ---source test_deinit.inc ---enable_result_log ---enable_query_log ---enable_warnings ---echo ---echo end of test diff --git a/storage/spider/mysql-test/spider/oracle2/t/basic_sql_part.test b/storage/spider/mysql-test/spider/oracle2/t/basic_sql_part.test deleted file mode 100644 index 1bb18358d5d..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/t/basic_sql_part.test +++ /dev/null @@ -1,571 +0,0 @@ -# This test tests by executing basic SQL ---disable_warnings ---disable_query_log ---disable_result_log ---source test_init.inc ---enable_result_log ---enable_query_log -if (!$HAVE_PARTITION) -{ - --disable_query_log - --disable_result_log - --source test_deinit.inc - --enable_result_log - --enable_query_log - --enable_warnings - skip Test requires partitioning; -} - ---echo ---echo drop and create databases ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - CREATE DATABASE auto_test_remote; - USE auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; - CREATE DATABASE auto_test_remote2; - USE auto_test_remote2; -} ---enable_warnings - ---echo ---echo test select 1 ---connection master_1 -SELECT 1; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - SELECT 1; - --connection child2_2 - SELECT 1; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---connection master_1 ---disable_warnings -DROP TABLE IF EXISTS tb_l; ---enable_warnings ---disable_query_log -echo CREATE TABLE tb_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) MASTER_1_ENGINE2 MASTER_1_CHARSET2; -eval CREATE TABLE tb_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) $MASTER_1_ENGINE2 $MASTER_1_CHARSET2; ---enable_query_log -INSERT INTO tb_l (a, b, c) VALUES - (1, 'f', '2008-07-01 10:21:39'), - (2, 'g', '2000-02-01 00:00:00'), - (3, 'j', '2007-05-04 20:03:11'), - (4, 'i', '2003-10-30 05:01:03'), - (5, 'h', '2001-10-31 23:59:59'); - ---echo ---echo create table with partition and select test -if ($HAVE_PARTITION) -{ - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_2_DROP_TABLES; - echo CHILD2_2_CREATE_TABLES; - } - --disable_warnings - eval $CHILD2_2_DROP_TABLES; - --enable_warnings - eval $CHILD2_2_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_TABLES2; - echo CHILD2_1_CREATE_TABLES2; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES2; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES2; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - --disable_query_log - echo CREATE TABLE ta_l2 ( - PRIMARY KEY(a) - ) MASTER_1_ENGINE MASTER_1_COMMENT_P_2_1 - SELECT a, b, c FROM tb_l; - if ($MASTER_1_MERGE) - { - --error ER_WRONG_OBJECT - eval CREATE TABLE ta_l2 ( - PRIMARY KEY(a) - ) $MASTER_1_ENGINE $MASTER_1_COMMENT_P_2_1 - SELECT a, b, c FROM tb_l; - eval CREATE TABLE ta_l2 ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) - ) $MASTER_1_ENGINE $MASTER_1_COMMENT_P_2_1; - INSERT INTO ta_l2 SELECT a, b, c FROM tb_l; - } - if (!$MASTER_1_MERGE) - { - eval CREATE TABLE ta_l2 ( - PRIMARY KEY(a) - ) $MASTER_1_ENGINE $MASTER_1_COMMENT_P_2_1 - SELECT a, b, c FROM tb_l; - } - --enable_query_log - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%insert %'; - } - eval $CHILD2_2_SELECT_TABLES; - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%insert %'; - } - eval $CHILD2_1_SELECT_TABLES2; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -} - ---echo ---echo select partition using pushdown -if ($HAVE_PARTITION) -{ - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - SELECT a.a, a.b, date_format(a.c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 a WHERE - a.b = 'g' ORDER BY a.a; - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } -} - ---echo ---echo select partition using index pushdown -if ($HAVE_PARTITION) -{ - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - SELECT a.a, a.b, date_format(a.c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 a WHERE - a.a > 0 AND a.b = 'g' ORDER BY a.a; - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } -} - ---echo ---echo update partition pushdown -if ($HAVE_PARTITION) -{ - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - UPDATE ta_l2 SET b = 'e', c = '2009-03-03 03:03:03' WHERE b = 'j'; - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'update %'; - } - eval $CHILD2_2_SELECT_TABLES; - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'update %'; - } - eval $CHILD2_1_SELECT_TABLES2; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -} - ---echo ---echo update partition index pushdown -if ($HAVE_PARTITION) -{ - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - UPDATE ta_l2 SET b = 'j', c = '2009-03-03 03:03:03' WHERE a > 0 AND b = 'e'; - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'update %'; - } - eval $CHILD2_2_SELECT_TABLES; - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'update %'; - } - eval $CHILD2_1_SELECT_TABLES2; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -} - ---echo ---echo delete partition pushdown -if ($HAVE_PARTITION) -{ - TRUNCATE TABLE ta_l2; - INSERT INTO ta_l2 SELECT a, b, c FROM tb_l; - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - DELETE FROM ta_l2 WHERE b = 'g'; - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'delete %'; - } - eval $CHILD2_2_SELECT_TABLES; - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'delete %'; - } - eval $CHILD2_1_SELECT_TABLES2; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -} - ---echo ---echo delete partition index pushdown -if ($HAVE_PARTITION) -{ - TRUNCATE TABLE ta_l2; - INSERT INTO ta_l2 SELECT a, b, c FROM tb_l; - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - DELETE FROM ta_l2 WHERE a > 0 AND b = 'g'; - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'delete %'; - } - eval $CHILD2_2_SELECT_TABLES; - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE 'delete %'; - } - eval $CHILD2_1_SELECT_TABLES2; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; -} - ---echo ---echo deinit ---disable_warnings ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; -} ---disable_query_log ---disable_result_log ---source test_deinit.inc ---enable_result_log ---enable_query_log ---enable_warnings ---echo ---echo end of test diff --git a/storage/spider/mysql-test/spider/oracle2/t/connect_child2_1.inc b/storage/spider/mysql-test/spider/oracle2/t/connect_child2_1.inc deleted file mode 100644 index cd9b0c9ca9b..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/t/connect_child2_1.inc +++ /dev/null @@ -1 +0,0 @@ ---connect (child2_1, localhost, root, , , $CHILD2_1_MYPORT, $CHILD2_1_MYSOCK) diff --git a/storage/spider/mysql-test/spider/oracle2/t/connect_child2_2.inc b/storage/spider/mysql-test/spider/oracle2/t/connect_child2_2.inc deleted file mode 100644 index e145f66b630..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/t/connect_child2_2.inc +++ /dev/null @@ -1 +0,0 @@ ---connect (child2_2, localhost, root, , , $CHILD2_2_MYPORT, $CHILD2_2_MYSOCK) diff --git a/storage/spider/mysql-test/spider/oracle2/t/connect_child2_3.inc b/storage/spider/mysql-test/spider/oracle2/t/connect_child2_3.inc deleted file mode 100644 index d356348d8ea..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/t/connect_child2_3.inc +++ /dev/null @@ -1 +0,0 @@ ---connect (child2_3, localhost, root, , , $CHILD2_3_MYPORT, $CHILD2_3_MYSOCK) diff --git a/storage/spider/mysql-test/spider/oracle2/t/connect_child3_1.inc b/storage/spider/mysql-test/spider/oracle2/t/connect_child3_1.inc deleted file mode 100644 index 03e5c188c89..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/t/connect_child3_1.inc +++ /dev/null @@ -1 +0,0 @@ ---connect (child3_1, localhost, root, , , $CHILD3_1_MYPORT, $CHILD3_1_MYSOCK) diff --git a/storage/spider/mysql-test/spider/oracle2/t/connect_child3_2.inc b/storage/spider/mysql-test/spider/oracle2/t/connect_child3_2.inc deleted file mode 100644 index d62a7ada824..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/t/connect_child3_2.inc +++ /dev/null @@ -1 +0,0 @@ ---connect (child3_2, localhost, root, , , $CHILD3_2_MYPORT, $CHILD3_2_MYSOCK) diff --git a/storage/spider/mysql-test/spider/oracle2/t/connect_child3_3.inc b/storage/spider/mysql-test/spider/oracle2/t/connect_child3_3.inc deleted file mode 100644 index fb49f5bfdac..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/t/connect_child3_3.inc +++ /dev/null @@ -1 +0,0 @@ ---connect (child3_3, localhost, root, , , $CHILD3_3_MYPORT, $CHILD3_3_MYSOCK) diff --git a/storage/spider/mysql-test/spider/oracle2/t/connect_master_1.inc b/storage/spider/mysql-test/spider/oracle2/t/connect_master_1.inc deleted file mode 100644 index 0c129ce5775..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/t/connect_master_1.inc +++ /dev/null @@ -1 +0,0 @@ ---connect (master_1, localhost, root, , , $MASTER_1_MYPORT, $MASTER_1_MYSOCK) diff --git a/storage/spider/mysql-test/spider/oracle2/t/connect_slave1_1.inc b/storage/spider/mysql-test/spider/oracle2/t/connect_slave1_1.inc deleted file mode 100644 index 45a822743e0..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/t/connect_slave1_1.inc +++ /dev/null @@ -1 +0,0 @@ ---connect (slave1_1, localhost, root, , , $SLAVE1_1_MYPORT, $SLAVE1_1_MYSOCK) diff --git a/storage/spider/mysql-test/spider/oracle2/t/direct_aggregate.test b/storage/spider/mysql-test/spider/oracle2/t/direct_aggregate.test deleted file mode 100644 index 5c0c37f483d..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/t/direct_aggregate.test +++ /dev/null @@ -1,179 +0,0 @@ ---disable_warnings ---disable_query_log ---disable_result_log ---source test_init.inc ---enable_result_log ---enable_query_log - ---echo ---echo drop and create databases ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - CREATE DATABASE auto_test_remote; - USE auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; - CREATE DATABASE auto_test_remote2; - USE auto_test_remote2; -} ---enable_warnings - ---echo ---echo test select 1 ---connection master_1 -SELECT 1; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - SELECT 1; - --connection child2_2 - SELECT 1; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo create table select test -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_TABLES; - echo CHILD2_1_CREATE_TABLES; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 ---disable_warnings -DROP TABLE IF EXISTS ta_l; ---enable_warnings ---disable_query_log -echo CREATE TABLE ta_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_2_1; -eval CREATE TABLE ta_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_2_1; ---enable_query_log -INSERT INTO ta_l (a, b, c) VALUES - (1, 'a', '2008-08-01 10:21:39'), - (2, 'b', '2000-01-01 00:00:00'), - (3, 'e', '2007-06-04 20:03:11'), - (4, 'd', '2003-11-30 05:01:03'), - (5, 'c', '2001-12-31 23:59:59'); - ---echo ---echo direct_aggregating test -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -eval $MASTER_1_CHECK_DIRECT_AGGREGATE_STATUS; -SELECT COUNT(*) FROM ta_l; -eval $MASTER_1_CHECK_DIRECT_AGGREGATE_STATUS; -SELECT MAX(a) FROM ta_l; -eval $MASTER_1_CHECK_DIRECT_AGGREGATE_STATUS; -SELECT MIN(a) FROM ta_l; -eval $MASTER_1_CHECK_DIRECT_AGGREGATE_STATUS; -SELECT MAX(a) FROM ta_l WHERE a < 5; -eval $MASTER_1_CHECK_DIRECT_AGGREGATE_STATUS; -SELECT MIN(a) FROM ta_l WHERE a > 1; -eval $MASTER_1_CHECK_DIRECT_AGGREGATE_STATUS; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%handler %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo deinit ---disable_warnings ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; -} ---disable_query_log ---disable_result_log ---source test_deinit.inc ---enable_result_log ---enable_query_log ---enable_warnings ---echo ---echo end of test diff --git a/storage/spider/mysql-test/spider/oracle2/t/direct_aggregate_part.test b/storage/spider/mysql-test/spider/oracle2/t/direct_aggregate_part.test deleted file mode 100644 index cb0b55e9788..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/t/direct_aggregate_part.test +++ /dev/null @@ -1,192 +0,0 @@ ---disable_warnings ---disable_query_log ---disable_result_log ---source test_init.inc ---enable_result_log ---enable_query_log -if (!$HAVE_PARTITION) -{ - --disable_query_log - --disable_result_log - --source test_deinit.inc - --enable_result_log - --enable_query_log - --enable_warnings - skip Test requires partitioning; -} - ---echo ---echo drop and create databases ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - CREATE DATABASE auto_test_remote; - USE auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; - CREATE DATABASE auto_test_remote2; - USE auto_test_remote2; -} ---enable_warnings - ---echo ---echo test select 1 ---connection master_1 -SELECT 1; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - SELECT 1; - --connection child2_2 - SELECT 1; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo with partition test -if ($HAVE_PARTITION) -{ - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_2_DROP_TABLES; - echo CHILD2_2_CREATE_TABLES; - } - --disable_warnings - eval $CHILD2_2_DROP_TABLES; - --enable_warnings - eval $CHILD2_2_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_TABLES2; - echo CHILD2_1_CREATE_TABLES2; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES2; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES2; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - --disable_query_log - echo CREATE TABLE ta_l2 ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) - ) MASTER_1_ENGINE MASTER_1_COMMENT2_P_2_1; - eval CREATE TABLE ta_l2 ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) - ) $MASTER_1_ENGINE $MASTER_1_COMMENT2_P_2_1; - INSERT INTO ta_l2 (a, b, c) VALUES - (1, 'a', '2008-08-01 10:21:39'), - (2, 'b', '2000-01-01 00:00:00'), - (3, 'e', '2007-06-04 20:03:11'), - (4, 'd', '2003-11-30 05:01:03'), - (5, 'c', '2001-12-31 23:59:59'); - --enable_query_log - eval $MASTER_1_CHECK_DIRECT_AGGREGATE_STATUS; - SELECT COUNT(*) FROM ta_l2; - eval $MASTER_1_CHECK_DIRECT_AGGREGATE_STATUS; - SELECT MAX(a) FROM ta_l2; - eval $MASTER_1_CHECK_DIRECT_AGGREGATE_STATUS; - SELECT MIN(a) FROM ta_l2; - eval $MASTER_1_CHECK_DIRECT_AGGREGATE_STATUS; - SELECT MAX(a) FROM ta_l2 WHERE a < 5; - eval $MASTER_1_CHECK_DIRECT_AGGREGATE_STATUS; - SELECT MIN(a) FROM ta_l2 WHERE a > 1; - eval $MASTER_1_CHECK_DIRECT_AGGREGATE_STATUS; - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%handler %'; - } - eval $CHILD2_2_SELECT_TABLES; - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%handler %'; - } - eval $CHILD2_1_SELECT_TABLES2; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } -} - ---echo ---echo deinit ---disable_warnings ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; -} ---disable_query_log ---disable_result_log ---source test_deinit.inc ---enable_result_log ---enable_query_log ---enable_warnings ---echo ---echo end of test diff --git a/storage/spider/mysql-test/spider/oracle2/t/direct_update.test b/storage/spider/mysql-test/spider/oracle2/t/direct_update.test deleted file mode 100644 index 94f27e2859c..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/t/direct_update.test +++ /dev/null @@ -1,198 +0,0 @@ ---disable_warnings ---disable_query_log ---disable_result_log ---source test_init.inc ---enable_result_log ---enable_query_log - ---echo ---echo drop and create databases ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - CREATE DATABASE auto_test_remote; - USE auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; - CREATE DATABASE auto_test_remote2; - USE auto_test_remote2; -} ---enable_warnings - ---echo ---echo test select 1 ---connection master_1 -SELECT 1; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - SELECT 1; - --connection child2_2 - SELECT 1; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo create table select test -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_TABLES; - echo CHILD2_1_CREATE_TABLES; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 ---disable_warnings -DROP TABLE IF EXISTS ta_l; ---enable_warnings ---disable_query_log -echo CREATE TABLE ta_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_2_1; -eval CREATE TABLE ta_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_2_1; ---enable_query_log -INSERT INTO ta_l (a, b, c) VALUES - (1, 'a', '2008-08-01 10:21:39'), - (2, 'b', '2000-01-01 00:00:00'), - (3, 'e', '2007-06-04 20:03:11'), - (4, 'd', '2003-11-30 05:01:03'), - (5, 'c', '2001-12-31 23:59:59'); - ---echo ---echo direct_updating test -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -eval $MASTER_1_CHECK_DIRECT_UPDATE_STATUS; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; ---echo update all rows with function -UPDATE ta_l SET c = ADDDATE(c, 1); -eval $MASTER_1_CHECK_DIRECT_UPDATE_STATUS; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; ---echo update by primary key -UPDATE ta_l SET b = 'x' WHERE a = 3; -eval $MASTER_1_CHECK_DIRECT_UPDATE_STATUS; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; ---echo update by a column without index -UPDATE ta_l SET c = '2011-10-17' WHERE b = 'x'; -eval $MASTER_1_CHECK_DIRECT_UPDATE_STATUS; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; ---echo update by primary key with order and limit -UPDATE ta_l SET c = ADDDATE(c, 1) WHERE a < 4 ORDER BY b DESC LIMIT 1; -eval $MASTER_1_CHECK_DIRECT_UPDATE_STATUS; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; ---echo delete by primary key with order and limit -DELETE FROM ta_l WHERE a < 4 ORDER BY c LIMIT 1; -eval $MASTER_1_CHECK_DIRECT_DELETE_STATUS; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; ---echo delete by a column without index -DELETE FROM ta_l WHERE b = 'c'; -eval $MASTER_1_CHECK_DIRECT_DELETE_STATUS; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; ---echo delete by primary key -DELETE FROM ta_l WHERE a = 3; -eval $MASTER_1_CHECK_DIRECT_DELETE_STATUS; -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%handler %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo deinit ---disable_warnings ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; -} ---disable_query_log ---disable_result_log ---source test_deinit.inc ---enable_result_log ---enable_query_log ---enable_warnings ---echo ---echo end of test diff --git a/storage/spider/mysql-test/spider/oracle2/t/direct_update_part.test b/storage/spider/mysql-test/spider/oracle2/t/direct_update_part.test deleted file mode 100644 index e8f1882594c..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/t/direct_update_part.test +++ /dev/null @@ -1,211 +0,0 @@ ---disable_warnings ---disable_query_log ---disable_result_log ---source test_init.inc ---enable_result_log ---enable_query_log -if (!$HAVE_PARTITION) -{ - --disable_query_log - --disable_result_log - --source test_deinit.inc - --enable_result_log - --enable_query_log - --enable_warnings - skip Test requires partitioning; -} - ---echo ---echo drop and create databases ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - CREATE DATABASE auto_test_remote; - USE auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; - CREATE DATABASE auto_test_remote2; - USE auto_test_remote2; -} ---enable_warnings - ---echo ---echo test select 1 ---connection master_1 -SELECT 1; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - SELECT 1; - --connection child2_2 - SELECT 1; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo with partition test -if ($HAVE_PARTITION) -{ - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_2_DROP_TABLES; - echo CHILD2_2_CREATE_TABLES; - } - --disable_warnings - eval $CHILD2_2_DROP_TABLES; - --enable_warnings - eval $CHILD2_2_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_TABLES2; - echo CHILD2_1_CREATE_TABLES2; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES2; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES2; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - --disable_query_log - echo CREATE TABLE ta_l2 ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) - ) MASTER_1_ENGINE MASTER_1_COMMENT2_P_2_1; - eval CREATE TABLE ta_l2 ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) - ) $MASTER_1_ENGINE $MASTER_1_COMMENT2_P_2_1; - INSERT INTO ta_l2 (a, b, c) VALUES - (1, 'a', '2008-08-01 10:21:39'), - (2, 'b', '2000-01-01 00:00:00'), - (3, 'e', '2007-06-04 20:03:11'), - (4, 'd', '2003-11-30 05:01:03'), - (5, 'c', '2001-12-31 23:59:59'); - --enable_query_log - eval $MASTER_1_CHECK_DIRECT_UPDATE_STATUS; - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; - --echo update all rows with function - UPDATE ta_l2 SET c = ADDDATE(c, 1); - eval $MASTER_1_CHECK_DIRECT_UPDATE_STATUS; - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; - --echo update by primary key - UPDATE ta_l2 SET b = 'x' WHERE a = 3; - eval $MASTER_1_CHECK_DIRECT_UPDATE_STATUS; - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; - --echo update by a column without index - UPDATE ta_l2 SET c = '2011-10-17' WHERE b = 'x'; - eval $MASTER_1_CHECK_DIRECT_UPDATE_STATUS; - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; - --echo update by primary key with order and limit - UPDATE ta_l2 SET c = ADDDATE(c, 1) WHERE a < 4 ORDER BY b DESC LIMIT 1; - eval $MASTER_1_CHECK_DIRECT_UPDATE_STATUS; - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; - --echo delete by primary key with order and limit - DELETE FROM ta_l2 WHERE a < 4 ORDER BY c LIMIT 1; - eval $MASTER_1_CHECK_DIRECT_DELETE_STATUS; - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; - --echo delete by a column without index - DELETE FROM ta_l2 WHERE b = 'c'; - eval $MASTER_1_CHECK_DIRECT_DELETE_STATUS; - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; - --echo delete by primary key - DELETE FROM ta_l2 WHERE a = 3; - eval $MASTER_1_CHECK_DIRECT_DELETE_STATUS; - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%handler %'; - } - eval $CHILD2_2_SELECT_TABLES; - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%handler %'; - } - eval $CHILD2_1_SELECT_TABLES2; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } -} - ---echo ---echo deinit ---disable_warnings ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; -} ---disable_query_log ---disable_result_log ---source test_deinit.inc ---enable_result_log ---enable_query_log ---enable_warnings ---echo ---echo end of test diff --git a/storage/spider/mysql-test/spider/oracle2/t/function.test b/storage/spider/mysql-test/spider/oracle2/t/function.test deleted file mode 100644 index 2472e774782..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/t/function.test +++ /dev/null @@ -1,253 +0,0 @@ -# This test tests for using functions ---disable_warnings ---disable_query_log ---disable_result_log ---source test_init.inc ---enable_result_log ---enable_query_log - ---echo ---echo drop and create databases ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - CREATE DATABASE auto_test_remote; - USE auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; - CREATE DATABASE auto_test_remote2; - USE auto_test_remote2; -} ---enable_warnings - ---echo ---echo test select 1 ---connection master_1 -SELECT 1; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - SELECT 1; - --connection child2_2 - SELECT 1; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo in() -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_result_log - } - --disable_query_log - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - echo CHILD2_1_DROP_TEXT_PK_TABLES1; - echo CHILD2_1_CREATE_TEXT_PK_TABLES1; - } - --disable_warnings - eval $CHILD2_1_DROP_TEXT_PK_TABLES1; - --enable_warnings - eval $CHILD2_1_CREATE_TEXT_PK_TABLES1; - --enable_query_log - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_result_log - } -} ---connection master_1 ---disable_query_log -echo CREATE TABLE t1 ( - a VARCHAR(255), - PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET3 MASTER_1_COMMENT_TEXT_PK1_1; -eval CREATE TABLE t1 ( - a VARCHAR(255), - PRIMARY KEY(a) -) $MASTER_1_ENGINE $MASTER_1_CHARSET3 $MASTER_1_COMMENT_TEXT_PK1_1; ---enable_query_log -insert into t1 values ('1'); -insert into t1 select a + 1 from t1; -insert into t1 select a + 2 from t1; -insert into t1 select a + 4 from t1; -insert into t1 select a + 8 from t1; -insert into t1 select a + 16 from t1; -insert into t1 select a + 32 from t1; -insert into t1 select a + 64 from t1; -insert into t1 select a + 128 from t1; -insert into t1 select a + 256 from t1; -insert into t1 select a + 512 from t1; -flush tables; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -select a from t1 where a in ('15', '120'); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_1_SELECT_TEXT_PK_TABLES1; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo date_sub() -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_TABLES; - echo CHILD2_1_CREATE_TABLES; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 ---disable_warnings -DROP TABLE IF EXISTS ta_l; ---enable_warnings ---disable_query_log -echo CREATE TABLE ta_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_2_1; -eval CREATE TABLE ta_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_2_1; ---enable_query_log -INSERT INTO ta_l (a, b, c) VALUES - (1, 'a', '2008-08-01 10:21:39'), - (2, 'b', '2000-01-01 00:00:00'), - (3, 'e', '2007-06-04 20:03:11'), - (4, 'd', '2003-11-30 05:01:03'), - (5, 'c', '2001-12-31 23:59:59'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -UPDATE ta_l SET c = DATE_SUB(c, INTERVAL 1 YEAR); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -UPDATE ta_l SET c = DATE_ADD(c, INTERVAL 1 QUARTER); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -UPDATE ta_l SET c = DATE_SUB(c, INTERVAL 1 MONTH); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -UPDATE ta_l SET c = DATE_ADD(c, INTERVAL 1 WEEK); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -UPDATE ta_l SET c = DATE_SUB(c, INTERVAL 1 DAY); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -UPDATE ta_l SET c = DATE_ADD(c, INTERVAL 1 HOUR); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -UPDATE ta_l SET c = DATE_SUB(c, INTERVAL 1 MINUTE); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -UPDATE ta_l SET c = DATE_ADD(c, INTERVAL 1 SECOND); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%update %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo deinit ---disable_warnings ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; -} ---disable_query_log ---disable_result_log ---source test_deinit.inc ---enable_result_log ---enable_query_log ---enable_warnings ---echo ---echo end of test diff --git a/storage/spider/mysql-test/spider/oracle2/t/ha.test b/storage/spider/mysql-test/spider/oracle2/t/ha.test deleted file mode 100644 index c36b7363a6d..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/t/ha.test +++ /dev/null @@ -1,878 +0,0 @@ -# This test tests for ha features -if ($USE_HA_TEST) -{ ---disable_warnings ---disable_query_log ---disable_result_log ---source test_init.inc ---source ha_test_init.inc ---enable_result_log ---enable_query_log - ---echo ---echo drop and create databases ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - CREATE DATABASE auto_test_remote; - USE auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; - CREATE DATABASE auto_test_remote2; - USE auto_test_remote2; - --connection child2_3 - DROP DATABASE IF EXISTS auto_test_remote3; - CREATE DATABASE auto_test_remote3; - USE auto_test_remote3; -} -if ($USE_CHILD_GROUP3) -{ - --connection child3_1 - DROP DATABASE IF EXISTS auto_test_local; - CREATE DATABASE auto_test_local; - USE auto_test_local; - --connection child3_2 - DROP DATABASE IF EXISTS auto_test_local; - CREATE DATABASE auto_test_local; - USE auto_test_local; - --connection child3_3 - DROP DATABASE IF EXISTS auto_test_local; - CREATE DATABASE auto_test_local; - USE auto_test_local; -} ---enable_warnings - ---echo ---echo test select 1 ---connection master_1 -SELECT 1; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - SELECT 1; - --connection child2_2 - SELECT 1; - --connection child2_3 - SELECT 1; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} -if ($USE_CHILD_GROUP3) -{ - if (!$OUTPUT_CHILD_GROUP3) - { - --disable_query_log - --disable_result_log - } - --connection child3_1 - SELECT 1; - --connection child3_2 - SELECT 1; - --connection child3_3 - SELECT 1; - if (!$OUTPUT_CHILD_GROUP3) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo create table test -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_TABLES; - echo CHILD2_1_CREATE_TABLES; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_2 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_2_DROP_TABLES; - echo CHILD2_2_CREATE_TABLES; - } - --disable_warnings - eval $CHILD2_2_DROP_TABLES; - --enable_warnings - eval $CHILD2_2_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} -if ($USE_CHILD_GROUP3) -{ - if (!$OUTPUT_CHILD_GROUP3) - { - --disable_query_log - --disable_result_log - } - --connection child3_1 - --disable_warnings - eval $CHILD3_1_DROP_TABLES_HA_2_1; - --enable_warnings - eval $CHILD3_1_CREATE_TABLES_HA_2_1; - --connection child3_2 - --disable_warnings - eval $CHILD3_2_DROP_TABLES_HA_2_1; - --enable_warnings - eval $CHILD3_2_CREATE_TABLES_HA_2_1; - --connection child3_3 - --disable_warnings - eval $CHILD3_3_DROP_TABLES_HA_2_1; - --enable_warnings - eval $CHILD3_3_CREATE_TABLES_HA_2_1; - if (!$OUTPUT_CHILD_GROUP3) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 ---disable_warnings -DROP TABLE IF EXISTS ta_l; ---enable_warnings ---disable_query_log -echo CREATE TABLE ta_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_HA_2_1; -eval CREATE TABLE ta_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_HA_2_1; ---enable_query_log -INSERT INTO ta_l (a, b, c) VALUES - (1, 'a', '2008-08-01 10:21:39'), - (2, 'b', '2000-01-01 00:00:00'), - (3, 'e', '2007-06-04 20:03:11'), - (4, 'd', '2003-11-30 05:01:03'), - (5, 'c', '2001-12-31 23:59:59'); - ---echo ---echo select test -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_1_SELECT_TABLES; - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_2_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo fail-over test -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_2 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_2_HA_DROP_TABLES; - } - --disable_warnings - eval $CHILD2_2_HA_DROP_TABLES; - --enable_warnings - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -eval $MASTER_1_CHECK_HA_STATUS; ---error 12511 -INSERT INTO ta_l (a, b, c) VALUES - (6, 'e', '2011-05-05 20:04:05'); -eval $MASTER_1_CHECK_LINK_STATUS; -eval $MASTER_1_CHECK_LINK_FAILED_LOG; -eval $MASTER_1_CHECK_HA_STATUS; -INSERT INTO ta_l (a, b, c) VALUES - (6, 'e', '2011-05-05 20:04:05'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} -if ($USE_CHILD_GROUP3) -{ - if (!$OUTPUT_CHILD_GROUP3) - { - --disable_query_log - --disable_result_log - } - --connection child3_1 - eval $CHILD3_1_CHECK_LINK_STATUS; - eval $CHILD3_1_CHECK_LINK_FAILED_LOG; - --connection child3_2 - eval $CHILD3_2_CHECK_LINK_STATUS; - eval $CHILD3_2_CHECK_LINK_FAILED_LOG; - --connection child3_3 - eval $CHILD3_3_CHECK_LINK_STATUS; - eval $CHILD3_3_CHECK_LINK_FAILED_LOG; - if (!$OUTPUT_CHILD_GROUP3) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo recovery test -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_2 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_2_HA_CREATE_TABLES; - } - eval $CHILD2_2_HA_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} -if ($USE_CHILD_GROUP3) -{ - if (!$OUTPUT_CHILD_GROUP3) - { - --disable_query_log - --disable_result_log - } - --connection child3_1 - eval $CHILD3_1_SET_RECOVERY_STATUS_2_1; - eval $CHILD3_1_CHECK_LINK_STATUS; - --connection child3_2 - eval $CHILD3_2_SET_RECOVERY_STATUS_2_1; - eval $CHILD3_2_CHECK_LINK_STATUS; - --connection child3_3 - eval $CHILD3_3_SET_RECOVERY_STATUS_2_1; - eval $CHILD3_3_CHECK_LINK_STATUS; - if (!$OUTPUT_CHILD_GROUP3) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -eval $MASTER_1_SET_RECOVERY_STATUS_2_1; -eval $MASTER_1_CHECK_LINK_STATUS; -eval $MASTER_1_COPY_TABLES_2_1; -if ($USE_CHILD_GROUP3) -{ - if (!$OUTPUT_CHILD_GROUP3) - { - --disable_query_log - --disable_result_log - } - --connection child3_1 - eval $CHILD3_1_SET_OK_STATUS_2_1; - eval $CHILD3_1_CHECK_LINK_STATUS; - --connection child3_2 - eval $CHILD3_2_SET_OK_STATUS_2_1; - eval $CHILD3_2_CHECK_LINK_STATUS; - --connection child3_3 - eval $CHILD3_3_SET_OK_STATUS_2_1; - eval $CHILD3_3_CHECK_LINK_STATUS; - if (!$OUTPUT_CHILD_GROUP3) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -eval $MASTER_1_SET_OK_STATUS_2_1; -eval $MASTER_1_CHECK_LINK_STATUS; -INSERT INTO ta_l (a, b, c) VALUES - (8, 'g', '2011-05-05 21:33:30'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -DROP TABLE ta_l; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_1_SELECT_TABLES; - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_2_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} -if ($USE_CHILD_GROUP3) -{ - if (!$OUTPUT_CHILD_GROUP3) - { - --disable_query_log - --disable_result_log - } - --connection child3_1 - --disable_warnings - eval $CHILD3_1_DROP_TABLES_HA_2_1; - --enable_warnings - --connection child3_2 - --disable_warnings - eval $CHILD3_2_DROP_TABLES_HA_2_1; - --enable_warnings - --connection child3_3 - --disable_warnings - eval $CHILD3_3_DROP_TABLES_HA_2_1; - --enable_warnings - if (!$OUTPUT_CHILD_GROUP3) - { - --enable_query_log - --enable_result_log - } -} - ---connection master_1 -eval $MASTER_1_CHANGE_HA_MON; - ---echo ---echo active standby test ---echo create table test -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_TABLES; - echo CHILD2_1_CREATE_TABLES; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_2 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_2_DROP_TABLES; - echo CHILD2_2_CREATE_TABLES; - } - --disable_warnings - eval $CHILD2_2_DROP_TABLES; - --enable_warnings - eval $CHILD2_2_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} -if ($USE_CHILD_GROUP3) -{ - if (!$OUTPUT_CHILD_GROUP3) - { - --disable_query_log - --disable_result_log - } - --connection child3_1 - --disable_warnings - eval $CHILD3_1_DROP_TABLES_HA_2_1; - --enable_warnings - eval $CHILD3_1_CREATE_TABLES_HA_AS_2_1; - --connection child3_2 - --disable_warnings - eval $CHILD3_2_DROP_TABLES_HA_2_1; - --enable_warnings - eval $CHILD3_2_CREATE_TABLES_HA_AS_2_1; - --connection child3_3 - --disable_warnings - eval $CHILD3_3_DROP_TABLES_HA_2_1; - --enable_warnings - eval $CHILD3_3_CREATE_TABLES_HA_AS_2_1; - if (!$OUTPUT_CHILD_GROUP3) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 ---disable_warnings -DROP TABLE IF EXISTS ta_l; ---enable_warnings ---disable_query_log -echo CREATE TABLE ta_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_HA_AS_2_1; -eval CREATE TABLE ta_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_HA_AS_2_1; ---enable_query_log -INSERT INTO ta_l (a, b, c) VALUES - (1, 'a', '2008-08-01 10:21:39'), - (2, 'b', '2000-01-01 00:00:00'), - (3, 'e', '2007-06-04 20:03:11'), - (4, 'd', '2003-11-30 05:01:03'), - (5, 'c', '2001-12-31 23:59:59'); - ---echo ---echo select test -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_1_SELECT_TABLES; - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_2_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo fail-over test -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_HA_AS_DROP_TABLES; - } - --disable_warnings - eval $CHILD2_1_HA_AS_DROP_TABLES; - --enable_warnings - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -eval $MASTER_1_CHECK_HA_STATUS; ---error 12511 -INSERT INTO ta_l (a, b, c) VALUES - (6, 'e', '2011-05-05 20:04:05'); -eval $MASTER_1_CHECK_LINK_STATUS; -eval $MASTER_1_CHECK_LINK_FAILED_LOG; -eval $MASTER_1_CHECK_HA_STATUS; -INSERT INTO ta_l (a, b, c) VALUES - (6, 'e', '2011-05-05 20:04:05'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_2_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} -if ($USE_CHILD_GROUP3) -{ - if (!$OUTPUT_CHILD_GROUP3) - { - --disable_query_log - --disable_result_log - } - --connection child3_1 - eval $CHILD3_1_CHECK_LINK_STATUS; - eval $CHILD3_1_CHECK_LINK_FAILED_LOG; - --connection child3_2 - eval $CHILD3_2_CHECK_LINK_STATUS; - eval $CHILD3_2_CHECK_LINK_FAILED_LOG; - --connection child3_3 - eval $CHILD3_3_CHECK_LINK_STATUS; - eval $CHILD3_3_CHECK_LINK_FAILED_LOG; - if (!$OUTPUT_CHILD_GROUP3) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo recovery test -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_HA_AS_CREATE_TABLES; - } - eval $CHILD2_1_HA_AS_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} -if ($USE_CHILD_GROUP3) -{ - if (!$OUTPUT_CHILD_GROUP3) - { - --disable_query_log - --disable_result_log - } - --connection child3_1 - eval $CHILD3_1_SET_OK_STATUS_AS_2_1; - eval $CHILD3_1_CHECK_LINK_STATUS; - --connection child3_2 - eval $CHILD3_2_SET_OK_STATUS_AS_2_1; - eval $CHILD3_2_CHECK_LINK_STATUS; - --connection child3_3 - eval $CHILD3_3_SET_OK_STATUS_AS_2_1; - eval $CHILD3_3_CHECK_LINK_STATUS; - if (!$OUTPUT_CHILD_GROUP3) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -eval $MASTER_1_SET_OK_STATUS_AS_2_1; -eval $MASTER_1_CHECK_LINK_STATUS; -INSERT INTO ta_l (a, b, c) VALUES - (8, 'g', '2011-05-05 21:33:30'); -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; -DROP TABLE ta_l; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_1_SELECT_TABLES; - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_2_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} -if ($USE_CHILD_GROUP3) -{ - if (!$OUTPUT_CHILD_GROUP3) - { - --disable_query_log - --disable_result_log - } - --connection child3_1 - --disable_warnings - eval $CHILD3_1_DROP_TABLES_HA_2_1; - --enable_warnings - --connection child3_2 - --disable_warnings - eval $CHILD3_2_DROP_TABLES_HA_2_1; - --enable_warnings - --connection child3_3 - --disable_warnings - eval $CHILD3_3_DROP_TABLES_HA_2_1; - --enable_warnings - if (!$OUTPUT_CHILD_GROUP3) - { - --enable_query_log - --enable_result_log - } -} - ---connection master_1 -eval $MASTER_1_CHANGE_HA_MON; - ---echo ---echo deinit ---disable_warnings ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; - --connection child2_3 - DROP DATABASE IF EXISTS auto_test_remote3; -} -if ($USE_CHILD_GROUP3) -{ - --connection child3_1 - DROP DATABASE IF EXISTS auto_test_local; - --connection child3_2 - DROP DATABASE IF EXISTS auto_test_local; - --connection child3_3 - DROP DATABASE IF EXISTS auto_test_local; -} ---disable_query_log ---disable_result_log ---source ha_test_deinit.inc ---source test_deinit.inc ---enable_result_log ---enable_query_log ---enable_warnings -} ---echo ---echo end of test diff --git a/storage/spider/mysql-test/spider/oracle2/t/ha_part.test b/storage/spider/mysql-test/spider/oracle2/t/ha_part.test deleted file mode 100644 index 33fe9850b68..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/t/ha_part.test +++ /dev/null @@ -1,1017 +0,0 @@ -# This test tests for ha features -if ($USE_HA_TEST) -{ ---disable_warnings ---disable_query_log ---disable_result_log ---source test_init.inc ---source ha_test_init.inc ---enable_result_log ---enable_query_log -if (!$HAVE_PARTITION) -{ - --disable_query_log - --disable_result_log - --source ha_test_deinit.inc - --source test_deinit.inc - --enable_result_log - --enable_query_log - --enable_warnings - skip Test requires partitioning; -} - ---echo ---echo drop and create databases ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - CREATE DATABASE auto_test_remote; - USE auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; - CREATE DATABASE auto_test_remote2; - USE auto_test_remote2; - --connection child2_3 - DROP DATABASE IF EXISTS auto_test_remote3; - CREATE DATABASE auto_test_remote3; - USE auto_test_remote3; -} -if ($USE_CHILD_GROUP3) -{ - --connection child3_1 - DROP DATABASE IF EXISTS auto_test_local; - CREATE DATABASE auto_test_local; - USE auto_test_local; - --connection child3_2 - DROP DATABASE IF EXISTS auto_test_local; - CREATE DATABASE auto_test_local; - USE auto_test_local; - --connection child3_3 - DROP DATABASE IF EXISTS auto_test_local; - CREATE DATABASE auto_test_local; - USE auto_test_local; -} ---enable_warnings - ---echo ---echo test select 1 ---connection master_1 -SELECT 1; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - SELECT 1; - --connection child2_2 - SELECT 1; - --connection child2_3 - SELECT 1; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} -if ($USE_CHILD_GROUP3) -{ - if (!$OUTPUT_CHILD_GROUP3) - { - --disable_query_log - --disable_result_log - } - --connection child3_1 - SELECT 1; - --connection child3_2 - SELECT 1; - --connection child3_3 - SELECT 1; - if (!$OUTPUT_CHILD_GROUP3) - { - --enable_query_log - --enable_result_log - } -} - -if ($HAVE_PARTITION) -{ - --echo - --echo create table with partition test - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_TABLES; - echo CHILD2_1_DROP_TABLES2; - echo CHILD2_1_CREATE_TABLES; - echo CHILD2_1_CREATE_TABLES2; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES; - eval $CHILD2_1_DROP_TABLES2; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES; - eval $CHILD2_1_CREATE_TABLES2; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_2 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_2_DROP_TABLES; - echo CHILD2_2_CREATE_TABLES; - } - --disable_warnings - eval $CHILD2_2_DROP_TABLES; - --enable_warnings - eval $CHILD2_2_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_3 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_3_DROP_TABLES; - echo CHILD2_3_CREATE_TABLES; - } - --disable_warnings - eval $CHILD2_3_DROP_TABLES; - --enable_warnings - eval $CHILD2_3_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - if ($USE_CHILD_GROUP3) - { - if (!$OUTPUT_CHILD_GROUP3) - { - --disable_query_log - --disable_result_log - } - --connection child3_1 - --disable_warnings - eval $CHILD3_1_DROP_TABLES_HA_P_2_1; - --enable_warnings - eval $CHILD3_1_CREATE_TABLES_HA_P_2_1; - --connection child3_2 - --disable_warnings - eval $CHILD3_2_DROP_TABLES_HA_P_2_1; - --enable_warnings - eval $CHILD3_2_CREATE_TABLES_HA_P_2_1; - --connection child3_3 - --disable_warnings - eval $CHILD3_3_DROP_TABLES_HA_P_2_1; - --enable_warnings - eval $CHILD3_3_CREATE_TABLES_HA_P_2_1; - if (!$OUTPUT_CHILD_GROUP3) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - --disable_warnings - DROP TABLE IF EXISTS ta_l2; - --enable_warnings - --disable_query_log - echo CREATE TABLE ta_l2 ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) - ) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_HA_P_2_1; - eval CREATE TABLE ta_l2 ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_HA_P_2_1; - --enable_query_log - INSERT INTO ta_l2 (a, b, c) VALUES - (1, 'a', '2008-08-01 10:21:39'), - (2, 'b', '2000-01-01 00:00:00'), - (3, 'e', '2007-06-04 20:03:11'), - (4, 'd', '2003-11-30 05:01:03'), - (5, 'c', '2001-12-31 23:59:59'); - - --echo - --echo select test - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_3 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_1_SELECT_TABLES; - eval $CHILD2_1_SELECT_TABLES2; - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_2_SELECT_TABLES; - --connection child2_3 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_3_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - - --echo - --echo fail-over test - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_3 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_3_HA_DROP_TABLES; - } - --disable_warnings - eval $CHILD2_3_HA_DROP_TABLES; - --enable_warnings - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - eval $MASTER_1_CHECK_HA_STATUS; - --error 12511 - INSERT INTO ta_l2 (a, b, c) VALUES - (6, 'e', '2011-05-05 20:04:05'); - eval $MASTER_1_CHECK_LINK_STATUS; - eval $MASTER_1_CHECK_LINK_FAILED_LOG; - eval $MASTER_1_CHECK_HA_STATUS; - INSERT INTO ta_l2 (a, b, c) VALUES - (6, 'e', '2011-05-05 20:04:05'); - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_1_SELECT_TABLES; - eval $CHILD2_1_SELECT_TABLES2; - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_2_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - if ($USE_CHILD_GROUP3) - { - if (!$OUTPUT_CHILD_GROUP3) - { - --disable_query_log - --disable_result_log - } - --connection child3_1 - eval $CHILD3_1_CHECK_LINK_STATUS; - eval $CHILD3_1_CHECK_LINK_FAILED_LOG; - --connection child3_2 - eval $CHILD3_2_CHECK_LINK_STATUS; - eval $CHILD3_2_CHECK_LINK_FAILED_LOG; - --connection child3_3 - eval $CHILD3_3_CHECK_LINK_STATUS; - eval $CHILD3_3_CHECK_LINK_FAILED_LOG; - if (!$OUTPUT_CHILD_GROUP3) - { - --enable_query_log - --enable_result_log - } - } - - --echo - --echo recovery test - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_3 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_3_HA_CREATE_TABLES; - } - eval $CHILD2_3_HA_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - if ($USE_CHILD_GROUP3) - { - if (!$OUTPUT_CHILD_GROUP3) - { - --disable_query_log - --disable_result_log - } - --connection child3_1 - eval $CHILD3_1_SET_RECOVERY_STATUS_P_2_1; - eval $CHILD3_1_CHECK_LINK_STATUS; - --connection child3_2 - eval $CHILD3_2_SET_RECOVERY_STATUS_P_2_1; - eval $CHILD3_2_CHECK_LINK_STATUS; - --connection child3_3 - eval $CHILD3_3_SET_RECOVERY_STATUS_P_2_1; - eval $CHILD3_3_CHECK_LINK_STATUS; - if (!$OUTPUT_CHILD_GROUP3) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - eval $MASTER_1_SET_RECOVERY_STATUS_P_2_1; - eval $MASTER_1_CHECK_LINK_STATUS; - eval $MASTER_1_COPY_TABLES_P_2_1; - if ($USE_CHILD_GROUP3) - { - if (!$OUTPUT_CHILD_GROUP3) - { - --disable_query_log - --disable_result_log - } - --connection child3_1 - eval $CHILD3_1_SET_OK_STATUS_P_2_1; - eval $CHILD3_1_CHECK_LINK_STATUS; - --connection child3_2 - eval $CHILD3_2_SET_OK_STATUS_P_2_1; - eval $CHILD3_2_CHECK_LINK_STATUS; - --connection child3_3 - eval $CHILD3_3_SET_OK_STATUS_P_2_1; - eval $CHILD3_3_CHECK_LINK_STATUS; - if (!$OUTPUT_CHILD_GROUP3) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - eval $MASTER_1_SET_OK_STATUS_P_2_1; - eval $MASTER_1_CHECK_LINK_STATUS; - INSERT INTO ta_l2 (a, b, c) VALUES - (8, 'g', '2011-05-05 21:33:30'), - (9, 'h', '2011-05-05 22:32:10'); - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; - DROP TABLE ta_l2; - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_1_SELECT_TABLES; - eval $CHILD2_1_SELECT_TABLES2; - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_2_SELECT_TABLES; - --connection child2_3 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_3_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - if ($USE_CHILD_GROUP3) - { - if (!$OUTPUT_CHILD_GROUP3) - { - --disable_query_log - --disable_result_log - } - --connection child3_1 - --disable_warnings - eval $CHILD3_1_DROP_TABLES_HA_P_2_1; - --enable_warnings - --connection child3_2 - --disable_warnings - eval $CHILD3_2_DROP_TABLES_HA_P_2_1; - --enable_warnings - --connection child3_3 - --disable_warnings - eval $CHILD3_3_DROP_TABLES_HA_P_2_1; - --enable_warnings - if (!$OUTPUT_CHILD_GROUP3) - { - --enable_query_log - --enable_result_log - } - } -} - -if ($HAVE_PARTITION) -{ - --echo - --echo create table with partition test - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_TABLES; - echo CHILD2_1_DROP_TABLES2; - echo CHILD2_1_CREATE_TABLES; - echo CHILD2_1_CREATE_TABLES2; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES; - eval $CHILD2_1_DROP_TABLES2; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES; - eval $CHILD2_1_CREATE_TABLES2; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_2 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_2_DROP_TABLES; - echo CHILD2_2_CREATE_TABLES; - } - --disable_warnings - eval $CHILD2_2_DROP_TABLES; - --enable_warnings - eval $CHILD2_2_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_3 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_3_DROP_TABLES; - echo CHILD2_3_CREATE_TABLES; - } - --disable_warnings - eval $CHILD2_3_DROP_TABLES; - --enable_warnings - eval $CHILD2_3_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - if ($USE_CHILD_GROUP3) - { - if (!$OUTPUT_CHILD_GROUP3) - { - --disable_query_log - --disable_result_log - } - --connection child3_1 - --disable_warnings - eval $CHILD3_1_DROP_TABLES_HA_P_2_1; - --enable_warnings - eval $CHILD3_1_CREATE_TABLES_HA_AS_P_2_1; - --connection child3_2 - --disable_warnings - eval $CHILD3_2_DROP_TABLES_HA_P_2_1; - --enable_warnings - eval $CHILD3_2_CREATE_TABLES_HA_AS_P_2_1; - --connection child3_3 - --disable_warnings - eval $CHILD3_3_DROP_TABLES_HA_P_2_1; - --enable_warnings - eval $CHILD3_3_CREATE_TABLES_HA_AS_P_2_1; - if (!$OUTPUT_CHILD_GROUP3) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - --disable_warnings - DROP TABLE IF EXISTS ta_l2; - --enable_warnings - --disable_query_log - echo CREATE TABLE ta_l2 ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) - ) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_HA_AS_P_2_1; - eval CREATE TABLE ta_l2 ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_HA_AS_P_2_1; - --enable_query_log - INSERT INTO ta_l2 (a, b, c) VALUES - (1, 'a', '2008-08-01 10:21:39'), - (2, 'b', '2000-01-01 00:00:00'), - (3, 'e', '2007-06-04 20:03:11'), - (4, 'd', '2003-11-30 05:01:03'), - (5, 'c', '2001-12-31 23:59:59'); - - --echo - --echo select test - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_3 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_1_SELECT_TABLES; - eval $CHILD2_1_SELECT_TABLES2; - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_2_SELECT_TABLES; - --connection child2_3 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_3_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - - --echo - --echo fail-over test - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_HA_AS_DROP_TABLES2; - } - --disable_warnings - eval $CHILD2_1_HA_AS_DROP_TABLES2; - --enable_warnings - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_3 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - eval $MASTER_1_CHECK_HA_STATUS; - --error 12511 - INSERT INTO ta_l2 (a, b, c) VALUES - (6, 'e', '2011-05-05 20:04:05'); - eval $MASTER_1_CHECK_LINK_STATUS; - eval $MASTER_1_CHECK_LINK_FAILED_LOG; - eval $MASTER_1_CHECK_HA_STATUS; - INSERT INTO ta_l2 (a, b, c) VALUES - (6, 'e', '2011-05-05 20:04:05'); - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_1_SELECT_TABLES; - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_2_SELECT_TABLES; - --connection child2_3 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_3_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - if ($USE_CHILD_GROUP3) - { - if (!$OUTPUT_CHILD_GROUP3) - { - --disable_query_log - --disable_result_log - } - --connection child3_1 - eval $CHILD3_1_CHECK_LINK_STATUS; - eval $CHILD3_1_CHECK_LINK_FAILED_LOG; - --connection child3_2 - eval $CHILD3_2_CHECK_LINK_STATUS; - eval $CHILD3_2_CHECK_LINK_FAILED_LOG; - --connection child3_3 - eval $CHILD3_3_CHECK_LINK_STATUS; - eval $CHILD3_3_CHECK_LINK_FAILED_LOG; - if (!$OUTPUT_CHILD_GROUP3) - { - --enable_query_log - --enable_result_log - } - } - - --echo - --echo recovery test - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_HA_AS_CREATE_TABLES2; - } - eval $CHILD2_1_HA_AS_CREATE_TABLES2; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_3 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - if ($USE_CHILD_GROUP3) - { - if (!$OUTPUT_CHILD_GROUP3) - { - --disable_query_log - --disable_result_log - } - --connection child3_1 - eval $CHILD3_1_SET_OK_STATUS_AS_P_2_1; - eval $CHILD3_1_CHECK_LINK_STATUS; - --connection child3_2 - eval $CHILD3_2_SET_OK_STATUS_AS_P_2_1; - eval $CHILD3_2_CHECK_LINK_STATUS; - --connection child3_3 - eval $CHILD3_3_SET_OK_STATUS_AS_P_2_1; - eval $CHILD3_3_CHECK_LINK_STATUS; - if (!$OUTPUT_CHILD_GROUP3) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - eval $MASTER_1_SET_OK_STATUS_AS_P_2_1; - eval $MASTER_1_CHECK_LINK_STATUS; - INSERT INTO ta_l2 (a, b, c) VALUES - (8, 'g', '2011-05-05 21:33:30'), - (9, 'h', '2011-05-05 22:32:10'); - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 ORDER BY a; - DROP TABLE ta_l2; - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_1_SELECT_TABLES; - eval $CHILD2_1_SELECT_TABLES2; - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_2_SELECT_TABLES; - --connection child2_3 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_3_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - if ($USE_CHILD_GROUP3) - { - if (!$OUTPUT_CHILD_GROUP3) - { - --disable_query_log - --disable_result_log - } - --connection child3_1 - --disable_warnings - eval $CHILD3_1_DROP_TABLES_HA_P_2_1; - --enable_warnings - --connection child3_2 - --disable_warnings - eval $CHILD3_2_DROP_TABLES_HA_P_2_1; - --enable_warnings - --connection child3_3 - --disable_warnings - eval $CHILD3_3_DROP_TABLES_HA_P_2_1; - --enable_warnings - if (!$OUTPUT_CHILD_GROUP3) - { - --enable_query_log - --enable_result_log - } - } -} - ---echo ---echo deinit ---disable_warnings ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; - --connection child2_3 - DROP DATABASE IF EXISTS auto_test_remote3; -} -if ($USE_CHILD_GROUP3) -{ - --connection child3_1 - DROP DATABASE IF EXISTS auto_test_local; - --connection child3_2 - DROP DATABASE IF EXISTS auto_test_local; - --connection child3_3 - DROP DATABASE IF EXISTS auto_test_local; -} ---disable_query_log ---disable_result_log ---source ha_test_deinit.inc ---source test_deinit.inc ---enable_result_log ---enable_query_log ---enable_warnings -} ---echo ---echo end of test diff --git a/storage/spider/mysql-test/spider/oracle2/t/ha_test_deinit.inc b/storage/spider/mysql-test/spider/oracle2/t/ha_test_deinit.inc deleted file mode 100644 index 53d0409d066..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/t/ha_test_deinit.inc +++ /dev/null @@ -1,30 +0,0 @@ -# get connection and exist engine test ---echo for master_1 ---connection master_1 ---source ../include/ha_deinit_master_1.inc ---echo for child2 -if ($USE_CHILD_GROUP2) -{ - --echo child2_1 - --connection child2_1 - --source ../include/ha_deinit_child2_1.inc - --echo child2_2 - --connection child2_2 - --source ../include/ha_deinit_child2_2.inc - --echo child2_3 - --connection child2_3 - --source ../include/ha_deinit_child2_3.inc -} ---echo for child3 -if ($USE_CHILD_GROUP3) -{ - --echo child3_1 - --connection child3_1 - --source ../include/ha_deinit_child3_1.inc - --echo child3_2 - --connection child3_2 - --source ../include/ha_deinit_child3_2.inc - --echo child3_3 - --connection child3_3 - --source ../include/ha_deinit_child3_3.inc -} diff --git a/storage/spider/mysql-test/spider/oracle2/t/ha_test_init.inc b/storage/spider/mysql-test/spider/oracle2/t/ha_test_init.inc deleted file mode 100644 index 70576ab16dc..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/t/ha_test_init.inc +++ /dev/null @@ -1,30 +0,0 @@ -# get connection and exist engine test ---echo for master_1 ---connection master_1 ---source ../include/ha_init_master_1.inc ---echo for child2 -if ($USE_CHILD_GROUP2) -{ - --echo child2_1 - --connection child2_1 - --source ../include/ha_init_child2_1.inc - --echo child2_2 - --connection child2_2 - --source ../include/ha_init_child2_2.inc - --echo child2_3 - --connection child2_3 - --source ../include/ha_init_child2_3.inc -} ---echo for child3 -if ($USE_CHILD_GROUP3) -{ - --echo child3_1 - --connection child3_1 - --source ../include/ha_init_child3_1.inc - --echo child3_2 - --connection child3_2 - --source ../include/ha_init_child3_2.inc - --echo child3_3 - --connection child3_3 - --source ../include/ha_init_child3_3.inc -} diff --git a/storage/spider/mysql-test/spider/oracle2/t/have_engine.inc b/storage/spider/mysql-test/spider/oracle2/t/have_engine.inc deleted file mode 100644 index 64bef7499cb..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/t/have_engine.inc +++ /dev/null @@ -1,7 +0,0 @@ -if (!`SELECT count(*) FROM information_schema.engines WHERE - (support = 'YES' OR support = 'DEFAULT') AND - engine = '$TEST_ENGINE_TYPE'`) -{ - SELECT engine, support FROM information_schema.engines; - --let $SKIP_REASON= "Need $TEST_ENGINE_TYPE engine" -} diff --git a/storage/spider/mysql-test/spider/oracle2/t/have_func.inc b/storage/spider/mysql-test/spider/oracle2/t/have_func.inc deleted file mode 100644 index e0823e73fc8..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/t/have_func.inc +++ /dev/null @@ -1,5 +0,0 @@ -if (!`SELECT count(*) FROM mysql.func WHERE name = '$TEST_FUNC_NAME'`) -{ - SELECT name FROM mysql.func; - --let $SKIP_REASON= "Need $TEST_FUNC_NAME function" -} diff --git a/storage/spider/mysql-test/spider/oracle2/t/have_partition.inc b/storage/spider/mysql-test/spider/oracle2/t/have_partition.inc deleted file mode 100644 index b6e699475db..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/t/have_partition.inc +++ /dev/null @@ -1,7 +0,0 @@ -let $HAVE_PARTITION= 0; -if (`SELECT count(*) FROM information_schema.plugins WHERE - plugin_status = 'ACTIVE' AND - plugin_name = 'partition'`) -{ - let $HAVE_PARTITION= 1; -} diff --git a/storage/spider/mysql-test/spider/oracle2/t/have_trigger.inc b/storage/spider/mysql-test/spider/oracle2/t/have_trigger.inc deleted file mode 100644 index 32de484b388..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/t/have_trigger.inc +++ /dev/null @@ -1,2 +0,0 @@ -let $HAVE_TRIGGER= `SELECT COUNT(*) FROM information_schema.tables - WHERE TABLE_SCHEMA = 'information_schema' AND TABLE_NAME = 'TRIGGERS'`; diff --git a/storage/spider/mysql-test/spider/oracle2/t/hs_test_deinit.inc b/storage/spider/mysql-test/spider/oracle2/t/hs_test_deinit.inc deleted file mode 100644 index 7ec2e981fd2..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/t/hs_test_deinit.inc +++ /dev/null @@ -1,17 +0,0 @@ -# get connection and exist engine test ---echo for master_1 ---connection master_1 ---source ../include/hs_deinit_master_1.inc ---echo for child2 -if ($USE_CHILD_GROUP2) -{ - --echo child2_1 - --connection child2_1 - --source ../include/hs_deinit_child2_1.inc - --echo child2_2 - --connection child2_2 - --source ../include/hs_deinit_child2_2.inc - --echo child2_3 - --connection child2_3 - --source ../include/hs_deinit_child2_3.inc -} diff --git a/storage/spider/mysql-test/spider/oracle2/t/hs_test_init.inc b/storage/spider/mysql-test/spider/oracle2/t/hs_test_init.inc deleted file mode 100644 index 831bf479524..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/t/hs_test_init.inc +++ /dev/null @@ -1,17 +0,0 @@ -# get connection and exist engine test ---echo for master_1 ---connection master_1 ---source ../include/hs_init_master_1.inc ---echo for child2 -if ($USE_CHILD_GROUP2) -{ - --echo child2_1 - --connection child2_1 - --source ../include/hs_init_child2_1.inc - --echo child2_2 - --connection child2_2 - --source ../include/hs_init_child2_2.inc - --echo child2_3 - --connection child2_3 - --source ../include/hs_init_child2_3.inc -} diff --git a/storage/spider/mysql-test/spider/oracle2/t/slave_test_deinit.inc b/storage/spider/mysql-test/spider/oracle2/t/slave_test_deinit.inc deleted file mode 100644 index e9d99b7a960..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/t/slave_test_deinit.inc +++ /dev/null @@ -1,6 +0,0 @@ -# get connection and exist engine test ---echo for slave1_1 ---connection slave1_1 -STOP SLAVE; ---source ../include/deinit_slave1_1.inc ---disconnect slave1_1 diff --git a/storage/spider/mysql-test/spider/oracle2/t/slave_test_init.inc b/storage/spider/mysql-test/spider/oracle2/t/slave_test_init.inc deleted file mode 100644 index 739d88970c5..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/t/slave_test_init.inc +++ /dev/null @@ -1,44 +0,0 @@ -# get connection and exist engine test ---echo for slave1_1 ---source connect_slave1_1.inc ---connection slave1_1 -SET SESSION sql_log_bin= 0; ---let $SLAVE1_1_SERVER_ID=`SELECT @@global.server_id` ---let $TEST_ENGINE_TYPE= $SLAVE1_1_ENGINE_TYPE ---source have_partition.inc ---source have_trigger.inc ---source ../include/init_slave1_1.inc ---source have_engine.inc ---let $SLAVE1_1_SLAVE_STATUS=`SHOW SLAVE STATUS` -if (!$SLAVE1_1_SLAVE_STATUS) -{ - eval CHANGE MASTER TO - MASTER_HOST = '127.0.0.1', - MASTER_USER = 'root', - MASTER_PASSWORD = '', - MASTER_PORT = $MASTER_1_MYPORT - ; -} -START SLAVE; ---connection master_1 -call mtr.add_suppression("Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT"); ---connection slave1_1 -call mtr.add_suppression("Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT"); -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - call mtr.add_suppression("Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT"); - --connection child2_2 - call mtr.add_suppression("Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT"); - --connection child2_3 - call mtr.add_suppression("Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT"); -} -if ($USE_CHILD_GROUP3) -{ - --connection child3_1 - call mtr.add_suppression("Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT"); - --connection child3_2 - call mtr.add_suppression("Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT"); - --connection child3_3 - call mtr.add_suppression("Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT"); -} diff --git a/storage/spider/mysql-test/spider/oracle2/t/spider3_fixes.test b/storage/spider/mysql-test/spider/oracle2/t/spider3_fixes.test deleted file mode 100644 index 962abbad19f..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/t/spider3_fixes.test +++ /dev/null @@ -1,292 +0,0 @@ -# This test tests for Spider 3.0's bug fixes -source include/have_log_bin.inc; ---disable_warnings ---disable_query_log ---disable_result_log ---source test_init.inc ---source slave_test_init.inc ---enable_result_log ---enable_query_log - ---echo ---echo drop and create databases ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -if ($USE_REPLICATION) -{ - --connection slave1_1 - DROP DATABASE IF EXISTS auto_test_local; - CREATE DATABASE auto_test_local; - USE auto_test_local; -} -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - CREATE DATABASE auto_test_remote; - USE auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; - CREATE DATABASE auto_test_remote2; - USE auto_test_remote2; -} ---enable_warnings - ---echo ---echo test select 1 ---connection master_1 -SELECT 1; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - SELECT 1; - --connection child2_2 - SELECT 1; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - - ---echo ---echo 3.1 ---echo auto_increment -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_INCREMENT_TABLES1; - echo CHILD2_1_CREATE_INCREMENT_TABLES1; - echo CHILD2_1_AUTO_INCREMENT_INCREMENT2; - echo CHILD2_1_AUTO_INCREMENT_OFFSET2; - } - --disable_warnings - eval $CHILD2_1_DROP_INCREMENT_TABLES1; - --enable_warnings - eval $CHILD2_1_CREATE_INCREMENT_TABLES1; - eval $CHILD2_1_AUTO_INCREMENT_INCREMENT2; - eval $CHILD2_1_AUTO_INCREMENT_OFFSET2; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -if ($USE_REPLICATION) -{ - save_master_pos; - --connection slave1_1 - sync_with_master; - --connection master_1 - --disable_query_log - SET SESSION sql_log_bin= 0; - --enable_query_log -} ---disable_warnings -DROP TABLE IF EXISTS t1, t2; ---enable_warnings ---disable_query_log -echo CREATE TABLE t1 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_INCREMENT1_1; -echo CREATE TABLE t2 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_INCREMENT1_1; -echo MASTER_1_AUTO_INCREMENT_INCREMENT2; -echo MASTER_1_AUTO_INCREMENT_OFFSET2; -eval CREATE TABLE t1 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) -) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_INCREMENT1_1; -eval CREATE TABLE t2 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) -) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_INCREMENT1_1; -eval $MASTER_1_AUTO_INCREMENT_INCREMENT2; -eval $MASTER_1_AUTO_INCREMENT_OFFSET2; -if ($USE_REPLICATION) -{ - SET SESSION sql_log_bin= 1; - --connection slave1_1 - --disable_warnings - DROP TABLE IF EXISTS t1, t2; - --enable_warnings - echo CREATE TABLE t1 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) - ) SLAVE1_1_ENGINE SLAVE1_1_CHARSET SLAVE1_1_COMMENT_INCREMENT1_1; - echo CREATE TABLE t2 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) - ) SLAVE1_1_ENGINE SLAVE1_1_CHARSET SLAVE1_1_COMMENT_INCREMENT1_1; - eval CREATE TABLE t1 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) - ) $SLAVE1_1_ENGINE $SLAVE1_1_CHARSET $SLAVE1_1_COMMENT_INCREMENT1_1; - eval CREATE TABLE t2 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) - ) $SLAVE1_1_ENGINE $SLAVE1_1_CHARSET $SLAVE1_1_COMMENT_INCREMENT1_1; - --connection master_1 -} ---enable_query_log -INSERT INTO t1 () VALUES (); -SELECT LAST_INSERT_ID(); -SELECT MAX(id) FROM t1; -INSERT INTO t2 () VALUES (); -SELECT LAST_INSERT_ID(); -SELECT MAX(id) FROM t2; ---disable_query_log -echo MASTER_1_AUTO_INCREMENT_OFFSET3; -eval $MASTER_1_AUTO_INCREMENT_OFFSET3; ---enable_query_log -INSERT INTO t1 (id) VALUES (null); -SELECT LAST_INSERT_ID(); -SELECT MAX(id) FROM t1; ---disable_query_log -echo MASTER_1_AUTO_INCREMENT_OFFSET4; -eval $MASTER_1_AUTO_INCREMENT_OFFSET4; ---enable_query_log -INSERT INTO t2 (id) VALUES (null); -SELECT LAST_INSERT_ID(); -SELECT MAX(id) FROM t2; ---disable_query_log -echo MASTER_1_AUTO_INCREMENT_OFFSET3; -eval $MASTER_1_AUTO_INCREMENT_OFFSET3; ---enable_query_log -INSERT INTO t1 () VALUES (),(),(),(); -SELECT LAST_INSERT_ID(); -SELECT id FROM t1 ORDER BY id; ---disable_query_log -echo MASTER_1_AUTO_INCREMENT_OFFSET4; -eval $MASTER_1_AUTO_INCREMENT_OFFSET4; ---enable_query_log -INSERT INTO t2 () VALUES (),(),(),(); -SELECT LAST_INSERT_ID(); -SELECT id FROM t2 ORDER BY id; -TRUNCATE TABLE t1; -TRUNCATE TABLE t2; -INSERT INTO t1 () VALUES (),(),(),(); -SELECT LAST_INSERT_ID(); -SELECT id FROM t1 ORDER BY id; -INSERT INTO t2 () VALUES (),(),(),(); -SELECT LAST_INSERT_ID(); -SELECT id FROM t2 ORDER BY id; -SET INSERT_ID=5000; ---disable_query_log -echo MASTER_1_AUTO_INCREMENT_OFFSET3; -eval $MASTER_1_AUTO_INCREMENT_OFFSET3; ---enable_query_log -INSERT INTO t1 () VALUES (); -SELECT LAST_INSERT_ID(); -SELECT MAX(id) FROM t1; ---disable_query_log -echo MASTER_1_AUTO_INCREMENT_OFFSET4; -eval $MASTER_1_AUTO_INCREMENT_OFFSET4; ---enable_query_log -INSERT INTO t2 () VALUES (); -SELECT LAST_INSERT_ID(); -SELECT MAX(id) FROM t2; -INSERT INTO t1 (id) VALUES (10000); -SELECT LAST_INSERT_ID(); -SELECT MAX(id) FROM t1; -INSERT INTO t2 (id) VALUES (1000); -SELECT LAST_INSERT_ID(); -SELECT MAX(id) FROM t2; -if ($USE_REPLICATION) -{ - save_master_pos; - --connection slave1_1 - sync_with_master; - SELECT id FROM t1 ORDER BY id; - --connection master_1 - --disable_query_log - SET SESSION sql_log_bin= 0; - --enable_query_log -} -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%insert %'; - } - eval $CHILD2_1_SELECT_INCREMENT_TABLES1; - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_AUTO_INCREMENT_INCREMENT1; - echo CHILD2_1_AUTO_INCREMENT_OFFSET1; - } - eval $CHILD2_1_AUTO_INCREMENT_INCREMENT1; - eval $CHILD2_1_AUTO_INCREMENT_OFFSET1; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - - ---echo ---echo deinit ---disable_warnings ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -if ($USE_REPLICATION) -{ - --connection slave1_1 - DROP DATABASE IF EXISTS auto_test_local; -} -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; -} ---disable_query_log ---disable_result_log ---source slave_test_deinit.inc ---source test_deinit.inc ---enable_result_log ---enable_query_log ---enable_warnings ---echo ---echo end of test diff --git a/storage/spider/mysql-test/spider/oracle2/t/spider3_fixes_part.test b/storage/spider/mysql-test/spider/oracle2/t/spider3_fixes_part.test deleted file mode 100644 index c609108ca9e..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/t/spider3_fixes_part.test +++ /dev/null @@ -1,345 +0,0 @@ -# This test tests for Spider 3.0's bug fixes -source include/have_log_bin.inc; ---disable_warnings ---disable_query_log ---disable_result_log ---source test_init.inc ---source slave_test_init.inc ---enable_result_log ---enable_query_log -if (!$HAVE_PARTITION) -{ - --disable_query_log - --disable_result_log - --source slave_test_deinit.inc - --source test_deinit.inc - --enable_result_log - --enable_query_log - --enable_warnings - skip Test requires partitioning; -} - ---echo ---echo drop and create databases ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -if ($USE_REPLICATION) -{ - --connection slave1_1 - DROP DATABASE IF EXISTS auto_test_local; - CREATE DATABASE auto_test_local; - USE auto_test_local; -} -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - CREATE DATABASE auto_test_remote; - USE auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; - CREATE DATABASE auto_test_remote2; - USE auto_test_remote2; -} ---enable_warnings - ---echo ---echo test select 1 ---connection master_1 -SELECT 1; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - SELECT 1; - --connection child2_2 - SELECT 1; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - - ---echo auto_increment with partition -if ($HAVE_PARTITION) -{ - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_INCREMENT_TABLES1; - echo CHILD2_1_CREATE_INCREMENT_TABLES1; - echo CHILD2_1_AUTO_INCREMENT_INCREMENT2; - echo CHILD2_1_AUTO_INCREMENT_OFFSET2; - } - --disable_warnings - eval $CHILD2_1_DROP_INCREMENT_TABLES1; - --enable_warnings - eval $CHILD2_1_CREATE_INCREMENT_TABLES1; - eval $CHILD2_1_AUTO_INCREMENT_INCREMENT2; - eval $CHILD2_1_AUTO_INCREMENT_OFFSET2; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_2 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_2_DROP_INCREMENT_TABLES1; - echo CHILD2_2_CREATE_INCREMENT_TABLES1; - echo CHILD2_2_AUTO_INCREMENT_INCREMENT2; - echo CHILD2_2_AUTO_INCREMENT_OFFSET2; - } - --disable_warnings - eval $CHILD2_2_DROP_INCREMENT_TABLES1; - --enable_warnings - eval $CHILD2_2_CREATE_INCREMENT_TABLES1; - eval $CHILD2_2_AUTO_INCREMENT_INCREMENT2; - eval $CHILD2_2_AUTO_INCREMENT_OFFSET2; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - if ($USE_REPLICATION) - { - save_master_pos; - --connection slave1_1 - sync_with_master; - --connection master_1 - --disable_query_log - SET SESSION sql_log_bin= 0; - --enable_query_log - } - --disable_warnings - DROP TABLE IF EXISTS t1, t2; - --enable_warnings - --disable_query_log - echo CREATE TABLE t1 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) - ) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_INCREMENT1_P_1; - echo CREATE TABLE t2 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) - ) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_INCREMENT1_P_1; - echo MASTER_1_AUTO_INCREMENT_INCREMENT2; - echo MASTER_1_AUTO_INCREMENT_OFFSET2; - eval CREATE TABLE t1 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_INCREMENT1_P_1; - eval CREATE TABLE t2 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_INCREMENT1_P_1; - eval $MASTER_1_AUTO_INCREMENT_INCREMENT2; - eval $MASTER_1_AUTO_INCREMENT_OFFSET2; - if ($USE_REPLICATION) - { - SET SESSION sql_log_bin= 1; - --connection slave1_1 - --disable_warnings - DROP TABLE IF EXISTS t1, t2; - --enable_warnings - echo CREATE TABLE t1 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) - ) SLAVE1_1_ENGINE SLAVE1_1_CHARSET SLAVE1_1_COMMENT_INCREMENT1_P_1; - echo CREATE TABLE t2 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) - ) SLAVE1_1_ENGINE SLAVE1_1_CHARSET SLAVE1_1_COMMENT_INCREMENT1_P_1; - eval CREATE TABLE t1 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) - ) $SLAVE1_1_ENGINE $SLAVE1_1_CHARSET $SLAVE1_1_COMMENT_INCREMENT1_P_1; - eval CREATE TABLE t2 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) - ) $SLAVE1_1_ENGINE $SLAVE1_1_CHARSET $SLAVE1_1_COMMENT_INCREMENT1_P_1; - --connection master_1 - } - --enable_query_log - INSERT INTO t1 () VALUES (); - SELECT LAST_INSERT_ID(); - SELECT MAX(id) FROM t1; - INSERT INTO t2 () VALUES (); - SELECT LAST_INSERT_ID(); - SELECT MAX(id) FROM t2; - --disable_query_log - echo MASTER_1_AUTO_INCREMENT_OFFSET3; - eval $MASTER_1_AUTO_INCREMENT_OFFSET3; - --enable_query_log - INSERT INTO t1 (id) VALUES (null); - SELECT LAST_INSERT_ID(); - SELECT MAX(id) FROM t1; - --disable_query_log - echo MASTER_1_AUTO_INCREMENT_OFFSET4; - eval $MASTER_1_AUTO_INCREMENT_OFFSET4; - --enable_query_log - INSERT INTO t2 (id) VALUES (null); - SELECT LAST_INSERT_ID(); - SELECT MAX(id) FROM t2; - --disable_query_log - echo MASTER_1_AUTO_INCREMENT_OFFSET3; - eval $MASTER_1_AUTO_INCREMENT_OFFSET3; - --enable_query_log - INSERT INTO t1 () VALUES (),(),(),(); - SELECT LAST_INSERT_ID(); - SELECT id FROM t1 ORDER BY id; - --disable_query_log - echo MASTER_1_AUTO_INCREMENT_OFFSET4; - eval $MASTER_1_AUTO_INCREMENT_OFFSET4; - --enable_query_log - INSERT INTO t2 () VALUES (),(),(),(); - SELECT LAST_INSERT_ID(); - SELECT id FROM t2 ORDER BY id; - TRUNCATE TABLE t1; - TRUNCATE TABLE t2; - INSERT INTO t1 () VALUES (),(),(),(); - SELECT LAST_INSERT_ID(); - SELECT id FROM t1 ORDER BY id; - INSERT INTO t2 () VALUES (),(),(),(); - SELECT LAST_INSERT_ID(); - SELECT id FROM t2 ORDER BY id; - SET INSERT_ID=5000; - --disable_query_log - echo MASTER_1_AUTO_INCREMENT_OFFSET3; - eval $MASTER_1_AUTO_INCREMENT_OFFSET3; - --enable_query_log - INSERT INTO t1 () VALUES (); - SELECT LAST_INSERT_ID(); - SELECT MAX(id) FROM t1; - --disable_query_log - echo MASTER_1_AUTO_INCREMENT_OFFSET4; - eval $MASTER_1_AUTO_INCREMENT_OFFSET4; - --enable_query_log - INSERT INTO t2 () VALUES (); - SELECT LAST_INSERT_ID(); - SELECT MAX(id) FROM t2; - INSERT INTO t1 (id) VALUES (10000); - SELECT LAST_INSERT_ID(); - SELECT MAX(id) FROM t1; - INSERT INTO t2 (id) VALUES (1000); - SELECT LAST_INSERT_ID(); - SELECT MAX(id) FROM t2; - if ($USE_REPLICATION) - { - save_master_pos; - --connection slave1_1 - sync_with_master; - SELECT id FROM t1 ORDER BY id; - --connection master_1 - --disable_query_log - SET SESSION sql_log_bin= 0; - --enable_query_log - } - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%insert %'; - } - eval $CHILD2_1_SELECT_INCREMENT_TABLES1; - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_AUTO_INCREMENT_INCREMENT1; - echo CHILD2_1_AUTO_INCREMENT_OFFSET1; - } - eval $CHILD2_1_AUTO_INCREMENT_INCREMENT1; - eval $CHILD2_1_AUTO_INCREMENT_OFFSET1; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%insert %'; - } - eval $CHILD2_2_SELECT_INCREMENT_TABLES1; - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_2_AUTO_INCREMENT_INCREMENT1; - echo CHILD2_2_AUTO_INCREMENT_OFFSET1; - } - eval $CHILD2_2_AUTO_INCREMENT_INCREMENT1; - eval $CHILD2_2_AUTO_INCREMENT_OFFSET1; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } -} - - ---echo ---echo deinit ---disable_warnings ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -if ($USE_REPLICATION) -{ - --connection slave1_1 - DROP DATABASE IF EXISTS auto_test_local; -} -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; -} ---disable_query_log ---disable_result_log ---source slave_test_deinit.inc ---source test_deinit.inc ---enable_result_log ---enable_query_log ---enable_warnings ---echo ---echo end of test diff --git a/storage/spider/mysql-test/spider/oracle2/t/spider_fixes.test b/storage/spider/mysql-test/spider/oracle2/t/spider_fixes.test deleted file mode 100644 index d0158c7dc0b..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/t/spider_fixes.test +++ /dev/null @@ -1,1419 +0,0 @@ -# This test tests for Spider's bug fixes -source include/have_log_bin.inc; ---disable_warnings ---disable_query_log ---disable_result_log ---source test_init.inc ---source slave_test_init.inc ---enable_result_log ---enable_query_log - ---echo ---echo drop and create databases ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -if ($USE_REPLICATION) -{ - --connection slave1_1 - DROP DATABASE IF EXISTS auto_test_local; - CREATE DATABASE auto_test_local; - USE auto_test_local; -} -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - CREATE DATABASE auto_test_remote; - USE auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; - CREATE DATABASE auto_test_remote2; - USE auto_test_remote2; -} ---enable_warnings - ---echo ---echo test select 1 ---connection master_1 -SELECT 1; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - SELECT 1; - --connection child2_2 - SELECT 1; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo create table and insert -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_TABLES; - echo CHILD2_1_CREATE_TABLES; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 ---disable_warnings -DROP TABLE IF EXISTS tb_l; ---enable_warnings ---disable_query_log -echo CREATE TABLE tb_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) MASTER_1_ENGINE2 MASTER_1_CHARSET2; -eval CREATE TABLE tb_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) $MASTER_1_ENGINE2 $MASTER_1_CHARSET2; ---enable_query_log -INSERT INTO tb_l (a, b, c) VALUES - (1, 'a', '2008-08-01 10:21:39'), - (2, 'b', '2000-01-01 00:00:00'), - (3, 'e', '2007-06-04 20:03:11'), - (4, 'd', '2003-11-30 05:01:03'), - (5, 'c', '2001-12-31 23:59:59'); ---disable_warnings -DROP TABLE IF EXISTS ta_l; ---enable_warnings ---disable_query_log -echo CREATE TABLE ta_l ( - PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_2_1; -eval CREATE TABLE ta_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_2_1; ---enable_query_log -INSERT INTO ta_l SELECT a, b, c FROM tb_l; - ---echo ---echo 2.13 ---echo select table with "order by desc" and "<" -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l -WHERE a < 5 ORDER BY a DESC LIMIT 3; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo select table with "order by desc" and "<=" -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l -WHERE a <= 5 ORDER BY a DESC LIMIT 3; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo 2.14 ---echo update table with range scan and split_read -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -UPDATE ta_l SET c = '2000-02-02 00:00:00' WHERE a > 1; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l ORDER BY a; - ---echo ---echo 2.15 ---echo select table with range scan -TRUNCATE TABLE ta_l; ---disable_warnings -DROP TABLE IF EXISTS ta_l; ---enable_warnings -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_TABLES6; - echo CHILD2_1_CREATE_TABLES6; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES6; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES6; - --enable_query_log - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_result_log - } -} ---connection master_1 ---disable_query_log -echo CREATE TABLE ta_l ( - a int(11) NOT NULL DEFAULT '0', - b char(1) DEFAULT NULL, - c datetime DEFAULT NULL, - PRIMARY KEY (a, b, c) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT5_2_1; -eval CREATE TABLE ta_l ( - a int(11) NOT NULL DEFAULT '0', - b char(1) DEFAULT NULL, - c datetime DEFAULT NULL, - PRIMARY KEY (a, b, c) -) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT5_2_1; ---enable_query_log -INSERT INTO ta_l SELECT a, b, c FROM tb_l; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a = 4 AND b >= 'b' -AND c = '2003-11-30 05:01:03'; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a = 4 AND b > 'b' -AND c = '2003-11-30 05:01:03'; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a >= 4 AND b = 'd' -AND c = '2003-11-30 05:01:03'; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a > 4 AND b = 'c' -AND c = '2001-12-31 23:59:59'; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a = 4 AND b <= 'd' -AND c = '2003-11-30 05:01:03'; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a = 4 AND b < 'e' -AND c = '2003-11-30 05:01:03'; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a <= 4 AND b = 'b' -AND c = '2000-01-01 00:00:00'; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a < 4 AND b = 'b' -AND c = '2000-01-01 00:00:00'; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a = 4 AND b >= 'b' -AND b <= 'd' AND c = '2003-11-30 05:01:03'; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a = 4 AND b > 'b' -AND b < 'e' AND c = '2003-11-30 05:01:03'; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a <= 4 AND a >= 1 -AND b >= 'b' AND c = '2003-11-30 05:01:03'; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, c FROM ta_l FORCE INDEX(PRIMARY) WHERE a < 4 AND a > 1 -AND b >= 'b' AND c = '2000-01-01 00:00:00'; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo 2.16 ---echo auto_increment insert with trigger -if ($HAVE_TRIGGER) -{ - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_result_log - } - --disable_query_log - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - echo CHILD2_1_DROP_TABLES4; - echo CHILD2_1_CREATE_TABLES4; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES4; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES4; - --enable_query_log - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_result_log - } - } - --connection master_1 - --disable_query_log - echo CREATE TABLE ta_l_auto_inc ( - a INT AUTO_INCREMENT, - b CHAR(1) DEFAULT 'c', - c DATETIME DEFAULT '1999-10-10 10:10:10', - PRIMARY KEY(a) - ) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT3_2_1; - eval CREATE TABLE ta_l_auto_inc ( - a INT AUTO_INCREMENT, - b CHAR(1) DEFAULT 'c', - c DATETIME DEFAULT '1999-10-10 10:10:10', - PRIMARY KEY(a) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT3_2_1; - echo CREATE TABLE tc_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) - ) MASTER_1_ENGINE2 MASTER_1_CHARSET2; - eval CREATE TABLE tc_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) - ) $MASTER_1_ENGINE2 $MASTER_1_CHARSET2; - --enable_query_log - --eval CREATE TRIGGER ins_ta_l_auto_inc AFTER INSERT ON ta_l_auto_inc FOR EACH ROW BEGIN INSERT INTO tc_l (a, b, c) VALUES (NEW.a, NEW.b, NEW.c); END; - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - INSERT INTO ta_l_auto_inc (a, b, c) VALUES - (NULL, 's', '2008-12-31 20:59:59'); - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%insert %'; - } - eval $CHILD2_1_SELECT_TABLES4; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM tc_l ORDER BY a; -} - ---echo ---echo 2.17 ---echo engine-condition-pushdown with "or" and joining -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l WHERE a = 1 OR a IN (SELECT a FROM tb_l); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo 2.23 ---echo index merge -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_result_log - } - --disable_query_log - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - echo CHILD2_1_DROP_TABLES5; - echo CHILD2_1_CREATE_TABLES5; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES5; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES5; - --enable_query_log - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_result_log - } -} ---connection master_1 ---disable_query_log -echo CREATE TABLE ta_l_int ( - a INT AUTO_INCREMENT, - b INT DEFAULT 10, - c INT DEFAULT 11, - PRIMARY KEY(a), - KEY idx1(b), - KEY idx2(c) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT4_2_1; -eval CREATE TABLE ta_l_int ( - a INT AUTO_INCREMENT, - b INT DEFAULT 10, - c INT DEFAULT 11, - PRIMARY KEY(a), - KEY idx1(b), - KEY idx2(c) -) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT4_2_1; ---enable_query_log -INSERT INTO ta_l_int (a, b, c) VALUES (1, 2, 3); -INSERT INTO ta_l_int (a, b, c) SELECT a + 1, b + 1, c + 1 FROM ta_l_int; -INSERT INTO ta_l_int (a, b, c) SELECT a + 2, b + 2, c + 2 FROM ta_l_int; -INSERT INTO ta_l_int (a, b, c) SELECT a + 4, b + 4, c + 4 FROM ta_l_int; -INSERT INTO ta_l_int (a, b, c) SELECT a + 8, b + 8, c + 8 FROM ta_l_int; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, c FROM ta_l_int force index(primary, idx1, idx2) -WHERE a = 5 OR b = 5 OR c = 5 ORDER BY a; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo 2.24 ---echo index scan update without PK ---connection master_1 ---disable_warnings -DROP TABLE IF EXISTS ta_l_int; ---enable_warnings ---disable_query_log -echo CREATE TABLE ta_l_int ( - a INT NOT NULL, - b INT DEFAULT 10, - c INT DEFAULT 11, - KEY idx1(b), - KEY idx2(c) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT4_2_1; -if ($MASTER_1_NEEDPK) -{ - --error ER_REQUIRES_PRIMARY_KEY - eval CREATE TABLE ta_l_int ( - a INT NOT NULL, - b INT DEFAULT 10, - c INT DEFAULT 11, - KEY idx1(b), - KEY idx2(c) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT4_2_1; - eval CREATE TABLE ta_l_int ( - a INT NOT NULL, - b INT DEFAULT 10, - c INT DEFAULT 11, - PRIMARY KEY(a), - KEY idx1(b), - KEY idx2(c) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT4_2_1; -} -if (!$MASTER_1_NEEDPK) -{ - eval CREATE TABLE ta_l_int ( - a INT NOT NULL, - b INT DEFAULT 10, - c INT DEFAULT 11, - KEY idx1(b), - KEY idx2(c) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT4_2_1; -} ---enable_query_log -SELECT a, b, c FROM ta_l_int ORDER BY a; -INSERT INTO ta_l_int (a, b, c) VALUES (0, 2, 3); -INSERT INTO ta_l_int (a, b, c) VALUES (18, 2, 3); -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -UPDATE ta_l_int SET c = 4 WHERE b = 2; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%update %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -SELECT a, b, c FROM ta_l_int ORDER BY a; - - ---echo ---echo 2.25 ---echo direct order limit ---connection master_1 -eval $MASTER_1_CHECK_DIRECT_ORDER_LIMIT_STATUS; -SELECT a, b, c FROM ta_l_int ORDER BY a LIMIT 3; -eval $MASTER_1_CHECK_DIRECT_ORDER_LIMIT_STATUS; - - ---echo ---echo 2.26 ---echo lock tables -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_LOCK_TABLES1; - echo CHILD2_1_DROP_LOCK_TABLES2; - echo CHILD2_1_CREATE_LOCK_TABLES1; - echo CHILD2_1_CREATE_LOCK_TABLES2; - } - --disable_warnings - eval $CHILD2_1_DROP_LOCK_TABLES1; - eval $CHILD2_1_DROP_LOCK_TABLES2; - --enable_warnings - eval $CHILD2_1_CREATE_LOCK_TABLES1; - eval $CHILD2_1_CREATE_LOCK_TABLES2; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_2 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_2_DROP_LOCK_TABLES1; - echo CHILD2_2_DROP_LOCK_TABLES2; - echo CHILD2_2_CREATE_LOCK_TABLES1; - echo CHILD2_2_CREATE_LOCK_TABLES2; - } - --disable_warnings - eval $CHILD2_2_DROP_LOCK_TABLES1; - eval $CHILD2_2_DROP_LOCK_TABLES2; - --enable_warnings - eval $CHILD2_2_CREATE_LOCK_TABLES1; - eval $CHILD2_2_CREATE_LOCK_TABLES2; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 ---disable_warnings -DROP TABLE IF EXISTS t1; -DROP TABLE IF EXISTS t2; ---enable_warnings ---disable_query_log -echo CREATE TABLE t1 ( - id int(11) NOT NULL, - PRIMARY KEY (id) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_LOCK1; -eval CREATE TABLE t1 ( - id int(11) NOT NULL, - PRIMARY KEY (id) -) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_LOCK1; -echo CREATE TABLE t2 ( - id int(11) NOT NULL, - PRIMARY KEY (id) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_LOCK2; -eval CREATE TABLE t2 ( - id int(11) NOT NULL, - PRIMARY KEY (id) -) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_LOCK2; ---enable_query_log -LOCK TABLES t1 READ, t2 READ; -UNLOCK TABLES; - - ---echo ---echo auto_increment -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_INCREMENT_TABLES1; - echo CHILD2_1_CREATE_INCREMENT_TABLES1; - echo CHILD2_1_AUTO_INCREMENT_INCREMENT2; - echo CHILD2_1_AUTO_INCREMENT_OFFSET2; - } - --disable_warnings - eval $CHILD2_1_DROP_INCREMENT_TABLES1; - --enable_warnings - eval $CHILD2_1_CREATE_INCREMENT_TABLES1; - eval $CHILD2_1_AUTO_INCREMENT_INCREMENT2; - eval $CHILD2_1_AUTO_INCREMENT_OFFSET2; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -if ($USE_REPLICATION) -{ - save_master_pos; - --connection slave1_1 - sync_with_master; - --connection master_1 - --disable_query_log - SET SESSION sql_log_bin= 0; - --enable_query_log -} ---disable_warnings -DROP TABLE IF EXISTS t1; ---enable_warnings ---disable_query_log -echo CREATE TABLE t1 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_INCREMENT1_1; -echo MASTER_1_AUTO_INCREMENT_INCREMENT2; -echo MASTER_1_AUTO_INCREMENT_OFFSET2; -eval CREATE TABLE t1 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) -) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_INCREMENT1_1; -eval $MASTER_1_AUTO_INCREMENT_INCREMENT2; -eval $MASTER_1_AUTO_INCREMENT_OFFSET2; -if ($USE_REPLICATION) -{ - SET SESSION sql_log_bin= 1; - --connection slave1_1 - --disable_warnings - DROP TABLE IF EXISTS t1; - --enable_warnings - echo CREATE TABLE t1 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) - ) SLAVE1_1_ENGINE SLAVE1_1_CHARSET SLAVE1_1_COMMENT_INCREMENT1_1; - eval CREATE TABLE t1 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) - ) $SLAVE1_1_ENGINE $SLAVE1_1_CHARSET $SLAVE1_1_COMMENT_INCREMENT1_1; - --connection master_1 -} ---enable_query_log -INSERT INTO t1 () VALUES (); -SELECT LAST_INSERT_ID(); -SELECT MAX(id) FROM t1; -INSERT INTO t1 () VALUES (); -SELECT LAST_INSERT_ID(); -SELECT MAX(id) FROM t1; -INSERT INTO t1 (id) VALUES (null); -SELECT LAST_INSERT_ID(); -SELECT MAX(id) FROM t1; -INSERT INTO t1 (id) VALUES (null); -SELECT LAST_INSERT_ID(); -SELECT MAX(id) FROM t1; -INSERT INTO t1 () VALUES (),(),(),(); -SELECT LAST_INSERT_ID(); -SELECT id FROM t1 ORDER BY id; -SET INSERT_ID=5000; -INSERT INTO t1 () VALUES (); -SELECT LAST_INSERT_ID(); -SELECT MAX(id) FROM t1; -INSERT INTO t1 (id) VALUES (10000); -SELECT LAST_INSERT_ID(); -SELECT MAX(id) FROM t1; -INSERT INTO t1 (id) VALUES (1000); -SELECT LAST_INSERT_ID(); -SELECT MAX(id) FROM t1; -if ($USE_REPLICATION) -{ - save_master_pos; - --connection slave1_1 - sync_with_master; - SELECT id FROM t1 ORDER BY id; - --connection master_1 - --disable_query_log - SET SESSION sql_log_bin= 0; - --enable_query_log -} -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%insert %'; - } - eval $CHILD2_1_SELECT_INCREMENT_TABLES1; - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_AUTO_INCREMENT_INCREMENT1; - echo CHILD2_1_AUTO_INCREMENT_OFFSET1; - } - eval $CHILD2_1_AUTO_INCREMENT_INCREMENT1; - eval $CHILD2_1_AUTO_INCREMENT_OFFSET1; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - - ---echo ---echo read only -let $MASTER_1_ENGINE_IS_SPIDER= - `SELECT IF('$MASTER_1_ENGINE_TYPE' = 'Spider' OR - '$MASTER_1_HIDDEN_ENGINE_TYPE' = 'Spider', 1, 0)`; -if ($MASTER_1_ENGINE_IS_SPIDER) -{ - --connection master_1 - --disable_warnings - DROP TABLE IF EXISTS t1; - --enable_warnings - --disable_query_log - echo CREATE TABLE t1 ( - id int(11) NOT NULL, - PRIMARY KEY (id) - ) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_READONLY1_1; - eval CREATE TABLE t1 ( - id int(11) NOT NULL, - PRIMARY KEY (id) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_READONLY1_1; - --let $MIN_VAL= `SELECT MIN(id) FROM t1` - --enable_query_log - SELECT id FROM t1 ORDER BY id; - --error 12518 - INSERT INTO t1 (id) VALUES (1); - --error 12518 - eval UPDATE t1 SET id = 4 WHERE id = $MIN_VAL; - --error 12518 - eval DELETE FROM t1 WHERE id = $MIN_VAL; - --error 12518 - DELETE FROM t1; - --error 12518 - TRUNCATE t1; -} -if (!$MASTER_1_ENGINE_IS_SPIDER) -{ - --echo skipped -} - - ---echo ---echo 2.27 ---echo error mode -if ($MASTER_1_ENGINE_IS_SPIDER) -{ - --connection master_1 - --disable_warnings - DROP TABLE IF EXISTS t1; - --enable_warnings - --disable_query_log - echo CREATE TABLE t1 ( - id int(11) NOT NULL, - PRIMARY KEY (id) - ) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_ERROR_MODE1_1; - eval CREATE TABLE t1 ( - id int(11) NOT NULL, - PRIMARY KEY (id) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_ERROR_MODE1_1; - --enable_query_log - SELECT id FROM t1 ORDER BY id; - INSERT INTO t1 (id) VALUES (1); - DELETE FROM t1; - TRUNCATE t1; -} -if (!$MASTER_1_ENGINE_IS_SPIDER) -{ - --echo skipped -} - - ---echo ---echo 3.0 ---echo is null -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_result_log - } - --disable_query_log - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - echo CHILD2_1_DROP_TEXT_KEY_TABLES1; - echo CHILD2_1_CREATE_TEXT_KEY_TABLES1; - } - --disable_warnings - eval $CHILD2_1_DROP_TEXT_KEY_TABLES1; - --enable_warnings - eval $CHILD2_1_CREATE_TEXT_KEY_TABLES1; - --enable_query_log - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_result_log - } -} ---connection master_1 ---disable_warnings -DROP TABLE IF EXISTS t1; ---enable_warnings ---disable_query_log -echo CREATE TABLE t1 ( - a VARCHAR(255), - b VARCHAR(255), - c VARCHAR(255), - KEY idx1(a,b), - KEY idx2(b), - PRIMARY KEY(c) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_TEXT_KEY1_1; -eval CREATE TABLE t1 ( - a VARCHAR(255), - b VARCHAR(255), - c VARCHAR(255), - KEY idx1(a,b), - KEY idx2(b), - PRIMARY KEY(c) -) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_TEXT_KEY1_1; ---enable_query_log -insert into t1 values (null, null, '2048'); -insert into t1 values ('1', '1', '1'); -insert into t1 select a + 1, b + 1, c + 1 from t1; -insert into t1 select a + 2, b + 2, c + 2 from t1; -insert into t1 select a + 4, b + 4, c + 4 from t1; -insert into t1 select a + 8, b + 8, c + 8 from t1; -insert into t1 select a + 16, b + 16, c + 16 from t1; -insert into t1 select a + 32, b + 32, c + 32 from t1; -insert into t1 select a + 64, b + 64, c + 64 from t1; -insert into t1 select a + 128, b + 128, c + 128 from t1; -insert into t1 select a + 256, b + 256, c + 256 from t1; -insert into t1 select a + 512, b + 512, c + 512 from t1; -flush tables; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -select a from t1 where a is null order by a limit 30; -select b from t1 where b is null order by b limit 30; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_1_SELECT_TEXT_PK_TABLES1; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - - ---echo ---echo direct_order_limit ---connection master_1 -TRUNCATE TABLE t1; -insert into t1 values ('1', '1', '1'); -insert into t1 select a + 1, b + 1, c + 1 from t1; -insert into t1 select a + 2, b + 2, c + 2 from t1; -insert into t1 select a + 4, b + 4, c + 4 from t1; -insert into t1 select a + 8, b + 8, c + 8 from t1; -insert into t1 select a + 16, b + 16, c + 16 from t1; -insert into t1 select a, b + 32, c + 32 from t1; -insert into t1 select a, b + 64, c + 64 from t1; -insert into t1 select a, b + 128, c + 128 from t1; -flush tables; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -select a, b, c from t1 where a = '10' and b <> '100' order by c desc limit 5; -select a, c from t1 where a = '10' order by b desc limit 5; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_1_SELECT_TEXT_PK_TABLES1; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - - ---echo ---echo deinit ---disable_warnings ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -if ($USE_REPLICATION) -{ - --connection slave1_1 - DROP DATABASE IF EXISTS auto_test_local; -} -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; -} ---disable_query_log ---disable_result_log ---source slave_test_deinit.inc ---source test_deinit.inc ---enable_result_log ---enable_query_log ---enable_warnings ---echo ---echo end of test diff --git a/storage/spider/mysql-test/spider/oracle2/t/spider_fixes_part.test b/storage/spider/mysql-test/spider/oracle2/t/spider_fixes_part.test deleted file mode 100644 index 3053b0008e7..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/t/spider_fixes_part.test +++ /dev/null @@ -1,645 +0,0 @@ -# This test tests for Spider's bug fixes -source include/have_log_bin.inc; ---disable_warnings ---disable_query_log ---disable_result_log ---source test_init.inc ---source slave_test_init.inc ---enable_result_log ---enable_query_log -if (!$HAVE_PARTITION) -{ - --disable_query_log - --disable_result_log - --source slave_test_deinit.inc - --source test_deinit.inc - --enable_result_log - --enable_query_log - --enable_warnings - skip Test requires partitioning; -} - ---echo ---echo drop and create databases ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -if ($USE_REPLICATION) -{ - --connection slave1_1 - DROP DATABASE IF EXISTS auto_test_local; - CREATE DATABASE auto_test_local; - USE auto_test_local; -} -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - CREATE DATABASE auto_test_remote; - USE auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; - CREATE DATABASE auto_test_remote2; - USE auto_test_remote2; -} ---enable_warnings - ---echo ---echo test select 1 ---connection master_1 -SELECT 1; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - SELECT 1; - --connection child2_2 - SELECT 1; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---connection master_1 ---disable_warnings -DROP TABLE IF EXISTS tb_l; ---enable_warnings ---disable_query_log -echo CREATE TABLE tb_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) MASTER_1_ENGINE2 MASTER_1_CHARSET2; -eval CREATE TABLE tb_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) $MASTER_1_ENGINE2 $MASTER_1_CHARSET2; ---enable_query_log -INSERT INTO tb_l (a, b, c) VALUES - (1, 'a', '2008-08-01 10:21:39'), - (2, 'b', '2000-01-01 00:00:00'), - (3, 'e', '2007-06-04 20:03:11'), - (4, 'd', '2003-11-30 05:01:03'), - (5, 'c', '2001-12-31 23:59:59'); - ---echo ---echo 2.17 ---echo partition with sort -if ($HAVE_PARTITION) -{ - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_2_DROP_TABLES; - echo CHILD2_2_CREATE_TABLES; - } - --disable_warnings - eval $CHILD2_2_DROP_TABLES; - --enable_warnings - eval $CHILD2_2_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_TABLES2; - echo CHILD2_1_CREATE_TABLES2; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES2; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES2; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - --disable_query_log - echo CREATE TABLE ta_l2 ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) - ) MASTER_1_ENGINE MASTER_1_COMMENT2_P_2_1; - eval CREATE TABLE ta_l2 ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) - ) $MASTER_1_ENGINE $MASTER_1_COMMENT2_P_2_1; - --enable_query_log - INSERT INTO ta_l2 SELECT a, b, c FROM tb_l; - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2 WHERE a > 1 - ORDER BY a; - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_2_SELECT_TABLES; - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - eval $CHILD2_1_SELECT_TABLES2; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } -} - ---echo ---echo 2.23 ---echo partition update with moving partition -if ($HAVE_PARTITION) -{ - --connection master_1 - --disable_warnings - DROP TABLE IF EXISTS ta_l2; - --enable_warnings - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_2_DROP_TABLES; - echo CHILD2_2_CREATE_TABLES; - } - --disable_warnings - eval $CHILD2_2_DROP_TABLES; - --enable_warnings - eval $CHILD2_2_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_TABLES2; - echo CHILD2_1_CREATE_TABLES2; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES2; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES2; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - --disable_query_log - echo CREATE TABLE ta_l2 ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) - ) MASTER_1_ENGINE MASTER_1_COMMENT2_P_2_1; - eval CREATE TABLE ta_l2 ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) - ) $MASTER_1_ENGINE $MASTER_1_COMMENT2_P_2_1; - --enable_query_log - INSERT INTO ta_l2 (a, b, c) VALUES (3, 'B', '2010-09-26 00:00:00'); - UPDATE ta_l2 SET a = 4 WHERE a = 3; - SELECT a, b, date_format(c, '%Y-%m-%d %H:%i:%s') FROM ta_l2; - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%insert %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%update %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%delete %'; - } - eval $CHILD2_2_SELECT_TABLES; - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%insert %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%update %'; - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%delete %'; - } - eval $CHILD2_1_SELECT_TABLES2; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } -} - ---echo index merge with partition -if ($HAVE_PARTITION) -{ - --connection master_1 - --disable_warnings - DROP TABLE IF EXISTS ta_l_int; - --enable_warnings - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_result_log - } - --disable_query_log - --connection child2_2 - if ($OUTPUT_CHILD_GROUP2) - { - echo CHILD2_2_DROP_TABLES5; - echo CHILD2_2_CREATE_TABLES5; - } - --disable_warnings - eval $CHILD2_2_DROP_TABLES5; - --enable_warnings - eval $CHILD2_2_CREATE_TABLES5; - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - echo CHILD2_1_DROP_TABLES5; - echo CHILD2_1_CREATE_TABLES5; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES5; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES5; - --enable_query_log - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_result_log - } - } - --connection master_1 - --disable_query_log - echo CREATE TABLE ta_l_int ( - a INT AUTO_INCREMENT, - b INT DEFAULT 10, - c INT DEFAULT 11, - PRIMARY KEY(a), - KEY idx1(b), - KEY idx2(c) - ) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT3_P_2_1; - eval CREATE TABLE ta_l_int ( - a INT AUTO_INCREMENT, - b INT DEFAULT 10, - c INT DEFAULT 11, - PRIMARY KEY(a), - KEY idx1(b), - KEY idx2(c) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT3_P_2_1; - --enable_query_log - INSERT INTO ta_l_int (a, b, c) VALUES (1, 2, 3); - INSERT INTO ta_l_int (a, b, c) SELECT a + 1, b + 1, c + 1 FROM ta_l_int; - INSERT INTO ta_l_int (a, b, c) SELECT a + 2, b + 2, c + 2 FROM ta_l_int; - INSERT INTO ta_l_int (a, b, c) SELECT a + 4, b + 4, c + 4 FROM ta_l_int; - INSERT INTO ta_l_int (a, b, c) SELECT a + 8, b + 8, c + 8 FROM ta_l_int; - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - SELECT a, b, c FROM ta_l_int force index(primary, idx1, idx2) - WHERE a = 5 OR b = 5 OR c = 5 ORDER BY a; - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%select %'; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } -} - - ---echo ---echo 2.26 ---echo auto_increment with partition -if ($HAVE_PARTITION) -{ - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_INCREMENT_TABLES1; - echo CHILD2_1_CREATE_INCREMENT_TABLES1; - echo CHILD2_1_AUTO_INCREMENT_INCREMENT2; - echo CHILD2_1_AUTO_INCREMENT_OFFSET2; - } - --disable_warnings - eval $CHILD2_1_DROP_INCREMENT_TABLES1; - --enable_warnings - eval $CHILD2_1_CREATE_INCREMENT_TABLES1; - eval $CHILD2_1_AUTO_INCREMENT_INCREMENT2; - eval $CHILD2_1_AUTO_INCREMENT_OFFSET2; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - --connection child2_2 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_2_DROP_INCREMENT_TABLES1; - echo CHILD2_2_CREATE_INCREMENT_TABLES1; - echo CHILD2_2_AUTO_INCREMENT_INCREMENT2; - echo CHILD2_2_AUTO_INCREMENT_OFFSET2; - } - --disable_warnings - eval $CHILD2_2_DROP_INCREMENT_TABLES1; - --enable_warnings - eval $CHILD2_2_CREATE_INCREMENT_TABLES1; - eval $CHILD2_2_AUTO_INCREMENT_INCREMENT2; - eval $CHILD2_2_AUTO_INCREMENT_OFFSET2; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } - --connection master_1 - if ($USE_REPLICATION) - { - save_master_pos; - --connection slave1_1 - sync_with_master; - --connection master_1 - --disable_query_log - SET SESSION sql_log_bin= 0; - --enable_query_log - } - --disable_warnings - DROP TABLE IF EXISTS t1; - --enable_warnings - --disable_query_log - echo CREATE TABLE t1 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) - ) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_INCREMENT1_P_1; - echo MASTER_1_AUTO_INCREMENT_INCREMENT2; - echo MASTER_1_AUTO_INCREMENT_OFFSET2; - eval CREATE TABLE t1 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) - ) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_INCREMENT1_P_1; - eval $MASTER_1_AUTO_INCREMENT_INCREMENT2; - eval $MASTER_1_AUTO_INCREMENT_OFFSET2; - if ($USE_REPLICATION) - { - SET SESSION sql_log_bin= 1; - --connection slave1_1 - --disable_warnings - DROP TABLE IF EXISTS t1; - --enable_warnings - echo CREATE TABLE t1 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) - ) SLAVE1_1_ENGINE SLAVE1_1_CHARSET SLAVE1_1_COMMENT_INCREMENT1_P_1; - eval CREATE TABLE t1 ( - id int(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) - ) $SLAVE1_1_ENGINE $SLAVE1_1_CHARSET $SLAVE1_1_COMMENT_INCREMENT1_P_1; - --connection master_1 - } - --enable_query_log - INSERT INTO t1 () VALUES (); - SELECT LAST_INSERT_ID(); - SELECT MAX(id) FROM t1; - INSERT INTO t1 () VALUES (); - SELECT LAST_INSERT_ID(); - SELECT MAX(id) FROM t1; - INSERT INTO t1 (id) VALUES (null); - SELECT LAST_INSERT_ID(); - SELECT MAX(id) FROM t1; - INSERT INTO t1 (id) VALUES (null); - SELECT LAST_INSERT_ID(); - SELECT MAX(id) FROM t1; - INSERT INTO t1 () VALUES (),(),(),(); - SELECT LAST_INSERT_ID(); - SELECT id FROM t1 ORDER BY id; - SET INSERT_ID=5000; - INSERT INTO t1 () VALUES (); - SELECT LAST_INSERT_ID(); - SELECT MAX(id) FROM t1; - INSERT INTO t1 (id) VALUES (10000); - SELECT LAST_INSERT_ID(); - SELECT MAX(id) FROM t1; - INSERT INTO t1 (id) VALUES (1000); - SELECT LAST_INSERT_ID(); - SELECT MAX(id) FROM t1; - if ($USE_REPLICATION) - { - save_master_pos; - --connection slave1_1 - sync_with_master; - SELECT id FROM t1 ORDER BY id; - --connection master_1 - --disable_query_log - SET SESSION sql_log_bin= 0; - --enable_query_log - } - if ($USE_CHILD_GROUP2) - { - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%insert %'; - } - eval $CHILD2_1_SELECT_INCREMENT_TABLES1; - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_AUTO_INCREMENT_INCREMENT1; - echo CHILD2_1_AUTO_INCREMENT_OFFSET1; - } - eval $CHILD2_1_AUTO_INCREMENT_INCREMENT1; - eval $CHILD2_1_AUTO_INCREMENT_OFFSET1; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - --connection child2_2 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%insert %'; - } - eval $CHILD2_2_SELECT_INCREMENT_TABLES1; - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_2_AUTO_INCREMENT_INCREMENT1; - echo CHILD2_2_AUTO_INCREMENT_OFFSET1; - } - eval $CHILD2_2_AUTO_INCREMENT_INCREMENT1; - eval $CHILD2_2_AUTO_INCREMENT_OFFSET1; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } - } -} - - ---echo ---echo deinit ---disable_warnings ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -if ($USE_REPLICATION) -{ - --connection slave1_1 - DROP DATABASE IF EXISTS auto_test_local; -} -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; -} ---disable_query_log ---disable_result_log ---source slave_test_deinit.inc ---source test_deinit.inc ---enable_result_log ---enable_query_log ---enable_warnings ---echo ---echo end of test diff --git a/storage/spider/mysql-test/spider/oracle2/t/test_deinit.inc b/storage/spider/mysql-test/spider/oracle2/t/test_deinit.inc deleted file mode 100644 index 989bde26d3c..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/t/test_deinit.inc +++ /dev/null @@ -1,37 +0,0 @@ -# get connection and exist engine test ---echo for master_1 ---connection master_1 ---source ../include/deinit_master_1.inc ---disconnect master_1 ---echo for child2 -if ($USE_CHILD_GROUP2) -{ - --echo child2_1 - --connection child2_1 - --source ../include/deinit_child2_1.inc - --disconnect child2_1 - --echo child2_2 - --connection child2_2 - --source ../include/deinit_child2_2.inc - --disconnect child2_2 - --echo child2_3 - --connection child2_3 - --source ../include/deinit_child2_3.inc - --disconnect child2_3 -} ---echo for child3 -if ($USE_CHILD_GROUP3) -{ - --echo child3_1 - --connection child3_1 - --source ../include/deinit_child3_1.inc - --disconnect child3_1 - --echo child3_2 - --connection child3_2 - --source ../include/deinit_child3_2.inc - --disconnect child3_2 - --echo child3_3 - --connection child3_3 - --source ../include/deinit_child3_3.inc - --disconnect child3_3 -} diff --git a/storage/spider/mysql-test/spider/oracle2/t/test_init.inc b/storage/spider/mysql-test/spider/oracle2/t/test_init.inc deleted file mode 100644 index f2cd6c0269f..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/t/test_init.inc +++ /dev/null @@ -1,74 +0,0 @@ -# get connection and exist engine test ---echo for master_1 ---source connect_master_1.inc ---connection master_1 -CALL mtr.add_suppression("unknown variable"); -SET SESSION sql_log_bin= 0; ---let $MASTER_1_SERVER_ID=`SELECT @@global.server_id` ---let $TEST_ENGINE_TYPE= $MASTER_1_ENGINE_TYPE ---source have_partition.inc ---source have_trigger.inc ---source ../include/init_master_1.inc ---source have_engine.inc ---echo for child2 -if ($USE_CHILD_GROUP2) -{ - --echo child2_1 - --source connect_child2_1.inc - --connection child2_1 - CALL mtr.add_suppression("unknown variable *"); - SET SESSION sql_log_bin= 0; - --let $CHILD2_1_SERVER_ID=`SELECT @@global.server_id` - --let $TEST_ENGINE_TYPE= $CHILD2_1_ENGINE_TYPE - --source ../include/init_child2_1.inc - --source have_engine.inc - --echo child2_2 - --source connect_child2_2.inc - --connection child2_2 - CALL mtr.add_suppression("unknown variable *"); - SET SESSION sql_log_bin= 0; - --let $CHILD2_2_SERVER_ID=`SELECT @@global.server_id` - --let $TEST_ENGINE_TYPE= $CHILD2_2_ENGINE_TYPE - --source ../include/init_child2_2.inc - --source have_engine.inc - --echo child2_3 - --source connect_child2_3.inc - --connection child2_3 - CALL mtr.add_suppression("unknown variable *"); - SET SESSION sql_log_bin= 0; - --let $CHILD2_3_SERVER_ID=`SELECT @@global.server_id` - --let $TEST_ENGINE_TYPE= $CHILD2_3_ENGINE_TYPE - --source ../include/init_child2_3.inc - --source have_engine.inc -} ---echo for child3 -if ($USE_CHILD_GROUP3) -{ - --echo child3_1 - --source connect_child3_1.inc - --connection child3_1 - CALL mtr.add_suppression("unknown variable *"); - SET SESSION sql_log_bin= 0; - --let $CHILD3_1_SERVER_ID=`SELECT @@global.server_id` - --let $TEST_ENGINE_TYPE= $CHILD3_1_ENGINE_TYPE - --source ../include/init_child3_1.inc - --source have_engine.inc - --echo child3_2 - --source connect_child3_2.inc - --connection child3_2 - CALL mtr.add_suppression("unknown variable *"); - SET SESSION sql_log_bin= 0; - --let $CHILD3_2_SERVER_ID=`SELECT @@global.server_id` - --let $TEST_ENGINE_TYPE= $CHILD3_2_ENGINE_TYPE - --source ../include/init_child3_2.inc - --source have_engine.inc - --echo child3_3 - --source connect_child3_3.inc - --connection child3_3 - CALL mtr.add_suppression("unknown variable *"); - SET SESSION sql_log_bin= 0; - --let $CHILD3_3_SERVER_ID=`SELECT @@global.server_id` - --let $TEST_ENGINE_TYPE= $CHILD3_3_ENGINE_TYPE - --source ../include/init_child3_3.inc - --source have_engine.inc -} diff --git a/storage/spider/mysql-test/spider/oracle2/t/vp_fixes.test b/storage/spider/mysql-test/spider/oracle2/t/vp_fixes.test deleted file mode 100644 index 2c3e1523611..00000000000 --- a/storage/spider/mysql-test/spider/oracle2/t/vp_fixes.test +++ /dev/null @@ -1,335 +0,0 @@ -# This test tests for VP's bug fixes ---disable_warnings ---disable_query_log ---disable_result_log ---source test_init.inc ---enable_result_log ---enable_query_log - ---echo ---echo drop and create databases ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -CREATE DATABASE auto_test_local; -USE auto_test_local; -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - CREATE DATABASE auto_test_remote; - USE auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; - CREATE DATABASE auto_test_remote2; - USE auto_test_remote2; -} ---enable_warnings - ---echo ---echo test select 1 ---connection master_1 -SELECT 1; -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - SELECT 1; - --connection child2_2 - SELECT 1; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo create table and insert -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - --disable_query_log - echo CHILD2_1_DROP_TABLES; - echo CHILD2_1_CREATE_TABLES; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES; - if ($OUTPUT_CHILD_GROUP2) - { - --enable_query_log - } - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 ---disable_warnings -DROP TABLE IF EXISTS tb_l; ---enable_warnings ---disable_query_log -echo CREATE TABLE tb_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) MASTER_1_ENGINE2 MASTER_1_CHARSET2; -eval CREATE TABLE tb_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) $MASTER_1_ENGINE2 $MASTER_1_CHARSET2; ---enable_query_log -INSERT INTO tb_l (a, b, c) VALUES - (1, 'a', '2008-08-01 10:21:39'), - (2, 'b', '2000-01-01 00:00:00'), - (3, 'e', '2007-06-04 20:03:11'), - (4, 'd', '2003-11-30 05:01:03'), - (5, 'c', '2001-12-31 23:59:59'); ---disable_warnings -DROP TABLE IF EXISTS ta_l; ---enable_warnings ---disable_query_log -echo CREATE TABLE ta_l ( - PRIMARY KEY(a) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT_2_1; -eval CREATE TABLE ta_l ( - a INT, - b CHAR(1), - c DATETIME, - PRIMARY KEY(a) -) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT_2_1; ---enable_query_log -INSERT INTO ta_l SELECT a, b, c FROM tb_l; - ---echo ---echo 0.9 ---echo create different primary key table -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_result_log - } - --disable_query_log - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - echo CHILD2_1_DROP_TABLES5; - echo CHILD2_1_CREATE_TABLES5; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES5; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES5; - --enable_query_log - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_result_log - } -} ---connection master_1 ---disable_query_log -echo CREATE TABLE ta_l_int ( - a INT DEFAULT 10, - b INT AUTO_INCREMENT, - c INT DEFAULT 11, - PRIMARY KEY(b) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT4_2_1; -eval CREATE TABLE ta_l_int ( - a INT DEFAULT 10, - b INT AUTO_INCREMENT, - c INT DEFAULT 11, - PRIMARY KEY(b) -) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT4_2_1; ---enable_query_log -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 ---let $MASTER_1_IS_VP= `SELECT IF('$MASTER_1_ENGINE_TYPE' = 'VP', 1, 0)` -if ($MASTER_1_IS_VP) -{ - --error 14514 - INSERT INTO ta_l_int (a, b, c) VALUES (2, NULL, 3); -} -if (!$MASTER_1_IS_VP) -{ - INSERT INTO ta_l_int (a, b, c) VALUES (2, NULL, 3); - --disable_query_log - --disable_result_log - TRUNCATE TABLE ta_l_int; - --enable_query_log - --enable_result_log -} -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%insert %'; - } - eval $CHILD2_1_SELECT_TABLES5; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo create un-correspond primary key table ---connection master_1 ---disable_warnings -DROP TABLE IF EXISTS ta_l_int; ---enable_warnings -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_result_log - } - --disable_query_log - --connection child2_1 - if ($OUTPUT_CHILD_GROUP2) - { - echo CHILD2_1_DROP_TABLES5; - echo CHILD2_1_CREATE_TABLES5; - } - --disable_warnings - eval $CHILD2_1_DROP_TABLES5; - --enable_warnings - eval $CHILD2_1_CREATE_TABLES5; - --enable_query_log - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_result_log - } -} ---connection master_1 ---disable_query_log -echo CREATE TABLE ta_l_int ( - a INT DEFAULT 10, - b INT DEFAULT 12, - c INT DEFAULT 11, - PRIMARY KEY(c) -) MASTER_1_ENGINE MASTER_1_CHARSET MASTER_1_COMMENT4_2_1; -eval CREATE TABLE ta_l_int ( - a INT DEFAULT 10, - b INT DEFAULT 12, - c INT DEFAULT 11, - PRIMARY KEY(c) -) $MASTER_1_ENGINE $MASTER_1_CHARSET $MASTER_1_COMMENT4_2_1; ---enable_query_log -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - TRUNCATE TABLE mysql.general_log; - } - eval $CHILD2_1_SELECT_TABLES; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} ---connection master_1 -if ($MASTER_1_IS_VP) -{ - --error 14514 - INSERT INTO ta_l_int (a, b, c) VALUES (2, NULL, 3); -} -if (!$MASTER_1_IS_VP) -{ - INSERT INTO ta_l_int (a, b, c) VALUES (2, NULL, 3); - --disable_query_log - --disable_result_log - TRUNCATE TABLE ta_l_int; - --enable_query_log - --enable_result_log -} -if ($USE_CHILD_GROUP2) -{ - if (!$OUTPUT_CHILD_GROUP2) - { - --disable_query_log - --disable_result_log - } - --connection child2_1 - if ($USE_GENERAL_LOG) - { - SELECT argument FROM mysql.general_log WHERE command_type != 'Execute' AND argument LIKE '%insert %'; - } - eval $CHILD2_1_SELECT_TABLES5; - if (!$OUTPUT_CHILD_GROUP2) - { - --enable_query_log - --enable_result_log - } -} - ---echo ---echo deinit ---disable_warnings ---connection master_1 -DROP DATABASE IF EXISTS auto_test_local; -if ($USE_CHILD_GROUP2) -{ - --connection child2_1 - DROP DATABASE IF EXISTS auto_test_remote; - --connection child2_2 - DROP DATABASE IF EXISTS auto_test_remote2; -} ---disable_query_log ---disable_result_log ---source test_deinit.inc ---enable_result_log ---enable_query_log ---enable_warnings ---echo ---echo end of test diff --git a/storage/spider/spd_conn.cc b/storage/spider/spd_conn.cc index 5495f40cd86..feb3cab6a7f 100644 --- a/storage/spider/spd_conn.cc +++ b/storage/spider/spd_conn.cc @@ -18,17 +18,12 @@ #include <my_global.h> #include "mysql_version.h" #include "spd_environ.h" -#if MYSQL_VERSION_ID < 50500 -#include "mysql_priv.h" -#include <mysql/plugin.h> -#else #include "sql_priv.h" #include "probes_mysql.h" #include "sql_class.h" #include "sql_partition.h" #include "sql_table.h" #include "tztime.h" -#endif #include "spd_err.h" #include "spd_param.h" #include "spd_db_include.h" @@ -63,7 +58,6 @@ pthread_mutex_t spider_conn_id_mutex; pthread_mutex_t spider_ipport_conn_mutex; ulonglong spider_conn_id = 1; -#ifndef WITHOUT_SPIDER_BG_SEARCH extern pthread_attr_t spider_pt_attr; #ifdef HAVE_PSI_INTERFACE @@ -71,7 +65,6 @@ extern PSI_mutex_key spd_key_mutex_mta_conn; extern PSI_mutex_key spd_key_mutex_conn_i; extern PSI_mutex_key spd_key_mutex_conn_loop_check; extern PSI_cond_key spd_key_cond_conn_i; -#ifndef WITHOUT_SPIDER_BG_SEARCH extern PSI_mutex_key spd_key_mutex_bg_conn_chain; extern PSI_mutex_key spd_key_mutex_bg_conn_sync; extern PSI_mutex_key spd_key_mutex_bg_conn; @@ -90,8 +83,6 @@ extern PSI_thread_key spd_key_thd_bg_sts; extern PSI_thread_key spd_key_thd_bg_crd; extern PSI_thread_key spd_key_thd_bg_mon; #endif -#endif -#endif /* UTC time zone for timestamp columns */ extern Time_zone *UTC; @@ -160,12 +151,8 @@ int spider_conn_init( ) { int error_num = HA_ERR_OUT_OF_MEM; DBUG_ENTER("spider_conn_init"); -#if MYSQL_VERSION_ID < 50500 - if (pthread_mutex_init(&conn->loop_check_mutex, MY_MUTEX_INIT_FAST)) -#else if (mysql_mutex_init(spd_key_mutex_conn_loop_check, &conn->loop_check_mutex, MY_MUTEX_INIT_FAST)) -#endif { goto error_loop_check_mutex_init; } @@ -277,9 +264,7 @@ int spider_free_conn_alloc( SPIDER_CONN *conn ) { DBUG_ENTER("spider_free_conn_alloc"); -#ifndef WITHOUT_SPIDER_BG_SEARCH spider_free_conn_thread(conn); -#endif spider_db_disconnect(conn); if (conn->db_conn) { @@ -320,12 +305,7 @@ void spider_free_conn_from_trx( if (another) { ha_spider *next_spider; -#ifdef HASH_UPDATE_WITH_HASH_VALUE - my_hash_delete_with_hash_value(&trx->trx_another_conn_hash, - conn->conn_key_hash_value, (uchar*) conn); -#else my_hash_delete(&trx->trx_another_conn_hash, (uchar*) conn); -#endif spider = (ha_spider*) conn->another_ha_first; while (spider) { @@ -340,12 +320,7 @@ void spider_free_conn_from_trx( conn->another_ha_first = NULL; conn->another_ha_last = NULL; } else { -#ifdef HASH_UPDATE_WITH_HASH_VALUE - my_hash_delete_with_hash_value(&trx->trx_conn_hash, - conn->conn_key_hash_value, (uchar*) conn); -#else my_hash_delete(&trx->trx_conn_hash, (uchar*) conn); -#endif } if ( @@ -365,12 +340,7 @@ void spider_free_conn_from_trx( } else { pthread_mutex_lock(&spider_conn_mutex); uint old_elements = spider_open_connections.array.max_element; -#ifdef HASH_UPDATE_WITH_HASH_VALUE - if (my_hash_insert_with_hash_value(&spider_open_connections, - conn->conn_key_hash_value, (uchar*) conn)) -#else if (my_hash_insert(&spider_open_connections, (uchar*) conn)) -#endif { pthread_mutex_unlock(&spider_conn_mutex); spider_free_conn(conn); @@ -485,9 +455,7 @@ SPIDER_CONN *spider_create_conn( conn->conn_key = tmp_name; memcpy(conn->conn_key, share->conn_keys[link_idx], share->conn_keys_lengths[link_idx]); -#ifdef SPIDER_HAS_HASH_VALUE_TYPE conn->conn_key_hash_value = share->conn_keys_hash_value[link_idx]; -#endif conn->tgt_host_length = share->tgt_hosts_lengths[link_idx]; conn->tgt_host = tmp_host; memcpy(conn->tgt_host, share->tgt_hosts[link_idx], @@ -641,12 +609,8 @@ SPIDER_CONN *spider_create_conn( else conn->need_mon = need_mon; -#if MYSQL_VERSION_ID < 50500 - if (pthread_mutex_init(&conn->mta_conn_mutex, MY_MUTEX_INIT_FAST)) -#else if (mysql_mutex_init(spd_key_mutex_mta_conn, &conn->mta_conn_mutex, MY_MUTEX_INIT_FAST)) -#endif { *error_num = HA_ERR_OUT_OF_MEM; goto error_mta_conn_mutex_init; @@ -666,14 +630,9 @@ SPIDER_CONN *spider_create_conn( pthread_mutex_unlock(&spider_conn_id_mutex); pthread_mutex_lock(&spider_ipport_conn_mutex); -#ifdef SPIDER_HAS_HASH_VALUE_TYPE if ((ip_port_conn = (SPIDER_IP_PORT_CONN*) my_hash_search_using_hash_value( &spider_ipport_conns, conn->conn_key_hash_value, (uchar*)conn->conn_key, conn->conn_key_length))) -#else - if ((ip_port_conn = (SPIDER_IP_PORT_CONN*) my_hash_search( - &spider_ipport_conns, (uchar*)conn->conn_key, conn->conn_key_length))) -#endif { /* exists, +1 */ pthread_mutex_unlock(&spider_ipport_conn_mutex); pthread_mutex_lock(&ip_port_conn->mutex); @@ -746,7 +705,6 @@ SPIDER_CONN *spider_get_conn( #ifdef DBUG_TRACE spider_print_keys(conn_key, share->conn_keys_lengths[link_idx]); #endif -#ifdef SPIDER_HAS_HASH_VALUE_TYPE if ( (another && !(conn = (SPIDER_CONN*) my_hash_search_using_hash_value( @@ -759,16 +717,6 @@ SPIDER_CONN *spider_get_conn( share->conn_keys_hash_value[link_idx], (uchar*) conn_key, share->conn_keys_lengths[link_idx]))) ) -#else - if ( - (another && - !(conn = (SPIDER_CONN*) my_hash_search(&trx->trx_another_conn_hash, - (uchar*) conn_key, share->conn_keys_lengths[link_idx]))) || - (!another && - !(conn = (SPIDER_CONN*) my_hash_search(&trx->trx_conn_hash, - (uchar*) conn_key, share->conn_keys_lengths[link_idx]))) - ) -#endif { if ( !trx->thd || @@ -778,16 +726,10 @@ SPIDER_CONN *spider_get_conn( ) ) { pthread_mutex_lock(&spider_conn_mutex); -#ifdef SPIDER_HAS_HASH_VALUE_TYPE if (!(conn = (SPIDER_CONN*) my_hash_search_using_hash_value( &spider_open_connections, share->conn_keys_hash_value[link_idx], (uchar*) share->conn_keys[link_idx], share->conn_keys_lengths[link_idx]))) -#else - if (!(conn = (SPIDER_CONN*) my_hash_search(&spider_open_connections, - (uchar*) share->conn_keys[link_idx], - share->conn_keys_lengths[link_idx]))) -#endif { pthread_mutex_unlock(&spider_conn_mutex); if (spider_param_max_connections()) @@ -813,12 +755,7 @@ SPIDER_CONN *spider_get_conn( } } } else { -#ifdef HASH_UPDATE_WITH_HASH_VALUE - my_hash_delete_with_hash_value(&spider_open_connections, - conn->conn_key_hash_value, (uchar*) conn); -#else my_hash_delete(&spider_open_connections, (uchar*) conn); -#endif pthread_mutex_unlock(&spider_conn_mutex); DBUG_PRINT("info",("spider get global conn")); if (spider) @@ -848,13 +785,7 @@ SPIDER_CONN *spider_get_conn( if (another) { uint old_elements = trx->trx_another_conn_hash.array.max_element; -#ifdef HASH_UPDATE_WITH_HASH_VALUE - if (my_hash_insert_with_hash_value(&trx->trx_another_conn_hash, - share->conn_keys_hash_value[link_idx], - (uchar*) conn)) -#else if (my_hash_insert(&trx->trx_another_conn_hash, (uchar*) conn)) -#endif { spider_free_conn(conn); *error_num = HA_ERR_OUT_OF_MEM; @@ -869,13 +800,7 @@ SPIDER_CONN *spider_get_conn( } } else { uint old_elements = trx->trx_conn_hash.array.max_element; -#ifdef HASH_UPDATE_WITH_HASH_VALUE - if (my_hash_insert_with_hash_value(&trx->trx_conn_hash, - share->conn_keys_hash_value[link_idx], - (uchar*) conn)) -#else if (my_hash_insert(&trx->trx_conn_hash, (uchar*) conn)) -#endif { spider_free_conn(conn); *error_num = HA_ERR_OUT_OF_MEM; @@ -999,9 +924,7 @@ int spider_check_and_init_casual_read( (!thd_test_options(thd, OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN)) && ( result_list->direct_order_limit -#ifdef HANDLER_HAS_DIRECT_AGGREGATE || result_list->direct_aggregate -#endif ) ) { if (!result_list->casual_read[link_idx]) @@ -1177,16 +1100,10 @@ int spider_conn_queue_and_merge_loop_check( SPIDER_CONN_LOOP_CHECK *lcqptr, *lcrptr; DBUG_ENTER("spider_conn_queue_and_merge_loop_check"); DBUG_PRINT("info", ("spider conn=%p", conn)); -#ifdef SPIDER_HAS_HASH_VALUE_TYPE if (unlikely(!(lcqptr = (SPIDER_CONN_LOOP_CHECK *) my_hash_search_using_hash_value(&conn->loop_check_queue, lcptr->hash_value_to, (uchar *) lcptr->to_name.str, lcptr->to_name.length)))) -#else - if (unlikely(!(lcqptr = (SPIDER_CONN_LOOP_CHECK *) my_hash_search( - &conn->loop_check_queue, - (uchar *) lcptr->to_name.str, lcptr->to_name.length)))) -#endif { DBUG_PRINT("info", ("spider create merged_value and insert")); lcptr->merged_value.length = spider_unique_id.length + @@ -1199,12 +1116,7 @@ int spider_conn_queue_and_merge_loop_check( *tmp_name = '-'; ++tmp_name; memcpy(tmp_name, lcptr->from_value.str, lcptr->from_value.length + 1); -#ifdef HASH_UPDATE_WITH_HASH_VALUE - if (unlikely(my_hash_insert_with_hash_value(&conn->loop_check_queue, - lcptr->hash_value_to, (uchar *) lcptr))) -#else if (unlikely(my_hash_insert(&conn->loop_check_queue, (uchar *) lcptr))) -#endif { goto error_hash_insert_queue; } @@ -1225,10 +1137,8 @@ int spider_conn_queue_and_merge_loop_check( )) { goto error_alloc_loop_check_replace; } -#ifdef SPIDER_HAS_HASH_VALUE_TYPE lcrptr->hash_value_to = lcqptr->hash_value_to; lcrptr->hash_value_full = lcqptr->hash_value_full; -#endif lcrptr->from_name.str = from_name; lcrptr->from_name.length = lcqptr->from_name.length; memcpy(from_name, lcqptr->from_name.str, lcqptr->from_name.length + 1); @@ -1258,33 +1168,16 @@ int spider_conn_queue_and_merge_loop_check( memcpy(merged_value, lcptr->from_value.str, lcptr->from_value.length + 1); DBUG_PRINT("info", ("spider free lcqptr")); -#ifdef HASH_UPDATE_WITH_HASH_VALUE - my_hash_delete_with_hash_value(&conn->loop_checked, - lcqptr->hash_value_full, (uchar *) lcqptr); - my_hash_delete_with_hash_value(&conn->loop_check_queue, - lcqptr->hash_value_to, (uchar *) lcqptr); -#else my_hash_delete(&conn->loop_checked, (uchar*) lcqptr); my_hash_delete(&conn->loop_check_queue, (uchar*) lcqptr); -#endif spider_free(spider_current_trx, lcqptr, MYF(0)); lcptr = lcrptr; -#ifdef HASH_UPDATE_WITH_HASH_VALUE - if (unlikely(my_hash_insert_with_hash_value(&conn->loop_checked, - lcptr->hash_value_full, (uchar *) lcptr))) -#else if (unlikely(my_hash_insert(&conn->loop_checked, (uchar *) lcptr))) -#endif { goto error_hash_insert; } -#ifdef HASH_UPDATE_WITH_HASH_VALUE - if (unlikely(my_hash_insert_with_hash_value(&conn->loop_check_queue, - lcptr->hash_value_to, (uchar *) lcptr))) -#else if (unlikely(my_hash_insert(&conn->loop_check_queue, (uchar *) lcptr))) -#endif { goto error_hash_insert_queue; } @@ -1303,12 +1196,7 @@ int spider_conn_queue_and_merge_loop_check( error_alloc_loop_check_replace: error_hash_insert_queue: -#ifdef HASH_UPDATE_WITH_HASH_VALUE - my_hash_delete_with_hash_value(&conn->loop_checked, - lcptr->hash_value_full, (uchar *) lcptr); -#else my_hash_delete(&conn->loop_checked, (uchar*) lcptr); -#endif error_hash_insert: spider_free(spider_current_trx, lcptr, MYF(0)); pthread_mutex_unlock(&conn->loop_check_mutex); @@ -1329,12 +1217,7 @@ int spider_conn_reset_queue_loop_check( if (!lcptr->flag) { DBUG_PRINT("info", ("spider free lcptr")); -#ifdef HASH_UPDATE_WITH_HASH_VALUE - my_hash_delete_with_hash_value(&conn->loop_checked, - lcptr->hash_value_full, (uchar *) lcptr); -#else my_hash_delete(&conn->loop_checked, (uchar*) lcptr); -#endif spider_free(spider_current_trx, lcptr, MYF(0)); } ++l; @@ -1466,19 +1349,12 @@ int spider_conn_queue_loop_check( memcpy(tmp_name, to_str.str, to_str.length); tmp_name += to_str.length; *tmp_name = '\0'; -#ifdef SPIDER_HAS_HASH_VALUE_TYPE my_hash_value_type hash_value = my_calc_hash(&conn->loop_checked, (uchar *) loop_check_buf, buf_sz - 1); -#endif pthread_mutex_lock(&conn->loop_check_mutex); -#ifdef SPIDER_HAS_HASH_VALUE_TYPE lcptr = (SPIDER_CONN_LOOP_CHECK *) my_hash_search_using_hash_value(&conn->loop_checked, hash_value, (uchar *) loop_check_buf, buf_sz - 1); -#else - lcptr = (SPIDER_CONN_LOOP_CHECK *) my_hash_search( - &conn->loop_checked, (uchar *) loop_check_buf, buf_sz - 1); -#endif if (unlikely( !lcptr || ( @@ -1493,12 +1369,7 @@ int spider_conn_queue_loop_check( if (unlikely(lcptr)) { DBUG_PRINT("info", ("spider free lcptr")); -#ifdef HASH_UPDATE_WITH_HASH_VALUE - my_hash_delete_with_hash_value(&conn->loop_checked, - lcptr->hash_value_full, (uchar *) lcptr); -#else my_hash_delete(&conn->loop_checked, (uchar*) lcptr); -#endif spider_free(spider_current_trx, lcptr, MYF(0)); } DBUG_PRINT("info", ("spider alloc_lcptr")); @@ -1533,17 +1404,10 @@ int spider_conn_queue_loop_check( lcptr->from_value.length = lex_str.length; memcpy(from_value, lex_str.str, lex_str.length + 1); lcptr->merged_value.str = merged_value; -#ifdef SPIDER_HAS_HASH_VALUE_TYPE lcptr->hash_value_to = my_calc_hash(&conn->loop_checked, (uchar *) to_str.str, to_str.length); lcptr->hash_value_full = hash_value; -#endif -#ifdef HASH_UPDATE_WITH_HASH_VALUE - if (unlikely(my_hash_insert_with_hash_value(&conn->loop_checked, - lcptr->hash_value_full, (uchar *) lcptr))) -#else if (unlikely(my_hash_insert(&conn->loop_checked, (uchar *) lcptr))) -#endif { my_afree(loop_check_buf); goto error_hash_insert; @@ -1843,7 +1707,6 @@ SPIDER_CONN *spider_tree_delete( DBUG_RETURN(top); } -#ifndef WITHOUT_SPIDER_BG_SEARCH int spider_set_conn_bg_param( ha_spider *spider ) { @@ -1895,7 +1758,6 @@ int spider_set_conn_bg_param( if (result_list->bgs_phase > 0) { -#ifdef SPIDER_HAS_GROUP_BY_HANDLER if (spider->use_fields) { SPIDER_LINK_IDX_CHAIN *link_idx_chain; @@ -1907,7 +1769,6 @@ int spider_set_conn_bg_param( DBUG_RETURN(error_num); } } else { -#endif for ( roop_count = spider_conn_link_idx_next(share->link_statuses, spider->conn_link_idx, -1, share->link_count, @@ -1922,9 +1783,7 @@ int spider_set_conn_bg_param( if ((error_num = spider_create_conn_thread(spider->conns[roop_count]))) DBUG_RETURN(error_num); } -#ifdef SPIDER_HAS_GROUP_BY_HANDLER } -#endif } DBUG_RETURN(0); } @@ -1936,43 +1795,27 @@ int spider_create_conn_thread( DBUG_ENTER("spider_create_conn_thread"); if (conn && !conn->bg_init) { -#if MYSQL_VERSION_ID < 50500 - if (pthread_mutex_init(&conn->bg_conn_chain_mutex, MY_MUTEX_INIT_FAST)) -#else if (mysql_mutex_init(spd_key_mutex_bg_conn_chain, &conn->bg_conn_chain_mutex, MY_MUTEX_INIT_FAST)) -#endif { error_num = HA_ERR_OUT_OF_MEM; goto error_chain_mutex_init; } conn->bg_conn_chain_mutex_ptr = NULL; -#if MYSQL_VERSION_ID < 50500 - if (pthread_mutex_init(&conn->bg_conn_sync_mutex, MY_MUTEX_INIT_FAST)) -#else if (mysql_mutex_init(spd_key_mutex_bg_conn_sync, &conn->bg_conn_sync_mutex, MY_MUTEX_INIT_FAST)) -#endif { error_num = HA_ERR_OUT_OF_MEM; goto error_sync_mutex_init; } -#if MYSQL_VERSION_ID < 50500 - if (pthread_mutex_init(&conn->bg_conn_mutex, MY_MUTEX_INIT_FAST)) -#else if (mysql_mutex_init(spd_key_mutex_bg_conn, &conn->bg_conn_mutex, MY_MUTEX_INIT_FAST)) -#endif { error_num = HA_ERR_OUT_OF_MEM; goto error_mutex_init; } -#if MYSQL_VERSION_ID < 50500 - if (pthread_mutex_init(&conn->bg_job_stack_mutex, MY_MUTEX_INIT_FAST)) -#else if (mysql_mutex_init(spd_key_mutex_bg_job_stack, &conn->bg_job_stack_mutex, MY_MUTEX_INIT_FAST)) -#endif { error_num = HA_ERR_OUT_OF_MEM; goto error_job_stack_mutex_init; @@ -1989,36 +1832,22 @@ int spider_create_conn_thread( conn->bg_job_stack.max_element * conn->bg_job_stack.size_of_element); conn->bg_job_stack_cur_pos = 0; -#if MYSQL_VERSION_ID < 50500 - if (pthread_cond_init(&conn->bg_conn_sync_cond, NULL)) -#else if (mysql_cond_init(spd_key_cond_bg_conn_sync, &conn->bg_conn_sync_cond, NULL)) -#endif { error_num = HA_ERR_OUT_OF_MEM; goto error_sync_cond_init; } -#if MYSQL_VERSION_ID < 50500 - if (pthread_cond_init(&conn->bg_conn_cond, NULL)) -#else if (mysql_cond_init(spd_key_cond_bg_conn, &conn->bg_conn_cond, NULL)) -#endif { error_num = HA_ERR_OUT_OF_MEM; goto error_cond_init; } pthread_mutex_lock(&conn->bg_conn_mutex); -#if MYSQL_VERSION_ID < 50500 - if (pthread_create(&conn->bg_thread, &spider_pt_attr, - spider_bg_conn_action, (void *) conn) - ) -#else if (mysql_thread_create(spd_key_thd_bg, &conn->bg_thread, &spider_pt_attr, spider_bg_conn_action, (void *) conn) ) -#endif { pthread_mutex_unlock(&conn->bg_conn_mutex); error_num = HA_ERR_OUT_OF_MEM; @@ -2120,10 +1949,8 @@ void spider_bg_all_conn_wait( SPIDER_LINK_STATUS_RECOVERY) ) { conn = spider->conns[roop_count]; -#ifndef WITHOUT_SPIDER_BG_SEARCH if (conn && result_list->bgs_working) spider_bg_conn_wait(conn); -#endif } DBUG_VOID_RETURN; } @@ -2132,13 +1959,10 @@ int spider_bg_all_conn_pre_next( ha_spider *spider, int link_idx ) { -#ifndef WITHOUT_SPIDER_BG_SEARCH int roop_start, roop_end, roop_count, lock_mode, link_ok, error_num; SPIDER_RESULT_LIST *result_list = &spider->result_list; SPIDER_SHARE *share = spider->share; -#endif DBUG_ENTER("spider_bg_all_conn_pre_next"); -#ifndef WITHOUT_SPIDER_BG_SEARCH if (result_list->bgs_phase > 0) { lock_mode = spider_conn_lock_mode(spider); @@ -2168,7 +1992,6 @@ int spider_bg_all_conn_pre_next( DBUG_RETURN(error_num); } } -#endif DBUG_RETURN(0); } @@ -2214,10 +2037,8 @@ void spider_bg_all_conn_break( SPIDER_LINK_STATUS_RECOVERY) ) { conn = spider->conns[roop_count]; -#ifndef WITHOUT_SPIDER_BG_SEARCH if (conn && result_list->bgs_working) spider_bg_conn_break(conn, spider); -#endif if (spider->quick_targets[roop_count]) { spider_db_free_one_quick_result((SPIDER_RESULT *) result_list->current); @@ -2404,9 +2225,7 @@ int spider_bg_conn_search( conn->bg_target = spider; conn->link_idx = link_idx; conn->bg_discard_result = discard_result; -#ifdef SPIDER_HAS_GROUP_BY_HANDLER conn->link_idx_chain = spider->link_idx_chain; -#endif pthread_mutex_lock(&conn->bg_conn_sync_mutex); pthread_cond_signal(&conn->bg_conn_cond); pthread_mutex_unlock(&conn->bg_conn_mutex); @@ -2548,9 +2367,7 @@ int spider_bg_conn_search( conn->bg_target = spider; conn->link_idx = link_idx; conn->bg_discard_result = discard_result; -#ifdef SPIDER_HAS_GROUP_BY_HANDLER conn->link_idx_chain = spider->link_idx_chain; -#endif result_list->bgs_working = TRUE; conn->bg_search = TRUE; if (with_lock) @@ -2769,13 +2586,6 @@ void *spider_bg_conn_action( } sql_type &= ~SPIDER_SQL_TYPE_TMP_SQL; DBUG_PRINT("info",("spider sql_type=%lu", sql_type)); -#ifdef HA_CAN_BULK_ACCESS - if (spider->is_bulk_access_clone) - { - spider->connection_ids[conn->link_idx] = conn->connection_id; - spider_trx_add_bulk_access_conn(spider->trx, conn); - } -#endif if (!result_list->bgs_error) { conn->need_mon = &spider->need_mons[conn->link_idx]; @@ -2783,10 +2593,6 @@ void *spider_bg_conn_action( DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later); conn->mta_conn_mutex_lock_already = TRUE; conn->mta_conn_mutex_unlock_later = TRUE; -#ifdef HA_CAN_BULK_ACCESS - if (!spider->is_bulk_access_clone) - { -#endif if (!(result_list->bgs_error = spider_db_set_names(spider, conn, conn->link_idx))) { @@ -2855,9 +2661,6 @@ void *spider_bg_conn_action( strmov(result_list->bgs_error_msg, spider_stmt_da_message(thd)); } -#ifdef HA_CAN_BULK_ACCESS - } -#endif DBUG_ASSERT(conn->mta_conn_mutex_lock_already); DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); conn->mta_conn_mutex_lock_already = FALSE; @@ -3008,35 +2811,21 @@ int spider_create_sts_thread( DBUG_ENTER("spider_create_sts_thread"); if (!share->bg_sts_init) { -#if MYSQL_VERSION_ID < 50500 - if (pthread_cond_init(&share->bg_sts_cond, NULL)) -#else if (mysql_cond_init(spd_key_cond_bg_sts, &share->bg_sts_cond, NULL)) -#endif { error_num = HA_ERR_OUT_OF_MEM; goto error_cond_init; } -#if MYSQL_VERSION_ID < 50500 - if (pthread_cond_init(&share->bg_sts_sync_cond, NULL)) -#else if (mysql_cond_init(spd_key_cond_bg_sts_sync, &share->bg_sts_sync_cond, NULL)) -#endif { error_num = HA_ERR_OUT_OF_MEM; goto error_sync_cond_init; } -#if MYSQL_VERSION_ID < 50500 - if (pthread_create(&share->bg_sts_thread, &spider_pt_attr, - spider_bg_sts_action, (void *) share) - ) -#else if (mysql_thread_create(spd_key_thd_bg_sts, &share->bg_sts_thread, &spider_pt_attr, spider_bg_sts_action, (void *) share) ) -#endif { error_num = HA_ERR_OUT_OF_MEM; goto error_thread_create; @@ -3293,18 +3082,11 @@ void *spider_bg_sts_action( } if (spider.search_link_idx != -1 && conns[spider.search_link_idx]) { -#ifdef WITH_PARTITION_STORAGE_ENGINE if (spider_get_sts(share, spider.search_link_idx, share->bg_sts_try_time, &spider, share->bg_sts_interval, share->bg_sts_mode, share->bg_sts_sync, 2, HA_STATUS_CONST | HA_STATUS_VARIABLE)) -#else - if (spider_get_sts(share, spider.search_link_idx, - share->bg_sts_try_time, &spider, - share->bg_sts_interval, share->bg_sts_mode, - 2, HA_STATUS_CONST | HA_STATUS_VARIABLE)) -#endif { /* if ( @@ -3349,35 +3131,21 @@ int spider_create_crd_thread( DBUG_ENTER("spider_create_crd_thread"); if (!share->bg_crd_init) { -#if MYSQL_VERSION_ID < 50500 - if (pthread_cond_init(&share->bg_crd_cond, NULL)) -#else if (mysql_cond_init(spd_key_cond_bg_crd, &share->bg_crd_cond, NULL)) -#endif { error_num = HA_ERR_OUT_OF_MEM; goto error_cond_init; } -#if MYSQL_VERSION_ID < 50500 - if (pthread_cond_init(&share->bg_crd_sync_cond, NULL)) -#else if (mysql_cond_init(spd_key_cond_bg_crd_sync, &share->bg_crd_sync_cond, NULL)) -#endif { error_num = HA_ERR_OUT_OF_MEM; goto error_sync_cond_init; } -#if MYSQL_VERSION_ID < 50500 - if (pthread_create(&share->bg_crd_thread, &spider_pt_attr, - spider_bg_crd_action, (void *) share) - ) -#else if (mysql_thread_create(spd_key_thd_bg_crd, &share->bg_crd_thread, &spider_pt_attr, spider_bg_crd_action, (void *) share) ) -#endif { error_num = HA_ERR_OUT_OF_MEM; goto error_thread_create; @@ -3639,18 +3407,11 @@ void *spider_bg_crd_action( } if (spider.search_link_idx != -1 && conns[spider.search_link_idx]) { -#ifdef WITH_PARTITION_STORAGE_ENGINE if (spider_get_crd(share, spider.search_link_idx, share->bg_crd_try_time, &spider, &table, share->bg_crd_interval, share->bg_crd_mode, share->bg_crd_sync, 2)) -#else - if (spider_get_crd(share, spider.search_link_idx, - share->bg_crd_try_time, &spider, &table, - share->bg_crd_interval, share->bg_crd_mode, - 2)) -#endif { /* if ( @@ -3770,13 +3531,8 @@ int spider_create_mon_threads( { if ( share->monitoring_bg_kind[roop_count] && -#if MYSQL_VERSION_ID < 50500 - pthread_mutex_init(&share->bg_mon_mutexes[roop_count], - MY_MUTEX_INIT_FAST) -#else mysql_mutex_init(spd_key_mutex_bg_mon, &share->bg_mon_mutexes[roop_count], MY_MUTEX_INIT_FAST) -#endif ) { error_num = HA_ERR_OUT_OF_MEM; my_afree(buf); @@ -3788,12 +3544,8 @@ int spider_create_mon_threads( { if ( share->monitoring_bg_kind[roop_count] && -#if MYSQL_VERSION_ID < 50500 - pthread_cond_init(&share->bg_mon_conds[roop_count], NULL) -#else mysql_cond_init(spd_key_cond_bg_mon, &share->bg_mon_conds[roop_count], NULL) -#endif ) { error_num = HA_ERR_OUT_OF_MEM; my_afree(buf); @@ -3805,12 +3557,8 @@ int spider_create_mon_threads( { if ( share->monitoring_bg_kind[roop_count] && -#if MYSQL_VERSION_ID < 50500 - pthread_cond_init(&share->bg_mon_sleep_conds[roop_count], NULL) -#else mysql_cond_init(spd_key_cond_bg_mon_sleep, &share->bg_mon_sleep_conds[roop_count], NULL) -#endif ) { error_num = HA_ERR_OUT_OF_MEM; my_afree(buf); @@ -3825,16 +3573,10 @@ int spider_create_mon_threads( { link_pack.link_idx = roop_count; pthread_mutex_lock(&share->bg_mon_mutexes[roop_count]); -#if MYSQL_VERSION_ID < 50500 - if (pthread_create(&share->bg_mon_threads[roop_count], - &spider_pt_attr, spider_bg_mon_action, (void *) &link_pack) - ) -#else if (mysql_thread_create(spd_key_thd_bg_mon, &share->bg_mon_threads[roop_count], &spider_pt_attr, spider_bg_mon_action, (void *) &link_pack) ) -#endif { error_num = HA_ERR_OUT_OF_MEM; my_afree(buf); @@ -4044,7 +3786,6 @@ void *spider_bg_mon_action( } } } -#endif int spider_conn_first_link_idx( THD *thd, @@ -4088,17 +3829,9 @@ int spider_conn_first_link_idx( my_afree(link_idxs); DBUG_RETURN(-1); } -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100002 DBUG_PRINT("info",("spider server_id=%lu", thd->variables.server_id)); -#else - DBUG_PRINT("info",("spider server_id=%u", thd->server_id)); -#endif DBUG_PRINT("info",("spider thread_id=%lu", thd_get_thread_id(thd))); -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100002 rand_val = spider_rand(thd->variables.server_id + thd_get_thread_id(thd)); -#else - rand_val = spider_rand(thd->server_id + thd_get_thread_id(thd)); -#endif DBUG_PRINT("info",("spider rand_val=%f", rand_val)); balance_val = (longlong) (rand_val * balance_total); DBUG_PRINT("info",("spider balance_val=%lld", balance_val)); @@ -4216,7 +3949,6 @@ bool spider_conn_use_handler( DBUG_PRINT("info",("spider use_handler=%d", use_handler)); DBUG_PRINT("info",("spider spider->conn_kind[link_idx]=%u", spider->conn_kind[link_idx])); -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS if (spider->do_direct_update) { spider->sql_kinds |= SPIDER_SQL_KIND_SQL; @@ -4225,7 +3957,6 @@ bool spider_conn_use_handler( DBUG_PRINT("info",("spider FALSE by using direct_update")); DBUG_RETURN(FALSE); } -#endif if (spider->use_spatial_index) { DBUG_PRINT("info",("spider FALSE by use_spatial_index")); @@ -4315,15 +4046,9 @@ SPIDER_CONN* spider_get_conn_from_idle_connection( set_timespec(abstime, 0); pthread_mutex_lock(&spider_ipport_conn_mutex); -#ifdef SPIDER_HAS_HASH_VALUE_TYPE if ((ip_port_conn = (SPIDER_IP_PORT_CONN*) my_hash_search_using_hash_value( &spider_ipport_conns, share->conn_keys_hash_value[link_idx], (uchar*) share->conn_keys[link_idx], share->conn_keys_lengths[link_idx]))) -#else - if ((ip_port_conn = (SPIDER_IP_PORT_CONN*) my_hash_search( - &spider_ipport_conns, - (uchar*) share->conn_keys[link_idx], share->conn_keys_lengths[link_idx]))) -#endif { /* exists */ pthread_mutex_unlock(&spider_ipport_conn_mutex); pthread_mutex_lock(&ip_port_conn->mutex); @@ -4362,24 +4087,13 @@ SPIDER_CONN* spider_get_conn_from_idle_connection( } pthread_mutex_lock(&spider_conn_mutex); -#ifdef SPIDER_HAS_HASH_VALUE_TYPE if ((conn = (SPIDER_CONN*) my_hash_search_using_hash_value( &spider_open_connections, share->conn_keys_hash_value[link_idx], (uchar*) share->conn_keys[link_idx], share->conn_keys_lengths[link_idx]))) -#else - if ((conn = (SPIDER_CONN*) my_hash_search(&spider_open_connections, - (uchar*) share->conn_keys[link_idx], - share->conn_keys_lengths[link_idx]))) -#endif { /* get conn from spider_open_connections, then delete conn in spider_open_connections */ -#ifdef HASH_UPDATE_WITH_HASH_VALUE - my_hash_delete_with_hash_value(&spider_open_connections, - conn->conn_key_hash_value, (uchar*) conn); -#else my_hash_delete(&spider_open_connections, (uchar*) conn); -#endif pthread_mutex_unlock(&spider_conn_mutex); DBUG_PRINT("info",("spider get global conn")); if (spider) @@ -4428,21 +4142,13 @@ SPIDER_IP_PORT_CONN* spider_create_ipport_conn(SPIDER_CONN *conn) goto err_return_direct; } -#if MYSQL_VERSION_ID < 50500 - if (pthread_mutex_init(&ret->mutex, MY_MUTEX_INIT_FAST)) -#else if (mysql_mutex_init(spd_key_mutex_conn_i, &ret->mutex, MY_MUTEX_INIT_FAST)) -#endif { //error goto err_malloc_key; } -#if MYSQL_VERSION_ID < 50500 - if (pthread_cond_init(&ret->cond, NULL)) -#else if (mysql_cond_init(spd_key_cond_conn_i, &ret->cond, NULL)) -#endif { pthread_mutex_destroy(&ret->mutex); goto err_malloc_key; @@ -4472,9 +4178,7 @@ SPIDER_IP_PORT_CONN* spider_create_ipport_conn(SPIDER_CONN *conn) ret->conn_id = conn->conn_id; ret->ip_port_count = 1; // init -#ifdef SPIDER_HAS_HASH_VALUE_TYPE ret->key_hash_value = conn->conn_key_hash_value; -#endif DBUG_RETURN(ret); err_malloc_key: spider_my_free(ret, MYF(0)); diff --git a/storage/spider/spd_conn.h b/storage/spider/spd_conn.h index 92da278eecc..53c10572687 100644 --- a/storage/spider/spd_conn.h +++ b/storage/spider/spd_conn.h @@ -22,9 +22,7 @@ #define SPIDER_SIMPLE_CONNECT 1 #define SPIDER_SIMPLE_DISCONNECT 2 #define SPIDER_SIMPLE_RECORDS 3 -#ifdef HA_HAS_CHECKSUM_EXTENDED #define SPIDER_SIMPLE_CHECKSUM_TABLE 4 -#endif #define SPIDER_LOP_CHK_QUEUED (1 << 0) #define SPIDER_LOP_CHK_MERAGED (1 << 1) @@ -33,10 +31,8 @@ typedef struct st_spider_conn_loop_check { uint flag; -#ifdef SPIDER_HAS_HASH_VALUE_TYPE my_hash_value_type hash_value_to; my_hash_value_type hash_value_full; -#endif LEX_CSTRING from_name; LEX_CSTRING cur_name; LEX_CSTRING to_name; @@ -256,7 +252,6 @@ SPIDER_CONN *spider_tree_delete( SPIDER_CONN *top ); -#ifndef WITHOUT_SPIDER_BG_SEARCH int spider_set_conn_bg_param( ha_spider *spider ); @@ -353,7 +348,6 @@ void spider_free_mon_threads( void *spider_bg_mon_action( void *arg ); -#endif int spider_conn_first_link_idx( THD *thd, diff --git a/storage/spider/spd_copy_tables.cc b/storage/spider/spd_copy_tables.cc index 51e3b920eea..4b2f5174ce0 100644 --- a/storage/spider/spd_copy_tables.cc +++ b/storage/spider/spd_copy_tables.cc @@ -18,17 +18,12 @@ #include <my_global.h> #include "mysql_version.h" #include "spd_environ.h" -#if MYSQL_VERSION_ID < 50500 -#include "mysql_priv.h" -#include <mysql/plugin.h> -#else #include "sql_priv.h" #include "probes_mysql.h" #include "sql_class.h" #include "sql_base.h" #include "sql_partition.h" #include "transaction.h" -#endif #include "spd_err.h" #include "spd_param.h" #include "spd_db_include.h" @@ -73,10 +68,8 @@ int spider_udf_set_copy_tables_param_default( copy_tables->use_table_charset = 1; if (copy_tables->use_transaction == -1) copy_tables->use_transaction = 1; -#ifndef WITHOUT_SPIDER_BG_SEARCH if (copy_tables->bg_mode == -1) copy_tables->bg_mode = 0; -#endif DBUG_RETURN(0); } @@ -226,9 +219,7 @@ int spider_udf_parse_copy_tables_param( copy_tables->bulk_insert_rows = -1; copy_tables->use_table_charset = -1; copy_tables->use_transaction = -1; -#ifndef WITHOUT_SPIDER_BG_SEARCH copy_tables->bg_mode = -1; -#endif if (param_length == 0) goto set_default; @@ -281,9 +272,7 @@ int spider_udf_parse_copy_tables_param( goto error; continue; case 3: -#ifndef WITHOUT_SPIDER_BG_SEARCH SPIDER_PARAM_INT_WITH_MAX("bgm", bg_mode, 0, 1); -#endif SPIDER_PARAM_INT("bii", bulk_insert_interval, 0); SPIDER_PARAM_LONGLONG("bir", bulk_insert_rows, 1); SPIDER_PARAM_STR("dtb", database); @@ -291,12 +280,10 @@ int spider_udf_parse_copy_tables_param( SPIDER_PARAM_INT_WITH_MAX("utr", use_transaction, 0, 1); error_num = param_string_parse.print_param_error(); goto error; -#ifndef WITHOUT_SPIDER_BG_SEARCH case 7: SPIDER_PARAM_INT_WITH_MAX("bg_mode", bg_mode, 0, 1); error_num = param_string_parse.print_param_error(); goto error; -#endif case 8: SPIDER_PARAM_STR("database", database); error_num = param_string_parse.print_param_error(); @@ -422,10 +409,8 @@ int spider_udf_get_copy_tgt_tables( if ( (error_num = spider_set_connect_info_default( tmp_share, -#ifdef WITH_PARTITION_STORAGE_ENGINE NULL, NULL, -#endif NULL )) || (error_num = spider_set_connect_info_default_db_table( @@ -787,7 +772,6 @@ int spider_udf_copy_tables_create_table_list( DBUG_RETURN(0); } -#ifndef WITHOUT_SPIDER_BG_SEARCH int spider_udf_bg_copy_exec_sql( SPIDER_COPY_TABLE_CONN *table_conn ) { @@ -816,7 +800,6 @@ int spider_udf_bg_copy_exec_sql( conn->bg_caller_sync_wait = FALSE; DBUG_RETURN(0); } -#endif long long spider_copy_tables_body( UDF_INIT *initid, @@ -847,13 +830,8 @@ long long spider_copy_tables_body( thd->handler_tables_hash.records != 0 || thd->derived_tables != 0 || thd->lock != 0 || -#if MYSQL_VERSION_ID < 50500 - thd->locked_tables != 0 || - thd->prelocked_mode != NON_PRELOCKED -#else thd->locked_tables_list.locked_tables() || thd->locked_tables_mode != LTM_NONE -#endif ) { if (thd->open_tables != 0) { @@ -876,18 +854,6 @@ long long spider_copy_tables_body( my_printf_error(ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_NUM, ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_STR_WITH_PTR, MYF(0), "thd->lock", thd->lock); -#if MYSQL_VERSION_ID < 50500 - } else if (thd->locked_tables != 0) - { - my_printf_error(ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_NUM, - ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_STR_WITH_PTR, MYF(0), - "thd->locked_tables", thd->locked_tables); - } else if (thd->prelocked_mode != NON_PRELOCKED) - { - my_printf_error(ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_NUM, - ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_STR_WITH_NUM, MYF(0), - "thd->prelocked_mode", (longlong) thd->prelocked_mode); -#else } else if (thd->locked_tables_list.locked_tables()) { my_printf_error(ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_NUM, @@ -899,7 +865,6 @@ long long spider_copy_tables_body( my_printf_error(ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_NUM, ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_STR_WITH_NUM, MYF(0), "thd->locked_tables_mode", (longlong) thd->locked_tables_mode); -#endif } goto error; } @@ -991,9 +956,7 @@ long long spider_copy_tables_body( copy_tables->trx->trx_start = TRUE; copy_tables->trx->updated_in_this_trx = FALSE; DBUG_PRINT("info",("spider trx->updated_in_this_trx=FALSE")); -#if MYSQL_VERSION_ID < 50500 - if (open_and_lock_tables(thd, table_list)) -#else + MDL_REQUEST_INIT(&table_list->mdl_request, MDL_key::TABLE, SPIDER_TABLE_LIST_db_str(table_list), @@ -1002,7 +965,6 @@ long long spider_copy_tables_body( MDL_TRANSACTION ); if (open_and_lock_tables(thd, table_list, FALSE, 0)) -#endif { thd->m_reprepare_observer = reprepare_observer_backup; copy_tables->trx->trx_start = FALSE; @@ -1223,11 +1185,7 @@ long long spider_copy_tables_body( */ if (table_list->table) { -#if MYSQL_VERSION_ID < 50500 - ha_autocommit_or_rollback(thd, 0); -#else (thd->is_error() ? trans_rollback_stmt(thd) : trans_commit_stmt(thd)); -#endif close_thread_tables(thd); } if (spider) @@ -1285,11 +1243,7 @@ error: } if (table_list && table_list->table) { -#if MYSQL_VERSION_ID < 50500 - ha_autocommit_or_rollback(thd, 0); -#else (thd->is_error() ? trans_rollback_stmt(thd) : trans_commit_stmt(thd)); -#endif close_thread_tables(thd); } if (spider) diff --git a/storage/spider/spd_copy_tables.h b/storage/spider/spd_copy_tables.h index 8c06e115dea..4f7ba7791cb 100644 --- a/storage/spider/spd_copy_tables.h +++ b/storage/spider/spd_copy_tables.h @@ -48,8 +48,6 @@ int spider_udf_copy_tables_create_table_list( uint dst_link_idx_list_length ); -#ifndef WITHOUT_SPIDER_BG_SEARCH int spider_udf_bg_copy_exec_sql( SPIDER_COPY_TABLE_CONN *table_conn ); -#endif diff --git a/storage/spider/spd_db_conn.cc b/storage/spider/spd_db_conn.cc index 09bc66f09b4..055dcd984b1 100644 --- a/storage/spider/spd_db_conn.cc +++ b/storage/spider/spd_db_conn.cc @@ -18,10 +18,6 @@ #include <my_global.h> #include "mysql_version.h" #include "spd_environ.h" -#if MYSQL_VERSION_ID < 50500 -#include "mysql_priv.h" -#include <mysql/plugin.h> -#else #include "sql_priv.h" #include "probes_mysql.h" #include "sql_class.h" @@ -30,10 +26,7 @@ #include "sql_base.h" #include "tztime.h" #include "errmsg.h" -#ifdef HANDLER_HAS_DIRECT_AGGREGATE #include "sql_select.h" -#endif -#endif #include "sql_common.h" #include <errmsg.h> #include "spd_err.h" @@ -71,9 +64,7 @@ extern SPIDER_DBTON spider_dbton[SPIDER_DBTON_SIZE]; #define SPIDER_SQL_PING_TABLE_STR "spider_ping_table(" #define SPIDER_SQL_PING_TABLE_LEN (sizeof(SPIDER_SQL_PING_TABLE_STR) - 1) -#ifdef SPIDER_HAS_HASH_VALUE_TYPE extern HASH spider_open_connections; -#endif pthread_mutex_t spider_open_conn_mutex; const char spider_dig_upper[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"; @@ -588,10 +579,8 @@ int spider_db_before_query( int error_num; DBUG_ENTER("spider_db_before_query"); DBUG_ASSERT(need_mon); -#ifndef WITHOUT_SPIDER_BG_SEARCH if (conn->bg_search) spider_bg_conn_break(conn, NULL); -#endif conn->in_before_query = TRUE; pthread_mutex_assert_owner(&conn->mta_conn_mutex); DBUG_ASSERT(conn->mta_conn_mutex_file_pos.file_name); @@ -1411,14 +1400,12 @@ int spider_db_append_select_columns( DBUG_ENTER("spider_db_append_select_columns"); if (spider->sql_kinds & SPIDER_SQL_KIND_SQL) { -#ifdef HANDLER_HAS_DIRECT_AGGREGATE if ( result_list->direct_aggregate && (error_num = spider->append_sum_select_sql_part( SPIDER_SQL_TYPE_SELECT_SQL, NULL, 0)) ) DBUG_RETURN(error_num); -#endif if ((error_num = spider->append_match_select_sql_part( SPIDER_SQL_TYPE_SELECT_SQL, NULL, 0))) DBUG_RETURN(error_num); @@ -1812,12 +1799,6 @@ int spider_db_append_key_where_internal( if (use_key == start_key) { -#ifdef SPIDER_HANDLER_SUPPORT_MULTIPLE_KEY_PARTS - if (spider_dbton[dbton_id].db_util-> - append_column_value(spider, str_part, field, ptr, false, - share->access_charset)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); -#else if (str_part->length() == SPIDER_SQL_OPEN_PAREN_LEN) { if (str->reserve(SPIDER_SQL_EQUAL_LEN)) @@ -1828,17 +1809,14 @@ int spider_db_append_key_where_internal( share->access_charset)) DBUG_RETURN(HA_ERR_OUT_OF_MEM); } -#endif } } } else { DBUG_PRINT("info", ("spider start_key->flag=%d", start_key->flag)); switch (start_key->flag) { -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000 case HA_READ_PREFIX_LAST: result_list->desc_flg = TRUE; -#endif /* fall through */ case HA_READ_KEY_EXACT: if (sql_kind == SPIDER_SQL_KIND_SQL) @@ -1878,18 +1856,6 @@ int spider_db_append_key_where_internal( if (use_key == start_key) { -#ifdef SPIDER_HANDLER_SUPPORT_MULTIPLE_KEY_PARTS - if (tgt_key_part_map == 1 || !end_key_part_map) - { - if (str->reserve(SPIDER_SQL_EQUAL_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_EQUAL_STR, SPIDER_SQL_EQUAL_LEN); - } - if (spider_dbton[dbton_id].db_util-> - append_column_value(spider, str_part, field, ptr, false, - share->access_charset)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); -#else if (str_part->length() == SPIDER_SQL_OPEN_PAREN_LEN) { if (str->reserve(SPIDER_SQL_EQUAL_LEN)) @@ -1900,7 +1866,6 @@ int spider_db_append_key_where_internal( share->access_charset)) DBUG_RETURN(HA_ERR_OUT_OF_MEM); } -#endif } } break; @@ -1949,18 +1914,6 @@ int spider_db_append_key_where_internal( if (use_key == start_key) { -#ifdef SPIDER_HANDLER_SUPPORT_MULTIPLE_KEY_PARTS - if (tgt_key_part_map == 1 || !end_key_part_map) - { - if (str->reserve(SPIDER_SQL_GT_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_GT_STR, SPIDER_SQL_GT_LEN); - } - if (spider_dbton[dbton_id].db_util-> - append_column_value(spider, str_part, field, ptr, false, - share->access_charset)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); -#else if (str_part->length() == SPIDER_SQL_OPEN_PAREN_LEN) { if (str->reserve(SPIDER_SQL_GT_LEN)) @@ -1971,7 +1924,6 @@ int spider_db_append_key_where_internal( share->access_charset)) DBUG_RETURN(HA_ERR_OUT_OF_MEM); } -#endif } } break; @@ -2021,18 +1973,6 @@ int spider_db_append_key_where_internal( if (use_key == start_key) { -#ifdef SPIDER_HANDLER_SUPPORT_MULTIPLE_KEY_PARTS - if (tgt_key_part_map == 1 || !end_key_part_map) - { - if (str->reserve(SPIDER_SQL_LT_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_LT_STR, SPIDER_SQL_LT_LEN); - } - if (spider_dbton[dbton_id].db_util-> - append_column_value(spider, str_part, field, ptr, false, - share->access_charset)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); -#else if (str_part->length() == SPIDER_SQL_OPEN_PAREN_LEN) { if (str->reserve(SPIDER_SQL_LT_LEN)) @@ -2043,16 +1983,9 @@ int spider_db_append_key_where_internal( share->access_charset)) DBUG_RETURN(HA_ERR_OUT_OF_MEM); } -#endif } } break; -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000 -#else - case HA_READ_PREFIX_LAST: - result_list->limit_num = 1; - /* fall through */ -#endif case HA_READ_KEY_OR_PREV: case HA_READ_PREFIX_LAST_OR_PREV: result_list->desc_flg = TRUE; @@ -2094,18 +2027,6 @@ int spider_db_append_key_where_internal( if (use_key == start_key) { -#ifdef SPIDER_HANDLER_SUPPORT_MULTIPLE_KEY_PARTS - if (tgt_key_part_map == 1 || !end_key_part_map) - { - if (str->reserve(SPIDER_SQL_LTEQUAL_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_LTEQUAL_STR, SPIDER_SQL_LTEQUAL_LEN); - } - if (spider_dbton[dbton_id].db_util-> - append_column_value(spider, str_part, field, ptr, false, - share->access_charset)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); -#else if (str_part->length() == SPIDER_SQL_OPEN_PAREN_LEN) { if (str->reserve(SPIDER_SQL_LTEQUAL_LEN)) @@ -2116,7 +2037,6 @@ int spider_db_append_key_where_internal( share->access_charset)) DBUG_RETURN(HA_ERR_OUT_OF_MEM); } -#endif } } break; @@ -2238,18 +2158,6 @@ int spider_db_append_key_where_internal( if (use_key == start_key) { -#ifdef SPIDER_HANDLER_SUPPORT_MULTIPLE_KEY_PARTS - if (tgt_key_part_map == 1 || !end_key_part_map) - { - if (str->reserve(SPIDER_SQL_GTEQUAL_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_GTEQUAL_STR, SPIDER_SQL_GTEQUAL_LEN); - } - if (spider_dbton[dbton_id].db_util-> - append_column_value(spider, str_part, field, ptr, false, - share->access_charset)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); -#else if (str_part->length() == SPIDER_SQL_OPEN_PAREN_LEN) { if (str->reserve(SPIDER_SQL_GTEQUAL_LEN)) @@ -2260,7 +2168,6 @@ int spider_db_append_key_where_internal( share->access_charset)) DBUG_RETURN(HA_ERR_OUT_OF_MEM); } -#endif } } break; @@ -2279,14 +2186,6 @@ int spider_db_append_key_where_internal( str_part2->q_append(SPIDER_SQL_AND_STR, SPIDER_SQL_AND_LEN); -#ifdef SPIDER_HANDLER_SUPPORT_MULTIPLE_KEY_PARTS - if (use_key == start_key) - { - if (str_part->reserve(SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str_part->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } -#endif } } @@ -2337,12 +2236,6 @@ int spider_db_append_key_where_internal( if (use_key == end_key) { -#ifdef SPIDER_HANDLER_SUPPORT_MULTIPLE_KEY_PARTS - if (spider_dbton[dbton_id].db_util-> - append_column_value(spider, str_part, field, ptr, false, - share->access_charset)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); -#else if (str_part->length() == SPIDER_SQL_OPEN_PAREN_LEN) { if (str->reserve(SPIDER_SQL_EQUAL_LEN)) @@ -2353,7 +2246,6 @@ int spider_db_append_key_where_internal( share->access_charset)) DBUG_RETURN(HA_ERR_OUT_OF_MEM); } -#endif } } } else { @@ -2404,18 +2296,6 @@ int spider_db_append_key_where_internal( if (use_key == end_key) { -#ifdef SPIDER_HANDLER_SUPPORT_MULTIPLE_KEY_PARTS - if (tgt_key_part_map == 1 || !start_key_part_map) - { - if (str->reserve(SPIDER_SQL_LT_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_LT_STR, SPIDER_SQL_LT_LEN); - } - if (spider_dbton[dbton_id].db_util-> - append_column_value(spider, str_part, field, ptr, false, - share->access_charset)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); -#else if (str_part->length() == SPIDER_SQL_OPEN_PAREN_LEN) { if (str->reserve(SPIDER_SQL_LT_LEN)) @@ -2426,7 +2306,6 @@ int spider_db_append_key_where_internal( false, share->access_charset)) DBUG_RETURN(HA_ERR_OUT_OF_MEM); } -#endif } } break; @@ -2468,18 +2347,6 @@ int spider_db_append_key_where_internal( if (use_key == end_key) { -#ifdef SPIDER_HANDLER_SUPPORT_MULTIPLE_KEY_PARTS - if (tgt_key_part_map == 1 || !start_key_part_map) - { - if (str->reserve(SPIDER_SQL_LTEQUAL_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_LTEQUAL_STR, SPIDER_SQL_LTEQUAL_LEN); - } - if (spider_dbton[dbton_id].db_util-> - append_column_value(spider, str_part, field, ptr, false, - share->access_charset)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); -#else if (str_part->length() == SPIDER_SQL_OPEN_PAREN_LEN) { if (str->reserve(SPIDER_SQL_LTEQUAL_LEN)) @@ -2490,7 +2357,6 @@ int spider_db_append_key_where_internal( false, share->access_charset)) DBUG_RETURN(HA_ERR_OUT_OF_MEM); } -#endif } } break; @@ -2508,14 +2374,6 @@ int spider_db_append_key_where_internal( str_part2->q_append(SPIDER_SQL_AND_STR, SPIDER_SQL_AND_LEN); -#ifdef SPIDER_HANDLER_SUPPORT_MULTIPLE_KEY_PARTS - if (use_key == end_key) - { - if (str_part->reserve(SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str_part->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } -#endif } } if (use_both && (!start_key_part_map || !end_key_part_map)) @@ -2582,7 +2440,6 @@ int spider_db_append_charset_name_before_string( DBUG_RETURN(0); } -#ifdef HANDLER_HAS_DIRECT_AGGREGATE int spider_db_refetch_for_item_sum_funcs( ha_spider *spider ) { @@ -2775,7 +2632,6 @@ int spider_db_fetch_for_item_sum_func( } DBUG_RETURN(0); } -#endif int spider_db_append_match_fetch( ha_spider *spider, @@ -2870,13 +2726,8 @@ int spider_db_get_row_from_tmp_tbl( current->result_tmp_tbl_inited = 1; } if ( -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 50200 (error_num = current->result_tmp_tbl->file->ha_rnd_next( current->result_tmp_tbl->record[0])) -#else - (error_num = current->result_tmp_tbl->file->rnd_next( - current->result_tmp_tbl->record[0])) -#endif ) { DBUG_RETURN(error_num); } @@ -2904,13 +2755,8 @@ int spider_db_get_row_from_tmp_tbl_pos( result->result_tmp_tbl_inited = 2; } if ( -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 50200 (error_num = tmp_tbl->file->ha_rnd_pos(tmp_tbl->record[0], (uchar *) &pos->tmp_tbl_pos)) -#else - (error_num = tmp_tbl->file->rnd_pos(tmp_tbl->record[0], - (uchar *) &pos->tmp_tbl_pos)) -#endif ) { DBUG_RETURN(error_num); } @@ -2984,13 +2830,11 @@ int spider_db_fetch_table( } DBUG_PRINT("info", ("spider row=%p", row)); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE DBUG_PRINT("info", ("spider direct_aggregate=%s", result_list->direct_aggregate ? "TRUE" : "FALSE")); result_list->snap_mrr_with_cnt = spider->mrr_with_cnt; result_list->snap_direct_aggregate = result_list->direct_aggregate; result_list->snap_row = row; -#endif /* for mrr */ if (spider->mrr_with_cnt) @@ -3000,43 +2844,33 @@ int spider_db_fetch_table( { if (!row->is_null()) spider->multi_range_hit_point = row->val_int(); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE else if (result_list->direct_aggregate) { table->status = STATUS_NOT_FOUND; DBUG_RETURN(HA_ERR_END_OF_FILE); } -#endif else DBUG_RETURN(ER_SPIDER_UNKNOWN_NUM); row->next(); } else { spider->multi_range_hit_point = 0; -#ifdef HANDLER_HAS_DIRECT_AGGREGATE result_list->snap_mrr_with_cnt = FALSE; -#endif } } -#ifdef HANDLER_HAS_DIRECT_AGGREGATE /* for direct_aggregate */ if (result_list->direct_aggregate) { if ((error_num = spider_db_fetch_for_item_sum_funcs(row, spider))) DBUG_RETURN(error_num); } -#endif -#ifdef SPIDER_HAS_GROUP_BY_HANDLER if (!spider->use_fields) { -#endif if ((error_num = spider_db_append_match_fetch(spider, spider->ft_first, spider->ft_current, row))) DBUG_RETURN(error_num); -#ifdef SPIDER_HAS_GROUP_BY_HANDLER } -#endif for ( field = table->field; @@ -3114,13 +2948,11 @@ int spider_db_fetch_key( } DBUG_PRINT("info", ("spider row=%p", row)); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE DBUG_PRINT("info", ("spider direct_aggregate=%s", result_list->direct_aggregate ? "TRUE" : "FALSE")); result_list->snap_mrr_with_cnt = spider->mrr_with_cnt; result_list->snap_direct_aggregate = result_list->direct_aggregate; result_list->snap_row = row; -#endif /* for mrr */ if (spider->mrr_with_cnt) @@ -3128,26 +2960,22 @@ int spider_db_fetch_key( DBUG_PRINT("info", ("spider mrr_with_cnt")); if (!row->is_null()) spider->multi_range_hit_point = row->val_int(); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE else if (result_list->direct_aggregate) { table->status = STATUS_NOT_FOUND; DBUG_RETURN(HA_ERR_END_OF_FILE); } -#endif else DBUG_RETURN(ER_SPIDER_UNKNOWN_NUM); row->next(); } -#ifdef HANDLER_HAS_DIRECT_AGGREGATE /* for direct_aggregate */ if (result_list->direct_aggregate) { if ((error_num = spider_db_fetch_for_item_sum_funcs(row, spider))) DBUG_RETURN(error_num); } -#endif if ((error_num = spider_db_append_match_fetch(spider, spider->ft_first, spider->ft_current, row))) @@ -3231,13 +3059,11 @@ int spider_db_fetch_minimum_columns( } DBUG_PRINT("info", ("spider row=%p", row)); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE DBUG_PRINT("info", ("spider direct_aggregate=%s", result_list->direct_aggregate ? "TRUE" : "FALSE")); result_list->snap_mrr_with_cnt = spider->mrr_with_cnt; result_list->snap_direct_aggregate = result_list->direct_aggregate; result_list->snap_row = row; -#endif /* for mrr */ if (spider->mrr_with_cnt) @@ -3245,26 +3071,22 @@ int spider_db_fetch_minimum_columns( DBUG_PRINT("info", ("spider mrr_with_cnt")); if (!row->is_null()) spider->multi_range_hit_point = row->val_int(); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE else if (result_list->direct_aggregate) { table->status = STATUS_NOT_FOUND; DBUG_RETURN(HA_ERR_END_OF_FILE); } -#endif else DBUG_RETURN(ER_SPIDER_UNKNOWN_NUM); row->next(); } -#ifdef HANDLER_HAS_DIRECT_AGGREGATE /* for direct_aggregate */ if (result_list->direct_aggregate) { if ((error_num = spider_db_fetch_for_item_sum_funcs(row, spider))) DBUG_RETURN(error_num); } -#endif if ((error_num = spider_db_append_match_fetch(spider, spider->ft_first, spider->ft_current, row))) @@ -3624,9 +3446,7 @@ int spider_db_free_result( DBUG_PRINT("info",("spider result_list->finish_flg = FALSE")); result_list->finish_flg = FALSE; result_list->quick_phase = 0; -#ifndef WITHOUT_SPIDER_BG_SEARCH result_list->bgs_phase = 0; -#endif DBUG_RETURN(0); } @@ -3688,9 +3508,7 @@ int spider_db_store_result( current = (SPIDER_RESULT*) result_list->current; } else { if ( -#ifndef WITHOUT_SPIDER_BG_SEARCH result_list->bgs_phase > 0 || -#endif result_list->quick_phase > 0 ) { if (result_list->bgs_current == result_list->last) @@ -3718,9 +3536,7 @@ int spider_db_store_result( result_list->bgs_current = result_list->bgs_current->next; } if ( -#ifndef WITHOUT_SPIDER_BG_SEARCH result_list->bgs_phase == 1 || -#endif result_list->quick_phase == 2 ) { if (result_list->low_mem_read && @@ -3805,15 +3621,11 @@ int spider_db_store_result( DBUG_PRINT("info",("spider result_list->finish_flg = TRUE")); current->finish_flg = TRUE; result_list->finish_flg = TRUE; -#ifndef WITHOUT_SPIDER_BG_SEARCH if (result_list->bgs_phase <= 1) { -#endif result_list->current_row_num = 0; table->status = STATUS_NOT_FOUND; -#ifndef WITHOUT_SPIDER_BG_SEARCH } -#endif if (!conn->mta_conn_mutex_unlock_later && !call_db_errorno) { DBUG_ASSERT(!conn->mta_conn_mutex_lock_already); @@ -3849,14 +3661,10 @@ int spider_db_store_result( current->finish_flg = TRUE; result_list->finish_flg = TRUE; } -#ifndef WITHOUT_SPIDER_BG_SEARCH if (result_list->bgs_phase <= 1) { -#endif result_list->current_row_num = 0; -#ifndef WITHOUT_SPIDER_BG_SEARCH } -#endif } } else { /* has_result() for case of result with result_tmp_tbl */ @@ -3927,9 +3735,7 @@ int spider_db_store_result( conn->quick_target = NULL; spider->quick_targets[link_idx] = NULL; if ( -#ifndef WITHOUT_SPIDER_BG_SEARCH result_list->bgs_phase <= 1 && -#endif result_list->quick_phase == 0 ) { result_list->current_row_num = 0; @@ -4105,14 +3911,10 @@ int spider_db_store_result( spider->quick_targets[link_idx] = NULL; } } -#ifndef WITHOUT_SPIDER_BG_SEARCH DBUG_PRINT("info", ("spider bgs_phase=%d", result_list->bgs_phase)); -#endif DBUG_PRINT("info", ("spider quick_phase=%d", result_list->quick_phase)); if ( -#ifndef WITHOUT_SPIDER_BG_SEARCH result_list->bgs_phase <= 1 && -#endif result_list->quick_phase == 0 ) { result_list->current_row_num = 0; @@ -4171,9 +3973,7 @@ int spider_db_store_result_for_reuse_cursor( current = (SPIDER_RESULT*) result_list->current; } else { if ( -#ifndef WITHOUT_SPIDER_BG_SEARCH result_list->bgs_phase > 0 || -#endif result_list->quick_phase > 0 ) { if (result_list->bgs_current == result_list->last) @@ -4195,9 +3995,7 @@ int spider_db_store_result_for_reuse_cursor( result_list->bgs_current = result_list->bgs_current->next; } if ( -#ifndef WITHOUT_SPIDER_BG_SEARCH result_list->bgs_phase == 1 || -#endif result_list->quick_phase == 2 ) { result_list->current = result_list->bgs_current; @@ -4257,14 +4055,10 @@ int spider_db_store_result_for_reuse_cursor( current->finish_flg = TRUE; result_list->finish_flg = TRUE; } -#ifndef WITHOUT_SPIDER_BG_SEARCH if (result_list->bgs_phase <= 1) { -#endif result_list->current_row_num = 0; -#ifndef WITHOUT_SPIDER_BG_SEARCH } -#endif } else { DBUG_ASSERT(current->prev); DBUG_ASSERT(current->prev->result); @@ -4303,9 +4097,7 @@ int spider_db_store_result_for_reuse_cursor( conn->quick_target = NULL; spider->quick_targets[link_idx] = NULL; if ( -#ifndef WITHOUT_SPIDER_BG_SEARCH result_list->bgs_phase <= 1 && -#endif result_list->quick_phase == 0 ) { result_list->current_row_num = 0; @@ -4478,14 +4270,10 @@ int spider_db_store_result_for_reuse_cursor( spider->quick_targets[link_idx] = NULL; } } -#ifndef WITHOUT_SPIDER_BG_SEARCH DBUG_PRINT("info", ("spider bgs_phase=%d", result_list->bgs_phase)); -#endif DBUG_PRINT("info", ("spider quick_phase=%d", result_list->quick_phase)); if ( -#ifndef WITHOUT_SPIDER_BG_SEARCH result_list->bgs_phase <= 1 && -#endif result_list->quick_phase == 0 ) { result_list->current_row_num = 0; @@ -4557,42 +4345,6 @@ void spider_db_discard_multiple_result( DBUG_VOID_RETURN; } -#ifdef HA_CAN_BULK_ACCESS -int spider_db_bulk_store_result( - ha_spider *spider, - SPIDER_CONN *conn, - int link_idx, - bool discard_result -) { - int error_num, tmp_error_num; - DBUG_ENTER("spider_db_bulk_store_result"); - DBUG_PRINT("info",("spider spider=%p", spider)); - DBUG_PRINT("info",("spider conn=%p", conn)); - DBUG_PRINT("info",("spider link_idx=%d", link_idx)); - if (conn->conn_kind == SPIDER_CONN_KIND_MYSQL) - { - /* already stored */ - DBUG_RETURN(0); - } - error_num = spider_db_bulk_open_handler(spider, conn, link_idx); - if (!discard_result) - { - pthread_mutex_assert_not_owner(&conn->mta_conn_mutex); - DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_unlock_later = TRUE; - if ((tmp_error_num = spider_db_store_result(spider, link_idx, - spider->get_table()))) - { - error_num = tmp_error_num; - } - conn->mta_conn_mutex_unlock_later = FALSE; - } else { - if (spider->connection_ids[link_idx] == conn->connection_id) - spider_db_discard_result(spider, link_idx, conn); - } - DBUG_RETURN(error_num); -} -#endif int spider_db_fetch( uchar *buf, @@ -4677,10 +4429,8 @@ int spider_db_seek_next( (SPIDER_RESULT*) result_list->current); int roop_start = 0, roop_end = 1, roop_count, lock_mode, link_ok = 0; -#ifdef SPIDER_HAS_GROUP_BY_HANDLER if (!spider->use_fields) { -#endif lock_mode = spider_conn_lock_mode(spider); if (lock_mode) { @@ -4697,14 +4447,10 @@ int spider_db_seek_next( roop_start = link_idx; roop_end = link_idx + 1; } -#ifdef SPIDER_HAS_GROUP_BY_HANDLER } -#endif -#ifndef WITHOUT_SPIDER_BG_SEARCH if (result_list->bgs_phase > 0) { -#ifdef SPIDER_HAS_GROUP_BY_HANDLER if (spider->use_fields) { SPIDER_LINK_IDX_CHAIN *link_idx_chain; @@ -4728,7 +4474,6 @@ int spider_db_seek_next( } } } else { -#endif for (roop_count = roop_start; roop_count < roop_end; roop_count = spider_conn_link_idx_next(share->link_statuses, spider->conn_link_idx, roop_count, share->link_count, @@ -4741,11 +4486,8 @@ int spider_db_seek_next( DBUG_RETURN(error_num); } } -#ifdef SPIDER_HAS_GROUP_BY_HANDLER } -#endif } else { -#endif if (result_list->current == result_list->bgs_current) { if (result_list->finish_flg) @@ -4795,7 +4537,6 @@ int spider_db_seek_next( } } -#ifdef SPIDER_HAS_GROUP_BY_HANDLER if (spider->use_fields) { SPIDER_LINK_IDX_CHAIN *link_idx_chain; @@ -4920,7 +4661,6 @@ int spider_db_seek_next( } } } else { -#endif for (roop_count = roop_start; roop_count < roop_end; roop_count = spider_conn_link_idx_next(share->link_statuses, spider->conn_link_idx, roop_count, share->link_count, @@ -5091,9 +4831,7 @@ int spider_db_seek_next( } } } -#ifdef SPIDER_HAS_GROUP_BY_HANDLER } -#endif } else { spider->connection_ids[link_idx] = conn->connection_id; pthread_mutex_assert_not_owner(&conn->mta_conn_mutex); @@ -5119,9 +4857,7 @@ int spider_db_seek_next( DBUG_RETURN(HA_ERR_END_OF_FILE); } } -#ifndef WITHOUT_SPIDER_BG_SEARCH } -#endif DBUG_RETURN(spider_db_fetch(buf, spider, table)); } else DBUG_RETURN(spider_db_fetch(buf, spider, table)); @@ -5664,9 +5400,7 @@ void spider_db_create_position( current->use_position = TRUE; pos->use_position = TRUE; pos->mrr_with_cnt = spider->mrr_with_cnt; -#ifdef HANDLER_HAS_DIRECT_AGGREGATE pos->direct_aggregate = result_list->direct_aggregate; -#endif pos->sql_kind = spider->sql_kind[spider->result_link_idx]; pos->position_bitmap = spider->wide_handler->position_bitmap; pos->ft_first = spider->ft_first; @@ -5732,7 +5466,6 @@ int spider_db_seek_tmp_table( } DBUG_PRINT("info", ("spider row=%p", row)); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE if (!spider->result_list.in_cmp_ref) { DBUG_PRINT("info", ("spider direct_aggregate=%s", @@ -5741,7 +5474,6 @@ int spider_db_seek_tmp_table( spider->result_list.snap_direct_aggregate = pos->direct_aggregate; spider->result_list.snap_row = row; } -#endif /* for mrr */ if (pos->mrr_with_cnt) @@ -5751,20 +5483,16 @@ int spider_db_seek_tmp_table( { row->next(); } else { -#ifdef HANDLER_HAS_DIRECT_AGGREGATE spider->result_list.snap_mrr_with_cnt = FALSE; -#endif } } -#ifdef HANDLER_HAS_DIRECT_AGGREGATE /* for direct_aggregate */ if (pos->direct_aggregate) { if ((error_num = spider_db_fetch_for_item_sum_funcs(row, spider))) DBUG_RETURN(error_num); } -#endif if ((error_num = spider_db_append_match_fetch(spider, pos->ft_first, pos->ft_current, row))) @@ -5824,7 +5552,6 @@ int spider_db_seek_tmp_key( } DBUG_PRINT("info", ("spider row=%p", row)); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE if (!spider->result_list.in_cmp_ref) { DBUG_PRINT("info", ("spider direct_aggregate=%s", @@ -5833,7 +5560,6 @@ int spider_db_seek_tmp_key( spider->result_list.snap_direct_aggregate = pos->direct_aggregate; spider->result_list.snap_row = row; } -#endif /* for mrr */ if (pos->mrr_with_cnt) @@ -5842,14 +5568,12 @@ int spider_db_seek_tmp_key( row->next(); } -#ifdef HANDLER_HAS_DIRECT_AGGREGATE /* for direct_aggregate */ if (pos->direct_aggregate) { if ((error_num = spider_db_fetch_for_item_sum_funcs(row, spider))) DBUG_RETURN(error_num); } -#endif if ((error_num = spider_db_append_match_fetch(spider, pos->ft_first, pos->ft_current, row))) @@ -5909,7 +5633,6 @@ int spider_db_seek_tmp_minimum_columns( } DBUG_PRINT("info", ("spider row=%p", row)); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE if (!spider->result_list.in_cmp_ref) { DBUG_PRINT("info", ("spider direct_aggregate=%s", @@ -5918,7 +5641,6 @@ int spider_db_seek_tmp_minimum_columns( spider->result_list.snap_direct_aggregate = pos->direct_aggregate; spider->result_list.snap_row = row; } -#endif /* for mrr */ if (pos->mrr_with_cnt) @@ -5927,14 +5649,12 @@ int spider_db_seek_tmp_minimum_columns( row->next(); } -#ifdef HANDLER_HAS_DIRECT_AGGREGATE /* for direct_aggregate */ if (pos->direct_aggregate) { if ((error_num = spider_db_fetch_for_item_sum_funcs(row, spider))) DBUG_RETURN(error_num); } -#endif if ((error_num = spider_db_append_match_fetch(spider, pos->ft_first, pos->ft_current, row))) @@ -6017,14 +5737,12 @@ int spider_db_simple_action( link_idx ); break; -#ifdef HA_HAS_CHECKSUM_EXTENDED case SPIDER_SIMPLE_CHECKSUM_TABLE: DBUG_PRINT("info",("spider simple checksum_table")); error_num = db_handler->checksum_table( link_idx ); break; -#endif default: DBUG_ASSERT(0); error_num = HA_ERR_CRASHED; @@ -6239,10 +5957,6 @@ int spider_db_bulk_insert( spider->set_insert_to_pos_sql(SPIDER_SQL_TYPE_INSERT_SQL); DBUG_RETURN(error_num); } -#ifdef HA_CAN_BULK_ACCESS - if (!spider->is_bulk_access_clone) - { -#endif bool insert_info = FALSE; for ( roop_count2 = spider_conn_link_idx_next(share->link_statuses, @@ -6444,9 +6158,6 @@ int spider_db_bulk_insert( SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); pthread_mutex_unlock(&conn->mta_conn_mutex); spider->store_last_insert_id = 0; -#ifdef HA_CAN_BULK_ACCESS - } -#endif } if ( (bulk_end || !spider->bulk_insert) && @@ -6456,95 +6167,6 @@ int spider_db_bulk_insert( DBUG_RETURN(0); } -#ifdef HA_CAN_BULK_ACCESS -int spider_db_bulk_bulk_insert( - ha_spider *spider -) { - int error_num = 0, first_insert_link_idx = -1, tmp_error_num; - int roop_count2; - SPIDER_SHARE *share = spider->share; - SPIDER_CONN *conn, *first_insert_conn = NULL; - TABLE *table = spider->get_table(); - THD *thd = spider->wide_handler->trx->thd; - DBUG_ENTER("spider_db_bulk_bulk_insert"); - for ( - roop_count2 = spider_conn_link_idx_next(share->link_statuses, - spider->conn_link_idx, -1, share->link_count, - SPIDER_LINK_STATUS_RECOVERY); - roop_count2 < (int) share->link_count; - roop_count2 = spider_conn_link_idx_next(share->link_statuses, - spider->conn_link_idx, roop_count2, share->link_count, - SPIDER_LINK_STATUS_RECOVERY) - ) { - conn = spider->conns[roop_count2]; - pthread_mutex_assert_not_owner(&conn->mta_conn_mutex); - pthread_mutex_lock(&conn->mta_conn_mutex); - SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos); - DBUG_ASSERT(!conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = TRUE; - conn->mta_conn_mutex_unlock_later = TRUE; - if ((tmp_error_num = spider_db_bulk_open_handler(spider, conn, - roop_count2))) - { - error_num = tmp_error_num; - } - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - if (first_insert_link_idx == -1) - { - first_insert_link_idx = roop_count2; - first_insert_conn = conn; - } - } - - conn = first_insert_conn; - pthread_mutex_assert_not_owner(&conn->mta_conn_mutex); - pthread_mutex_lock(&conn->mta_conn_mutex); - SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos); - conn->need_mon = &spider->need_mons[first_insert_link_idx]; - DBUG_ASSERT(!conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = TRUE; - conn->mta_conn_mutex_unlock_later = TRUE; - if (table->next_number_field && - ( - !table->auto_increment_field_not_null || - ( - !table->next_number_field->val_int() && - !(thd->variables.sql_mode & MODE_NO_AUTO_VALUE_ON_ZERO) - ) - ) - ) { - ulonglong last_insert_id; - if (spider->store_last_insert_id) - last_insert_id = spider->store_last_insert_id; - else - last_insert_id = conn->db_conn->last_insert_id(); - table->next_number_field->set_notnull(); - if ( - (tmp_error_num = spider_db_update_auto_increment(spider, - first_insert_link_idx)) || - (tmp_error_num = table->next_number_field->store( - last_insert_id, TRUE)) - ) { - error_num = tmp_error_num; - } - } - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - spider->store_last_insert_id = 0; - DBUG_RETURN(error_num); -} -#endif int spider_db_update_auto_increment( ha_spider *spider, @@ -6581,11 +6203,7 @@ int spider_db_update_auto_increment( if ( table->s->next_number_keypart == 0 && mysql_bin_log.is_open() && -#if MYSQL_VERSION_ID < 50500 - !thd->current_stmt_binlog_row_based -#else !thd->is_current_stmt_binlog_format_row() -#endif ) { if ( spider->check_partitioned() && @@ -6614,11 +6232,7 @@ int spider_db_update_auto_increment( if ( table->s->next_number_keypart == 0 && mysql_bin_log.is_open() && -#if MYSQL_VERSION_ID < 50500 - !thd->current_stmt_binlog_row_based -#else !thd->is_current_stmt_binlog_format_row() -#endif ) { for (roop_count = 0; roop_count < (int) affected_rows; roop_count++) push_warning_printf(thd, SPIDER_WARN_LEVEL_NOTE, @@ -6905,9 +6519,7 @@ int spider_db_update( ) { conn = spider->conns[roop_count]; spider_db_handler *dbton_hdl = spider->dbton_handler[conn->dbton_id]; -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000 conn->ignore_dup_key = spider->wide_handler->ignore_dup_key; -#endif pthread_mutex_assert_not_owner(&conn->mta_conn_mutex); if (dbton_hdl->need_lock_before_set_sql_for_exec( SPIDER_SQL_TYPE_UPDATE_SQL)) @@ -7079,246 +6691,6 @@ int spider_db_update( DBUG_RETURN(0); } -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS_WITH_HS -int spider_db_direct_update( - ha_spider *spider, - TABLE *table, - KEY_MULTI_RANGE *ranges, - uint range_count, - ha_rows *update_rows, - ha_rows *found_rows -) { - int error_num, roop_count; - SPIDER_SHARE *share = spider->share; - SPIDER_CONN *conn; - SPIDER_RESULT_LIST *result_list = &spider->result_list; - bool counted = FALSE; - st_select_lex *select_lex; - longlong select_limit; - longlong offset_limit; - DBUG_ENTER("spider_db_direct_update"); - - spider_set_result_list_param(spider); - result_list->finish_flg = FALSE; - DBUG_PRINT("info", ("spider do_direct_update=%s", - spider->do_direct_update ? "TRUE" : "FALSE")); - DBUG_PRINT("info", ("spider direct_update_kinds=%u", - spider->direct_update_kinds)); - if ((error_num = spider->append_update_sql_part())) - DBUG_RETURN(error_num); - -/* - SQL access -> SQL remote access - !spider->do_direct_update && - (spider->sql_kinds & SPIDER_SQL_KIND_SQL) - - SQL access -> SQL remote access with dirct_update - spider->do_direct_update && - spider->direct_update_kinds == SPIDER_SQL_KIND_SQL && - spider->wide_handler->direct_update_fields - - Handlersocket access -> SQL remote access with dirct_update - spider->do_direct_update && - (spider->direct_update_kinds & SPIDER_SQL_KIND_SQL) - - Handlersocket access -> Handlersocket access - spider->do_direct_update && - (spider->direct_update_kinds & SPIDER_SQL_KIND_HS) -*/ - -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS - if (!spider->do_direct_update) - { -#endif - if ( - (spider->sql_kinds & SPIDER_SQL_KIND_SQL) && - (error_num = spider->append_update_set_sql_part()) - ) { - DBUG_RETURN(error_num); - } -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS - } else { - if ( - (spider->direct_update_kinds & SPIDER_SQL_KIND_SQL) && - (error_num = spider->append_direct_update_set_sql_part()) - ) { - DBUG_RETURN(error_num); - } - } -#endif - - result_list->desc_flg = FALSE; - result_list->sorted = TRUE; - if (spider->active_index == MAX_KEY) - result_list->key_info = NULL; - else - result_list->key_info = &table->key_info[spider->active_index]; - spider_get_select_limit(spider, &select_lex, &select_limit, &offset_limit); - result_list->limit_num = - result_list->internal_limit >= select_limit ? - select_limit : result_list->internal_limit; - result_list->internal_offset += offset_limit; - if (spider->direct_update_kinds & SPIDER_SQL_KIND_SQL) - { - if ( - (error_num = spider->append_key_where_sql_part( - (ranges && ranges->start_key.key) ? &ranges->start_key : NULL, - (ranges && ranges->end_key.key) ? &ranges->end_key : NULL, - SPIDER_SQL_TYPE_UPDATE_SQL)) || - (error_num = spider-> - append_key_order_for_direct_order_limit_with_alias_sql_part( - NULL, 0, SPIDER_SQL_TYPE_UPDATE_SQL)) || - (error_num = spider->append_limit_sql_part( - result_list->internal_offset, result_list->limit_num, - SPIDER_SQL_TYPE_UPDATE_SQL)) - ) { - DBUG_RETURN(error_num); - } - } - - for ( - roop_count = spider_conn_link_idx_next(share->link_statuses, - spider->conn_link_idx, -1, share->link_count, - SPIDER_LINK_STATUS_RECOVERY); - roop_count < (int) share->link_count; - roop_count = spider_conn_link_idx_next(share->link_statuses, - spider->conn_link_idx, roop_count, share->link_count, - SPIDER_LINK_STATUS_RECOVERY) - ) { - ulong sql_type; - DBUG_PRINT("info", ("spider exec sql")); - conn = spider->conns[roop_count]; - sql_type = SPIDER_SQL_TYPE_UPDATE_SQL; - spider_db_handler *dbton_hdl = spider->dbton_handler[conn->dbton_id]; - pthread_mutex_assert_not_owner(&conn->mta_conn_mutex); - if (dbton_hdl->need_lock_before_set_sql_for_exec(sql_type)) - { - pthread_mutex_lock(&conn->mta_conn_mutex); - SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos); - } - if ((error_num = dbton_hdl->set_sql_for_exec(sql_type, roop_count))) - { - if (dbton_hdl->need_lock_before_set_sql_for_exec(sql_type)) - { - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - } - DBUG_RETURN(error_num); - } - if (!dbton_hdl->need_lock_before_set_sql_for_exec(sql_type)) - { - pthread_mutex_lock(&conn->mta_conn_mutex); - SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos); - } -#ifdef HA_CAN_BULK_ACCESS - if (spider->is_bulk_access_clone) - { - spider->connection_ids[roop_count] = conn->connection_id; - spider_trx_add_bulk_access_conn(spider->wide_handler->trx, conn); - } else { -#endif - conn->need_mon = &spider->need_mons[roop_count]; - DBUG_ASSERT(!conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = TRUE; - conn->mta_conn_mutex_unlock_later = TRUE; - if ((error_num = spider_db_set_names(spider, conn, roop_count))) - { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - if ( - share->monitoring_kind[roop_count] && - spider->need_mons[roop_count] - ) { - error_num = spider_ping_table_mon_from_table( - spider->wide_handler->trx, - spider->wide_handler->trx->thd, - share, - roop_count, - (uint32) share->monitoring_sid[roop_count], - share->table_name, - share->table_name_length, - spider->conn_link_idx[roop_count], - NULL, - 0, - share->monitoring_kind[roop_count], - share->monitoring_limit[roop_count], - share->monitoring_flag[roop_count], - TRUE - ); - } - DBUG_RETURN(error_num); - } - spider_conn_set_timeout_from_share(conn, roop_count, - spider->wide_handler->trx->thd, - share); - if ( - (error_num = dbton_hdl->execute_sql( - sql_type, - conn, - -1, - &spider->need_mons[roop_count]) - ) && - (error_num != HA_ERR_FOUND_DUPP_KEY || !spider->ignore_dup_key) - ) { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - error_num = spider_db_errorno(conn); - if ( - error_num != ER_DUP_ENTRY && - error_num != ER_DUP_KEY && - error_num != HA_ERR_FOUND_DUPP_KEY && - share->monitoring_kind[roop_count] && - spider->need_mons[roop_count] - ) { - error_num = spider_ping_table_mon_from_table( - spider->wide_handler->trx, - spider->wide_handler->trx->thd, - share, - roop_count, - (uint32) share->monitoring_sid[roop_count], - share->table_name, - share->table_name_length, - spider->conn_link_idx[roop_count], - NULL, - 0, - share->monitoring_kind[roop_count], - share->monitoring_limit[roop_count], - share->monitoring_flag[roop_count], - TRUE - ); - } - DBUG_RETURN(error_num); - } - if (!counted) - { - *update_rows = spider->conns[roop_count]->db_conn->affected_rows(); - DBUG_PRINT("info", ("spider update_rows = %llu", *update_rows)); - *found_rows = spider->conns[roop_count]->db_conn->matched_rows(); - DBUG_PRINT("info", ("spider found_rows = %llu", *found_rows)); - counted = TRUE; - } - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; -#ifdef HA_CAN_BULK_ACCESS - } -#endif - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - } - spider->reset_sql_sql(SPIDER_SQL_TYPE_UPDATE_SQL); - DBUG_RETURN(0); -} -#else int spider_db_direct_update( ha_spider *spider, TABLE *table, @@ -7355,17 +6727,14 @@ int spider_db_direct_update( spider->wide_handler->direct_update_fields */ -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS if (!spider->do_direct_update) { -#endif if ( (spider->sql_kinds & SPIDER_SQL_KIND_SQL) && (error_num = spider->append_update_set_sql_part()) ) { DBUG_RETURN(error_num); } -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS } else { if ( (spider->direct_update_kinds & SPIDER_SQL_KIND_SQL) && @@ -7374,7 +6743,6 @@ int spider_db_direct_update( DBUG_RETURN(error_num); } } -#endif result_list->desc_flg = FALSE; result_list->sorted = TRUE; @@ -7439,13 +6807,6 @@ int spider_db_direct_update( pthread_mutex_lock(&conn->mta_conn_mutex); SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos); } -#ifdef HA_CAN_BULK_ACCESS - if (spider->is_bulk_access_clone) - { - spider->connection_ids[roop_count] = conn->connection_id; - spider_trx_add_bulk_access_conn(spider->wide_handler->trx, conn); - } else { -#endif conn->need_mon = &spider->need_mons[roop_count]; DBUG_ASSERT(!conn->mta_conn_mutex_lock_already); DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later); @@ -7538,70 +6899,13 @@ int spider_db_direct_update( DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); conn->mta_conn_mutex_lock_already = FALSE; conn->mta_conn_mutex_unlock_later = FALSE; -#ifdef HA_CAN_BULK_ACCESS - } -#endif SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); pthread_mutex_unlock(&conn->mta_conn_mutex); } spider->reset_sql_sql(SPIDER_SQL_TYPE_UPDATE_SQL); DBUG_RETURN(0); } -#endif -#endif -#ifdef HA_CAN_BULK_ACCESS -int spider_db_bulk_direct_update( - ha_spider *spider, - ha_rows *update_rows, - ha_rows *found_rows -) { - int error_num = 0, roop_count, tmp_error_num; - SPIDER_SHARE *share = spider->share; - SPIDER_CONN *conn; - bool counted = FALSE; - DBUG_ENTER("spider_db_bulk_direct_update"); - for ( - roop_count = spider_conn_link_idx_next(share->link_statuses, - spider->conn_link_idx, -1, share->link_count, - SPIDER_LINK_STATUS_RECOVERY); - roop_count < (int) share->link_count; - roop_count = spider_conn_link_idx_next(share->link_statuses, - spider->conn_link_idx, roop_count, share->link_count, - SPIDER_LINK_STATUS_RECOVERY) - ) { - DBUG_PRINT("info", ("spider exec sql")); - conn = spider->conns[roop_count]; - pthread_mutex_assert_not_owner(&conn->mta_conn_mutex); - pthread_mutex_lock(&conn->mta_conn_mutex); - SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos); - DBUG_ASSERT(!conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = TRUE; - conn->mta_conn_mutex_unlock_later = TRUE; - if ((tmp_error_num = spider_db_bulk_open_handler(spider, conn, - roop_count))) - { - error_num = tmp_error_num; - } - if (!counted) - { - *update_rows = spider->conns[roop_count]->db_conn->affected_rows(); - DBUG_PRINT("info", ("spider update_rows = %llu", *update_rows)); - *found_rows = spider->conns[roop_count]->db_conn->matched_rows(); - DBUG_PRINT("info", ("spider found_rows = %llu", *found_rows)); - counted = TRUE; - } - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - } - DBUG_RETURN(error_num); -} -#endif int spider_db_bulk_delete( ha_spider *spider, @@ -7704,207 +7008,6 @@ int spider_db_delete( DBUG_RETURN(0); } -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS_WITH_HS -int spider_db_direct_delete( - ha_spider *spider, - TABLE *table, - KEY_MULTI_RANGE *ranges, - uint range_count, - ha_rows *delete_rows -) { - int error_num, roop_count; - SPIDER_SHARE *share = spider->share; - SPIDER_CONN *conn; - SPIDER_RESULT_LIST *result_list = &spider->result_list; - bool counted = FALSE; - st_select_lex *select_lex; - longlong select_limit; - longlong offset_limit; - DBUG_ENTER("spider_db_direct_delete"); - - spider_set_result_list_param(spider); - result_list->finish_flg = FALSE; - result_list->desc_flg = FALSE; - result_list->sorted = TRUE; - if (spider->active_index == MAX_KEY) - result_list->key_info = NULL; - else - result_list->key_info = &table->key_info[spider->active_index]; - spider_get_select_limit(spider, &select_lex, &select_limit, &offset_limit); - result_list->limit_num = - result_list->internal_limit >= select_limit ? - select_limit : result_list->internal_limit; - result_list->internal_offset += offset_limit; -/* - result_list->limit_num = - result_list->internal_limit >= result_list->split_read ? - result_list->split_read : result_list->internal_limit; -*/ - if (spider->direct_update_kinds & SPIDER_SQL_KIND_SQL) - { - if ( - (error_num = spider->append_delete_sql_part()) || - (error_num = spider->append_from_sql_part(SPIDER_SQL_TYPE_DELETE_SQL)) - ) { - DBUG_RETURN(error_num); - } - spider->set_where_pos_sql(SPIDER_SQL_TYPE_DELETE_SQL); - if ( - (error_num = spider->append_key_where_sql_part( - (ranges && ranges->start_key.key) ? &ranges->start_key : NULL, - (ranges && ranges->end_key.key) ? &ranges->end_key : NULL, - SPIDER_SQL_TYPE_DELETE_SQL)) || - (error_num = spider-> - append_key_order_for_direct_order_limit_with_alias_sql_part( - NULL, 0, SPIDER_SQL_TYPE_DELETE_SQL)) || - (error_num = spider->append_limit_sql_part( - result_list->internal_offset, result_list->limit_num, - SPIDER_SQL_TYPE_DELETE_SQL)) - ) { - DBUG_RETURN(error_num); - } - } - - for ( - roop_count = spider_conn_link_idx_next(share->link_statuses, - spider->conn_link_idx, -1, share->link_count, - SPIDER_LINK_STATUS_RECOVERY); - roop_count < (int) share->link_count; - roop_count = spider_conn_link_idx_next(share->link_statuses, - spider->conn_link_idx, roop_count, share->link_count, - SPIDER_LINK_STATUS_RECOVERY) - ) { - ulong sql_type; - DBUG_PRINT("info", ("spider exec sql")); - conn = spider->conns[roop_count]; - sql_type = SPIDER_SQL_TYPE_DELETE_SQL; - spider_db_handler *dbton_hdl = spider->dbton_handler[conn->dbton_id]; - pthread_mutex_assert_not_owner(&conn->mta_conn_mutex); - if (dbton_hdl->need_lock_before_set_sql_for_exec(sql_type)) - { - pthread_mutex_lock(&conn->mta_conn_mutex); - SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos); - } - if ((error_num = dbton_hdl->set_sql_for_exec(sql_type, roop_count))) - { - if (dbton_hdl->need_lock_before_set_sql_for_exec(sql_type)) - { - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - } - DBUG_RETURN(error_num); - } - if (!dbton_hdl->need_lock_before_set_sql_for_exec(sql_type)) - { - pthread_mutex_lock(&conn->mta_conn_mutex); - SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos); - } -#ifdef HA_CAN_BULK_ACCESS - if (spider->is_bulk_access_clone) - { - spider->connection_ids[roop_count] = conn->connection_id; - spider_trx_add_bulk_access_conn(spider->wide_handler->trx, conn); - } else { -#endif - conn->need_mon = &spider->need_mons[roop_count]; - DBUG_ASSERT(!conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = TRUE; - conn->mta_conn_mutex_unlock_later = TRUE; - if ((error_num = spider_db_set_names(spider, conn, roop_count))) - { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - if ( - share->monitoring_kind[roop_count] && - spider->need_mons[roop_count] - ) { - error_num = spider_ping_table_mon_from_table( - spider->wide_handler->trx, - spider->wide_handler->trx->thd, - share, - roop_count, - (uint32) share->monitoring_sid[roop_count], - share->table_name, - share->table_name_length, - spider->conn_link_idx[roop_count], - NULL, - 0, - share->monitoring_kind[roop_count], - share->monitoring_limit[roop_count], - share->monitoring_flag[roop_count], - TRUE - ); - } - DBUG_RETURN(error_num); - } - spider_conn_set_timeout_from_share(conn, roop_count, - spider->wide_handler->trx->thd, - share); - if (dbton_hdl->execute_sql( - sql_type, - conn, - -1, - &spider->need_mons[roop_count]) - ) { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - error_num = spider_db_errorno(conn); - if ( - share->monitoring_kind[roop_count] && - spider->need_mons[roop_count] - ) { - error_num = spider_ping_table_mon_from_table( - spider->wide_handler->trx, - spider->wide_handler->trx->thd, - share, - roop_count, - (uint32) share->monitoring_sid[roop_count], - share->table_name, - share->table_name_length, - spider->conn_link_idx[roop_count], - NULL, - 0, - share->monitoring_kind[roop_count], - share->monitoring_limit[roop_count], - share->monitoring_flag[roop_count], - TRUE - ); - } - DBUG_RETURN(error_num); - } - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - if (!counted) - { - *delete_rows = spider->conns[roop_count]->db_conn->affected_rows(); - DBUG_PRINT("info", ("spider delete_rows = %llu", *delete_rows)); - counted = TRUE; - } -#ifdef HA_CAN_BULK_ACCESS - } -#endif - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - } - int error_num2 = 0; - if (spider->direct_update_kinds & SPIDER_SQL_KIND_SQL) - { - if ((error_num = spider->reset_sql_sql(SPIDER_SQL_TYPE_DELETE_SQL))) - error_num2 = error_num; - } - DBUG_RETURN(error_num2); -} -#else int spider_db_direct_delete( ha_spider *spider, TABLE *table, @@ -7992,13 +7095,6 @@ int spider_db_direct_delete( pthread_mutex_lock(&conn->mta_conn_mutex); SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos); } -#ifdef HA_CAN_BULK_ACCESS - if (spider->is_bulk_access_clone) - { - spider->connection_ids[roop_count] = conn->connection_id; - spider_trx_add_bulk_access_conn(spider->wide_handler->trx, conn); - } else { -#endif conn->need_mon = &spider->need_mons[roop_count]; DBUG_ASSERT(!conn->mta_conn_mutex_lock_already); DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later); @@ -8082,9 +7178,6 @@ int spider_db_direct_delete( DBUG_PRINT("info", ("spider delete_rows = %llu", *delete_rows)); counted = TRUE; } -#ifdef HA_CAN_BULK_ACCESS - } -#endif SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); pthread_mutex_unlock(&conn->mta_conn_mutex); } @@ -8096,8 +7189,6 @@ int spider_db_direct_delete( } DBUG_RETURN(error_num2); } -#endif -#endif int spider_db_delete_all_rows( ha_spider *spider @@ -8823,11 +7914,9 @@ int spider_db_print_item_type( case Item::FUNC_ITEM: DBUG_RETURN(spider_db_open_item_func((Item_func *) item, spider, str, alias, alias_length, dbton_id, use_fields, fields)); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE case Item::SUM_FUNC_ITEM: DBUG_RETURN(spider_db_open_item_sum_func((Item_sum *)item, spider, str, alias, alias_length, dbton_id, use_fields, fields)); -#endif case Item::COND_ITEM: DBUG_RETURN(spider_db_open_item_cond((Item_cond *) item, spider, str, alias, alias_length, dbton_id, use_fields, fields)); @@ -8840,7 +7929,6 @@ int spider_db_print_item_type( case Item::ROW_ITEM: DBUG_RETURN(spider_db_open_item_row((Item_row *) item, spider, str, alias, alias_length, dbton_id, use_fields, fields)); -#ifdef SPIDER_USE_CONST_ITEM_FOR_STRING_INT_REAL_DECIMAL_DATE_ITEM case Item::CONST_ITEM: { switch (item->cmp_type()) { @@ -8858,16 +7946,6 @@ int spider_db_print_item_type( DBUG_RETURN(spider_db_print_item_type_default(item, spider, str)); } } -#else - case Item::STRING_ITEM: - DBUG_RETURN(spider_db_open_item_string(item, field, spider, str, - alias, alias_length, dbton_id, use_fields, fields)); - case Item::INT_ITEM: - case Item::REAL_ITEM: - case Item::DECIMAL_ITEM: - DBUG_RETURN(spider_db_open_item_int(item, field, spider, str, - alias, alias_length, dbton_id, use_fields, fields)); -#endif case Item::CACHE_ITEM: DBUG_RETURN(spider_db_open_item_cache((Item_cache *) item, field, spider, str, alias, alias_length, dbton_id, use_fields, fields)); @@ -8902,11 +7980,7 @@ int spider_db_print_item_type_default( { if (spider->share->access_charset->cset == system_charset_info->cset) { -#if MYSQL_VERSION_ID < 50500 - item->print(str->get_str(), QT_IS); -#else item->print(str->get_str(), QT_TO_SYSTEM_CHARSET); -#endif } else { item->print(str->get_str(), QT_ORDINARY); } @@ -9013,7 +8087,6 @@ int spider_db_open_item_func( item_func, spider, str, alias, alias_length, use_fields, fields)); } -#ifdef HANDLER_HAS_DIRECT_AGGREGATE int spider_db_open_item_sum_func( Item_sum *item_sum, ha_spider *spider, @@ -9028,7 +8101,6 @@ int spider_db_open_item_sum_func( DBUG_RETURN(spider_dbton[dbton_id].db_util->open_item_sum_func( item_sum, spider, str, alias, alias_length, use_fields, fields)); } -#endif int spider_db_open_item_ident( Item_ident *item_ident, @@ -9763,7 +8835,6 @@ int spider_db_append_condition( DBUG_RETURN(0); } -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS int spider_db_append_update_columns( ha_spider *spider, spider_string *str, @@ -9818,9 +8889,7 @@ int spider_db_append_update_columns( str->length(str->length() - SPIDER_SQL_COMMA_LEN); DBUG_RETURN(0); } -#endif -#ifdef HANDLER_HAS_DIRECT_AGGREGATE bool spider_db_check_select_colum_in_group( st_select_lex *select_lex, Field *field @@ -9843,7 +8912,6 @@ bool spider_db_check_select_colum_in_group( } DBUG_RETURN(FALSE); } -#endif uint spider_db_check_ft_idx( Item_func *item_func, @@ -10076,13 +9144,8 @@ int spider_db_udf_direct_sql( spider_param_ping_interval_at_trx_start(thd); time_t tmp_time = (time_t) time((time_t*) 0); bool need_trx_end, need_all_commit, insert_start = FALSE; -#if MYSQL_VERSION_ID < 50500 -#else enum_sql_command sql_command_backup; -#endif DBUG_ENTER("spider_db_udf_direct_sql"); -#if MYSQL_VERSION_ID < 50500 -#else if (direct_sql->real_table_used) { if (spider_sys_open_and_lock_tables(c_thd, &direct_sql->table_list_first, @@ -10101,7 +9164,6 @@ int spider_db_udf_direct_sql( direct_sql->open_tables_thd = c_thd; roop_count = 0; } -#endif if (c_thd != thd) { @@ -10109,21 +9171,15 @@ int spider_db_udf_direct_sql( need_trx_end = TRUE; } else { need_all_commit = FALSE; -#if MYSQL_VERSION_ID < 50500 -#else if (direct_sql->real_table_used) { need_trx_end = TRUE; } else { -#endif if (c_thd->transaction->stmt.ha_list) need_trx_end = FALSE; else need_trx_end = TRUE; -#if MYSQL_VERSION_ID < 50500 -#else } -#endif } if (!conn->disable_reconnect) @@ -10143,11 +9199,8 @@ int spider_db_udf_direct_sql( DBUG_RETURN(ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM); } -#if MYSQL_VERSION_ID < 50500 -#else sql_command_backup = c_thd->lex->sql_command; c_thd->lex->sql_command = SQLCOM_INSERT; -#endif pthread_mutex_assert_not_owner(&conn->mta_conn_mutex); pthread_mutex_lock(&conn->mta_conn_mutex); @@ -10230,9 +9283,6 @@ int spider_db_udf_direct_sql( for (; roop_count2 < set_off; roop_count2++) bitmap_clear_bit(table->write_set, (uint) roop_count2); -#if MYSQL_VERSION_ID < 50500 - if (table->file->has_transactions()) -#endif { THR_LOCK_DATA *to[2]; table->file->store_lock(table->in_use, to, @@ -10243,8 +9293,6 @@ int spider_db_udf_direct_sql( table->file->print_error(error_num, MYF(0)); break; } -#if MYSQL_VERSION_ID < 50500 -#else if ( table->s->tmp_table == NO_TMP_TABLE && table->pos_in_table_list @@ -10266,7 +9314,6 @@ int spider_db_udf_direct_sql( next_tables = next_tables->next_global; } } -#endif } if (direct_sql->iop) @@ -10328,13 +9375,8 @@ int spider_db_udf_direct_sql( else if (direct_sql->iop[roop_count] == 2) table->file->extra(HA_EXTRA_WRITE_CANNOT_REPLACE); } -#if MYSQL_VERSION_ID < 50500 - if (table->file->has_transactions()) -#endif { table->file->ha_external_unlock(table->in_use); -#if MYSQL_VERSION_ID < 50500 -#else if ( table->s->tmp_table == NO_TMP_TABLE && table->pos_in_table_list @@ -10350,7 +9392,6 @@ int spider_db_udf_direct_sql( next_tables = next_tables->next_global; } } -#endif } table->file->ha_reset(); table->in_use = thd; @@ -10413,10 +9454,7 @@ int spider_db_udf_direct_sql( } } } -#if MYSQL_VERSION_ID < 50500 -#else c_thd->lex->sql_command = sql_command_backup; -#endif DBUG_RETURN(error_num); } @@ -11375,7 +10413,6 @@ int spider_db_udf_copy_tables( } } */ -#ifndef WITHOUT_SPIDER_BG_SEARCH if (copy_tables->bg_mode) { for (dst_tbl_conn = copy_tables->table_conn[1]; dst_tbl_conn; @@ -11389,7 +10426,6 @@ int spider_db_udf_copy_tables( } } } else { -#endif for (dst_tbl_conn = copy_tables->table_conn[1]; dst_tbl_conn; dst_tbl_conn = dst_tbl_conn->next) { @@ -11428,11 +10464,8 @@ int spider_db_udf_copy_tables( pthread_mutex_unlock(&tmp_conn->mta_conn_mutex); } } -#ifndef WITHOUT_SPIDER_BG_SEARCH } -#endif -#ifndef WITHOUT_SPIDER_BG_SEARCH if (copy_tables->bg_mode) { for (dst_tbl_conn = copy_tables->table_conn[1]; dst_tbl_conn; @@ -11455,7 +10488,6 @@ int spider_db_udf_copy_tables( } } } -#endif } if (copy_tables->use_transaction) @@ -11501,7 +10533,6 @@ int spider_db_udf_copy_tables( DBUG_RETURN(0); error_db_query: -#ifndef WITHOUT_SPIDER_BG_SEARCH if (copy_tables->bg_mode) { for (dst_tbl_conn = copy_tables->table_conn[1]; dst_tbl_conn; @@ -11516,7 +10547,6 @@ error_db_query: } } } -#endif error_unlock_tables: error_commit: error_lock_tables: @@ -11631,20 +10661,6 @@ error: DBUG_RETURN(error_num); } -#ifdef HA_CAN_BULK_ACCESS -int spider_db_bulk_open_handler( - ha_spider *spider, - SPIDER_CONN *conn, - int link_idx -) { - int error_num = 0; - DBUG_ENTER("spider_db_bulk_open_handler"); - DBUG_PRINT("info",("spider spider=%p", spider)); - DBUG_PRINT("info",("spider conn=%p", conn)); - DBUG_PRINT("info",("spider link_idx=%d", link_idx)); - DBUG_RETURN(error_num); -} -#endif int spider_db_close_handler( ha_spider *spider, diff --git a/storage/spider/spd_db_conn.h b/storage/spider/spd_db_conn.h index b87c57bc4ab..adda66d547b 100644 --- a/storage/spider/spd_db_conn.h +++ b/storage/spider/spd_db_conn.h @@ -496,7 +496,6 @@ int spider_db_append_charset_name_before_string( CHARSET_INFO *cs ); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE int spider_db_refetch_for_item_sum_funcs( ha_spider *spider ); @@ -511,7 +510,6 @@ int spider_db_fetch_for_item_sum_func( Item_sum *item_sum, ha_spider *spider ); -#endif int spider_db_append_match_fetch( ha_spider *spider, @@ -636,14 +634,6 @@ void spider_db_discard_multiple_result( SPIDER_CONN *conn ); -#ifdef HA_CAN_BULK_ACCESS -int spider_db_bulk_store_result( - ha_spider *spider, - SPIDER_CONN *conn, - int link_idx, - bool discard_result -); -#endif int spider_db_fetch( uchar *buf, @@ -766,11 +756,6 @@ int spider_db_bulk_insert( bool bulk_end ); -#ifdef HA_CAN_BULK_ACCESS -int spider_db_bulk_bulk_insert( - ha_spider *spider -); -#endif int spider_db_update_auto_increment( ha_spider *spider, @@ -799,32 +784,13 @@ int spider_db_update( const uchar *old_data ); -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS_WITH_HS -int spider_db_direct_update( - ha_spider *spider, - TABLE *table, - KEY_MULTI_RANGE *ranges, - uint range_count, - ha_rows *update_rows, - ha_rows *found_rows -); -#else int spider_db_direct_update( ha_spider *spider, TABLE *table, ha_rows *update_rows, ha_rows *found_rows ); -#endif -#endif -#ifdef HA_CAN_BULK_ACCESS -int spider_db_bulk_direct_update( - ha_spider *spider, - ha_rows *update_rows -); -#endif int spider_db_bulk_delete( ha_spider *spider, @@ -838,23 +804,11 @@ int spider_db_delete( const uchar *buf ); -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS_WITH_HS int spider_db_direct_delete( ha_spider *spider, TABLE *table, - KEY_MULTI_RANGE *ranges, - uint range_count, ha_rows *delete_rows ); -#else -int spider_db_direct_delete( - ha_spider *spider, - TABLE *table, - ha_rows *delete_rows -); -#endif -#endif int spider_db_delete_all_rows( ha_spider *spider @@ -944,7 +898,6 @@ int spider_db_open_item_func( spider_fields *fields ); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE int spider_db_open_item_sum_func( Item_sum *item_sum, ha_spider *spider, @@ -955,7 +908,6 @@ int spider_db_open_item_sum_func( bool use_fields, spider_fields *fields ); -#endif int spider_db_open_item_ident( Item_ident *item_ident, @@ -1056,7 +1008,6 @@ int spider_db_append_condition( bool test_flg ); -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS int spider_db_append_update_columns( ha_spider *spider, spider_string *str, @@ -1066,14 +1017,11 @@ int spider_db_append_update_columns( bool use_fields, spider_fields *fields ); -#endif -#ifdef HANDLER_HAS_DIRECT_AGGREGATE bool spider_db_check_select_colum_in_group( st_select_lex *select_lex, Field *field ); -#endif uint spider_db_check_ft_idx( Item_func *item_func, @@ -1202,13 +1150,6 @@ int spider_db_open_handler( int link_idx ); -#ifdef HA_CAN_BULK_ACCESS -int spider_db_bulk_open_handler( - ha_spider *spider, - SPIDER_CONN *conn, - int link_idx -); -#endif int spider_db_close_handler( ha_spider *spider, diff --git a/storage/spider/spd_db_include.cc b/storage/spider/spd_db_include.cc index 4eab1f4be54..a4d7d4b49a0 100644 --- a/storage/spider/spd_db_include.cc +++ b/storage/spider/spd_db_include.cc @@ -12,20 +12,15 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA */ #define MYSQL_SERVER 1 #include <my_global.h> #include "mysql_version.h" #include "spd_environ.h" -#if MYSQL_VERSION_ID < 50500 -#include "mysql_priv.h" -#include <mysql/plugin.h> -#else #include "sql_priv.h" #include "probes_mysql.h" #include "sql_class.h" -#endif #include "sql_common.h" #include <mysql.h> #include <errmsg.h> @@ -45,7 +40,6 @@ spider_db_result::spider_db_result( DBUG_VOID_RETURN; } -#ifdef HA_HAS_CHECKSUM_EXTENDED int spider_db_result::fetch_table_checksum( ha_spider *spider ) { @@ -53,7 +47,6 @@ int spider_db_result::fetch_table_checksum( DBUG_PRINT("info",("spider this=%p", this)); DBUG_RETURN(0); } -#endif uint spider_db_result::limit_mode() { @@ -193,7 +186,6 @@ uint spider_db_util::limit_mode() DBUG_RETURN(0); } -#ifdef HA_HAS_CHECKSUM_EXTENDED bool spider_db_share::checksum_support() { DBUG_ENTER("spider_db_share::checksum_support"); @@ -208,9 +200,7 @@ int spider_db_handler::checksum_table( DBUG_PRINT("info",("spider this=%p", this)); DBUG_RETURN(0); } -#endif -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS bool spider_db_handler::check_direct_update( st_select_lex *select_lex, longlong select_limit, @@ -244,4 +234,3 @@ bool spider_db_handler::check_direct_delete( } DBUG_RETURN(FALSE); } -#endif diff --git a/storage/spider/spd_db_include.h b/storage/spider/spd_db_include.h index 09c39535f1f..338dc1030fc 100644 --- a/storage/spider/spd_db_include.h +++ b/storage/spider/spd_db_include.h @@ -28,56 +28,20 @@ #define SPIDER_DB_WRAPPER_MYSQL "mysql" #define SPIDER_DB_WRAPPER_MARIADB "mariadb" -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100204 #define PLUGIN_VAR_CAN_MEMALLOC -/* -#define ITEM_FUNC_CASE_PARAMS_ARE_PUBLIC -#define HASH_UPDATE_WITH_HASH_VALUE -*/ -#else -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS -#define HANDLER_HAS_DIRECT_UPDATE_ROWS_WITH_HS -#endif -#endif -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100002 -#define SPIDER_HAS_DISCOVER_TABLE_STRUCTURE #define SPIDER_HAS_APPEND_FOR_SINGLE_QUOTE #define SPIDER_HAS_SHOW_SIMPLE_FUNC #define SPIDER_HAS_JT_HASH_INDEX_MERGE #define SPIDER_HAS_EXPR_CACHE_ITEM -#else -#define SPIDER_NEED_CHECK_CONDITION_AT_CHECKING_DIRECT_ORDER_LIMIT -#endif - -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100007 #define SPIDER_ITEM_HAS_CMP_TYPE -#endif - -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100004 #define SPIDER_HAS_TIME_STATUS #define SPIDER_HAS_DECIMAL_OPERATION_RESULTS_VALUE_TYPE -#endif - -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100014 #define SPIDER_ITEM_STRING_WITHOUT_SET_STR_WITH_COPY -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100100 #define SPIDER_ITEM_STRING_WITHOUT_SET_STR_WITH_COPY_AND_THDPTR -#endif -#endif - -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100108 -#define SPIDER_HAS_GROUP_BY_HANDLER -#endif - -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100200 #define SPIDER_ORDER_HAS_ENUM_ORDER -#endif - -#if defined(MARIADB_BASE_VERSION) #define SPIDER_ITEM_GEOFUNC_NAME_HAS_MBR #define SPIDER_HANDLER_AUTO_REPAIR_HAS_ERROR -#endif class spider_db_conn; typedef spider_db_conn SPIDER_DB_CONN; @@ -827,7 +791,6 @@ public: bool use_fields, spider_fields *fields ) = 0; -#ifdef HANDLER_HAS_DIRECT_AGGREGATE virtual int open_item_sum_func( Item_sum *item_sum, ha_spider *spider, @@ -837,12 +800,10 @@ public: bool use_fields, spider_fields *fields ) = 0; -#endif virtual int append_escaped_util( spider_string *to, String *from ) = 0; -#ifdef SPIDER_HAS_GROUP_BY_HANDLER virtual int append_from_and_tables( ha_spider *spider, spider_fields *fields, @@ -861,7 +822,6 @@ public: virtual int append_having( spider_string *str ) = 0; -#endif virtual bool tables_on_different_db_are_joinable(); virtual bool socket_has_default_value(); virtual bool database_has_default_value(); @@ -944,11 +904,9 @@ public: int mode, ha_rows &records ) = 0; -#ifdef HA_HAS_CHECKSUM_EXTENDED virtual int fetch_table_checksum( ha_spider *spider ); -#endif virtual int fetch_table_cardinality( int mode, TABLE *table, @@ -965,7 +923,6 @@ public: longlong pos ) = 0; virtual int get_errno() = 0; -#ifdef SPIDER_HAS_DISCOVER_TABLE_STRUCTURE virtual int fetch_columns_for_discover_table_structure( spider_string *str, CHARSET_INFO *access_charset @@ -979,7 +936,6 @@ public: SPIDER_SHARE *spider_share, CHARSET_INFO *access_charset ) = 0; -#endif virtual uint limit_mode(); }; @@ -1186,16 +1142,12 @@ public: uint alias_length ) = 0; virtual bool need_change_db_table_name() = 0; -#ifdef SPIDER_HAS_DISCOVER_TABLE_STRUCTURE virtual int discover_table_structure( SPIDER_TRX *trx, SPIDER_SHARE *spider_share, spider_string *str ) = 0; -#endif -#ifdef HA_HAS_CHECKSUM_EXTENDED virtual bool checksum_support(); -#endif }; class spider_db_handler @@ -1210,9 +1162,7 @@ public: ha_spider *spider; spider_db_share *db_share; int first_link_idx; -#ifdef SPIDER_HAS_GROUP_BY_HANDLER SPIDER_LINK_IDX_CHAIN *link_idx_chain; -#endif bool strict_group_by; bool no_where_cond; spider_db_handler(ha_spider *spider, spider_db_share *db_share) : @@ -1264,7 +1214,6 @@ public: virtual int append_update_part() = 0; virtual int append_delete_part() = 0; virtual int append_update_set_part() = 0; -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS virtual int append_direct_update_set_part() = 0; virtual int append_dup_update_pushdown_part( const char *alias, @@ -1275,7 +1224,6 @@ public: uint alias_length ) = 0; virtual int check_update_columns_part() = 0; -#endif virtual int append_select_part( ulong sql_type ) = 0; @@ -1357,26 +1305,22 @@ public: const char *alias, uint alias_length ) = 0; -#ifdef HANDLER_HAS_DIRECT_AGGREGATE virtual int append_sum_select_part( ulong sql_type, const char *alias, uint alias_length ) = 0; -#endif virtual void set_order_pos( ulong sql_type ) = 0; virtual void set_order_to_pos( ulong sql_type ) = 0; -#ifdef HANDLER_HAS_DIRECT_AGGREGATE virtual int append_group_by_part( const char *alias, uint alias_length, ulong sql_type ) = 0; -#endif virtual int append_key_order_for_merge_with_alias_part( const char *alias, uint alias_length, @@ -1504,13 +1448,11 @@ public: virtual bool need_lock_before_set_sql_for_exec( ulong sql_type ) = 0; -#ifdef SPIDER_HAS_GROUP_BY_HANDLER virtual int set_sql_for_exec( ulong sql_type, int link_idx, SPIDER_LINK_IDX_CHAIN *link_idx_chain ) = 0; -#endif virtual int set_sql_for_exec( ulong sql_type, int link_idx @@ -1544,11 +1486,9 @@ public: virtual int show_records( int link_idx ) = 0; -#ifdef HA_HAS_CHECKSUM_EXTENDED virtual int checksum_table( int link_idx ); -#endif virtual int show_last_insert_id( int link_idx, ulonglong &last_insert_id @@ -1626,7 +1566,6 @@ public: int link_idx, ulong sql_type ) = 0; -#ifdef SPIDER_HAS_GROUP_BY_HANDLER virtual int append_from_and_tables_part( spider_fields *fields, ulong sql_type @@ -1673,8 +1612,6 @@ public: spider_fields *fields, ulong sql_type ) = 0; -#endif -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS virtual bool check_direct_update( st_select_lex *select_lex, longlong select_limit, @@ -1685,7 +1622,6 @@ public: longlong select_limit, longlong offset_limit ); -#endif }; class spider_db_copy_table @@ -1804,9 +1740,7 @@ typedef struct st_spider_position uint pos_mode; bool use_position; bool mrr_with_cnt; -#ifdef HANDLER_HAS_DIRECT_AGGREGATE bool direct_aggregate; -#endif uint sql_kind; uchar *position_bitmap; st_spider_ft_info *ft_first; @@ -1825,13 +1759,9 @@ typedef struct st_spider_result { uint dbton_id; SPIDER_DB_RESULT *result; -#ifndef WITHOUT_SPIDER_BG_SEARCH volatile -#endif st_spider_result *prev; -#ifndef WITHOUT_SPIDER_BG_SEARCH volatile -#endif st_spider_result *next; SPIDER_POSITION *first_position; /* for quick mode */ int pos_page_size; /* for quick mode */ @@ -1850,17 +1780,11 @@ typedef struct st_spider_result typedef struct st_spider_result_list { -#ifndef WITHOUT_SPIDER_BG_SEARCH volatile -#endif SPIDER_RESULT *first; -#ifndef WITHOUT_SPIDER_BG_SEARCH volatile -#endif SPIDER_RESULT *last; -#ifndef WITHOUT_SPIDER_BG_SEARCH volatile -#endif SPIDER_RESULT *current; KEY *key_info; int key_order; @@ -1907,12 +1831,10 @@ typedef struct st_spider_result_list /* the limit_offeset, without where condition */ bool direct_limit_offset; bool direct_distinct; -#ifdef HANDLER_HAS_DIRECT_AGGREGATE bool direct_aggregate; bool snap_mrr_with_cnt; bool snap_direct_aggregate; SPIDER_DB_ROW *snap_row; -#endif bool in_cmp_ref; bool set_split_read; bool insert_dup_update_pushdown; @@ -1924,14 +1846,11 @@ typedef struct st_spider_result_list longlong second_read; int set_split_read_count; int *casual_read; -#ifndef WITHOUT_SPIDER_BG_SEARCH /* 0:nomal 1:store 2:store end */ volatile -#endif int quick_phase; bool keyread; TABLE *table; -#ifndef WITHOUT_SPIDER_BG_SEARCH volatile int bgs_error; bool bgs_error_with_message; char bgs_error_msg[MYSQL_ERRMSG_SIZE]; @@ -1942,7 +1861,6 @@ typedef struct st_spider_result_list volatile longlong bgs_second_read; volatile longlong bgs_split_read; volatile -#endif SPIDER_RESULT *bgs_current; SPIDER_DB_ROW *tmp_pos_row_first; } SPIDER_RESULT_LIST; diff --git a/storage/spider/spd_db_mysql.cc b/storage/spider/spd_db_mysql.cc index 78172c61355..192d151eb35 100644 --- a/storage/spider/spd_db_mysql.cc +++ b/storage/spider/spd_db_mysql.cc @@ -1,5 +1,5 @@ /* Copyright (C) 2012-2018 Kentoku Shiba - Copyright (c) 2020, MariaDB Corporation. + Copyright (c) 2020, 2022, MariaDB Corporation. 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 @@ -18,10 +18,6 @@ #include <my_global.h> #include "mysql_version.h" #include "spd_environ.h" -#if MYSQL_VERSION_ID < 50500 -#include "mysql_priv.h" -#include <mysql/plugin.h> -#else #include "sql_priv.h" #include "probes_mysql.h" #include "sql_class.h" @@ -29,10 +25,7 @@ #include "sql_analyse.h" #include "sql_base.h" #include "tztime.h" -#ifdef HANDLER_HAS_DIRECT_AGGREGATE #include "sql_select.h" -#endif -#endif #include "sql_common.h" #include <mysql.h> #include <errmsg.h> @@ -145,7 +138,6 @@ static const char *name_quote_str = SPIDER_SQL_NAME_QUOTE_STR; #define SPIDER_SQL_BINLOG_GTID_POS_STR "select binlog_gtid_pos" #define SPIDER_SQL_BINLOG_GTID_POS_LEN sizeof(SPIDER_SQL_BINLOG_GTID_POS_STR) - 1 -#ifdef SPIDER_HAS_DISCOVER_TABLE_STRUCTURE #define SPIDER_SQL_SHOW_COLUMNS_STR "show columns from " #define SPIDER_SQL_SHOW_COLUMNS_LEN sizeof(SPIDER_SQL_SHOW_COLUMNS_STR) - 1 #define SPIDER_SQL_SELECT_COLUMNS_STR "select `column_name`,`column_default`,`is_nullable`,`character_set_name`,`collation_name`,`column_type`,`extra` from `information_schema`.`columns` where `table_schema` = " @@ -161,16 +153,13 @@ static const char *name_quote_str = SPIDER_SQL_NAME_QUOTE_STR; #define SPIDER_SQL_SPATIAL_LEN sizeof(SPIDER_SQL_SPATIAL_STR) - 1 #define SPIDER_SQL_USING_HASH_STR " using hash" #define SPIDER_SQL_USING_HASH_LEN sizeof(SPIDER_SQL_USING_HASH_STR) - 1 -#endif #define SPIDER_SQL_SHOW_RECORDS_RECORDS_POS 0 #define SPIDER_SQL_EXPLAIN_SELECT_RECORDS_POS 8 -#ifdef HA_HAS_CHECKSUM_EXTENDED #define SPIDER_SQL_CHECKSUM_CHECKSUM_POS 1 #define SPIDER_SQL_CHECKSUM_TABLE_STR "checksum table " #define SPIDER_SQL_CHECKSUM_TABLE_LEN (sizeof(SPIDER_SQL_CHECKSUM_TABLE_STR) - 1) -#endif #define SPIDER_SQL_LIKE_STR " like " #define SPIDER_SQL_LIKE_LEN (sizeof(SPIDER_SQL_LIKE_STR) - 1) @@ -821,11 +810,7 @@ int spider_db_mbase_result::fetch_table_status( int error_num; MYSQL_ROW mysql_row; MYSQL_TIME mysql_time; -#ifdef MARIADB_BASE_VERSION uint not_used_uint; -#else - my_bool not_used_my_bool; -#endif #ifdef SPIDER_HAS_TIME_STATUS MYSQL_TIME_STATUS time_status; #else @@ -903,13 +888,8 @@ int spider_db_mbase_result::fetch_table_status( #endif SPIDER_str_to_datetime(mysql_row[11], strlen(mysql_row[11]), &mysql_time, 0, &time_status); -#ifdef MARIADB_BASE_VERSION stat.create_time = (time_t) my_system_gmt_sec(&mysql_time, ¬_used_long, ¬_used_uint); -#else - stat.create_time = (time_t) my_system_gmt_sec(&mysql_time, - ¬_used_long, ¬_used_my_bool); -#endif } else stat.create_time = (time_t) 0; #ifdef DBUG_TRACE @@ -928,13 +908,8 @@ int spider_db_mbase_result::fetch_table_status( #endif SPIDER_str_to_datetime(mysql_row[12], strlen(mysql_row[12]), &mysql_time, 0, &time_status); -#ifdef MARIADB_BASE_VERSION stat.update_time = (time_t) my_system_gmt_sec(&mysql_time, ¬_used_long, ¬_used_uint); -#else - stat.update_time = (time_t) my_system_gmt_sec(&mysql_time, - ¬_used_long, ¬_used_my_bool); -#endif } else stat.update_time = (time_t) 0; #ifndef DBUG_OFF @@ -953,13 +928,8 @@ int spider_db_mbase_result::fetch_table_status( #endif SPIDER_str_to_datetime(mysql_row[13], strlen(mysql_row[13]), &mysql_time, 0, &time_status); -#ifdef MARIADB_BASE_VERSION stat.check_time = (time_t) my_system_gmt_sec(&mysql_time, ¬_used_long, ¬_used_uint); -#else - stat.check_time = (time_t) my_system_gmt_sec(&mysql_time, - ¬_used_long, ¬_used_my_bool); -#endif } else stat.check_time = (time_t) 0; #ifdef DBUG_TRACE @@ -1032,13 +1002,8 @@ int spider_db_mbase_result::fetch_table_status( #endif SPIDER_str_to_datetime(mysql_row[6], strlen(mysql_row[6]), &mysql_time, 0, &time_status); -#ifdef MARIADB_BASE_VERSION stat.create_time = (time_t) my_system_gmt_sec(&mysql_time, ¬_used_long, ¬_used_uint); -#else - stat.create_time = (time_t) my_system_gmt_sec(&mysql_time, - ¬_used_long, ¬_used_my_bool); -#endif } else stat.create_time = (time_t) 0; #ifdef DBUG_TRACE @@ -1057,13 +1022,8 @@ int spider_db_mbase_result::fetch_table_status( #endif SPIDER_str_to_datetime(mysql_row[7], strlen(mysql_row[7]), &mysql_time, 0, &time_status); -#ifdef MARIADB_BASE_VERSION stat.update_time = (time_t) my_system_gmt_sec(&mysql_time, ¬_used_long, ¬_used_uint); -#else - stat.update_time = (time_t) my_system_gmt_sec(&mysql_time, - ¬_used_long, ¬_used_my_bool); -#endif } else stat.update_time = (time_t) 0; #ifdef DBUG_TRACE @@ -1082,13 +1042,8 @@ int spider_db_mbase_result::fetch_table_status( #endif SPIDER_str_to_datetime(mysql_row[8], strlen(mysql_row[8]), &mysql_time, 0, &time_status); -#ifdef MARIADB_BASE_VERSION stat.check_time = (time_t) my_system_gmt_sec(&mysql_time, ¬_used_long, ¬_used_uint); -#else - stat.check_time = (time_t) my_system_gmt_sec(&mysql_time, - ¬_used_long, ¬_used_my_bool); -#endif } else stat.check_time = (time_t) 0; #ifdef DBUG_TRACE @@ -1155,7 +1110,6 @@ int spider_db_mbase_result::fetch_simple_action( DBUG_PRINT("info", ("spider records=%lld", *records)); break; } -#ifdef HA_HAS_CHECKSUM_EXTENDED case SPIDER_SIMPLE_CHECKSUM_TABLE: { ha_spider *spider = (ha_spider *) param; @@ -1172,7 +1126,6 @@ int spider_db_mbase_result::fetch_simple_action( } break; } -#endif default: DBUG_ASSERT(0); break; @@ -1196,7 +1149,6 @@ int spider_db_mbase_result::fetch_table_records( } } -#ifdef HA_HAS_CHECKSUM_EXTENDED int spider_db_mbase_result::fetch_table_checksum( ha_spider *spider ) { @@ -1205,7 +1157,6 @@ int spider_db_mbase_result::fetch_table_checksum( DBUG_RETURN(fetch_simple_action(SPIDER_SIMPLE_CHECKSUM_TABLE, SPIDER_SQL_CHECKSUM_CHECKSUM_POS, spider)); } -#endif int spider_db_mbase_result::fetch_table_cardinality( int mode, @@ -1430,7 +1381,6 @@ int spider_db_mbase_result::get_errno() DBUG_RETURN(store_error_num); } -#ifdef SPIDER_HAS_DISCOVER_TABLE_STRUCTURE int spider_db_mbase_result::fetch_columns_for_discover_table_structure( spider_string *str, CHARSET_INFO *access_charset @@ -1803,7 +1753,6 @@ int spider_db_mbase_result::fetch_table_for_discover_table_structure( } DBUG_RETURN(0); } -#endif spider_db_mbase::spider_db_mbase( SPIDER_CONN *conn, @@ -2304,13 +2253,8 @@ int spider_db_mbase::print_warnings( if (db_conn->status == MYSQL_STATUS_READY) { if ( -#if MYSQL_VERSION_ID < 50500 - !(db_conn->last_used_con->server_status & SERVER_MORE_RESULTS_EXISTS) && - db_conn->last_used_con->warning_count -#else !(db_conn->server_status & SERVER_MORE_RESULTS_EXISTS) && db_conn->warning_count -#endif ) { if ( spider_param_dry_access() || @@ -2443,11 +2387,7 @@ int spider_db_mbase::next_result() strmov(db_conn->net.sqlstate, "00000"); db_conn->affected_rows = ~(my_ulonglong) 0; -#if MYSQL_VERSION_ID < 50500 - if (db_conn->last_used_con->server_status & SERVER_MORE_RESULTS_EXISTS) -#else if (db_conn->server_status & SERVER_MORE_RESULTS_EXISTS) -#endif { if ((status = db_conn->methods->read_query_result(db_conn)) > 0) DBUG_RETURN(spider_db_errorno(conn)); @@ -2461,11 +2401,7 @@ uint spider_db_mbase::affected_rows() MYSQL *last_used_con; DBUG_ENTER("spider_db_mbase::affected_rows"); DBUG_PRINT("info",("spider this=%p", this)); -#if MYSQL_VERSION_ID < 50500 - last_used_con = db_conn->last_used_con; -#else last_used_con = db_conn; -#endif DBUG_RETURN((uint) last_used_con->affected_rows); } @@ -2474,11 +2410,7 @@ uint spider_db_mbase::matched_rows() MYSQL *last_used_con; DBUG_ENTER("spider_db_mysql::matched_rows"); DBUG_PRINT("info", ("spider this=%p", this)); -#if MYSQL_VERSION_ID < 50500 - last_used_con = db_conn->last_used_con; -#else last_used_con = db_conn; -#endif /* Rows matched: 65 Changed: 65 Warnings: 0 */ const char *info = last_used_con->info; if (!info) @@ -2503,11 +2435,7 @@ bool spider_db_mbase::inserted_info( { DBUG_RETURN(TRUE); } -#if MYSQL_VERSION_ID < 50500 - last_used_con = db_conn->last_used_con; -#else last_used_con = db_conn; -#endif /* Records: 10 Duplicates: 4 Warnings: 0 */ const char *info = last_used_con->info; if (!info) @@ -2549,11 +2477,7 @@ ulonglong spider_db_mbase::last_insert_id() MYSQL *last_used_con; DBUG_ENTER("spider_db_mbase::last_insert_id"); DBUG_PRINT("info",("spider this=%p", this)); -#if MYSQL_VERSION_ID < 50500 - last_used_con = db_conn->last_used_con; -#else last_used_con = db_conn; -#endif DBUG_RETURN((uint) last_used_con->insert_id); } @@ -3436,12 +3360,7 @@ int spider_db_mbase::set_loop_check( SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); pthread_mutex_unlock(&conn->mta_conn_mutex); -#ifdef HASH_UPDATE_WITH_HASH_VALUE - my_hash_delete_with_hash_value(&conn->loop_check_queue, - lcptr->hash_value, (uchar *) lcptr); -#else my_hash_delete(&conn->loop_check_queue, (uchar*) lcptr); -#endif } DBUG_RETURN(0); } @@ -3827,12 +3746,7 @@ int spider_db_mbase::append_lock_tables( my_hash_reset(&lock_table_hash); DBUG_RETURN(error_num); } -#ifdef HASH_UPDATE_WITH_HASH_VALUE - my_hash_delete_with_hash_value(&lock_table_hash, - tmp_link_for_hash->db_table_str_hash_value, (uchar*) tmp_link_for_hash); -#else my_hash_delete(&lock_table_hash, (uchar*) tmp_link_for_hash); -#endif } if ((error_num = spider_db_mbase_utility->append_lock_table_tail(str))) { @@ -6100,11 +6014,7 @@ int spider_db_mbase_util::open_item_func( DBUG_RETURN(HA_ERR_OUT_OF_MEM); str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN); } -#if MYSQL_VERSION_ID < 50500 - item_func->print(tmp_str.get_str(), QT_IS); -#else item_func->print(tmp_str.get_str(), QT_TO_SYSTEM_CHARSET); -#endif tmp_str.mem_calc(); if (tmp_str.reserve(1)) DBUG_RETURN(HA_ERR_OUT_OF_MEM); @@ -6238,11 +6148,7 @@ int spider_db_mbase_util::open_item_func( DBUG_RETURN(HA_ERR_OUT_OF_MEM); str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN); } -#if MYSQL_VERSION_ID < 50500 - item_func->print(tmp_str.get_str(), QT_IS); -#else item_func->print(tmp_str.get_str(), QT_TO_SYSTEM_CHARSET); -#endif tmp_str.mem_calc(); if (tmp_str.reserve(1)) DBUG_RETURN(HA_ERR_OUT_OF_MEM); @@ -6395,11 +6301,7 @@ int spider_db_mbase_util::open_item_func( DBUG_RETURN(HA_ERR_OUT_OF_MEM); str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN); } -#if MYSQL_VERSION_ID < 50500 - item_func->print(tmp_str.get_str(), QT_IS); -#else item_func->print(tmp_str.get_str(), QT_TO_SYSTEM_CHARSET); -#endif tmp_str.mem_calc(); if (tmp_str.reserve(1)) DBUG_RETURN(HA_ERR_OUT_OF_MEM); @@ -6858,7 +6760,6 @@ int spider_db_mbase_util::open_item_func( DBUG_RETURN(0); } -#ifdef HANDLER_HAS_DIRECT_AGGREGATE int spider_db_mbase_util::open_item_sum_func( Item_sum *item_sum, ha_spider *spider, @@ -6976,7 +6877,6 @@ int spider_db_mbase_util::open_item_sum_func( } DBUG_RETURN(0); } -#endif int spider_db_mbase_util::append_escaped_util( spider_string *to, @@ -6990,7 +6890,6 @@ int spider_db_mbase_util::append_escaped_util( DBUG_RETURN(0); } -#ifdef SPIDER_HAS_GROUP_BY_HANDLER int spider_db_mbase_util::append_table( ha_spider *spider, spider_fields *fields, @@ -7564,7 +7463,6 @@ int spider_db_mbase_util::append_having( str->q_append(SPIDER_SQL_HAVING_STR, SPIDER_SQL_HAVING_LEN); DBUG_RETURN(0); } -#endif bool spider_db_mbase_util::tables_on_different_db_are_joinable() { @@ -7635,9 +7533,7 @@ spider_mbase_share::spider_mbase_share( table_names_str(NULL), db_names_str(NULL), db_table_str(NULL), -#ifdef SPIDER_HAS_HASH_VALUE_TYPE db_table_str_hash_value(NULL), -#endif table_nm_max_length(0), db_nm_max_length(0), column_name_str(NULL), @@ -7724,10 +7620,8 @@ int spider_mbase_share::init() __func__, __FILE__, __LINE__, MYF(MY_WME | MY_ZEROFILL), &key_select_pos, sizeof(int) * keys, -#ifdef SPIDER_HAS_HASH_VALUE_TYPE &db_table_str_hash_value, sizeof(my_hash_value_type) * spider_share->all_link_count, -#endif NullS)) ) { DBUG_RETURN(HA_ERR_OUT_OF_MEM); @@ -8002,10 +7896,8 @@ int spider_mbase_share::create_table_names_str() if ((error_num = append_table_name(str, roop_count))) goto error; } -#ifdef SPIDER_HAS_HASH_VALUE_TYPE db_table_str_hash_value[roop_count] = my_calc_hash( &spider_open_connections, (uchar*) str->ptr(), str->length()); -#endif } DBUG_RETURN(0); @@ -8386,7 +8278,6 @@ bool spider_mbase_share::need_change_db_table_name() DBUG_RETURN(!same_db_table_name); } -#ifdef SPIDER_HAS_DISCOVER_TABLE_STRUCTURE int spider_mbase_share::discover_table_structure( SPIDER_TRX *trx, SPIDER_SHARE *spider_share, @@ -8690,16 +8581,13 @@ int spider_mbase_share::discover_table_structure( } DBUG_RETURN(error_num); } -#endif -#ifdef HA_HAS_CHECKSUM_EXTENDED bool spider_mbase_share::checksum_support() { DBUG_ENTER("spider_mbase_share::checksum_support"); DBUG_PRINT("info",("spider this=%p", this)); DBUG_RETURN(TRUE); } -#endif spider_mbase_handler::spider_mbase_handler( ha_spider *spider, @@ -8851,10 +8739,8 @@ int spider_mbase_handler::init() link_for_hash[roop_count].link_idx = roop_count; link_for_hash[roop_count].db_table_str = &mysql_share->db_table_str[roop_count]; -#ifdef SPIDER_HAS_HASH_VALUE_TYPE link_for_hash[roop_count].db_table_str_hash_value = mysql_share->db_table_str_hash_value[roop_count]; -#endif } DBUG_RETURN(0); } @@ -9154,14 +9040,12 @@ int spider_mbase_handler::append_tmp_table_and_sql_for_bka( SPIDER_SQL_B_DOT_STR, SPIDER_SQL_B_DOT_LEN))) DBUG_RETURN(error_num); } -#ifdef HANDLER_HAS_DIRECT_AGGREGATE else if (spider->result_list.direct_aggregate) { if ((error_num = append_group_by(&sql, SPIDER_SQL_B_DOT_STR, SPIDER_SQL_B_DOT_LEN))) DBUG_RETURN(error_num); } -#endif DBUG_RETURN(0); } @@ -9400,14 +9284,12 @@ int spider_mbase_handler::append_union_table_and_sql_for_bka( ) DBUG_RETURN(error_num); } -#ifdef HANDLER_HAS_DIRECT_AGGREGATE else if (spider->result_list.direct_aggregate) { if ((error_num = append_group_by(&tmp_sql, SPIDER_SQL_B_DOT_STR, SPIDER_SQL_B_DOT_LEN))) DBUG_RETURN(error_num); } -#endif DBUG_RETURN(0); } @@ -9670,11 +9552,7 @@ int spider_mbase_handler::append_insert( spider->wide_handler->ignore_dup_key && spider->direct_dup_insert && !spider->wide_handler->write_can_replace && -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS (!spider->wide_handler->insert_with_update || !dup_update_sql.length()) && -#else - !spider->wide_handler->insert_with_update && -#endif /* for direct_dup_insert without patch for partition */ spider->wide_handler->sql_command != SQLCOM_REPLACE && spider->wide_handler->sql_command != SQLCOM_REPLACE_SELECT @@ -9831,7 +9709,6 @@ int spider_mbase_handler::append_update_set( DBUG_RETURN(0); } -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS int spider_mbase_handler::append_direct_update_set_part() { int error_num; @@ -9908,7 +9785,6 @@ int spider_mbase_handler::append_update_columns( alias, alias_length, dbton_id, FALSE, NULL); DBUG_RETURN(error_num); } -#endif int spider_mbase_handler::append_select_part( ulong sql_type @@ -9958,29 +9834,16 @@ int spider_mbase_handler::append_select( wide_handler->lock_mode < 1) { /* no lock */ -#ifdef SPIDER_SQL_CACHE_IS_IN_LEX LEX *lex = wide_handler->trx->thd->lex; -#else - st_select_lex *select_lex = - &wide_handler->trx->thd->lex->select_lex; -#endif if ( -#ifdef SPIDER_SQL_CACHE_IS_IN_LEX lex->sql_cache == LEX::SQL_CACHE && -#else - select_lex->sql_cache == SELECT_LEX::SQL_CACHE && -#endif (spider->share->query_cache_sync & 1) ) { if (str->reserve(SPIDER_SQL_SQL_CACHE_LEN)) DBUG_RETURN(HA_ERR_OUT_OF_MEM); str->q_append(SPIDER_SQL_SQL_CACHE_STR, SPIDER_SQL_SQL_CACHE_LEN); } else if ( -#ifdef SPIDER_SQL_CACHE_IS_IN_LEX lex->sql_cache == LEX::SQL_NO_CACHE && -#else - select_lex->sql_cache == SELECT_LEX::SQL_NO_CACHE && -#endif (spider->share->query_cache_sync & 2) ) { if (str->reserve(SPIDER_SQL_SQL_NO_CACHE_LEN)) @@ -10033,13 +9896,10 @@ int spider_mbase_handler::append_table_select_part( int spider_mbase_handler::append_table_select( spider_string *str ) { -#ifdef HANDLER_HAS_DIRECT_AGGREGATE st_select_lex *select_lex = NULL; bool sgb = (spider->result_list.direct_aggregate && spider_param_strict_group_by(current_thd, (strict_group_by ? 1 : 0)) == 1); -#endif DBUG_ENTER("spider_mbase_handler::append_table_select"); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE if (sgb) { select_lex = spider_get_select_lex(spider); @@ -10078,13 +9938,10 @@ int spider_mbase_handler::append_table_select( } str->length(str->length() - SPIDER_SQL_COMMA_LEN); } else { -#endif table_name_pos = str->length() + mysql_share->table_select_pos; if (str->append(*(mysql_share->table_select))) DBUG_RETURN(HA_ERR_OUT_OF_MEM); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE } -#endif DBUG_RETURN(0); } @@ -10112,13 +9969,10 @@ int spider_mbase_handler::append_key_select( spider_string *str, uint idx ) { -#ifdef HANDLER_HAS_DIRECT_AGGREGATE st_select_lex *select_lex = NULL; bool sgb = (spider->result_list.direct_aggregate && spider_param_strict_group_by(current_thd, (strict_group_by ? 1 : 0)) == 1); -#endif DBUG_ENTER("spider_mbase_handler::append_key_select"); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE if (sgb) { select_lex = spider_get_select_lex(spider); @@ -10162,13 +10016,10 @@ int spider_mbase_handler::append_key_select( } str->length(str->length() - SPIDER_SQL_COMMA_LEN); } else { -#endif table_name_pos = str->length() + mysql_share->key_select_pos[idx]; if (str->append(mysql_share->key_select[idx])) DBUG_RETURN(HA_ERR_OUT_OF_MEM); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE } -#endif DBUG_RETURN(0); } @@ -10199,13 +10050,10 @@ int spider_mbase_handler::append_minimum_select( Field **field; int field_length; bool appended = FALSE; -#ifdef HANDLER_HAS_DIRECT_AGGREGATE st_select_lex *select_lex = NULL; bool sgb = (spider->result_list.direct_aggregate && spider_param_strict_group_by(current_thd, (strict_group_by ? 1 : 0)) == 1); -#endif DBUG_ENTER("spider_mbase_handler::append_minimum_select"); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE if (sgb) { select_lex = spider_get_select_lex(spider); @@ -10215,7 +10063,6 @@ int spider_mbase_handler::append_minimum_select( select_lex = NULL; } } -#endif minimum_select_bitmap_create(); for (field = table->field; *field; field++) { @@ -10226,7 +10073,6 @@ int spider_mbase_handler::append_minimum_select( */ field_length = mysql_share->column_name_str[(*field)->field_index].length(); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE if (select_lex && !spider_db_check_select_colum_in_group(select_lex, *field)) { @@ -10239,14 +10085,11 @@ int spider_mbase_handler::append_minimum_select( mysql_share->append_column_name(str, (*field)->field_index); str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN); } else { -#endif if (str->reserve(field_length + /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_COMMA_LEN)) DBUG_RETURN(HA_ERR_OUT_OF_MEM); mysql_share->append_column_name(str, (*field)->field_index); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE } -#endif str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); appended = TRUE; } @@ -10269,13 +10112,10 @@ int spider_mbase_handler::append_table_select_with_alias( TABLE *table = spider->get_table(); Field **field; int field_length; -#ifdef HANDLER_HAS_DIRECT_AGGREGATE st_select_lex *select_lex = NULL; bool sgb = (spider->result_list.direct_aggregate && spider_param_strict_group_by(current_thd, (strict_group_by ? 1 : 0)) == 1); -#endif DBUG_ENTER("spider_mbase_handler::append_table_select_with_alias"); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE if (sgb) { select_lex = spider_get_select_lex(spider); @@ -10285,12 +10125,10 @@ int spider_mbase_handler::append_table_select_with_alias( select_lex = NULL; } } -#endif for (field = table->field; *field; field++) { field_length = mysql_share->column_name_str[(*field)->field_index].length(); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE if (select_lex && !spider_db_check_select_colum_in_group(select_lex, *field)) { @@ -10304,15 +10142,12 @@ int spider_mbase_handler::append_table_select_with_alias( mysql_share->append_column_name(str, (*field)->field_index); str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN); } else { -#endif if (str->reserve(alias_length + field_length + /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_COMMA_LEN)) DBUG_RETURN(HA_ERR_OUT_OF_MEM); str->q_append(alias, alias_length); mysql_share->append_column_name(str, (*field)->field_index); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE } -#endif str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); } str->length(str->length() - SPIDER_SQL_COMMA_LEN); @@ -10329,13 +10164,10 @@ int spider_mbase_handler::append_key_select_with_alias( Field *field; uint part_num; int field_length; -#ifdef HANDLER_HAS_DIRECT_AGGREGATE st_select_lex *select_lex = NULL; bool sgb = (spider->result_list.direct_aggregate && spider_param_strict_group_by(current_thd, (strict_group_by ? 1 : 0)) == 1); -#endif DBUG_ENTER("spider_mbase_handler::append_key_select_with_alias"); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE if (sgb) { select_lex = spider_get_select_lex(spider); @@ -10345,13 +10177,11 @@ int spider_mbase_handler::append_key_select_with_alias( select_lex = NULL; } } -#endif for (key_part = key_info->key_part, part_num = 0; part_num < spider_user_defined_key_parts(key_info); key_part++, part_num++) { field = key_part->field; field_length = mysql_share->column_name_str[field->field_index].length(); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE if (select_lex && !spider_db_check_select_colum_in_group(select_lex, field)) { @@ -10365,15 +10195,12 @@ int spider_mbase_handler::append_key_select_with_alias( mysql_share->append_column_name(str, field->field_index); str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN); } else { -#endif if (str->reserve(alias_length + field_length + /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_COMMA_LEN)) DBUG_RETURN(HA_ERR_OUT_OF_MEM); str->q_append(alias, alias_length); mysql_share->append_column_name(str, field->field_index); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE } -#endif str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); } str->length(str->length() - SPIDER_SQL_COMMA_LEN); @@ -10389,13 +10216,10 @@ int spider_mbase_handler::append_minimum_select_with_alias( Field **field; int field_length; bool appended = FALSE; -#ifdef HANDLER_HAS_DIRECT_AGGREGATE st_select_lex *select_lex = NULL; bool sgb = (spider->result_list.direct_aggregate && spider_param_strict_group_by(current_thd, (strict_group_by ? 1 : 0)) == 1); -#endif DBUG_ENTER("spider_mbase_handler::append_minimum_select_with_alias"); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE if (sgb) { select_lex = spider_get_select_lex(spider); @@ -10405,7 +10229,6 @@ int spider_mbase_handler::append_minimum_select_with_alias( select_lex = NULL; } } -#endif minimum_select_bitmap_create(); for (field = table->field; *field; field++) { @@ -10416,7 +10239,6 @@ int spider_mbase_handler::append_minimum_select_with_alias( */ field_length = mysql_share->column_name_str[(*field)->field_index].length(); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE if (select_lex && !spider_db_check_select_colum_in_group(select_lex, *field)) { @@ -10430,15 +10252,12 @@ int spider_mbase_handler::append_minimum_select_with_alias( mysql_share->append_column_name(str, (*field)->field_index); str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN); } else { -#endif if (str->reserve(alias_length + field_length + /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_COMMA_LEN)) DBUG_RETURN(HA_ERR_OUT_OF_MEM); str->q_append(alias, alias_length); mysql_share->append_column_name(str, (*field)->field_index); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE } -#endif str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); appended = TRUE; } @@ -10461,13 +10280,11 @@ int spider_mbase_handler::append_select_columns_with_alias( int error_num; SPIDER_RESULT_LIST *result_list = &spider->result_list; DBUG_ENTER("spider_mbase_handler::append_select_columns_with_alias"); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE if ( result_list->direct_aggregate && (error_num = append_sum_select(str, alias, alias_length)) ) DBUG_RETURN(error_num); -#endif if ((error_num = append_match_select(str, alias, alias_length))) DBUG_RETURN(error_num); if (!spider->select_column_mode) @@ -11011,18 +10828,6 @@ int spider_mbase_handler::append_is_null( key->flag == HA_READ_KEY_EXACT || key->flag == HA_READ_KEY_OR_NEXT ) { -#ifdef SPIDER_HANDLER_SUPPORT_MULTIPLE_KEY_PARTS - if (tgt_final) - { - if (str->reserve(SPIDER_SQL_EQUAL_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_EQUAL_STR, SPIDER_SQL_EQUAL_LEN); - } - str = str_part; - if (str->reserve(SPIDER_SQL_NULL_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_NULL_STR, SPIDER_SQL_NULL_LEN); -#else if (str_part->length() == SPIDER_SQL_OPEN_PAREN_LEN) { if (str->reserve(SPIDER_SQL_EQUAL_LEN)) @@ -11033,29 +10838,7 @@ int spider_mbase_handler::append_is_null( DBUG_RETURN(HA_ERR_OUT_OF_MEM); str->q_append(SPIDER_SQL_NULL_STR, SPIDER_SQL_NULL_LEN); } -#endif } else { -#ifdef SPIDER_HANDLER_SUPPORT_MULTIPLE_KEY_PARTS - if (str_part->length() == SPIDER_SQL_OPEN_PAREN_LEN) - { - str = str_part; - str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN); - ha_next_pos = str->length(); - if (str->reserve(SPIDER_SQL_FIRST_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_FIRST_STR, SPIDER_SQL_FIRST_LEN); - spider->result_list.ha_read_kind = 1; - } else if (tgt_final) - { - if (str->reserve(SPIDER_SQL_GT_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_GT_STR, SPIDER_SQL_GT_LEN); - str = str_part; - if (str->reserve(SPIDER_SQL_NULL_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_NULL_STR, SPIDER_SQL_NULL_LEN); - } -#else if (str_part->length() == SPIDER_SQL_OPEN_PAREN_LEN) { str = str_part; @@ -11067,7 +10850,6 @@ int spider_mbase_handler::append_is_null( str->q_append(SPIDER_SQL_FIRST_STR, SPIDER_SQL_FIRST_LEN); spider->result_list.ha_read_kind = 1; } -#endif } str = str_part2; } @@ -11149,9 +10931,6 @@ int spider_mbase_handler::append_where_terminator( } else { str_part2->length(str_part2->length() - SPIDER_SQL_AND_LEN); -#ifdef SPIDER_HANDLER_SUPPORT_MULTIPLE_KEY_PARTS - str_part->length(str_part->length() - SPIDER_SQL_COMMA_LEN); -#endif if (!result_list->ha_read_kind) str_part->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN); @@ -11627,7 +11406,6 @@ int spider_mbase_handler::append_match_select( DBUG_RETURN(0); } -#ifdef HANDLER_HAS_DIRECT_AGGREGATE int spider_mbase_handler::append_sum_select_part( ulong sql_type, const char *alias, @@ -11674,7 +11452,6 @@ int spider_mbase_handler::append_sum_select( } DBUG_RETURN(0); } -#endif void spider_mbase_handler::set_order_pos( ulong sql_type @@ -11728,7 +11505,6 @@ void spider_mbase_handler::set_order_to_pos( DBUG_VOID_RETURN; } -#ifdef HANDLER_HAS_DIRECT_AGGREGATE int spider_mbase_handler::append_group_by_part( const char *alias, uint alias_length, @@ -11791,7 +11567,6 @@ int spider_mbase_handler::append_group_by( } DBUG_RETURN(0); } -#endif int spider_mbase_handler::append_key_order_for_merge_with_alias_part( const char *alias, @@ -11837,14 +11612,12 @@ int spider_mbase_handler::append_key_order_for_merge_with_alias( uint key_name_length; DBUG_ENTER("spider_mbase_handler::append_key_order_for_merge_with_alias"); DBUG_PRINT("info",("spider this=%p", this)); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE if (spider->result_list.direct_aggregate) { int error_num; if ((error_num = append_group_by(str, alias, alias_length))) DBUG_RETURN(error_num); } -#endif if (table->s->primary_key < MAX_KEY) { /* sort by primary key */ @@ -11953,13 +11726,11 @@ int spider_mbase_handler::append_key_order_for_direct_order_limit_with_alias( longlong offset_limit; DBUG_ENTER("spider_mbase_handler::append_key_order_for_direct_order_limit_with_alias"); DBUG_PRINT("info",("spider this=%p", this)); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE if (spider->result_list.direct_aggregate) { if ((error_num = append_group_by(str, alias, alias_length))) DBUG_RETURN(error_num); } -#endif spider_get_select_limit(spider, &select_lex, &select_limit, &offset_limit); if (select_lex->order_list.first) @@ -12055,14 +11826,12 @@ int spider_mbase_handler::append_key_order_with_alias( uint key_name_length; DBUG_ENTER("spider_mbase_handler::append_key_order_with_alias"); DBUG_PRINT("info",("spider this=%p", this)); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE if (spider->result_list.direct_aggregate) { int error_num; if ((error_num = append_group_by(str, alias, alias_length))) DBUG_RETURN(error_num); } -#endif if (result_list->sorted == TRUE) { if (result_list->desc_flg == TRUE) @@ -13552,11 +13321,7 @@ int spider_mbase_handler::bulk_tmp_table_rnd_next() int error_num; DBUG_ENTER("spider_mbase_handler::bulk_tmp_table_rnd_next"); DBUG_PRINT("info",("spider this=%p", this)); -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 50200 error_num = upd_tmp_tbl->file->ha_rnd_next(upd_tmp_tbl->record[0]); -#else - error_num = upd_tmp_tbl->file->rnd_next(upd_tmp_tbl->record[0]); -#endif if (!error_num) { error_num = restore_sql_from_bulk_tmp_table(&insert_sql, upd_tmp_tbl); @@ -13667,15 +13432,8 @@ int spider_mbase_handler::insert_lock_tables_list( DBUG_PRINT("info",("spider this=%p", this)); uint old_elements = db_conn->lock_table_hash.array.max_element; -#ifdef HASH_UPDATE_WITH_HASH_VALUE - if (my_hash_insert_with_hash_value( - &db_conn->lock_table_hash, - tmp_link_for_hash2->db_table_str_hash_value, - (uchar*) tmp_link_for_hash2)) -#else if (my_hash_insert(&db_conn->lock_table_hash, (uchar*) tmp_link_for_hash2)) -#endif { DBUG_RETURN(HA_ERR_OUT_OF_MEM); } @@ -13706,7 +13464,6 @@ int spider_mbase_handler::append_lock_tables_list( &mysql_share->db_table_str[conn_link_idx]; DBUG_PRINT("info",("spider db_table_str=%s", tmp_link_for_hash2->db_table_str->c_ptr_safe())); -#ifdef SPIDER_HAS_HASH_VALUE_TYPE tmp_link_for_hash2->db_table_str_hash_value = mysql_share->db_table_str_hash_value[conn_link_idx]; if (!(tmp_link_for_hash = (SPIDER_LINK_FOR_HASH *) @@ -13715,12 +13472,6 @@ int spider_mbase_handler::append_lock_tables_list( tmp_link_for_hash2->db_table_str_hash_value, (uchar*) tmp_link_for_hash2->db_table_str->ptr(), tmp_link_for_hash2->db_table_str->length()))) -#else - if (!(tmp_link_for_hash = (SPIDER_LINK_FOR_HASH *) my_hash_search( - &db_conn->lock_table_hash, - (uchar*) tmp_link_for_hash2->db_table_str->ptr(), - tmp_link_for_hash2->db_table_str->length()))) -#endif { if ((error_num = insert_lock_tables_list(conn, link_idx))) DBUG_RETURN(error_num); @@ -13729,26 +13480,12 @@ int spider_mbase_handler::append_lock_tables_list( if (tmp_link_for_hash->spider->wide_handler->lock_type < spider->wide_handler->lock_type) { -#ifdef HASH_UPDATE_WITH_HASH_VALUE - my_hash_delete_with_hash_value( - &db_conn->lock_table_hash, - tmp_link_for_hash->db_table_str_hash_value, - (uchar*) tmp_link_for_hash); -#else my_hash_delete(&db_conn->lock_table_hash, (uchar*) tmp_link_for_hash); -#endif uint old_elements = db_conn->lock_table_hash.array.max_element; -#ifdef HASH_UPDATE_WITH_HASH_VALUE - if (my_hash_insert_with_hash_value( - &db_conn->lock_table_hash, - tmp_link_for_hash2->db_table_str_hash_value, - (uchar*) tmp_link_for_hash2)) -#else if (my_hash_insert(&db_conn->lock_table_hash, (uchar*) tmp_link_for_hash2)) -#endif { DBUG_RETURN(HA_ERR_OUT_OF_MEM); } @@ -13855,7 +13592,6 @@ bool spider_mbase_handler::need_lock_before_set_sql_for_exec( DBUG_RETURN(FALSE); } -#ifdef SPIDER_HAS_GROUP_BY_HANDLER int spider_mbase_handler::set_sql_for_exec( ulong sql_type, int link_idx, @@ -13873,7 +13609,6 @@ int spider_mbase_handler::set_sql_for_exec( } DBUG_RETURN(0); } -#endif int spider_mbase_handler::set_sql_for_exec( ulong sql_type, @@ -14839,7 +14574,6 @@ int spider_mbase_handler::simple_action( DBUG_PRINT("info",("spider simple records")); str = &mysql_share->show_records[pos]; break; -#ifdef HA_HAS_CHECKSUM_EXTENDED case SPIDER_SIMPLE_CHECKSUM_TABLE: DBUG_PRINT("info",("spider simple checksum_table")); str = &spider->result_list.sqls[link_idx]; @@ -14869,7 +14603,6 @@ int spider_mbase_handler::simple_action( SPIDER_SQL_SQL_EXTENDED_LEN); } break; -#endif default: DBUG_ASSERT(0); DBUG_RETURN(0); @@ -14993,12 +14726,10 @@ int spider_mbase_handler::simple_action( DBUG_PRINT("info",("spider simple records")); error_num = res->fetch_table_records(1, spider->table_rows); break; -#ifdef HA_HAS_CHECKSUM_EXTENDED case SPIDER_SIMPLE_CHECKSUM_TABLE: DBUG_PRINT("info",("spider simple checksum_table")); error_num = res->fetch_table_checksum(spider); break; -#endif default: DBUG_ASSERT(0); break; @@ -15028,7 +14759,6 @@ int spider_mbase_handler::show_records( DBUG_RETURN(0); } -#ifdef HA_HAS_CHECKSUM_EXTENDED int spider_mbase_handler::checksum_table( int link_idx ) { @@ -15036,7 +14766,6 @@ int spider_mbase_handler::checksum_table( DBUG_RETURN(simple_action(SPIDER_SIMPLE_CHECKSUM_TABLE, link_idx)); DBUG_RETURN(0); } -#endif int spider_mbase_handler::show_last_insert_id( int link_idx, @@ -15842,11 +15571,7 @@ void spider_mbase_handler::minimum_select_bitmap_create() memset(minimum_select_bitmap, 0, no_bytes_in_map(table->read_set)); if ( spider->use_index_merge || -#ifdef HA_CAN_BULK_ACCESS - (spider->is_clone && !spider->is_bulk_access_clone) -#else spider->is_clone -#endif ) { /* need preparing for cmp_ref */ TABLE_SHARE *table_share = table->s; @@ -16007,7 +15732,6 @@ int spider_mbase_handler::reset_union_table_name( DBUG_RETURN(0); } -#ifdef SPIDER_HAS_GROUP_BY_HANDLER int spider_mbase_handler::append_from_and_tables_part( spider_fields *fields, ulong sql_type @@ -16330,9 +16054,7 @@ int spider_mbase_handler::append_order_by( } DBUG_RETURN(0); } -#endif -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS bool spider_mbase_handler::check_direct_update( st_select_lex *select_lex, longlong select_limit, @@ -16352,7 +16074,6 @@ bool spider_mbase_handler::check_direct_delete( DBUG_PRINT("info",("spider this=%p", this)); DBUG_RETURN(FALSE); } -#endif spider_mbase_copy_table::spider_mbase_copy_table( spider_mbase_share *db_share diff --git a/storage/spider/spd_db_mysql.h b/storage/spider/spd_db_mysql.h index df356a6d23e..59fe1190b42 100644 --- a/storage/spider/spd_db_mysql.h +++ b/storage/spider/spd_db_mysql.h @@ -126,7 +126,6 @@ public: bool use_fields, spider_fields *fields ) override; -#ifdef HANDLER_HAS_DIRECT_AGGREGATE int open_item_sum_func( Item_sum *item_sum, ha_spider *spider, @@ -136,12 +135,10 @@ public: bool use_fields, spider_fields *fields ) override; -#endif int append_escaped_util( spider_string *to, String *from ) override; -#ifdef SPIDER_HAS_GROUP_BY_HANDLER int append_table( ha_spider *spider, spider_fields *fields, @@ -194,7 +191,6 @@ public: int append_having( spider_string *str ) override; -#endif bool tables_on_different_db_are_joinable() override; bool socket_has_default_value() override; bool database_has_default_value() override; @@ -328,11 +324,9 @@ public: int mode, ha_rows &records ); -#ifdef HA_HAS_CHECKSUM_EXTENDED int fetch_table_checksum( ha_spider *spider ); -#endif int fetch_table_cardinality( int mode, TABLE *table, @@ -356,7 +350,6 @@ public: longlong pos ); int get_errno(); -#ifdef SPIDER_HAS_DISCOVER_TABLE_STRUCTURE int fetch_columns_for_discover_table_structure( spider_string *str, CHARSET_INFO *access_charset @@ -370,7 +363,6 @@ public: SPIDER_SHARE *spider_share, CHARSET_INFO *access_charset ); -#endif }; class spider_db_mysql_result: public spider_db_mbase_result @@ -636,9 +628,7 @@ public: spider_string *table_names_str; spider_string *db_names_str; spider_string *db_table_str; -#ifdef SPIDER_HAS_HASH_VALUE_TYPE my_hash_value_type *db_table_str_hash_value; -#endif uint table_nm_max_length; uint db_nm_max_length; spider_string *column_name_str; @@ -678,16 +668,12 @@ public: int *table_name_pos ); bool need_change_db_table_name(); -#ifdef SPIDER_HAS_DISCOVER_TABLE_STRUCTURE int discover_table_structure( SPIDER_TRX *trx, SPIDER_SHARE *spider_share, spider_string *str ); -#endif -#ifdef HA_HAS_CHECKSUM_EXTENDED bool checksum_support(); -#endif protected: int create_table_names_str(); void free_table_names_str(); @@ -874,7 +860,6 @@ public: int append_update_set( spider_string *str ); - #ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS int append_direct_update_set_part(); int append_direct_update_set( spider_string *str @@ -893,7 +878,6 @@ public: const char *alias, uint alias_length ); - #endif int append_select_part( ulong sql_type ); @@ -1090,7 +1074,6 @@ public: const char *alias, uint alias_length ); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE int append_sum_select_part( ulong sql_type, const char *alias, @@ -1101,14 +1084,12 @@ public: const char *alias, uint alias_length ); -#endif void set_order_pos( ulong sql_type ); void set_order_to_pos( ulong sql_type ); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE int append_group_by_part( const char *alias, uint alias_length, @@ -1119,7 +1100,6 @@ public: const char *alias, uint alias_length ); -#endif int append_key_order_for_merge_with_alias_part( const char *alias, uint alias_length, @@ -1403,13 +1383,11 @@ public: bool need_lock_before_set_sql_for_exec( ulong sql_type ); -#ifdef SPIDER_HAS_GROUP_BY_HANDLER int set_sql_for_exec( ulong sql_type, int link_idx, SPIDER_LINK_IDX_CHAIN *link_idx_chain ); -#endif int set_sql_for_exec( ulong sql_type, int link_idx @@ -1447,11 +1425,9 @@ public: int show_records( int link_idx ); -#ifdef HA_HAS_CHECKSUM_EXTENDED int checksum_table( int link_idx ); -#endif int show_last_insert_id( int link_idx, ulonglong &last_insert_id @@ -1530,7 +1506,6 @@ public: int link_idx, ulong sql_type ); -#ifdef SPIDER_HAS_GROUP_BY_HANDLER int append_from_and_tables_part( spider_fields *fields, ulong sql_type @@ -1601,8 +1576,6 @@ public: bool use_fields, spider_fields *fields ); -#endif -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS bool check_direct_update( st_select_lex *select_lex, longlong select_limit, @@ -1613,7 +1586,6 @@ public: longlong select_limit, longlong offset_limit ); -#endif }; class spider_mysql_handler: public spider_mbase_handler diff --git a/storage/spider/spd_db_oracle.cc b/storage/spider/spd_db_oracle.cc deleted file mode 100644 index 3b0854e609d..00000000000 --- a/storage/spider/spd_db_oracle.cc +++ /dev/null @@ -1,13609 +0,0 @@ -/* Copyright (C) 2012-2018 Kentoku Shiba - Copyright (c) 2020, MariaDB Corporation. - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; version 2 of the License. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */ - -#define MYSQL_SERVER 1 -#include <my_global.h> -#include "mysql_version.h" -#include "spd_environ.h" -#if MYSQL_VERSION_ID < 50500 -#include "mysql_priv.h" -#include <mysql/plugin.h> -#else -#include "sql_priv.h" -#include "probes_mysql.h" -#include "sql_partition.h" -#include "sql_analyse.h" -#ifdef HANDLER_HAS_DIRECT_AGGREGATE -#include "sql_select.h" -#endif -#endif - -#ifdef HAVE_ORACLE_OCI -#if (defined(WIN32) || defined(_WIN32) || defined(WINDOWS) || defined(_WINDOWS)) -#include <Shlwapi.h> -#define strcasestr StrStr -#endif -#include <oci.h> -#include "spd_err.h" -#include "spd_param.h" -#include "spd_db_include.h" -#include "spd_include.h" -#include "spd_db_oracle.h" -#include "ha_spider.h" -#include "spd_conn.h" -#include "spd_db_conn.h" -#include "spd_malloc.h" -#include "spd_sys_table.h" -#include "spd_table.h" - -extern struct charset_info_st *spd_charset_utf8mb3_bin; - -extern handlerton *spider_hton_ptr; -extern pthread_mutex_t spider_open_conn_mutex; -extern HASH spider_open_connections; -extern HASH spider_ipport_conns; -extern SPIDER_DBTON spider_dbton[SPIDER_DBTON_SIZE]; -extern const char spider_dig_upper[]; - -#define SPIDER_DB_WRAPPER_ORACLE "oracle" - -#define SPIDER_SQL_NAME_QUOTE_STR "\"" -#define SPIDER_SQL_NAME_QUOTE_LEN (sizeof(SPIDER_SQL_NAME_QUOTE_STR) - 1) -static const char *name_quote_str = SPIDER_SQL_NAME_QUOTE_STR; - -#define SPIDER_SQL_ISO_READ_COMMITTED_STR "set transaction isolation level read committed" -#define SPIDER_SQL_ISO_READ_COMMITTED_LEN sizeof(SPIDER_SQL_ISO_READ_COMMITTED_STR) - 1 -#define SPIDER_SQL_ISO_SERIALIZABLE_STR "set transaction isolation level serializable" -#define SPIDER_SQL_ISO_SERIALIZABLE_LEN sizeof(SPIDER_SQL_ISO_SERIALIZABLE_STR) - 1 - -#define SPIDER_SQL_START_TRANSACTION_STR "set transaction read write" -#define SPIDER_SQL_START_TRANSACTION_LEN sizeof(SPIDER_SQL_START_TRANSACTION_STR) - 1 - -#define SPIDER_SQL_AUTOCOMMIT_OFF_STR "set autocommit off" -#define SPIDER_SQL_AUTOCOMMIT_OFF_LEN sizeof(SPIDER_SQL_AUTOCOMMIT_OFF_STR) - 1 -#define SPIDER_SQL_AUTOCOMMIT_ON_STR "set autocommit on" -#define SPIDER_SQL_AUTOCOMMIT_ON_LEN sizeof(SPIDER_SQL_AUTOCOMMIT_ON_STR) - 1 - -#define SPIDER_SQL_LOCK_TABLE_STR "lock table " -#define SPIDER_SQL_LOCK_TABLE_LEN (sizeof(SPIDER_SQL_LOCK_TABLE_STR) - 1) -#define SPIDER_SQL_UNLOCK_TABLE_STR "unlock tables" -#define SPIDER_SQL_UNLOCK_TABLE_LEN (sizeof(SPIDER_SQL_UNLOCK_TABLE_STR) - 1) -#define SPIDER_SQL_LOCK_TABLE_SHARE_MODE_STR " in share mode" -#define SPIDER_SQL_LOCK_TABLE_SHARE_MODE_LEN (sizeof(SPIDER_SQL_LOCK_TABLE_SHARE_MODE_STR) - 1) -#define SPIDER_SQL_LOCK_TABLE_EXCLUSIVE_MODE_STR " in exclusive mode" -#define SPIDER_SQL_LOCK_TABLE_EXCLUSIVE_MODE_LEN (sizeof(SPIDER_SQL_LOCK_TABLE_EXCLUSIVE_MODE_STR) - 1) - -#define SPIDER_SQL_COMMIT_STR "commit" -#define SPIDER_SQL_COMMIT_LEN sizeof(SPIDER_SQL_COMMIT_STR) - 1 - -#define SPIDER_SQL_SET_NLS_DATE_FORMAT_STR "alter session set nls_date_format='YYYY-MM-DD HH24:MI:SS'" -#define SPIDER_SQL_SET_NLS_DATE_FORMAT_LEN sizeof(SPIDER_SQL_SET_NLS_DATE_FORMAT_STR) - 1 -#define SPIDER_SQL_SET_NLS_TIME_FORMAT_STR "alter session set nls_time_format='HH24:MI:SSXFF'" -#define SPIDER_SQL_SET_NLS_TIME_FORMAT_LEN sizeof(SPIDER_SQL_SET_NLS_TIME_FORMAT_STR) - 1 -#define SPIDER_SQL_SET_NLS_TIMESTAMP_FORMAT_STR "alter session set nls_timestamp_format='YYYY-MM-DD HH24:MI:SSXFF'" -#define SPIDER_SQL_SET_NLS_TIMESTAMP_FORMAT_LEN sizeof(SPIDER_SQL_SET_NLS_TIMESTAMP_FORMAT_STR) - 1 - -#define SPIDER_SQL_SELECT_WRAPPER_HEAD_STR "select * from (" -#define SPIDER_SQL_SELECT_WRAPPER_HEAD_LEN sizeof(SPIDER_SQL_SELECT_WRAPPER_HEAD_STR) - 1 -#define SPIDER_SQL_UPDATE_WRAPPER_HEAD_STR " where rowid in (select rowid from (select rowid, row_number() over (order by " -#define SPIDER_SQL_UPDATE_WRAPPER_HEAD_LEN sizeof(SPIDER_SQL_UPDATE_WRAPPER_HEAD_STR) - 1 -#define SPIDER_SQL_ROW_NUMBER_HEAD_STR ", row_number() over (order by " -#define SPIDER_SQL_ROW_NUMBER_HEAD_LEN sizeof(SPIDER_SQL_ROW_NUMBER_HEAD_STR) - 1 -#define SPIDER_SQL_ROW_NUMBER_TAIL_STR "rowid) row_num" -#define SPIDER_SQL_ROW_NUMBER_TAIL_LEN sizeof(SPIDER_SQL_ROW_NUMBER_TAIL_STR) - 1 -#define SPIDER_SQL_ROW_NUMBER_DESC_TAIL_STR "rowid desc) row_num" -#define SPIDER_SQL_ROW_NUMBER_DESC_TAIL_LEN sizeof(SPIDER_SQL_ROW_NUMBER_DESC_TAIL_STR) - 1 -#define SPIDER_SQL_SELECT_WRAPPER_TAIL_STR ") where row_num " -#define SPIDER_SQL_SELECT_WRAPPER_TAIL_LEN sizeof(SPIDER_SQL_SELECT_WRAPPER_TAIL_STR) - 1 -#define SPIDER_SQL_ROW_NUM_STR "row_num" -#define SPIDER_SQL_ROW_NUM_LEN sizeof(SPIDER_SQL_ROW_NUM_STR) - 1 -#define SPIDER_SQL_ROWNUM_STR "rownum" -#define SPIDER_SQL_ROWNUM_LEN sizeof(SPIDER_SQL_ROWNUM_STR) - 1 -#define SPIDER_SQL_NEXTVAL_STR ".nextval" -#define SPIDER_SQL_NEXTVAL_LEN sizeof(SPIDER_SQL_NEXTVAL_STR) - 1 -#define SPIDER_SQL_CURRVAL_STR ".currval" -#define SPIDER_SQL_CURRVAL_LEN sizeof(SPIDER_SQL_CURRVAL_STR) - 1 -#define SPIDER_SQL_FROM_DUAL_STR " from dual" -#define SPIDER_SQL_FROM_DUAL_LEN sizeof(SPIDER_SQL_FROM_DUAL_STR) - 1 - -#define SPIDER_SQL_SHOW_TABLE_STATUS_STR "show table status from " -#define SPIDER_SQL_SHOW_TABLE_STATUS_LEN sizeof(SPIDER_SQL_SHOW_TABLE_STATUS_STR) - 1 -#define SPIDER_SQL_SELECT_TABLES_STATUS_STR "select `table_rows`,`avg_row_length`,`data_length`,`max_data_length`,`index_length`,`auto_increment`,`create_time`,`update_time`,`check_time` from `information_schema`.`tables` where `table_schema` = " -#define SPIDER_SQL_SELECT_TABLES_STATUS_LEN sizeof(SPIDER_SQL_SELECT_TABLES_STATUS_STR) - 1 - -#define SPIDER_SQL_LIKE_STR " like " -#define SPIDER_SQL_LIKE_LEN (sizeof(SPIDER_SQL_LIKE_STR) - 1) -#define SPIDER_SQL_LIMIT1_STR "rownum = 1" -#define SPIDER_SQL_LIMIT1_LEN (sizeof(SPIDER_SQL_LIMIT1_STR) - 1) - -#define SPIDER_SQL_ADD_MONTHS_STR "add_months" -#define SPIDER_SQL_ADD_MONTHS_LEN (sizeof(SPIDER_SQL_ADD_MONTHS_STR) - 1) - -#define SPIDER_ORACLE_ERR_BUF_LEN 512 - -static uchar SPIDER_SQL_LINESTRING_HEAD_STR[] = - {0x00,0x00,0x00,0x00,0x01,0x02,0x00,0x00,0x00,0x02,0x00,0x00,0x00}; -#define SPIDER_SQL_LINESTRING_HEAD_LEN sizeof(SPIDER_SQL_LINESTRING_HEAD_STR) - -static const char *spider_db_table_lock_str[] = -{ - " in share mode", - " in share mode", - " in exclusive mode", - " in exclusive mode" -}; -static const int spider_db_table_lock_len[] = -{ - sizeof(" in share mode") - 1, - sizeof(" in share mode") - 1, - sizeof(" in exclusive mode") - 1, - sizeof(" in exclusive mode") - 1 -}; - -/* UTC time zone for timestamp columns */ -extern Time_zone *UTC; - -int spider_db_oracle_get_error( - sword res, - dvoid *hndlp, - int error_num, - const char *error1, - const char *error2, - CHARSET_INFO *access_charset, - char *stored_error_msg -) { - sb4 error_code; - char buf[SPIDER_ORACLE_ERR_BUF_LEN]; - char buf2[SPIDER_ORACLE_ERR_BUF_LEN]; - spider_string tmp_str(buf2, SPIDER_ORACLE_ERR_BUF_LEN, system_charset_info); - DBUG_ENTER("spider_db_oracle_get_error"); - tmp_str.init_calc_mem(176); - tmp_str.length(0); - - switch (res) - { - case OCI_SUCCESS: - DBUG_PRINT("info",("spider res=OCI_SUCCESS")); - break; - case OCI_SUCCESS_WITH_INFO: - DBUG_PRINT("info",("spider res=OCI_SUCCESS_WITH_INFO")); - OCIErrorGet(hndlp, 1, NULL, &error_code, (OraText *) buf, sizeof(buf), - OCI_HTYPE_ERROR); - DBUG_PRINT("info",("spider error_code=%d error='%s'",error_code ,buf)); - if (access_charset && access_charset->cset != system_charset_info->cset) - { - tmp_str.append(buf, strlen(buf), access_charset); - } else { - tmp_str.set(buf, strlen(buf), system_charset_info); - } - push_warning_printf(current_thd, SPIDER_WARN_LEVEL_WARN, - ER_SPIDER_ORACLE_NUM, ER_SPIDER_ORACLE_STR, res, error_code, - tmp_str.c_ptr_safe()); - break; - case OCI_NO_DATA: - DBUG_PRINT("info",("spider res=OCI_NO_DATA")); - DBUG_RETURN(HA_ERR_END_OF_FILE); - case OCI_ERROR: - DBUG_PRINT("info",("spider res=OCI_ERROR")); - OCIErrorGet(hndlp, 1, NULL, &error_code, (OraText *) buf, sizeof(buf), - OCI_HTYPE_ERROR); - DBUG_PRINT("info",("spider error_code=%d error='%s'",error_code ,buf)); - if (error_code == 1) - { - DBUG_PRINT("info",("spider found dupp key")); - if (stored_error_msg) - strmov(stored_error_msg, buf); - DBUG_RETURN(HA_ERR_FOUND_DUPP_KEY); - } - if (error_num) - { - if (error1) - { - if (error2) - { - my_printf_error(error_num, error1, MYF(0), error2); - } else { - my_printf_error(error_num, error1, MYF(0)); - } - } else if (error2) { - my_error(error_num, MYF(0), error2); - } else { - my_error(error_num, MYF(0)); - } - } - if (access_charset && access_charset->cset != system_charset_info->cset) - { - tmp_str.append(buf, strlen(buf), access_charset); - } else { - tmp_str.set(buf, strlen(buf), system_charset_info); - } - my_printf_error(ER_SPIDER_ORACLE_NUM, ER_SPIDER_ORACLE_STR, MYF(0), - res, error_code, tmp_str.c_ptr_safe()); - if (error_num) - { - DBUG_RETURN(error_num); - } else { - DBUG_RETURN(ER_SPIDER_ORACLE_NUM); - } - case OCI_INVALID_HANDLE: - case OCI_NEED_DATA: - if (res == OCI_INVALID_HANDLE) - DBUG_PRINT("info",("spider res=OCI_INVALID_HANDLE")); - else - DBUG_PRINT("info",("spider res=OCI_NEED_DATA")); - default: - DBUG_PRINT("info",("spider res=%d", res)); - if (error_num) - { - if (error1) - { - if (error2) - { - my_printf_error(error_num, error1, MYF(0), error2); - } else { - my_printf_error(error_num, error1, MYF(0)); - } - } else if (error2) { - my_error(error_num, MYF(0), error2); - } else { - my_error(error_num, MYF(0)); - } - } - my_printf_error(ER_SPIDER_ORACLE_NUM, ER_SPIDER_ORACLE_STR, MYF(0), - res, 0, ""); - if (error_num) - { - DBUG_RETURN(error_num); - } else { - DBUG_RETURN(ER_SPIDER_ORACLE_NUM); - } - } - DBUG_RETURN(0); -} - -int spider_oracle_init() -{ - DBUG_ENTER("spider_oracle_init"); - DBUG_RETURN(0); -} - -int spider_oracle_deinit() -{ - DBUG_ENTER("spider_oracle_deinit"); - DBUG_RETURN(0); -} - -spider_db_share *spider_oracle_create_share( - SPIDER_SHARE *share -) { - DBUG_ENTER("spider_oracle_create_share"); - DBUG_RETURN(new spider_oracle_share(share)); -} - -spider_db_handler *spider_oracle_create_handler( - ha_spider *spider, - spider_db_share *db_share -) { - DBUG_ENTER("spider_oracle_create_handler"); - DBUG_RETURN(new spider_oracle_handler(spider, - (spider_oracle_share *) db_share)); -} - -spider_db_copy_table *spider_oracle_create_copy_table( - spider_db_share *db_share -) { - DBUG_ENTER("spider_oracle_create_copy_table"); - DBUG_RETURN(new spider_oracle_copy_table( - (spider_oracle_share *) db_share)); -} - -SPIDER_DB_CONN *spider_oracle_create_conn( - SPIDER_CONN *conn -) { - DBUG_ENTER("spider_oracle_create_conn"); - DBUG_RETURN(new spider_db_oracle(conn)); -} - -bool spider_oracle_support_direct_join( -) { - DBUG_ENTER("spider_oracle_support_direct_join"); - DBUG_RETURN(FALSE); -} - -spider_db_oracle_util spider_db_oracle_utility; - -SPIDER_DBTON spider_dbton_oracle = { - 0, - SPIDER_DB_WRAPPER_ORACLE, - SPIDER_DB_ACCESS_TYPE_SQL, - spider_oracle_init, - spider_oracle_deinit, - spider_oracle_create_share, - spider_oracle_create_handler, - spider_oracle_create_copy_table, - spider_oracle_create_conn, - spider_oracle_support_direct_join, - &spider_db_oracle_utility, - "For communicating Oracle using native protocol", - "1.0.0", - SPIDER_MATURITY_BETA -}; - -spider_db_oracle_row::spider_db_oracle_row() : - spider_db_row(spider_dbton_oracle.dbton_id), - db_conn(NULL), result(NULL), - ind(NULL), val(NULL), rlen(NULL), ind_first(NULL), val_first(NULL), - rlen_first(NULL), val_str(NULL), val_str_first(NULL), defnp(NULL), - lobhp(NULL), colhp(NULL), coltp(NULL), colsz(NULL), field_count(0), - row_size(NULL), row_size_first(NULL), access_charset(NULL), cloned(FALSE) -{ - DBUG_ENTER("spider_db_oracle_row::spider_db_oracle_row"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_VOID_RETURN; -} - -spider_db_oracle_row::~spider_db_oracle_row() -{ - DBUG_ENTER("spider_db_oracle_row::~spider_db_oracle_row"); - DBUG_PRINT("info",("spider this=%p", this)); - deinit(); - DBUG_VOID_RETURN; -} - -int spider_db_oracle_row::store_to_field( - Field *field, - CHARSET_INFO *access_charset -) { - DBUG_ENTER("spider_db_oracle_row::store_to_field"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_PRINT("info",("spider ind=%d", *ind)); - if (*ind == -1) - { - DBUG_PRINT("info", ("spider field is null")); - field->set_null(); - field->reset(); - } else { - DBUG_PRINT("info", ("spider field->type()=%u", field->type())); - field->set_notnull(); - if (field->type() == MYSQL_TYPE_YEAR) - { - field->store(val_str->ptr(), 4, - field->table->s->table_charset); - } else if (field->type() == MYSQL_TYPE_DATE) - { - field->store(val_str->ptr(), 10, - field->table->s->table_charset); - } else if (field->type() == MYSQL_TYPE_TIME) - { - field->store(val_str->ptr() + 11, 8, - field->table->s->table_charset); - } else { - DBUG_PRINT("info", ("spider val_str->length()=%u", val_str->length())); - if (field->flags & BLOB_FLAG) - { - DBUG_PRINT("info", ("spider blob field")); - ((Field_blob *)field)->set_ptr( - val_str->length(), (uchar *) val_str->ptr()); - } else { - field->store(val_str->ptr(), val_str->length(), - field->table->s->table_charset); - } - } - } - DBUG_RETURN(0); -} - -int spider_db_oracle_row::append_to_str( - spider_string *str -) { - DBUG_ENTER("spider_db_oracle_row::append_to_str"); - DBUG_PRINT("info",("spider this=%p", this)); - if (str->reserve(val_str->length())) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(val_str->ptr(), val_str->length()); - DBUG_RETURN(0); -} - -int spider_db_oracle_row::append_escaped_to_str( - spider_string *str, - uint dbton_id -) { - DBUG_ENTER("spider_db_oracle_row::append_escaped_to_str"); - DBUG_PRINT("info",("spider this=%p", this)); -/* - spider_string tmp_str(*val, *rlen, str->charset()); - tmp_str.init_calc_mem(174); - tmp_str.length(*rlen); -#ifndef DBUG_OFF - tmp_str.c_ptr_safe(); -#endif - if (str->reserve(*rlen * 2)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - util.append_escaped(str, tmp_str.get_str()); -*/ - if (str->reserve(val_str->length() * 2)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - spider_dbton[dbton_id].db_util->append_escaped_util(str, val_str->get_str()); - DBUG_RETURN(0); -} - -void spider_db_oracle_row::first() -{ - DBUG_ENTER("spider_db_oracle_row::first"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_PRINT("info",("spider ind_first=%p", ind_first)); - ind = ind_first; - DBUG_PRINT("info",("spider val_first=%p", val_first)); - val = val_first; - DBUG_PRINT("info",("spider rlen_first=%p", rlen_first)); - rlen = rlen_first; - DBUG_PRINT("info",("spider row_size_first=%p", row_size_first)); - row_size = row_size_first; - DBUG_PRINT("info",("spider val_str_first=%p", val_str_first)); - val_str = val_str_first; - DBUG_VOID_RETURN; -} - -void spider_db_oracle_row::next() -{ - DBUG_ENTER("spider_db_oracle_row::next"); - DBUG_PRINT("info",("spider this=%p", this)); - ind++; - val++; - rlen++; - row_size++; - val_str++; - DBUG_VOID_RETURN; -} - -bool spider_db_oracle_row::is_null() -{ - DBUG_ENTER("spider_db_oracle_row::is_null"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN((*ind == -1)); -} - -int spider_db_oracle_row::val_int() -{ - DBUG_ENTER("spider_db_oracle_row::val_int"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN((*ind != -1) ? atoi(*val) : 0); -} - -double spider_db_oracle_row::val_real() -{ - DBUG_ENTER("spider_db_oracle_row::val_real"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN((*ind != -1) ? my_atof(*val) : 0.0); -} - -my_decimal *spider_db_oracle_row::val_decimal( - my_decimal *decimal_value, - CHARSET_INFO *access_charset -) { - DBUG_ENTER("spider_db_oracle_row::val_decimal"); - DBUG_PRINT("info",("spider this=%p", this)); - if (*ind == -1) - DBUG_RETURN(NULL); - -#ifdef SPIDER_HAS_DECIMAL_OPERATION_RESULTS_VALUE_TYPE - decimal_operation_results(str2my_decimal(0, *val, *rlen, access_charset, - decimal_value), "", ""); -#else - decimal_operation_results(str2my_decimal(0, *val, *rlen, access_charset, - decimal_value)); -#endif - - DBUG_RETURN(decimal_value); -} - -SPIDER_DB_ROW *spider_db_oracle_row::clone() -{ - uint i; - spider_db_oracle_row *clone_row; - DBUG_ENTER("spider_db_oracle_row::clone"); - DBUG_PRINT("info",("spider this=%p", this)); - if (!(clone_row = new spider_db_oracle_row(dbton_id))) - { - DBUG_RETURN(NULL); - } - clone_row->db_conn = db_conn; - clone_row->result = result; - clone_row->field_count = field_count; - clone_row->record_size = record_size; - clone_row->access_charset = access_charset; - clone_row->cloned = TRUE; - if (clone_row->init()) - { - delete clone_row; - DBUG_RETURN(NULL); - } - memcpy(clone_row->ind, ind_first, sizeof(ub2) * field_count * 4 + - sizeof(ulong) * field_count); - for (i = 0; i < field_count; i++) - { - if (clone_row->val_str[i].copy(val_str_first[i])) - { - delete clone_row; - DBUG_RETURN(NULL); - } - } - DBUG_RETURN((SPIDER_DB_ROW *) clone_row); -} - -int spider_db_oracle_row::store_to_tmp_table( - TABLE *tmp_table, - spider_string *str -) { - uint i; - DBUG_ENTER("spider_db_oracle_row::store_to_tmp_table"); - DBUG_PRINT("info",("spider this=%p", this)); - str->length(0); - for (i = 0; i < field_count; i++) - { - if (row_size_first[i]) - { - if (str->reserve(val_str_first[i].length())) - { - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - str->q_append(val_str_first[i].ptr(), val_str_first[i].length()); - } - } - tmp_table->field[0]->set_notnull(); - tmp_table->field[0]->store( - (const char *) row_size_first, - sizeof(ulong) * field_count, &my_charset_bin); - tmp_table->field[1]->set_notnull(); - tmp_table->field[1]->store( - str->ptr(), str->length(), &my_charset_bin); - tmp_table->field[2]->set_notnull(); - tmp_table->field[2]->store( - (char *) ind_first, (uint) (sizeof(sb2) * field_count), &my_charset_bin); - DBUG_RETURN(tmp_table->file->ha_write_row(tmp_table->record[0])); -} - -uint spider_db_oracle_row::get_byte_size() -{ - DBUG_ENTER("spider_db_oracle_row::get_byte_size"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(record_size); -} - -int spider_db_oracle_row::init() -{ - char *tmp_val; - uint i; - DBUG_ENTER("spider_db_oracle_row::init"); - DBUG_PRINT("info",("spider this=%p", this)); - if ( - !(ind = (sb2 *) - spider_bulk_malloc(spider_current_trx, 161, MYF(MY_WME | MY_ZEROFILL), - &ind, (uint) (sizeof(sb2) * field_count), - &rlen, (uint) (sizeof(ub2) * field_count), - &coltp, (uint) (sizeof(ub2) * field_count), - &colsz, (uint) (sizeof(ub2) * field_count), - &row_size, (uint) (sizeof(ulong) * field_count), - &val, (uint) (sizeof(char *) * field_count), - &tmp_val, (uint) (MAX_FIELD_WIDTH * field_count), - &defnp, (uint) (sizeof(OCIDefine *) * field_count), - &lobhp, (uint) (sizeof(OCILobLocator *) * field_count), - &colhp, (uint) (sizeof(OCIParam *) * field_count), - NullS) - ) || - !(val_str = new spider_string[field_count]) - ) { - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - ind_first = ind; - val_first = val; - rlen_first = rlen; - row_size_first = row_size; - val_str_first = val_str; - for (i = 0; i < field_count; i++) - { - val[i] = tmp_val; - val_str[i].init_calc_mem(177); - val_str[i].set(tmp_val, MAX_FIELD_WIDTH, access_charset); - tmp_val += MAX_FIELD_WIDTH; - } - DBUG_RETURN(0); -} - -void spider_db_oracle_row::deinit() -{ - uint i; - DBUG_ENTER("spider_db_oracle_row::deinit"); - DBUG_PRINT("info",("spider this=%p", this)); - if (!cloned) - { - for (i = 0; i < field_count; i++) - { - if (defnp && defnp[i]) - { - OCIHandleFree(defnp[i], OCI_HTYPE_DEFINE); - defnp[i] = NULL; - } - if (lobhp && lobhp[i]) - { - OCIDescriptorFree(lobhp[i], OCI_DTYPE_LOB); - lobhp[i] = NULL; - } - } - } - if (val_str_first) - { - delete [] val_str_first; - val_str_first = NULL; - } - if (ind_first) - { - spider_free(spider_current_trx, ind_first, MYF(0)); - ind_first = NULL; - } - DBUG_VOID_RETURN; -} - -int spider_db_oracle_row::define() -{ - sword res; - uint i; - DBUG_ENTER("spider_db_oracle_row::define"); - DBUG_PRINT("info",("spider this=%p", this)); - for (i = 0; i < field_count; i++) - { - if (coltp[i] == SQLT_BLOB) - { - res = OCIDescriptorAlloc(db_conn->envhp, (dvoid **) &lobhp[i], - OCI_DTYPE_LOB, 0, 0); - if (res != OCI_SUCCESS) - { - DBUG_RETURN( - spider_db_oracle_get_error(res, db_conn->errhp, 0, NULL, NULL, - access_charset, NULL)); - } - res = OCIDefineByPos(result->stmtp, &defnp[i], db_conn->errhp, i + 1, - &lobhp[i], 0, SQLT_BLOB, &ind[i], &rlen[i], NULL, - OCI_DEFAULT); - } else if (coltp[i] == SQLT_DAT) - { - res = OCIDefineByPos(result->stmtp, &defnp[i], db_conn->errhp, i + 1, - (char *) val_str[i].ptr() + 20, sizeof(ub1) * 7, SQLT_DAT, &ind[i], - &rlen[i], NULL, OCI_DEFAULT); - } else { - if (val_str[i].alloc(colsz[i])) - { - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - res = OCIDefineByPos(result->stmtp, &defnp[i], db_conn->errhp, i + 1, - (char *) val_str[i].ptr(), colsz[i], SQLT_CHR, &ind[i], &rlen[i], NULL, - OCI_DEFAULT); - } - if (res != OCI_SUCCESS) - { - DBUG_RETURN( - spider_db_oracle_get_error(res, db_conn->errhp, 0, NULL, NULL, - access_charset, NULL)); - } - } - DBUG_RETURN(0); -} - -int spider_db_oracle_row::fetch() -{ - sword res; - uint i; - DBUG_ENTER("spider_db_oracle_row::fetch"); - DBUG_PRINT("info",("spider this=%p", this)); - record_size = 0; - for (i = 0; i < field_count; i++) - { - if (ind[i] == -1) - { - DBUG_PRINT("info",("spider NULL")); - val_str[i].length(0); - } else { - if (coltp[i] == SQLT_BLOB) - { - DBUG_PRINT("info",("spider SQLT_BLOB")); - oraub8 len; - res = OCILobGetLength2(db_conn->svchp, db_conn->errhp, lobhp[i], &len); - if (res != OCI_SUCCESS) - { - DBUG_RETURN( - spider_db_oracle_get_error(res, db_conn->errhp, 0, NULL, NULL, - access_charset, NULL)); - } -#ifndef DBUG_OFF - { - ulonglong print_len = len; - DBUG_PRINT("info",("spider len=%llu", print_len)); - } -#endif - if (val_str[i].alloc(len)) - { - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - res = OCILobRead2(db_conn->svchp, db_conn->errhp, lobhp[i], &len, - NULL, 1, (char *) val_str[i].ptr(), len, OCI_ONE_PIECE, NULL, NULL, - 0, 0); - if (res != OCI_SUCCESS) - { - DBUG_RETURN( - spider_db_oracle_get_error(res, db_conn->errhp, 0, NULL, NULL, - access_charset, NULL)); - } -#ifndef DBUG_OFF - { - ulonglong print_len = len; - DBUG_PRINT("info",("spider lenb=%llu", print_len)); - } -#endif - val_str[i].length(len); - } else if (coltp[i] == SQLT_DAT) - { - DBUG_PRINT("info",("spider SQLT_DAT")); - char *val = (char *) val_str[i].ptr(); - ub1 *src = (ub1 *) val + 20; - val_str[i].length(19); - if (src[0] < 100) - my_sprintf(val, (val, "0000-00-00 00:00:00")); - else - my_sprintf(val, (val, "%02u%02u-%02u-%02u %02u:%02u:%02u", - src[0] - 100, src[1] - 100, src[2], src[3], - src[4] - 1, src[5] - 1, src[6] - 1)); - } else { - val_str[i].length(rlen[i]); - } - } - row_size[i] = val_str[i].length(); - record_size += row_size[i]; - } - DBUG_RETURN(0); -} - -spider_db_oracle_result::spider_db_oracle_result(SPIDER_DB_CONN *in_db_conn) : - spider_db_result(in_db_conn), - db_conn(NULL), stmtp(NULL), field_count(0), access_charset(NULL), - fetched(FALSE), row(in_db_conn->dbton_id) -{ - DBUG_ENTER("spider_db_oracle_result::spider_db_oracle_result"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_VOID_RETURN; -} - -spider_db_oracle_result::~spider_db_oracle_result() -{ - DBUG_ENTER("spider_db_oracle_result::~spider_db_oracle_result"); - DBUG_PRINT("info",("spider this=%p", this)); - free_result(); - DBUG_VOID_RETURN; -} - -bool spider_db_oracle_result::has_result() -{ - DBUG_ENTER("spider_db_oracle_result::has_result"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(stmtp); -} - -void spider_db_oracle_result::free_result() -{ - DBUG_ENTER("spider_db_oracle_result::free_result"); - DBUG_PRINT("info",("spider this=%p", this)); - if (stmtp) - { - OCIHandleFree(stmtp, OCI_HTYPE_STMT); - stmtp = NULL; - } - DBUG_VOID_RETURN; -} - -SPIDER_DB_ROW *spider_db_oracle_result::current_row() -{ - DBUG_ENTER("spider_db_oracle_result::current_row"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN((SPIDER_DB_ROW *) row.clone()); -} - -SPIDER_DB_ROW *spider_db_oracle_result::fetch_row() -{ - sword res; - DBUG_ENTER("spider_db_oracle_result::fetch_row"); - DBUG_PRINT("info",("spider this=%p", this)); - row.ind = row.ind_first; - row.val = row.val_first; - row.rlen = row.rlen_first; - row.row_size = row.row_size_first; - row.val_str = row.val_str_first; - if (fetched) - { - /* already fetched */ - fetched = FALSE; - } else { - res = OCIStmtFetch2(stmtp, db_conn->errhp, 1, OCI_FETCH_NEXT, 0, - OCI_DEFAULT); - if (res != OCI_SUCCESS) - { - store_error_num = spider_db_oracle_get_error(res, db_conn->errhp, 0, - NULL, NULL, access_charset, NULL); - DBUG_RETURN(NULL); - } - } - if ((store_error_num = row.fetch())) - { - DBUG_RETURN(NULL); - } - DBUG_RETURN((SPIDER_DB_ROW *) &row); -} - -SPIDER_DB_ROW *spider_db_oracle_result::fetch_row_from_result_buffer( - spider_db_result_buffer *spider_res_buf -) { - sword res; - DBUG_ENTER("spider_db_oracle_result::fetch_row_from_result_buffer"); - DBUG_PRINT("info",("spider this=%p", this)); - row.ind = row.ind_first; - row.val = row.val_first; - row.rlen = row.rlen_first; - row.row_size = row.row_size_first; - row.val_str = row.val_str_first; - if (fetched) - { - /* already fetched */ - fetched = FALSE; - } else { - res = OCIStmtFetch2(stmtp, db_conn->errhp, 1, OCI_FETCH_NEXT, 0, - OCI_DEFAULT); - if (res != OCI_SUCCESS) - { - store_error_num = spider_db_oracle_get_error(res, db_conn->errhp, 0, - NULL, NULL, access_charset, NULL); - DBUG_RETURN(NULL); - } - } - if ((store_error_num = row.fetch())) - { - DBUG_RETURN(NULL); - } - DBUG_RETURN((SPIDER_DB_ROW *) &row); -} - -SPIDER_DB_ROW *spider_db_oracle_result::fetch_row_from_tmp_table( - TABLE *tmp_table -) { - uint i; - const char *str; - spider_string tmp_str1, tmp_str2, tmp_str3; - DBUG_ENTER("spider_db_oracle_result::fetch_row_from_tmp_table"); - DBUG_PRINT("info",("spider this=%p", this)); - tmp_str1.init_calc_mem(175); - tmp_str2.init_calc_mem(178); - tmp_str3.init_calc_mem(179); - tmp_table->field[0]->val_str(tmp_str1.get_str()); - tmp_table->field[1]->val_str(tmp_str2.get_str()); - tmp_table->field[2]->val_str(tmp_str3.get_str()); - tmp_str1.mem_calc(); - tmp_str2.mem_calc(); - tmp_str3.mem_calc(); - row.ind = row.ind_first; - row.val = row.val_first; - row.rlen = row.rlen_first; - row.row_size = row.row_size_first; - row.val_str = row.val_str_first; - DBUG_PRINT("info",("spider tmp_str1.length()=%u", tmp_str1.length())); - DBUG_PRINT("info",("spider tmp_str2.length()=%u", tmp_str2.length())); - DBUG_PRINT("info",("spider tmp_str3.length()=%u", tmp_str3.length())); - memcpy(row.ind, tmp_str3.ptr(), tmp_str3.length()); - memcpy(row.row_size, tmp_str1.ptr(), tmp_str1.length()); - row.field_count = tmp_str1.length() / sizeof(ulong); - str = tmp_str2.ptr(); - for (i = 0; i < row.field_count; i++) - { - row.val_str[i].length(0); - if (row.row_size[i]) - { - if (row.val_str[i].reserve(row.row_size[i])) - { - store_error_num = HA_ERR_OUT_OF_MEM; - DBUG_RETURN(NULL); - } - row.val_str[i].q_append(str, row.row_size[i]); - str += row.row_size[i]; - } - } - row.record_size = tmp_str2.length(); - DBUG_RETURN((SPIDER_DB_ROW *) &row); -} - -int spider_db_oracle_result::fetch_table_status( - int mode, - ha_statistics &stat -) { - DBUG_ENTER("spider_db_oracle_result::fetch_table_status"); - DBUG_PRINT("info",("spider this=%p", this)); - /* TODO: develop later */ - stat.records = 2; - stat.mean_rec_length = 65535; - stat.data_file_length = 65535; - stat.max_data_file_length = 65535; - stat.index_file_length = 65535; -/* - auto_increment_value = 0; -*/ - stat.create_time = (time_t) 0; - stat.update_time = (time_t) 0; - stat.check_time = (time_t) 0; - DBUG_RETURN(0); -} - -int spider_db_oracle_result::fetch_table_records( - int mode, - ha_rows &records -) { - DBUG_ENTER("spider_db_oracle_result::fetch_table_records"); - DBUG_PRINT("info",("spider this=%p", this)); - if (!fetch_row()) - { - records = 0; - } else { - records = row.val_int(); - } - DBUG_RETURN(0); -} - -int spider_db_oracle_result::fetch_table_cardinality( - int mode, - TABLE *table, - longlong *cardinality, - uchar *cardinality_upd, - int bitmap_size -) { - DBUG_ENTER("spider_db_oracle_result::fetch_table_cardinality"); - DBUG_PRINT("info",("spider this=%p", this)); - /* TODO: develop later */ - DBUG_RETURN(0); -} - -int spider_db_oracle_result::fetch_table_mon_status( - int &status -) { - DBUG_ENTER("spider_db_oracle_result::fetch_table_mon_status"); - DBUG_PRINT("info",("spider this=%p", this)); - /* TODO: develop later */ - status = SPIDER_LINK_MON_OK; - DBUG_RETURN(0); -} - -longlong spider_db_oracle_result::num_rows() -{ - sword res; - ub4 rowcnt; - DBUG_ENTER("spider_db_oracle_result::num_rows"); - DBUG_PRINT("info",("spider this=%p", this)); - res = OCIAttrGet(stmtp, OCI_HTYPE_STMT, &rowcnt, 0, - OCI_ATTR_ROW_COUNT, db_conn->errhp); - if (res != OCI_SUCCESS) - { - spider_db_oracle_get_error(res, db_conn->errhp, 0, NULL, NULL, - access_charset, NULL); - DBUG_RETURN(0); - } - DBUG_PRINT("info",("spider rowcnt=%u", rowcnt)); - DBUG_RETURN((longlong) rowcnt); -} - -uint spider_db_oracle_result::num_fields() -{ - sword res; - ub4 parmcnt; - DBUG_ENTER("spider_db_oracle_result::num_fields"); - DBUG_PRINT("info",("spider this=%p", this)); - res = OCIAttrGet(stmtp, OCI_HTYPE_STMT, &parmcnt, 0, - OCI_ATTR_PARAM_COUNT, db_conn->errhp); - if (res != OCI_SUCCESS) - { - spider_db_oracle_get_error(res, db_conn->errhp, 0, NULL, NULL, - access_charset, NULL); - DBUG_RETURN(0); - } - DBUG_RETURN((uint) parmcnt); -} - -void spider_db_oracle_result::move_to_pos( - longlong pos -) { - sword res; - DBUG_ENTER("spider_db_oracle_result::move_to_pos"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_PRINT("info",("spider pos=%lld", pos)); - res = OCIStmtFetch2(stmtp, db_conn->errhp, 1, OCI_FETCH_ABSOLUTE, pos, - OCI_DEFAULT); - if (res != OCI_SUCCESS) - { - spider_db_oracle_get_error(res, db_conn->errhp, 0, NULL, NULL, - access_charset, NULL); - } - DBUG_VOID_RETURN; -} - -int spider_db_oracle_result::set_column_info() -{ - sword res; - uint i; - DBUG_ENTER("spider_db_oracle_result::set_column_info"); - DBUG_PRINT("info",("spider this=%p", this)); - for (i = 0; i < field_count; i++) - { - res = OCIParamGet(stmtp, OCI_HTYPE_STMT, db_conn->errhp, - (dvoid **) &row.colhp[i], i + 1); - if (res != OCI_SUCCESS) - { - DBUG_RETURN(spider_db_oracle_get_error(res, db_conn->errhp, 0, NULL, - NULL, access_charset, NULL)); - } - res = OCIAttrGet(row.colhp[i], OCI_DTYPE_PARAM, &row.coltp[i], NULL, - OCI_ATTR_DATA_TYPE, db_conn->errhp); - if (res != OCI_SUCCESS) - { - DBUG_RETURN(spider_db_oracle_get_error(res, db_conn->errhp, 0, NULL, - NULL, access_charset, NULL)); - } - res = OCIAttrGet(row.colhp[i], OCI_DTYPE_PARAM, &row.colsz[i], NULL, - OCI_ATTR_DATA_SIZE, db_conn->errhp); - if (res != OCI_SUCCESS) - { - DBUG_RETURN(spider_db_oracle_get_error(res, db_conn->errhp, 0, NULL, - NULL, access_charset, NULL)); - } - } - DBUG_RETURN(0); -} - -int spider_db_oracle_result::get_errno() -{ - DBUG_ENTER("spider_db_oracle_result::get_errno"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_PRINT("info",("spider store_error_num=%d", store_error_num)); - DBUG_RETURN(store_error_num); -} - -#ifdef SPIDER_HAS_DISCOVER_TABLE_STRUCTURE -int spider_db_oracle_result::fetch_columns_for_discover_table_structure( - spider_string *str, - CHARSET_INFO *access_charset -) { - DBUG_ENTER("spider_db_oracle_result::fetch_columns_for_discover_table_structure"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(HA_ERR_WRONG_COMMAND); -} - -int spider_db_oracle_result::fetch_index_for_discover_table_structure( - spider_string *str, - CHARSET_INFO *access_charset -) { - DBUG_ENTER("spider_db_oracle_result::fetch_index_for_discover_table_structure"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(HA_ERR_WRONG_COMMAND); -} - -int spider_db_oracle_result::fetch_table_for_discover_table_structure( - spider_string *str, - SPIDER_SHARE *spider_share, - CHARSET_INFO *access_charset -) { - DBUG_ENTER("spider_db_oracle_result::fetch_table_for_discover_table_structure"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(HA_ERR_WRONG_COMMAND); -} -#endif - -spider_db_oracle::spider_db_oracle( - SPIDER_CONN *conn -) : spider_db_conn(conn), envhp(NULL), errhp(NULL), srvhp(NULL), svchp(NULL), - usrhp(NULL), stmtp(NULL), txnhp(NULL), result(NULL), table_lock_mode(0), - lock_table_hash_inited(FALSE), handler_open_array_inited(FALSE) -{ - DBUG_ENTER("spider_db_oracle::spider_db_oracle"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_VOID_RETURN; -} - -spider_db_oracle::~spider_db_oracle() -{ - DBUG_ENTER("spider_db_oracle::~spider_db_oracle"); - DBUG_PRINT("info",("spider this=%p", this)); - if (handler_open_array_inited) - { - reset_opened_handler(); - spider_free_mem_calc(spider_current_trx, - handler_open_array_id, - handler_open_array.max_element * - handler_open_array.size_of_element); - delete_dynamic(&handler_open_array); - } - if (lock_table_hash_inited) - { - spider_free_mem_calc(spider_current_trx, - lock_table_hash_id, - lock_table_hash.array.max_element * - lock_table_hash.array.size_of_element); - my_hash_free(&lock_table_hash); - } - disconnect(); - DBUG_VOID_RETURN; -} - -int spider_db_oracle::init() -{ - DBUG_ENTER("spider_db_oracle::init"); - DBUG_PRINT("info",("spider this=%p", this)); - if ( - my_hash_init(&lock_table_hash, spd_charset_utf8mb3_bin, 32, 0, 0, - (my_hash_get_key) spider_link_get_key, 0, 0) - ) { - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - spider_alloc_calc_mem_init(lock_table_hash, 199); - spider_alloc_calc_mem(spider_current_trx, - lock_table_hash, - lock_table_hash.array.max_element * - lock_table_hash.array.size_of_element); - lock_table_hash_inited = TRUE; - - if ( - SPD_INIT_DYNAMIC_ARRAY2(&handler_open_array, - sizeof(SPIDER_LINK_FOR_HASH *), NULL, 16, 16, MYF(MY_WME)) - ) { - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - spider_alloc_calc_mem_init(handler_open_array, 164); - spider_alloc_calc_mem(spider_current_trx, - handler_open_array, - handler_open_array.max_element * - handler_open_array.size_of_element); - handler_open_array_inited = TRUE; - DBUG_RETURN(0); -} - -bool spider_db_oracle::is_connected() -{ - DBUG_ENTER("spider_db_oracle::is_connected"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(svchp); -} - -void spider_db_oracle::bg_connect() -{ - sword res; - DBUG_ENTER("spider_db_oracle::bg_connect"); - DBUG_PRINT("info",("spider this=%p", this)); - res = OCIEnvNlsCreate(&envhp, OCI_DEFAULT, 0, 0, 0, 0, 0, 0, 0, 0); -/* - res = OCIEnvCreate(&envhp, OCI_THREADED, 0, 0, 0, 0, 0, 0); -*/ - if (res != OCI_SUCCESS) - { - DBUG_PRINT("info",("spider create environment error")); - stored_error_num = set_error(res, errhp, 0, NULL, NULL); - goto error; - } - DBUG_PRINT("info",("spider OCI init envhp=%p", envhp)); - - res = OCIHandleAlloc(envhp, (dvoid **) &errhp, OCI_HTYPE_ERROR, 0, 0); - if (res != OCI_SUCCESS) - { - DBUG_PRINT("info",("spider create error handler error")); - stored_error_num = set_error(res, errhp, 0, NULL, NULL); - bg_disconnect(); - goto error; - } - DBUG_PRINT("info",("spider OCI init errhp=%p", errhp)); - - res = OCIHandleAlloc(envhp, (dvoid **) &srvhp, OCI_HTYPE_SERVER, 0, 0); - if (res != OCI_SUCCESS) - { - DBUG_PRINT("info",("spider create server handler error")); - stored_error_num = set_error(res, errhp, 0, NULL, NULL); - bg_disconnect(); - goto error; - } - DBUG_PRINT("info",("spider OCI init srvhp=%p", srvhp)); - - res = OCIServerAttach(srvhp, errhp, (OraText *) tgt_host, strlen(tgt_host), - OCI_DEFAULT); - if (res != OCI_SUCCESS) - { - DBUG_PRINT("info",("spider attach server error")); - stored_error_num = set_error(res, errhp, 0, NULL, NULL); - bg_disconnect(); - goto error; - } - - res = OCIHandleAlloc(envhp, (dvoid **) &svchp, OCI_HTYPE_SVCCTX, 0, 0); - if (res != OCI_SUCCESS) - { - DBUG_PRINT("info",("spider create service context error")); - stored_error_num = set_error(res, errhp, 0, NULL, NULL); - bg_disconnect(); - goto error; - } - DBUG_PRINT("info",("spider OCI init svchp=%p", svchp)); - - res = OCIAttrSet(svchp, OCI_HTYPE_SVCCTX, srvhp, 0, OCI_ATTR_SERVER, errhp); - if (res != OCI_SUCCESS) - { - DBUG_PRINT("info",("spider set server attr error")); - stored_error_num = set_error(res, errhp, 0, NULL, NULL); - bg_disconnect(); - goto error; - } - - res = OCIHandleAlloc(envhp, (dvoid **) &usrhp, OCI_HTYPE_SESSION, 0, 0); - if (res != OCI_SUCCESS) - { - DBUG_PRINT("info",("spider create session handler error")); - stored_error_num = set_error(res, errhp, 0, NULL, NULL); - bg_disconnect(); - goto error; - } - DBUG_PRINT("info",("spider OCI init usrhp=%p", usrhp)); - - res = OCIAttrSet(usrhp, OCI_HTYPE_SESSION, - tgt_username, strlen(tgt_username), OCI_ATTR_USERNAME, errhp); - if (res != OCI_SUCCESS) - { - DBUG_PRINT("info",("spider set username attr error")); - stored_error_num = set_error(res, errhp, 0, NULL, NULL); - bg_disconnect(); - goto error; - } - - res = OCIAttrSet(usrhp, OCI_HTYPE_SESSION, - tgt_password, strlen(tgt_password), OCI_ATTR_PASSWORD, errhp); - if (res != OCI_SUCCESS) - { - DBUG_PRINT("info",("spider set password attr error")); - stored_error_num = set_error(res, errhp, 0, NULL, NULL); - bg_disconnect(); - goto error; - } - - res = OCISessionBegin(svchp, errhp, usrhp, OCI_CRED_RDBMS, OCI_DEFAULT); - if (res != OCI_SUCCESS) - { - DBUG_PRINT("info",("spider session begin error")); - stored_error_num = set_error(res, errhp, 0, NULL, NULL); - bg_disconnect(); - goto error; - } - DBUG_PRINT("info",("spider OCISessionBegin")); - - // set the session in the context handle - res = OCIAttrSet(svchp, OCI_HTYPE_SVCCTX, usrhp, 0, OCI_ATTR_SESSION, errhp); - if (res != OCI_SUCCESS) - { - DBUG_PRINT("info",("spider set session attr error")); - stored_error_num = set_error(res, errhp, 0, NULL, NULL); - bg_disconnect(); - goto error; - } - - if ( - (stored_error_num = exec_query(SPIDER_SQL_SET_NLS_DATE_FORMAT_STR, - SPIDER_SQL_SET_NLS_DATE_FORMAT_LEN, -1)) || - (stored_error_num = exec_query(SPIDER_SQL_SET_NLS_TIME_FORMAT_STR, - SPIDER_SQL_SET_NLS_TIME_FORMAT_LEN, -1)) || - (stored_error_num = exec_query(SPIDER_SQL_SET_NLS_TIMESTAMP_FORMAT_STR, - SPIDER_SQL_SET_NLS_TIMESTAMP_FORMAT_LEN, -1)) - ) { - DBUG_PRINT("info",("spider init connection error")); - bg_disconnect(); - goto error; - } - DBUG_VOID_RETURN; - -error: - strmov(stored_error_msg, spider_stmt_da_message(current_thd)); - current_thd->clear_error(); - DBUG_VOID_RETURN; -} - -int spider_db_oracle::connect( - char *tgt_host, - char *tgt_username, - char *tgt_password, - long tgt_port, - char *tgt_socket, - char *server_name, - int connect_retry_count, - longlong connect_retry_interval -) { - int error_num; - DBUG_ENTER("spider_db_oracle::connect"); - DBUG_PRINT("info",("spider this=%p", this)); - this->tgt_host = tgt_host; - this->tgt_username = tgt_username; - this->tgt_password = tgt_password; - this->tgt_port = tgt_port; - this->tgt_socket = tgt_socket; - this->server_name = server_name; - this->connect_retry_count = connect_retry_count; - this->connect_retry_interval = connect_retry_interval; - if ((error_num = spider_create_conn_thread(conn))) - DBUG_RETURN(error_num); - spider_bg_conn_simple_action(conn, SPIDER_SIMPLE_CONNECT, TRUE, NULL, - 0, NULL); - - if (stored_error_num) - { - my_message(stored_error_num, stored_error_msg, MYF(0)); - DBUG_RETURN(stored_error_num); - } - DBUG_RETURN(0); -} - -int spider_db_oracle::ping( -) { - sword res; - DBUG_ENTER("spider_db_oracle::ping"); - DBUG_PRINT("info",("spider this=%p", this)); - res = OCIPing(svchp, errhp, OCI_DEFAULT); - if (res != OCI_SUCCESS) - { - DBUG_PRINT("info",("spider ping error %d", res)); - DBUG_RETURN(ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM); - } - DBUG_RETURN(0); -} - -void spider_db_oracle::bg_disconnect() -{ - DBUG_ENTER("spider_db_oracle::bg_disconnect"); - DBUG_PRINT("info",("spider this=%p", this)); - if (result) - { - delete result; - result = NULL; - } - if (txnhp) - { - DBUG_PRINT("info",("spider OCI free txnhp=%p", txnhp)); - OCIHandleFree(txnhp, OCI_HTYPE_TRANS); - txnhp = NULL; - } - if (stmtp) - { - DBUG_PRINT("info",("spider OCI free stmtp=%p", stmtp)); - OCIHandleFree(stmtp, OCI_HTYPE_STMT); - stmtp = NULL; - } - if (svchp && errhp && usrhp) - { - DBUG_PRINT("info",("spider OCISessionEnd")); - OCISessionEnd(svchp, errhp, usrhp, OCI_DEFAULT); - } - if (usrhp) - { - DBUG_PRINT("info",("spider OCI free usrhp=%p", usrhp)); - OCIHandleFree(usrhp, OCI_HTYPE_SESSION); - usrhp = NULL; - } - if (svchp) - { - DBUG_PRINT("info",("spider OCI free svchp=%p", svchp)); - OCIHandleFree(svchp, OCI_HTYPE_SVCCTX); - svchp = NULL; - } - if (srvhp) - { - DBUG_PRINT("info",("spider OCI free srvhp=%p", srvhp)); - OCIServerDetach(srvhp, errhp, OCI_DEFAULT); - OCIHandleFree(srvhp, OCI_HTYPE_SERVER); - srvhp = NULL; - } - if (errhp) - { - DBUG_PRINT("info",("spider OCI free errhp=%p", errhp)); - OCIHandleFree(errhp, OCI_HTYPE_ERROR); - errhp = NULL; - } - if (envhp) - { - DBUG_PRINT("info",("spider OCI free envhp=%p", envhp)); - OCIHandleFree(envhp, OCI_HTYPE_ENV); - envhp = NULL; - } - DBUG_VOID_RETURN; -} - -void spider_db_oracle::disconnect() -{ - DBUG_ENTER("spider_db_oracle::disconnect"); - DBUG_PRINT("info",("spider this=%p", this)); - if (!conn->bg_init) - DBUG_VOID_RETURN; - spider_bg_conn_simple_action(conn, SPIDER_SIMPLE_DISCONNECT, TRUE, NULL, - 0, NULL); - DBUG_VOID_RETURN; -} - -int spider_db_oracle::set_net_timeout() -{ - DBUG_ENTER("spider_db_oracle::set_net_timeout"); - DBUG_PRINT("info",("spider this=%p", this)); - /* TODO: develop later */ - DBUG_RETURN(0); -} - -int spider_db_oracle::exec_query( - const char *query, - uint length, - int quick_mode -) { - sword res; - int error_num; - DBUG_ENTER("spider_db_oracle::exec_query"); - DBUG_PRINT("info",("spider this=%p", this)); - if (spider_param_general_log()) - { - const char *tgt_str = conn->tgt_host; - uint32 tgt_len = conn->tgt_host_length; - spider_string tmp_query_str(length + conn->tgt_wrapper_length + - tgt_len + (SPIDER_SQL_SPACE_LEN * 2)); - tmp_query_str.init_calc_mem(232); - tmp_query_str.length(0); - tmp_query_str.q_append(conn->tgt_wrapper, conn->tgt_wrapper_length); - tmp_query_str.q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN); - tmp_query_str.q_append(tgt_str, tgt_len); - tmp_query_str.q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN); - tmp_query_str.q_append(query, length); - general_log_write(current_thd, COM_QUERY, tmp_query_str.ptr(), - tmp_query_str.length()); - } - stored_error_num = 0; - if (table_lock_mode && !conn->in_before_query) - { - DBUG_PRINT("info",("spider table_lock_mode=%d", table_lock_mode)); - table_lock_mode = 0; - if ((error_num = exec_query(exec_lock_sql->ptr(), exec_lock_sql->length(), - -1))) { - DBUG_RETURN(error_num); - } - } - - if (length) - { - if (result) - { - delete result; - result = NULL; - } - - if (!stmtp) - { - DBUG_PRINT("info",("spider create stmt")); - res = OCIHandleAlloc(envhp, (dvoid **) &stmtp, OCI_HTYPE_STMT, 0, 0); - if (res != OCI_SUCCESS) - { - DBUG_PRINT("info",("spider create stmt handler error")); - DBUG_RETURN(set_error(res, errhp, 0, NULL, NULL)); - } - } - - res = OCIStmtPrepare(stmtp, errhp, (OraText *) query, length, - OCI_NTV_SYNTAX, OCI_DEFAULT); - if (res != OCI_SUCCESS) - { - DBUG_PRINT("info",("spider stmt prepare error")); - DBUG_RETURN(set_error(res, errhp, 0, NULL, NULL)); - } - -/* - if ((result = new spider_db_oracle_result())) - { - result->db_conn = this; - result->stmtp = stmtp; - stmtp = NULL; - result->field_count = result->num_fields(); - result->row.field_count = result->field_count; - result->row.db_conn = this; - result->row.result = result; - if ((error_num = result->row.init())) - { - delete result; - result = NULL; - DBUG_RETURN(error_num); - } - } else { - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } -*/ - - /* select statement check */ - ub4 iters; - if ( - !strncasecmp(query, "select ", sizeof("select ") - 1) || - !strncasecmp(query, "(select ", sizeof("(select ") - 1) - ) { - iters = 0; - } else { - iters = 1; - } - - if (quick_mode) - { - DBUG_PRINT("info",("spider use OCI_DEFAULT")); - res = OCIStmtExecute(svchp, stmtp, errhp, iters, 0, NULL, NULL, - OCI_DEFAULT); - } else { - DBUG_PRINT("info",("spider use OCI_STMT_SCROLLABLE_READONLY")); - res = OCIStmtExecute(svchp, stmtp, errhp, iters, 0, NULL, NULL, - OCI_STMT_SCROLLABLE_READONLY); -/* - if (res == OCI_SUCCESS) - { - DBUG_PRINT("info",("spider fetch last for row count")); - res = OCIStmtFetch2(result->stmtp, errhp, 1, OCI_FETCH_LAST, 0, - OCI_DEFAULT); - } - if (res == OCI_SUCCESS) - { - DBUG_PRINT("info",("spider fetch first for row count")); - res = OCIStmtFetch2(result->stmtp, errhp, 1, OCI_FETCH_FIRST, 0, - OCI_DEFAULT); - } -*/ - } - if (res == OCI_SUCCESS && iters) - { - DBUG_PRINT("info",("spider get row count")); - ub4 row_count; - res = OCIAttrGet(stmtp, OCI_HTYPE_STMT, &row_count, 0, - OCI_ATTR_ROW_COUNT, errhp); - update_rows = (uint) row_count; - DBUG_PRINT("info",("spider row_count=%u", update_rows)); - } - if (res != OCI_SUCCESS) - { - DBUG_PRINT("info",("spider stmt execute error")); - error_num = set_error(res, errhp, 0, NULL, NULL); - if (error_num == HA_ERR_END_OF_FILE) - DBUG_RETURN(0); - DBUG_RETURN(error_num); - } - - if ((result = new spider_db_oracle_result(this))) - { - result->db_conn = this; - result->stmtp = stmtp; - stmtp = NULL; - result->field_count = result->num_fields(); - result->row.field_count = result->field_count; - result->row.db_conn = this; - result->row.result = result; - result->row.access_charset = conn->access_charset; - result->access_charset = conn->access_charset; - if ( - (error_num = result->row.init()) || - (error_num = result->set_column_info()) - ) { - delete result; - result = NULL; - DBUG_RETURN(error_num); - } - result->row.define(); - } else { - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - - if (!quick_mode && !iters) - { - if (res == OCI_SUCCESS) - { - DBUG_PRINT("info",("spider fetch last for row count")); - res = OCIStmtFetch2(result->stmtp, errhp, 1, OCI_FETCH_LAST, 0, - OCI_DEFAULT); - } - if (res == OCI_SUCCESS) - { - DBUG_PRINT("info",("spider fetch first for row count")); - res = OCIStmtFetch2(result->stmtp, errhp, 1, OCI_FETCH_FIRST, 0, - OCI_DEFAULT); - } - if (res != OCI_SUCCESS) - { - DBUG_PRINT("info",("spider stmt execute error")); - error_num = set_error(res, errhp, 0, NULL, NULL); - if (error_num == HA_ERR_END_OF_FILE) - DBUG_RETURN(0); - DBUG_RETURN(error_num); - } - result->fetched = TRUE; - } - } - DBUG_RETURN(0); -} - -int spider_db_oracle::get_errno() -{ - DBUG_ENTER("spider_db_oracle::get_errno"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_PRINT("info",("spider stored_error=%d", stored_error_num)); - DBUG_RETURN(stored_error_num); -} - -const char *spider_db_oracle::get_error() -{ - DBUG_ENTER("spider_db_oracle::get_error"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_PRINT("info",("spider error=%s", stored_error)); - DBUG_RETURN(stored_error); -} - -bool spider_db_oracle::is_server_gone_error( - int error_num -) { - DBUG_ENTER("spider_db_oracle::is_server_gone_error"); - DBUG_PRINT("info",("spider this=%p", this)); - /* TODO: develop later */ - DBUG_RETURN(FALSE); -} - -bool spider_db_oracle::is_dup_entry_error( - int error_num -) { - DBUG_ENTER("spider_db_oracle::is_dup_entry_error"); - DBUG_PRINT("info",("spider this=%p", this)); - if (error_num == HA_ERR_FOUND_DUPP_KEY) - DBUG_RETURN(TRUE); - DBUG_RETURN(FALSE); -} - -bool spider_db_oracle::is_xa_nota_error( - int error_num -) { - DBUG_ENTER("spider_db_oracle::is_xa_nota_error"); - DBUG_PRINT("info",("spider this=%p", this)); - /* TODO: develop later */ - DBUG_RETURN(FALSE); -} - -spider_db_result *spider_db_oracle::store_result( - spider_db_result_buffer **spider_res_buf, - st_spider_db_request_key *request_key, - int *error_num -) { - spider_db_oracle_result *tmp_result = result; - DBUG_ENTER("spider_db_oracle::store_result"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_ASSERT(!spider_res_buf); - if (stored_error_num == HA_ERR_END_OF_FILE) - { - *error_num = HA_ERR_END_OF_FILE; - DBUG_RETURN(NULL); - } - - *error_num = 0; - result = NULL; - DBUG_RETURN(tmp_result); -} - -spider_db_result *spider_db_oracle::use_result( - ha_spider *spider, - st_spider_db_request_key *request_key, - int *error_num -) { - spider_db_oracle_result *tmp_result = result; - DBUG_ENTER("spider_db_oracle::use_result"); - DBUG_PRINT("info",("spider this=%p", this)); - if (stored_error_num == HA_ERR_END_OF_FILE) - { - *error_num = HA_ERR_END_OF_FILE; - DBUG_RETURN(NULL); - } - - *error_num = 0; - result = NULL; - DBUG_RETURN(tmp_result); -} - -int spider_db_oracle::next_result() -{ - DBUG_ENTER("spider_db_oracle::next_result"); - DBUG_PRINT("info",("spider this=%p", this)); - /* TODO: develop later */ - DBUG_RETURN(-1); -} - -uint spider_db_oracle::affected_rows() -{ - DBUG_ENTER("spider_db_oracle::affected_rows"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(update_rows); -} - -uint spider_db_oracle::matched_rows() -{ - DBUG_ENTER("spider_db_oracle::matched_rows"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(0); -} - -bool spider_db_oracle::inserted_info( - spider_db_handler *handler, - ha_copy_info *copy_info -) { - DBUG_ENTER("spider_db_oracle::inserted_info"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(FALSE); -} - -ulonglong spider_db_oracle::last_insert_id() -{ - DBUG_ENTER("spider_db_oracle::last_insert_id"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(stored_last_insert_id); -} - -int spider_db_oracle::set_character_set( - const char *csname -) { - DBUG_ENTER("spider_db_oracle::set_character_set"); - DBUG_PRINT("info",("spider this=%p", this)); - /* TODO: develop later */ - DBUG_RETURN(0); -} - -int spider_db_oracle::select_db( - const char *dbname -) { - DBUG_ENTER("spider_db_oracle::select_db"); - DBUG_PRINT("info",("spider this=%p", this)); - /* nothing to do for oracle */ - DBUG_RETURN(0); -} - -int spider_db_oracle::consistent_snapshot( - int *need_mon -) { - DBUG_ENTER("spider_db_oracle::consistent_snapshot"); - DBUG_PRINT("info",("spider this=%p", this)); - /* nothing to do for oracle */ - DBUG_RETURN(0); -} - -bool spider_db_oracle::trx_start_in_bulk_sql() -{ - DBUG_ENTER("spider_db_oracle::trx_start_in_bulk_sql"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(FALSE); -} - -int spider_db_oracle::start_transaction( - int *need_mon -) { - DBUG_ENTER("spider_db_oracle::start_transaction"); - DBUG_PRINT("info",("spider this=%p", this)); - if (conn->in_before_query) - { - if (conn->queued_semi_trx_isolation) - { - if (conn->queued_semi_trx_isolation_val != conn->trx_isolation) - { - /* nothing to do */ - DBUG_RETURN(0); - } - } else if (conn->queued_trx_isolation) - { - if (conn->queued_trx_isolation_val != conn->trx_isolation) - { - /* nothing to do */ - DBUG_RETURN(0); - } - } - DBUG_RETURN(set_trx_isolation(conn->trx_isolation, need_mon)); - } - pthread_mutex_assert_owner(&conn->mta_conn_mutex); - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - if (spider_db_query( - conn, - SPIDER_SQL_START_TRANSACTION_STR, - SPIDER_SQL_START_TRANSACTION_LEN, - -1, - need_mon) - ) { - DBUG_RETURN(spider_db_errorno(conn)); - } - DBUG_RETURN(0); -} - -int spider_db_oracle::commit( - int *need_mon -) { - sword res; - DBUG_ENTER("spider_db_oracle::commit"); - DBUG_PRINT("info",("spider this=%p", this)); - if (conn->table_locked) - { - conn->table_locked = FALSE; - spider_current_trx->locked_connections--; - } - res = OCITransCommit(svchp, errhp, OCI_DEFAULT); - if (res != OCI_SUCCESS) - { - *need_mon = set_error(res, errhp, 0, NULL, NULL); - DBUG_RETURN(*need_mon); - } - DBUG_RETURN(0); -} - -int spider_db_oracle::rollback( - int *need_mon -) { - sword res; - DBUG_ENTER("spider_db_oracle::rollback"); - DBUG_PRINT("info",("spider this=%p", this)); - if (conn->table_locked) - { - conn->table_locked = FALSE; - spider_current_trx->locked_connections--; - } - if (svchp && errhp) - { - res = OCITransRollback(svchp, errhp, OCI_DEFAULT); - if (res != OCI_SUCCESS) - { - *need_mon = set_error(res, errhp, 0, NULL, NULL); - DBUG_RETURN(*need_mon); - } - } - DBUG_RETURN(0); -} - -bool spider_db_oracle::xa_start_in_bulk_sql() -{ - DBUG_ENTER("spider_db_oracle::xa_start_in_bulk_sql"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(FALSE); -} - -int spider_db_oracle::xa_start( - XID *xid, - int *need_mon -) { - sword res; - DBUG_ENTER("spider_db_oracle::xa_start"); - DBUG_PRINT("info",("spider this=%p", this)); - if (txnhp) - { - OCIHandleFree(txnhp, OCI_HTYPE_TRANS); - txnhp = NULL; - } - OCIHandleAlloc((dvoid *)envhp, (dvoid **)&txnhp, OCI_HTYPE_TRANS, 0, 0); - OCIAttrSet((dvoid *)svchp, OCI_HTYPE_SVCCTX, (dvoid *)txnhp, 0, - OCI_ATTR_TRANS, errhp); - OCIAttrSet((dvoid *)txnhp, OCI_HTYPE_TRANS, (dvoid *)xid, sizeof(XID), - OCI_ATTR_XID, errhp); - - res = OCITransStart(svchp, errhp, 31622400, OCI_TRANS_NEW); - if (res != OCI_SUCCESS) - { - *need_mon = set_error(res, errhp, 0, NULL, NULL); - DBUG_RETURN(*need_mon); - } - DBUG_RETURN(0); -} - -int spider_db_oracle::xa_end( - XID *xid, - int *need_mon -) { - DBUG_ENTER("spider_db_oracle::xa_end"); - DBUG_PRINT("info",("spider this=%p", this)); - /* nothing to do for oracle */ - DBUG_RETURN(0); -} - -int spider_db_oracle::xa_prepare( - XID *xid, - int *need_mon -) { - sword res; - DBUG_ENTER("spider_db_oracle::xa_prepare"); - DBUG_PRINT("info",("spider this=%p", this)); - res = OCITransPrepare(svchp, errhp, OCI_DEFAULT); - if (res != OCI_SUCCESS) - { - *need_mon = set_error(res, errhp, 0, NULL, NULL); - DBUG_RETURN(*need_mon); - } - DBUG_RETURN(0); -} - -int spider_db_oracle::xa_commit( - XID *xid, - int *need_mon -) { - sword res; - DBUG_ENTER("spider_db_oracle::xa_commit"); - DBUG_PRINT("info",("spider this=%p", this)); - if (conn->table_locked) - { - conn->table_locked = FALSE; - spider_current_trx->locked_connections--; - } - res = OCITransCommit(svchp, errhp, OCI_TRANS_TWOPHASE); - if (res != OCI_SUCCESS) - { - *need_mon = set_error(res, errhp, 0, NULL, NULL); - if (txnhp) - { - OCIHandleFree(txnhp, OCI_HTYPE_TRANS); - txnhp = NULL; - } - DBUG_RETURN(*need_mon); - } - if (txnhp) - { - OCIHandleFree(txnhp, OCI_HTYPE_TRANS); - txnhp = NULL; - } - DBUG_RETURN(0); -} - -int spider_db_oracle::xa_rollback( - XID *xid, - int *need_mon -) { - sword res; - DBUG_ENTER("spider_db_oracle::xa_rollback"); - DBUG_PRINT("info",("spider this=%p", this)); - if (svchp && errhp) - { - res = OCITransRollback(svchp, errhp, OCI_DEFAULT); - if (res != OCI_SUCCESS) - { - *need_mon = set_error(res, errhp, 0, NULL, NULL); - if (txnhp) - { - OCIHandleFree(txnhp, OCI_HTYPE_TRANS); - txnhp = NULL; - } - DBUG_RETURN(*need_mon); - } - } - if (txnhp) - { - OCIHandleFree(txnhp, OCI_HTYPE_TRANS); - txnhp = NULL; - } - DBUG_RETURN(0); -} - -bool spider_db_oracle::set_trx_isolation_in_bulk_sql() -{ - DBUG_ENTER("spider_db_oracle::set_trx_isolation_in_bulk_sql"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(FALSE); -} - -int spider_db_oracle::set_trx_isolation( - int trx_isolation, - int *need_mon -) { - DBUG_ENTER("spider_db_oracle::set_trx_isolation"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (trx_isolation) - { - case ISO_READ_UNCOMMITTED: - case ISO_READ_COMMITTED: - if (conn->in_before_query) - { - DBUG_RETURN(exec_query(SPIDER_SQL_ISO_READ_COMMITTED_STR, - SPIDER_SQL_ISO_READ_COMMITTED_LEN, -1)); - } - pthread_mutex_assert_not_owner(&conn->mta_conn_mutex); - pthread_mutex_lock(&conn->mta_conn_mutex); - SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos); - conn->need_mon = need_mon; - DBUG_ASSERT(!conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = TRUE; - conn->mta_conn_mutex_unlock_later = TRUE; - if (spider_db_query( - conn, - SPIDER_SQL_ISO_READ_COMMITTED_STR, - SPIDER_SQL_ISO_READ_COMMITTED_LEN, - -1, - need_mon) - ) { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - DBUG_RETURN(spider_db_errorno(conn)); - } - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - break; - case ISO_REPEATABLE_READ: - case ISO_SERIALIZABLE: - if (conn->in_before_query) - { - DBUG_RETURN(exec_query(SPIDER_SQL_ISO_SERIALIZABLE_STR, - SPIDER_SQL_ISO_SERIALIZABLE_LEN, -1)); - } - pthread_mutex_assert_not_owner(&conn->mta_conn_mutex); - pthread_mutex_lock(&conn->mta_conn_mutex); - SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos); - conn->need_mon = need_mon; - DBUG_ASSERT(!conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = TRUE; - conn->mta_conn_mutex_unlock_later = TRUE; - if (spider_db_query( - conn, - SPIDER_SQL_ISO_SERIALIZABLE_STR, - SPIDER_SQL_ISO_SERIALIZABLE_LEN, - -1, - need_mon) - ) { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - DBUG_RETURN(spider_db_errorno(conn)); - } - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - break; - default: - DBUG_RETURN(HA_ERR_UNSUPPORTED); - } - DBUG_RETURN(0); -} - -bool spider_db_oracle::set_autocommit_in_bulk_sql() -{ - DBUG_ENTER("spider_db_oracle::set_autocommit_in_bulk_sql"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(FALSE); -} - -int spider_db_oracle::set_autocommit( - bool autocommit, - int *need_mon -) { - DBUG_ENTER("spider_db_oracle::set_autocommit"); - DBUG_PRINT("info",("spider this=%p", this)); - if (autocommit) - { - if (conn->in_before_query) - { - DBUG_RETURN(exec_query(SPIDER_SQL_AUTOCOMMIT_ON_STR, - SPIDER_SQL_AUTOCOMMIT_ON_LEN, -1)); - } - pthread_mutex_assert_not_owner(&conn->mta_conn_mutex); - pthread_mutex_lock(&conn->mta_conn_mutex); - SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos); - conn->need_mon = need_mon; - DBUG_ASSERT(!conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = TRUE; - conn->mta_conn_mutex_unlock_later = TRUE; - if (spider_db_query( - conn, - SPIDER_SQL_AUTOCOMMIT_ON_STR, - SPIDER_SQL_AUTOCOMMIT_ON_LEN, - -1, - need_mon) - ) { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - DBUG_RETURN(spider_db_errorno(conn)); - } - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - } else { - if (conn->in_before_query) - { - DBUG_RETURN(exec_query(SPIDER_SQL_AUTOCOMMIT_OFF_STR, - SPIDER_SQL_AUTOCOMMIT_OFF_LEN, -1)); - } - pthread_mutex_assert_not_owner(&conn->mta_conn_mutex); - pthread_mutex_lock(&conn->mta_conn_mutex); - SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos); - conn->need_mon = need_mon; - DBUG_ASSERT(!conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = TRUE; - conn->mta_conn_mutex_unlock_later = TRUE; - if (spider_db_query( - conn, - SPIDER_SQL_AUTOCOMMIT_OFF_STR, - SPIDER_SQL_AUTOCOMMIT_OFF_LEN, - -1, - need_mon) - ) { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - DBUG_RETURN(spider_db_errorno(conn)); - } - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - } - DBUG_RETURN(0); -} - -bool spider_db_oracle::set_sql_log_off_in_bulk_sql() -{ - DBUG_ENTER("spider_db_oracle::set_sql_log_off_in_bulk_sql"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(FALSE); -} - -int spider_db_oracle::set_sql_log_off( - bool sql_log_off, - int *need_mon -) { - DBUG_ENTER("spider_db_oracle::set_sql_log_off"); - DBUG_PRINT("info",("spider this=%p", this)); - /* nothing to do */ - DBUG_RETURN(0); -} - -bool spider_db_oracle::set_wait_timeout_in_bulk_sql() -{ - DBUG_ENTER("spider_db_oracle::set_wait_timeout_in_bulk_sql"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(FALSE); -} - -int spider_db_oracle::set_wait_timeout( - int wait_timeout, - int *need_mon -) { - DBUG_ENTER("spider_db_oracle::set_wait_timeout"); - DBUG_PRINT("info",("spider this=%p", this)); - /* nothing to do */ - DBUG_RETURN(0); -} - -bool spider_db_oracle::set_sql_mode_in_bulk_sql() -{ - DBUG_ENTER("spider_db_oracle::set_sql_mode_in_bulk_sql"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(FALSE); -} - -int spider_db_oracle::set_sql_mode( - sql_mode_t sql_mode, - int *need_mon -) { - DBUG_ENTER("spider_db_oracle::set_sql_mode"); - DBUG_PRINT("info",("spider this=%p", this)); - /* nothing to do */ - DBUG_RETURN(0); -} - -bool spider_db_oracle::set_time_zone_in_bulk_sql() -{ - DBUG_ENTER("spider_db_oracle::set_time_zone_in_bulk_sql"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(FALSE); -} - -int spider_db_oracle::set_time_zone( - Time_zone *time_zone, - int *need_mon -) { - DBUG_ENTER("spider_db_oracle::set_time_zone"); - DBUG_PRINT("info",("spider this=%p", this)); - /* nothing to do */ - DBUG_RETURN(0); -} - -int spider_db_oracle::show_master_status( - SPIDER_TRX *trx, - SPIDER_SHARE *share, - int all_link_idx, - int *need_mon, - TABLE *table, - spider_string *str, - int mode, - SPIDER_DB_RESULT **res1, - SPIDER_DB_RESULT **res2 -) { - DBUG_ENTER("spider_db_oracle::show_master_status"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(0); -} - -size_t spider_db_oracle::escape_string( - char *to, - const char *from, - size_t from_length -) { - DBUG_ENTER("spider_db_oracle::escape_string"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(util.escape_string(to, from, from_length, conn->access_charset)); -} - -bool spider_db_oracle::have_lock_table_list() -{ - DBUG_ENTER("spider_db_oracle::have_lock_table_list"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(lock_table_hash.records); -} - -int spider_db_oracle::append_lock_tables( - spider_string *str -) { - int error_num; - ha_spider *tmp_spider; - int lock_type; - uint conn_link_idx; - int tmp_link_idx; - SPIDER_LINK_FOR_HASH *tmp_link_for_hash; - const char *db_name; - uint db_name_length; - CHARSET_INFO *db_name_charset; - const char *table_name; - uint table_name_length; - CHARSET_INFO *table_name_charset; - DBUG_ENTER("spider_db_oracle::lock_tables"); - DBUG_PRINT("info",("spider this=%p", this)); - if ((tmp_link_for_hash = - (SPIDER_LINK_FOR_HASH *) my_hash_element(&lock_table_hash, 0))) - { - if ((error_num = spider_db_oracle_utility.append_lock_table_head(str))) - { - DBUG_RETURN(error_num); - } - - tmp_spider = tmp_link_for_hash->spider; - tmp_link_idx = tmp_link_for_hash->link_idx; - switch (tmp_spider->wide_handler->lock_type) - { - case TL_READ: - lock_type = SPIDER_DB_TABLE_LOCK_READ_LOCAL; - break; - case TL_READ_NO_INSERT: - lock_type = SPIDER_DB_TABLE_LOCK_READ; - break; - case TL_WRITE_LOW_PRIORITY: - lock_type = SPIDER_DB_TABLE_LOCK_LOW_PRIORITY_WRITE; - break; - case TL_WRITE: - lock_type = SPIDER_DB_TABLE_LOCK_WRITE; - break; - default: - // no lock - DBUG_PRINT("info",("spider lock_type=%d", - tmp_spider->wide_handler->lock_type)); - DBUG_RETURN(0); - } - conn_link_idx = tmp_spider->conn_link_idx[tmp_link_idx]; - spider_oracle_share *db_share = (spider_oracle_share *) - tmp_spider->share->dbton_share[conn->dbton_id]; - if (&db_share->db_names_str[conn_link_idx]) - { - db_name = db_share->db_names_str[conn_link_idx].ptr(); - db_name_length = db_share->db_names_str[conn_link_idx].length(); - db_name_charset = tmp_spider->share->access_charset; - } else { - db_name = tmp_spider->share->tgt_dbs[conn_link_idx]; - db_name_length = tmp_spider->share->tgt_dbs_lengths[conn_link_idx]; - db_name_charset = system_charset_info; - } - if (&db_share->table_names_str[conn_link_idx]) - { - table_name = db_share->table_names_str[conn_link_idx].ptr(); - table_name_length = db_share->table_names_str[conn_link_idx].length(); - table_name_charset = tmp_spider->share->access_charset; - } else { - table_name = tmp_spider->share->tgt_table_names[conn_link_idx]; - table_name_length = - tmp_spider->share->tgt_table_names_lengths[conn_link_idx]; - table_name_charset = system_charset_info; - } - if ((error_num = spider_db_oracle_utility. - append_lock_table_body( - str, - db_name, - db_name_length, - db_name_charset, - table_name, - table_name_length, - table_name_charset, - lock_type - ) - )) { - my_hash_reset(&lock_table_hash); - DBUG_RETURN(error_num); - } -#ifdef HASH_UPDATE_WITH_HASH_VALUE - my_hash_delete_with_hash_value(&lock_table_hash, - tmp_link_for_hash->db_table_str_hash_value, (uchar*) tmp_link_for_hash); -#else - my_hash_delete(&lock_table_hash, (uchar*) tmp_link_for_hash); -#endif - - if ((error_num = spider_db_oracle_utility.append_lock_table_tail(str))) - { - DBUG_RETURN(error_num); - } - } - DBUG_RETURN(0); -} - -int spider_db_oracle::append_unlock_tables( - spider_string *str -) { - int error_num; - DBUG_ENTER("spider_db_oracle::append_unlock_tables"); - DBUG_PRINT("info",("spider this=%p", this)); - if ((error_num = spider_db_oracle_utility.append_unlock_table(str))) - { - DBUG_RETURN(error_num); - } - DBUG_RETURN(0); -} - -uint spider_db_oracle::get_lock_table_hash_count() -{ - DBUG_ENTER("spider_db_oracle::get_lock_table_hash_count"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(lock_table_hash.records); -} - -void spider_db_oracle::reset_lock_table_hash() -{ - DBUG_ENTER("spider_db_oracle::reset_lock_table_hash"); - DBUG_PRINT("info",("spider this=%p", this)); - my_hash_reset(&lock_table_hash); - DBUG_VOID_RETURN; -} - -uint spider_db_oracle::get_opened_handler_count() -{ - DBUG_ENTER("spider_db_oracle::get_opened_handler_count"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(handler_open_array.elements); -} - -void spider_db_oracle::reset_opened_handler() -{ - ha_spider *tmp_spider; - int tmp_link_idx; - SPIDER_LINK_FOR_HASH **tmp_link_for_hash; - DBUG_ENTER("spider_db_oracle::reset_opened_handler"); - DBUG_PRINT("info",("spider this=%p", this)); - while ((tmp_link_for_hash = - (SPIDER_LINK_FOR_HASH **) pop_dynamic(&handler_open_array))) - { - tmp_spider = (*tmp_link_for_hash)->spider; - tmp_link_idx = (*tmp_link_for_hash)->link_idx; - tmp_spider->clear_handler_opened(tmp_link_idx, conn->conn_kind); - } - DBUG_VOID_RETURN; -} - -void spider_db_oracle::set_dup_key_idx( - ha_spider *spider, - int link_idx -) { - TABLE *table = spider->get_table(); - uint roop_count, pk_idx = table->s->primary_key; - int key_name_length; - int max_length = 0; - char *key_name, *tmp_pos; - char buf[SPIDER_ORACLE_ERR_BUF_LEN]; - DBUG_ENTER("spider_db_oracle::set_dup_key_idx"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_PRINT("info",("spider error_str=%s", stored_error_msg)); - memcpy(buf, spider->share->tgt_dbs[link_idx], - spider->share->tgt_dbs_lengths[link_idx]); - tmp_pos = buf + spider->share->tgt_dbs_lengths[link_idx]; - *tmp_pos = '.'; - ++tmp_pos; - for (roop_count = 0; roop_count < table->s->keys; roop_count++) - { - if (roop_count == pk_idx) - { - DBUG_PRINT("info",("spider pk_idx=%u", roop_count)); - int all_link_idx = spider->conn_link_idx[link_idx]; - key_name = spider->share->tgt_pk_names[all_link_idx]; - key_name_length = spider->share->tgt_pk_names_lengths[all_link_idx]; - } else { -#ifdef SPIDER_use_LEX_CSTRING_for_KEY_Field_name - key_name = (char *) table->s->key_info[roop_count].name.str; - key_name_length = table->s->key_info[roop_count].name.length; -#else - key_name = table->s->key_info[roop_count].name; - key_name_length = strlen(key_name); -#endif - } - memcpy(tmp_pos, key_name, key_name_length + 1); - DBUG_PRINT("info",("spider key_name=%s", key_name)); - DBUG_PRINT("info",("spider full key name=%s", buf)); - if ( - max_length < key_name_length && - strcasestr(stored_error_msg, buf) - ) { - max_length = key_name_length; - spider->dup_key_idx = roop_count; - } - } - if (max_length == 0) - spider->dup_key_idx = (uint) -1; - DBUG_PRINT("info",("spider dup_key_idx=%d", spider->dup_key_idx)); - DBUG_VOID_RETURN; -} - -bool spider_db_oracle::cmp_request_key_to_snd( - st_spider_db_request_key *request_key -) { - DBUG_ENTER("spider_db_oracle::cmp_request_key_to_snd"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(TRUE); -} - -int spider_db_oracle::set_error( - sword res, - dvoid *hndlp, - int error_num, - const char *error1, - const char *error2 -) { - DBUG_ENTER("spider_db_oracle::set_error"); - DBUG_PRINT("info",("spider this=%p", this)); - stored_error_num = - spider_db_oracle_get_error(res, hndlp, error_num, error1, error2, - conn->access_charset, stored_error_msg); - if (stored_error_num) - stored_error = ER_SPIDER_ORACLE_ERR; - else - stored_error = ""; - DBUG_RETURN(stored_error_num); -} - -spider_db_oracle_util::spider_db_oracle_util() : spider_db_util() -{ - DBUG_ENTER("spider_db_oracle_util::spider_db_oracle_util"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_VOID_RETURN; -} - -spider_db_oracle_util::~spider_db_oracle_util() -{ - DBUG_ENTER("spider_db_oracle_util::~spider_db_oracle_util"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_VOID_RETURN; -} - -int spider_db_oracle_util::append_name( - spider_string *str, - const char *name, - uint name_length -) { - DBUG_ENTER("spider_db_oracle_util::append_name"); - str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN); - str->q_append(name, name_length); - str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN); - DBUG_RETURN(0); -} - -int spider_db_oracle_util::append_name_with_charset( - spider_string *str, - const char *name, - uint name_length, - CHARSET_INFO *name_charset -) { - DBUG_ENTER("spider_db_oracle_util::append_name_with_charset"); - if (str->reserve(SPIDER_SQL_NAME_QUOTE_LEN * 2 + name_length * 2)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN); - str->append(name, name_length, name_charset); - if (str->reserve(SPIDER_SQL_NAME_QUOTE_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN); - DBUG_RETURN(0); -} - -int spider_db_oracle_util::append_escaped_name( - spider_string *str, - const char *name, - uint name_length -) { - int error_num; - DBUG_ENTER("spider_db_oracle_util::append_name"); - if (str->reserve(SPIDER_SQL_NAME_QUOTE_LEN * 2 + name_length * 2)) - { - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN); - if ((error_num = spider_db_append_name_with_quote_str_internal( - str, name, name_length, dbton_id))) - { - DBUG_RETURN(error_num); - } - if (str->reserve(SPIDER_SQL_NAME_QUOTE_LEN)) - { - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN); - DBUG_RETURN(0); -} - -int spider_db_oracle_util::append_escaped_name_with_charset( - spider_string *str, - const char *name, - uint name_length, - CHARSET_INFO *name_charset -) { - int error_num; - DBUG_ENTER("spider_db_oracle_util::append_name_with_charset"); - if (str->reserve(SPIDER_SQL_NAME_QUOTE_LEN * 2 + name_length * 2)) - { - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN); - if ((error_num = spider_db_append_name_with_quote_str_internal( - str, name, name_length, name_charset, dbton_id))) - { - DBUG_RETURN(error_num); - } - if (str->reserve(SPIDER_SQL_NAME_QUOTE_LEN)) - { - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN); - DBUG_RETURN(0); -} - -bool spider_db_oracle_util::is_name_quote( - const char head_code -) { - DBUG_ENTER("spider_db_oracle_util::is_name_quote"); - DBUG_RETURN(head_code == *name_quote_str); -} - -int spider_db_oracle_util::append_escaped_name_quote( - spider_string *str -) { - DBUG_ENTER("spider_db_oracle_util::append_escaped_name_quote"); - if (str->reserve(SPIDER_SQL_NAME_QUOTE_LEN * 2)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN); - str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN); - DBUG_RETURN(0); -} - -int spider_db_oracle_util::append_column_value( - ha_spider *spider, - spider_string *str, - Field *field, - const uchar *new_ptr, - CHARSET_INFO *access_charset -) { - char buf[MAX_FIELD_WIDTH]; - spider_string tmp_str(buf, MAX_FIELD_WIDTH, &my_charset_bin); - String *ptr; - uint length; - Time_zone *saved_time_zone = thd->variables.time_zone; - DBUG_ENTER("spider_db_oracle_util::append_column_value"); - tmp_str.init_calc_mem(181); - - thd->variables.time_zone = UTC; - - if (new_ptr) - { - if ( - field->type() == MYSQL_TYPE_BLOB || - field->real_type() == MYSQL_TYPE_VARCHAR - ) { - length = uint2korr(new_ptr); - tmp_str.set((char *) new_ptr + HA_KEY_BLOB_LENGTH, length, - &my_charset_bin); - ptr = tmp_str.get_str(); - } else if (field->type() == MYSQL_TYPE_GEOMETRY) - { -/* - uint mlength = SIZEOF_STORED_DOUBLE, lcnt; - uchar *dest = (uchar *) buf; - const uchar *source; - for (lcnt = 0; lcnt < 4; lcnt++) - { - mlength = SIZEOF_STORED_DOUBLE; - source = new_ptr + mlength + SIZEOF_STORED_DOUBLE * lcnt; - while (mlength--) - *dest++ = *--source; - } - tmp_str.length(SIZEOF_STORED_DOUBLE * lcnt); -*/ - double xmin, xmax, ymin, ymax; -/* - float8store(buf,xmin); - float8store(buf+8,xmax); - float8store(buf+16,ymin); - float8store(buf+24,ymax); - memcpy(&xmin,new_ptr,sizeof(xmin)); - memcpy(&xmax,new_ptr + 8,sizeof(xmax)); - memcpy(&ymin,new_ptr + 16,sizeof(ymin)); - memcpy(&ymax,new_ptr + 24,sizeof(ymax)); - float8get(xmin, buf); - float8get(xmax, buf + 8); - float8get(ymin, buf + 16); - float8get(ymax, buf + 24); - DBUG_PRINT("info", ("spider geo is %f %f %f %f", - xmin, xmax, ymin, ymax)); - DBUG_PRINT("info", ("spider geo is %.14g %.14g %.14g %.14g", - xmin, xmax, ymin, ymax)); -*/ - float8get(xmin, new_ptr); - float8get(xmax, new_ptr + 8); - float8get(ymin, new_ptr + 16); - float8get(ymax, new_ptr + 24); - DBUG_PRINT("info", ("spider geo is %f %f %f %f", - xmin, xmax, ymin, ymax)); -/* - float8get(xmin, new_ptr + SIZEOF_STORED_DOUBLE * 4); - float8get(xmax, new_ptr + SIZEOF_STORED_DOUBLE * 5); - float8get(ymin, new_ptr + SIZEOF_STORED_DOUBLE * 6); - float8get(ymax, new_ptr + SIZEOF_STORED_DOUBLE * 7); - DBUG_PRINT("info", ("spider geo is %f %f %f %f", - xmin, xmax, ymin, ymax)); - float8get(xmin, new_ptr + SIZEOF_STORED_DOUBLE * 8); - float8get(xmax, new_ptr + SIZEOF_STORED_DOUBLE * 9); - float8get(ymin, new_ptr + SIZEOF_STORED_DOUBLE * 10); - float8get(ymax, new_ptr + SIZEOF_STORED_DOUBLE * 11); - DBUG_PRINT("info", ("spider geo is %f %f %f %f", - xmin, xmax, ymin, ymax)); - float8get(xmin, new_ptr + SIZEOF_STORED_DOUBLE * 12); - float8get(xmax, new_ptr + SIZEOF_STORED_DOUBLE * 13); - float8get(ymin, new_ptr + SIZEOF_STORED_DOUBLE * 14); - float8get(ymax, new_ptr + SIZEOF_STORED_DOUBLE * 15); - DBUG_PRINT("info", ("spider geo is %f %f %f %f", - xmin, xmax, ymin, ymax)); -*/ -/* - tmp_str.set((char *) new_ptr, SIZEOF_STORED_DOUBLE * 4, - &my_charset_bin); -*/ - tmp_str.length(0); - tmp_str.q_append((char *) SPIDER_SQL_LINESTRING_HEAD_STR, - SPIDER_SQL_LINESTRING_HEAD_LEN); - tmp_str.q_append((char *) new_ptr, SIZEOF_STORED_DOUBLE); - tmp_str.q_append((char *) new_ptr + SIZEOF_STORED_DOUBLE * 2, - SIZEOF_STORED_DOUBLE); - tmp_str.q_append((char *) new_ptr + SIZEOF_STORED_DOUBLE, - SIZEOF_STORED_DOUBLE); - tmp_str.q_append((char *) new_ptr + SIZEOF_STORED_DOUBLE * 3, - SIZEOF_STORED_DOUBLE); - ptr = tmp_str.get_str(); - } else { - ptr = field->val_str(tmp_str.get_str(), new_ptr); - tmp_str.mem_calc(); - } - } else { - ptr = field->val_str(tmp_str.get_str()); - tmp_str.mem_calc(); - } - - thd->variables.time_zone = saved_time_zone; - - DBUG_PRINT("info", ("spider field->type() is %d", field->type())); - DBUG_PRINT("info", ("spider ptr->length() is %d", ptr->length())); -/* - if ( - field->type() == MYSQL_TYPE_BIT || - (field->type() >= MYSQL_TYPE_TINY_BLOB && - field->type() <= MYSQL_TYPE_BLOB) - ) { - uchar *hex_ptr = (uchar *) ptr->ptr(), *end_ptr; - char *str_ptr; - DBUG_PRINT("info", ("spider HEX")); - if (str->reserve(SPIDER_SQL_HEX_LEN + ptr->length() * 2)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_HEX_STR, SPIDER_SQL_HEX_LEN); - str_ptr = (char *) str->ptr() + str->length(); - for (end_ptr = hex_ptr + ptr->length(); hex_ptr < end_ptr; hex_ptr++) - { - *str_ptr++ = spider_dig_upper[(*hex_ptr) >> 4]; - *str_ptr++ = spider_dig_upper[(*hex_ptr) & 0x0F]; - } - str->length(str->length() + ptr->length() * 2); - } else -*/ - if (field->result_type() == STRING_RESULT) - { - DBUG_PRINT("info", ("spider STRING_RESULT")); - if (str->reserve(SPIDER_SQL_VALUE_QUOTE_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN); - if ( - field->type() == MYSQL_TYPE_VARCHAR || - (field->type() >= MYSQL_TYPE_ENUM && - field->type() <= MYSQL_TYPE_GEOMETRY) - ) { - DBUG_PRINT("info", ("spider append_escaped")); - char buf2[MAX_FIELD_WIDTH]; - spider_string tmp_str2(buf2, MAX_FIELD_WIDTH, access_charset); - tmp_str2.init_calc_mem(182); - tmp_str2.length(0); - if ( - tmp_str2.append(ptr->ptr(), ptr->length(), field->charset()) || - str->reserve(tmp_str2.length() * 2) || - append_escaped_util(str, tmp_str2.get_str()) - ) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } else if (str->append(*ptr)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - if (str->reserve(SPIDER_SQL_VALUE_QUOTE_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN); - } else if (field->str_needs_quotes()) - { - if (str->reserve(SPIDER_SQL_VALUE_QUOTE_LEN * 2 + ptr->length() * 2 + 2)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN); - append_escaped_util(str, ptr); - str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN); - } else if (str->append(*ptr)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - DBUG_RETURN(0); -} - -int spider_db_oracle_util::append_from_with_alias( - spider_string *str, - const char **table_names, - uint *table_name_lengths, - const char **table_aliases, - uint *table_alias_lengths, - uint table_count, - int *table_name_pos, - bool over_write -) { - uint roop_count, length = 0; - DBUG_ENTER("spider_db_oracle_util::append_from_with_alias"); - DBUG_PRINT("info",("spider this=%p", this)); - if (!over_write) - { - for (roop_count = 0; roop_count < table_count; roop_count++) - length += table_name_lengths[roop_count] + SPIDER_SQL_SPACE_LEN + - table_alias_lengths[roop_count] + SPIDER_SQL_COMMA_LEN; - if (str->reserve(SPIDER_SQL_FROM_LEN + length)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_FROM_STR, SPIDER_SQL_FROM_LEN); - *table_name_pos = str->length(); - } - for (roop_count = 0; roop_count < table_count; roop_count++) - { - str->q_append(table_names[roop_count], table_name_lengths[roop_count]); - str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN); - str->q_append(table_aliases[roop_count], table_alias_lengths[roop_count]); - str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } - str->length(str->length() - SPIDER_SQL_COMMA_LEN); - DBUG_RETURN(0); -} - -int spider_db_oracle_util::append_trx_isolation( - spider_string *str, - int trx_isolation -) { - DBUG_ENTER("spider_db_oracle_util::append_trx_isolation"); - DBUG_PRINT("info",("spider this=%p", this)); - if (str->reserve(SPIDER_SQL_SEMICOLON_LEN + - SPIDER_SQL_ISO_READ_COMMITTED_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - if (str->length()) - { - str->q_append(SPIDER_SQL_SEMICOLON_STR, SPIDER_SQL_SEMICOLON_LEN); - } - switch (trx_isolation) - { - case ISO_READ_UNCOMMITTED: - case ISO_READ_COMMITTED: - str->q_append(SPIDER_SQL_ISO_READ_COMMITTED_STR, - SPIDER_SQL_ISO_READ_COMMITTED_LEN); - break; - case ISO_REPEATABLE_READ: - case ISO_SERIALIZABLE: - str->q_append(SPIDER_SQL_ISO_SERIALIZABLE_STR, - SPIDER_SQL_ISO_SERIALIZABLE_LEN); - break; - default: - DBUG_RETURN(HA_ERR_UNSUPPORTED); - } - DBUG_RETURN(0); -} - -int spider_db_oracle_util::append_autocommit( - spider_string *str, - bool autocommit -) { - DBUG_ENTER("spider_db_oracle_util::append_autocommit"); - DBUG_PRINT("info",("spider this=%p", this)); - if (str->reserve(SPIDER_SQL_SEMICOLON_LEN + SPIDER_SQL_AUTOCOMMIT_OFF_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - if (str->length()) - { - str->q_append(SPIDER_SQL_SEMICOLON_STR, SPIDER_SQL_SEMICOLON_LEN); - } - if (autocommit) - { - str->q_append(SPIDER_SQL_AUTOCOMMIT_ON_STR, - SPIDER_SQL_AUTOCOMMIT_ON_LEN); - } else { - str->q_append(SPIDER_SQL_AUTOCOMMIT_OFF_STR, - SPIDER_SQL_AUTOCOMMIT_OFF_LEN); - } - DBUG_RETURN(0); -} - -int spider_db_oracle_util::append_sql_log_off( - spider_string *str, - bool sql_log_off -) { - DBUG_ENTER("spider_db_oracle_util::append_sql_log_off"); - DBUG_PRINT("info",("spider this=%p", this)); - /* nothing to do */ - DBUG_RETURN(0); -} - -int spider_db_oracle_util::append_wait_timeout( - spider_string *str, - int wait_timeout -) { - DBUG_ENTER("spider_db_oracle_util::append_wait_timeout"); - DBUG_PRINT("info",("spider this=%p", this)); - /* nothing to do */ - DBUG_RETURN(0); -} - -int spider_db_oracle_util::append_sql_mode( - spider_string *str, - sql_mode_t sql_mode -) { - DBUG_ENTER("spider_db_oracle_util::append_sql_mode"); - DBUG_PRINT("info",("spider this=%p", this)); - /* nothing to do */ - DBUG_RETURN(0); -} - -int spider_db_oracle_util::append_time_zone( - spider_string *str, - Time_zone *time_zone -) { - DBUG_ENTER("spider_db_oracle_util::append_time_zone"); - DBUG_PRINT("info",("spider this=%p", this)); - /* nothing to do */ - DBUG_RETURN(0); -} - -int spider_db_oracle_util::append_start_transaction( - spider_string *str -) { - DBUG_ENTER("spider_db_oracle_util::append_start_transaction"); - DBUG_PRINT("info",("spider this=%p", this)); - if (str->reserve(SPIDER_SQL_SEMICOLON_LEN + - SPIDER_SQL_START_TRANSACTION_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - if (str->length()) - { - str->q_append(SPIDER_SQL_SEMICOLON_STR, SPIDER_SQL_SEMICOLON_LEN); - } - str->q_append(SPIDER_SQL_START_TRANSACTION_STR, - SPIDER_SQL_START_TRANSACTION_LEN); - DBUG_RETURN(0); -} - -int spider_db_oracle_util::append_xa_start( - spider_string *str, - XID *xid -) { - DBUG_ENTER("spider_db_oracle_util::append_xa_start"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_ASSERT(0); - DBUG_RETURN(0); -} - -int spider_db_oracle_util::append_lock_table_head( - spider_string *str -) { - DBUG_ENTER("spider_db_oracle_util::append_lock_table_head"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(0); -} - -int spider_db_oracle_util::append_lock_table_body( - spider_string *str, - const char *db_name, - uint db_name_length, - CHARSET_INFO *db_name_charset, - const char *table_name, - uint table_name_length, - CHARSET_INFO *table_name_charset, - int lock_type -) { - DBUG_ENTER("spider_db_oracle_util::append_lock_table_body"); - DBUG_PRINT("info",("spider this=%p", this)); - if (str->reserve(SPIDER_SQL_SEMICOLON_LEN + SPIDER_SQL_LOCK_TABLE_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - if (str->length()) - { - str->q_append(SPIDER_SQL_SEMICOLON_STR, SPIDER_SQL_SEMICOLON_LEN); - } - str->q_append(SPIDER_SQL_LOCK_TABLE_STR, SPIDER_SQL_LOCK_TABLE_LEN); - if (str->reserve(SPIDER_SQL_NAME_QUOTE_LEN)) - { - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN); - if ( - str->append(db_name, db_name_length, db_name_charset) || - str->reserve((SPIDER_SQL_NAME_QUOTE_LEN) * 2 + SPIDER_SQL_DOT_LEN) - ) { - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN); - str->q_append(SPIDER_SQL_DOT_STR, SPIDER_SQL_DOT_LEN); - str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN); - if ( - str->append(table_name, table_name_length, table_name_charset) || - str->reserve(SPIDER_SQL_NAME_QUOTE_LEN + - spider_db_table_lock_len[lock_type]) - ) { - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN); - str->q_append(spider_db_table_lock_str[lock_type], - spider_db_table_lock_len[lock_type]); - DBUG_RETURN(0); -} - -int spider_db_oracle_util::append_lock_table_tail( - spider_string *str -) { - DBUG_ENTER("spider_db_oracle_util::append_lock_table_tail"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(0); -} - -int spider_db_oracle_util::append_unlock_table( - spider_string *str -) { - DBUG_ENTER("spider_db_oracle_util::append_unlock_table"); - DBUG_PRINT("info",("spider this=%p", this)); - if (str->reserve(SPIDER_SQL_COMMIT_LEN)) - { - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - str->q_append(SPIDER_SQL_COMMIT_STR, SPIDER_SQL_COMMIT_LEN); - DBUG_RETURN(0); -} - -int spider_db_oracle_util::open_item_func( - Item_func *item_func, - ha_spider *spider, - spider_string *str, - const char *alias, - uint alias_length, - bool use_fields, - spider_fields *fields -) { - uint dbton_id = spider_dbton_oracle.dbton_id; - int error_num; - Item *item, **item_list = item_func->arguments(); - Field *field; - LEX_CSTRING func_name_c; - uint roop_count, item_count = item_func->argument_count(), start_item = 0; - const char *func_name = SPIDER_SQL_NULL_CHAR_STR, - *separator_str = SPIDER_SQL_NULL_CHAR_STR, - *last_str = SPIDER_SQL_NULL_CHAR_STR; - int func_name_length = SPIDER_SQL_NULL_CHAR_LEN, - separator_str_length = SPIDER_SQL_NULL_CHAR_LEN, - last_str_length = SPIDER_SQL_NULL_CHAR_LEN; - int use_pushdown_udf; - bool merge_func = FALSE; - DBUG_ENTER("spider_db_oracle_util::open_item_func"); - if (str) - { - if (str->reserve(SPIDER_SQL_OPEN_PAREN_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN); - } - DBUG_PRINT("info",("spider functype = %d", item_func->functype())); - switch (item_func->functype()) - { - case Item_func::ISNULL_FUNC: - last_str = SPIDER_SQL_IS_NULL_STR; - last_str_length = SPIDER_SQL_IS_NULL_LEN; - break; - case Item_func::ISNOTNULL_FUNC: - last_str = SPIDER_SQL_IS_NOT_NULL_STR; - last_str_length = SPIDER_SQL_IS_NOT_NULL_LEN; - break; - case Item_func::UNKNOWN_FUNC: - func_name_c = item_func->func_name_cstring(); - func_name = func_name_c.str; - func_name_length = func_name_c.lengthstr; - DBUG_PRINT("info",("spider func_name = %s", func_name)); - DBUG_PRINT("info",("spider func_name_length = %d", func_name_length)); - if (func_name_length == 1 && - ( - !strncasecmp("+", func_name, func_name_length) || - !strncasecmp("-", func_name, func_name_length) || - !strncasecmp("*", func_name, func_name_length) || - !strncasecmp("/", func_name, func_name_length) || - !strncasecmp("%", func_name, func_name_length) || - !strncasecmp("&", func_name, func_name_length) || - !strncasecmp("|", func_name, func_name_length) || - !strncasecmp("^", func_name, func_name_length) - ) - ) { - /* no action */ - break; - } else if (func_name_length == 2 && - ( - !strncasecmp("<<", func_name, func_name_length) || - !strncasecmp(">>", func_name, func_name_length) - ) - ) { - /* no action */ - break; - } else if (func_name_length == 3 && - !strncasecmp("div", func_name, func_name_length) - ) { - /* no action */ - break; - } else if (func_name_length == 4) - { - if ( - !strncasecmp("rand", func_name, func_name_length) && -#ifdef SPIDER_Item_args_arg_count_IS_PROTECTED - !item_func->argument_count() -#else - !item_func->arg_count -#endif - ) { - if (str) - str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN); - DBUG_RETURN(spider_db_open_item_int(item_func, NULL, spider, str, - alias, alias_length, dbton_id, use_fields, fields)); - } else if ( - !strncasecmp("case", func_name, func_name_length) - ) { -#ifdef ITEM_FUNC_CASE_PARAMS_ARE_PUBLIC - Item_func_case *item_func_case = (Item_func_case *) item_func; - if (str) - { - if (str->reserve(SPIDER_SQL_CASE_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_CASE_STR, SPIDER_SQL_CASE_LEN); - } - if (item_func_case->first_expr_num != -1) - { - if ((error_num = spider_db_print_item_type( - item_list[item_func_case->first_expr_num], NULL, spider, str, - alias, alias_length, dbton_id, use_fields, fields))) - DBUG_RETURN(error_num); - } - for (roop_count = 0; roop_count < item_func_case->ncases; - roop_count += 2) - { - if (str) - { - if (str->reserve(SPIDER_SQL_WHEN_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_WHEN_STR, SPIDER_SQL_WHEN_LEN); - } - if ((error_num = spider_db_print_item_type( - item_list[roop_count], NULL, spider, str, - alias, alias_length, dbton_id, use_fields, fields))) - DBUG_RETURN(error_num); - if (str) - { - if (str->reserve(SPIDER_SQL_THEN_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_THEN_STR, SPIDER_SQL_THEN_LEN); - } - if ((error_num = spider_db_print_item_type( - item_list[roop_count + 1], NULL, spider, str, - alias, alias_length, dbton_id, use_fields, fields))) - DBUG_RETURN(error_num); - } - if (item_func_case->else_expr_num != -1) - { - if (str) - { - if (str->reserve(SPIDER_SQL_ELSE_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_ELSE_STR, SPIDER_SQL_ELSE_LEN); - } - if ((error_num = spider_db_print_item_type( - item_list[item_func_case->else_expr_num], NULL, spider, str, - alias, alias_length, dbton_id, use_fields, fields))) - DBUG_RETURN(error_num); - } - if (str) - { - if (str->reserve(SPIDER_SQL_END_LEN + SPIDER_SQL_CLOSE_PAREN_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_END_STR, SPIDER_SQL_END_LEN); - str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, - SPIDER_SQL_CLOSE_PAREN_LEN); - } - DBUG_RETURN(0); -#else - DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM); -#endif - } - } else if (func_name_length == 6 && - !strncasecmp("istrue", func_name, func_name_length) - ) { - last_str = SPIDER_SQL_IS_TRUE_STR; - last_str_length = SPIDER_SQL_IS_TRUE_LEN; - break; - } else if (func_name_length == 7) - { - if (!strncasecmp("isfalse", func_name, func_name_length)) - { - last_str = SPIDER_SQL_IS_FALSE_STR; - last_str_length = SPIDER_SQL_IS_FALSE_LEN; - break; - } else if ( - !strncasecmp("sysdate", func_name, func_name_length) || - !strncasecmp("curdate", func_name, func_name_length) || - !strncasecmp("curtime", func_name, func_name_length) - ) { - if (str) - str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN); - DBUG_RETURN(spider_db_open_item_string(item_func, NULL, spider, str, - alias, alias_length, dbton_id, use_fields, fields)); - } else if ( - !strncasecmp("convert", func_name, func_name_length) - ) { - if (str) - { - if (str->reserve(func_name_length * 2 + SPIDER_SQL_OPEN_PAREN_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(func_name, func_name_length); - str->q_append(SPIDER_SQL_OPEN_PAREN_STR, - SPIDER_SQL_OPEN_PAREN_LEN); - last_str = SPIDER_SQL_CLOSE_PAREN_STR; - last_str_length = SPIDER_SQL_CLOSE_PAREN_LEN; - } - break; - } - } else if (func_name_length == 8 && - ( - !strncasecmp("utc_date", func_name, func_name_length) || - !strncasecmp("utc_time", func_name, func_name_length) - ) - ) { - if (str) - str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN); - DBUG_RETURN(spider_db_open_item_string(item_func, NULL, spider, str, - alias, alias_length, dbton_id, use_fields, fields)); - } else if (func_name_length == 9 && - !strncasecmp("isnottrue", func_name, func_name_length) - ) { - last_str = SPIDER_SQL_IS_NOT_TRUE_STR; - last_str_length = SPIDER_SQL_IS_NOT_TRUE_LEN; - break; - } else if (func_name_length == 10) - { - if (!strncasecmp("isnotfalse", func_name, func_name_length)) - { - last_str = SPIDER_SQL_IS_NOT_FALSE_STR; - last_str_length = SPIDER_SQL_IS_NOT_FALSE_LEN; - break; - } else if (!strncasecmp("column_get", func_name, func_name_length)) - { - if (str) - { - str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN); - if (str->reserve(func_name_length + SPIDER_SQL_OPEN_PAREN_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(func_name, func_name_length); - str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN); - } - func_name = SPIDER_SQL_COMMA_STR; - func_name_length = SPIDER_SQL_COMMA_LEN; - separator_str = SPIDER_SQL_COMMA_STR; - separator_str_length = SPIDER_SQL_COMMA_LEN; - break; - } - } else if (func_name_length == 12) - { - if (!strncasecmp("cast_as_date", func_name, func_name_length)) - { - item = item_list[0]; - if (item->type() == Item::FUNC_ITEM) - { - DBUG_PRINT("info",("spider child is FUNC_ITEM")); - Item_func *ifunc = (Item_func *) item; - if (ifunc->functype() == Item_func::UNKNOWN_FUNC) - { - LEX_CSTRING child_func_name_c; - const char *child_func_name; - int child_func_name_length; - DBUG_PRINT("info",("spider child is UNKNOWN_FUNC")); - child_func_name_c = ifunc->func_name_cstring(); - child_func_name = child_func_name_c.str; - child_func_name_length = child_func_name_c.length; - DBUG_PRINT("info",("spider child func_name is %s", child_func_name)); - if ( - child_func_name_length == 10 && - !strncasecmp("column_get", child_func_name, child_func_name_length) - ) { - DBUG_PRINT("info",("spider this is merge func")); - merge_func = TRUE; - } - } - } - - if (str) - { - str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN); - if (!merge_func) - { - if (str->reserve(SPIDER_SQL_CAST_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN); - } - } - last_str = SPIDER_SQL_AS_DATE_STR; - last_str_length = SPIDER_SQL_AS_DATE_LEN; - break; - } else if (!strncasecmp("cast_as_time", func_name, func_name_length)) - { - item = item_list[0]; - if (item->type() == Item::FUNC_ITEM) - { - DBUG_PRINT("info",("spider child is FUNC_ITEM")); - Item_func *ifunc = (Item_func *) item; - if (ifunc->functype() == Item_func::UNKNOWN_FUNC) - { - LEX_CSTRING child_func_name_c; - const char *child_func_name; - int child_func_name_length; - DBUG_PRINT("info",("spider child is UNKNOWN_FUNC")); - child_func_name_c = ifunc->func_name_cstring(); - child_func_name = child_func_name_c.str; - child_func_name_length = child_func_name_c.length; - DBUG_PRINT("info",("spider child func_name is %s", child_func_name)); - if ( - child_func_name_length == 10 && - !strncasecmp("column_get", child_func_name, child_func_name_length) - ) { - DBUG_PRINT("info",("spider this is merge func")); - merge_func = TRUE; - } - } - } - - if (str) - { - str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN); - if (!merge_func) - { - if (str->reserve(SPIDER_SQL_CAST_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN); - } - } - last_str = SPIDER_SQL_AS_TIME_STR; - last_str_length = SPIDER_SQL_AS_TIME_LEN; - break; - } - } else if (func_name_length == 13) - { - if (!strncasecmp("utc_timestamp", func_name, func_name_length)) - { - if (str) - str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN); - DBUG_RETURN(spider_db_open_item_string(item_func, NULL, spider, str, - alias, alias_length, dbton_id, use_fields, fields)); - } else if (!strncasecmp("timestampdiff", func_name, func_name_length)) - { -#ifdef ITEM_FUNC_TIMESTAMPDIFF_ARE_PUBLIC - Item_func_timestamp_diff *item_func_timestamp_diff = - (Item_func_timestamp_diff *) item_func; - if (str) - { - const char *interval_str; - uint interval_len; - switch (item_func_timestamp_diff->int_type) - { - case INTERVAL_YEAR: - interval_str = SPIDER_SQL_YEAR_STR; - interval_len = SPIDER_SQL_YEAR_LEN; - break; - case INTERVAL_QUARTER: - interval_str = SPIDER_SQL_QUARTER_STR; - interval_len = SPIDER_SQL_QUARTER_LEN; - break; - case INTERVAL_MONTH: - interval_str = SPIDER_SQL_MONTH_STR; - interval_len = SPIDER_SQL_MONTH_LEN; - break; - case INTERVAL_WEEK: - interval_str = SPIDER_SQL_WEEK_STR; - interval_len = SPIDER_SQL_WEEK_LEN; - break; - case INTERVAL_DAY: - interval_str = SPIDER_SQL_DAY_STR; - interval_len = SPIDER_SQL_DAY_LEN; - break; - case INTERVAL_HOUR: - interval_str = SPIDER_SQL_HOUR_STR; - interval_len = SPIDER_SQL_HOUR_LEN; - break; - case INTERVAL_MINUTE: - interval_str = SPIDER_SQL_MINUTE_STR; - interval_len = SPIDER_SQL_MINUTE_LEN; - break; - case INTERVAL_SECOND: - interval_str = SPIDER_SQL_SECOND_STR; - interval_len = SPIDER_SQL_SECOND_LEN; - break; - case INTERVAL_MICROSECOND: - interval_str = SPIDER_SQL_MICROSECOND_STR; - interval_len = SPIDER_SQL_MICROSECOND_LEN; - break; - default: - interval_str = ""; - interval_len = 0; - break; - } - str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN); - if (str->reserve(func_name_length + SPIDER_SQL_OPEN_PAREN_LEN + - interval_len + SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(func_name, func_name_length); - str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN); - str->q_append(interval_str, interval_len); - str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } - if ((error_num = spider_db_print_item_type(item_list[0], NULL, spider, - str, alias, alias_length, dbton_id, use_fields, fields))) - DBUG_RETURN(error_num); - if (str) - { - if (str->reserve(SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } - if ((error_num = spider_db_print_item_type(item_list[1], NULL, spider, - str, alias, alias_length, dbton_id, use_fields, fields))) - DBUG_RETURN(error_num); - if (str) - { - if (str->reserve(SPIDER_SQL_CLOSE_PAREN_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, - SPIDER_SQL_CLOSE_PAREN_LEN); - } - DBUG_RETURN(0); -#else - DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM); -#endif - } - } else if (func_name_length == 14) - { - if (!strncasecmp("cast_as_binary", func_name, func_name_length)) - { - item = item_list[0]; - if (item->type() == Item::FUNC_ITEM) - { - DBUG_PRINT("info",("spider child is FUNC_ITEM")); - Item_func *ifunc = (Item_func *) item; - if (ifunc->functype() == Item_func::UNKNOWN_FUNC) - { - LEX_CSTRING child_func_name_c; - const char *child_func_name; - int child_func_name_length; - DBUG_PRINT("info",("spider child is UNKNOWN_FUNC")); - child_func_name_c = ifunc->func_name_cstring(); - child_func_name = child_func_name_c.str; - child_func_name_length = child_func_name_c.length; - DBUG_PRINT("info",("spider child func_name is %s", child_func_name)); - if ( - child_func_name_length == 10 && - !strncasecmp("column_get", child_func_name, child_func_name_length) - ) { - DBUG_PRINT("info",("spider this is merge func")); - merge_func = TRUE; - } - } - } - - if (str) - { - char tmp_buf[MAX_FIELD_WIDTH], *tmp_ptr, *tmp_ptr2; - spider_string tmp_str(tmp_buf, MAX_FIELD_WIDTH, str->charset()); - tmp_str.init_calc_mem(123); - tmp_str.length(0); - str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN); - if (!merge_func) - { - if (str->reserve(SPIDER_SQL_CAST_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN); - } -#if MYSQL_VERSION_ID < 50500 - item_func->print(tmp_str.get_str(), QT_IS); -#else - item_func->print(tmp_str.get_str(), QT_TO_SYSTEM_CHARSET); -#endif - tmp_str.mem_calc(); - if (tmp_str.reserve(1)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - tmp_ptr = tmp_str.c_ptr_quick(); - DBUG_PRINT("info",("spider tmp_ptr = %s", tmp_ptr)); - while ((tmp_ptr2 = strstr(tmp_ptr, SPIDER_SQL_AS_BINARY_STR))) - tmp_ptr = tmp_ptr2 + 1; - last_str = tmp_ptr - 1; - last_str_length = strlen(last_str) - SPIDER_SQL_CLOSE_PAREN_LEN; - } - break; - } else if (!strncasecmp("cast_as_signed", func_name, func_name_length)) - { - item = item_list[0]; - if (item->type() == Item::FUNC_ITEM) - { - DBUG_PRINT("info",("spider child is FUNC_ITEM")); - Item_func *ifunc = (Item_func *) item; - if (ifunc->functype() == Item_func::UNKNOWN_FUNC) - { - LEX_CSTRING child_func_name_c; - const char *child_func_name; - int child_func_name_length; - DBUG_PRINT("info",("spider child is UNKNOWN_FUNC")); - child_func_name_c = ifunc->func_name_cstring(); - child_func_name = child_func_name_c.str; - child_func_name_length = child_func_name_c.length; - DBUG_PRINT("info",("spider child func_name is %s", child_func_name)); - if ( - child_func_name_length == 10 && - !strncasecmp("column_get", child_func_name, child_func_name_length) - ) { - DBUG_PRINT("info",("spider this is merge func")); - merge_func = TRUE; - } - } - } - - if (str) - { - str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN); - if (!merge_func) - { - if (str->reserve(SPIDER_SQL_CAST_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN); - } - } - last_str = SPIDER_SQL_AS_SIGNED_STR; - last_str_length = SPIDER_SQL_AS_SIGNED_LEN; - break; - } - } else if (func_name_length == 16) - { - if (!strncasecmp("cast_as_unsigned", func_name, func_name_length)) - { - item = item_list[0]; - if (item->type() == Item::FUNC_ITEM) - { - DBUG_PRINT("info",("spider child is FUNC_ITEM")); - Item_func *ifunc = (Item_func *) item; - if (ifunc->functype() == Item_func::UNKNOWN_FUNC) - { - LEX_CSTRING child_func_name_c; - const char *child_func_name; - int child_func_name_length; - DBUG_PRINT("info",("spider child is UNKNOWN_FUNC")); - child_func_name_c = ifunc->func_name_cstring(); - child_func_name = child_func_name_c.str; - child_func_name_length = child_func_name_c.length; - DBUG_PRINT("info",("spider child func_name is %s", child_func_name)); - if ( - child_func_name_length == 10 && - !strncasecmp("column_get", child_func_name, child_func_name_length) - ) { - DBUG_PRINT("info",("spider this is merge func")); - merge_func = TRUE; - } - } - } - - if (str) - { - str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN); - if (!merge_func) - { - if (str->reserve(SPIDER_SQL_CAST_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN); - } - } - last_str = SPIDER_SQL_AS_UNSIGNED_STR; - last_str_length = SPIDER_SQL_AS_UNSIGNED_LEN; - break; - } else if (!strncasecmp("decimal_typecast", func_name, - func_name_length)) - { - item = item_list[0]; - if (item->type() == Item::FUNC_ITEM) - { - DBUG_PRINT("info",("spider child is FUNC_ITEM")); - Item_func *ifunc = (Item_func *) item; - if (ifunc->functype() == Item_func::UNKNOWN_FUNC) - { - LEX_CSTRING child_func_name_c; - const char *child_func_name; - int child_func_name_length; - DBUG_PRINT("info",("spider child is UNKNOWN_FUNC")); - child_func_name_c = ifunc->func_name_cstring(); - child_func_name = child_func_name_c.str; - child_func_name_length = child_func_name_c.length; - DBUG_PRINT("info",("spider child func_name is %s", child_func_name)); - if ( - child_func_name_length == 10 && - !strncasecmp("column_get", child_func_name, child_func_name_length) - ) { - DBUG_PRINT("info",("spider this is merge func")); - merge_func = TRUE; - } - } - } - - if (str) - { - char tmp_buf[MAX_FIELD_WIDTH], *tmp_ptr, *tmp_ptr2; - spider_string tmp_str(tmp_buf, MAX_FIELD_WIDTH, str->charset()); - tmp_str.init_calc_mem(124); - tmp_str.length(0); - str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN); - if (!merge_func) - { - if (str->reserve(SPIDER_SQL_CAST_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN); - } -#if MYSQL_VERSION_ID < 50500 - item_func->print(tmp_str.get_str(), QT_IS); -#else - item_func->print(tmp_str.get_str(), QT_TO_SYSTEM_CHARSET); -#endif - tmp_str.mem_calc(); - if (tmp_str.reserve(1)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - tmp_ptr = tmp_str.c_ptr_quick(); - DBUG_PRINT("info",("spider tmp_ptr = %s", tmp_ptr)); - while ((tmp_ptr2 = strstr(tmp_ptr, SPIDER_SQL_AS_DECIMAL_STR))) - tmp_ptr = tmp_ptr2 + 1; - last_str = tmp_ptr - 1; - last_str_length = strlen(last_str) - SPIDER_SQL_CLOSE_PAREN_LEN; - } - break; - } else if (!strncasecmp("cast_as_datetime", func_name, - func_name_length)) - { - item = item_list[0]; - if (item->type() == Item::FUNC_ITEM) - { - DBUG_PRINT("info",("spider child is FUNC_ITEM")); - Item_func *ifunc = (Item_func *) item; - if (ifunc->functype() == Item_func::UNKNOWN_FUNC) - { - LEX_CSTRING child_func_name_c; - const char *child_func_name; - int child_func_name_length; - DBUG_PRINT("info",("spider child is UNKNOWN_FUNC")); - child_func_name_c = ifunc->func_name_cstring(); - child_func_name = child_func_name_c.str; - child_func_name_length = child_func_name_c.length; - DBUG_PRINT("info",("spider child func_name is %s", child_func_name)); - if ( - child_func_name_length == 10 && - !strncasecmp("column_get", child_func_name, child_func_name_length) - ) { - DBUG_PRINT("info",("spider this is merge func")); - merge_func = TRUE; - } - } - } - - if (str) - { - str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN); - if (!merge_func) - { - if (str->reserve(SPIDER_SQL_CAST_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN); - } - } - last_str = SPIDER_SQL_AS_DATETIME_STR; - last_str_length = SPIDER_SQL_AS_DATETIME_LEN; - break; - } - } else if (func_name_length == 17) - { - if (!strncasecmp("date_add_interval", func_name, func_name_length)) - { - Item_date_add_interval *item_date_add_interval = - (Item_date_add_interval *) item_func; - switch (item_date_add_interval->int_type) - { - case INTERVAL_YEAR: - case INTERVAL_QUARTER: - case INTERVAL_MONTH: - if (str) - { - if (str->reserve(SPIDER_SQL_ADD_MONTHS_LEN + - SPIDER_SQL_OPEN_PAREN_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_ADD_MONTHS_STR, - SPIDER_SQL_ADD_MONTHS_LEN); - str->q_append(SPIDER_SQL_OPEN_PAREN_STR, - SPIDER_SQL_OPEN_PAREN_LEN); - } - if ((error_num = spider_db_print_item_type(item_list[0], NULL, - spider, str, alias, alias_length, dbton_id, use_fields, - fields))) - DBUG_RETURN(error_num); - if (str) - { - if (item_date_add_interval->date_sub_interval) - { - if (str->reserve(SPIDER_SQL_COMMA_LEN + - SPIDER_SQL_MINUS_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - str->q_append(SPIDER_SQL_MINUS_STR, SPIDER_SQL_MINUS_LEN); - } else { - if (str->reserve(SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } - } - if ((error_num = spider_db_print_item_type(item_list[1], NULL, - spider, str, alias, alias_length, dbton_id, use_fields, - fields))) - DBUG_RETURN(error_num); - if (str) - { - if (item_date_add_interval->int_type == INTERVAL_YEAR) - { - func_name = " * 12"; - func_name_length = sizeof(" * 12") - 1; - if (str->reserve(func_name_length + - (SPIDER_SQL_CLOSE_PAREN_LEN * 2))) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(func_name, func_name_length); - str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, - SPIDER_SQL_CLOSE_PAREN_LEN); - str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, - SPIDER_SQL_CLOSE_PAREN_LEN); - } else if (item_date_add_interval->int_type == - INTERVAL_QUARTER) - { - func_name = " * 3"; - func_name_length = sizeof(" * 3") - 1; - if (str->reserve(func_name_length + - (SPIDER_SQL_CLOSE_PAREN_LEN * 2))) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(func_name, func_name_length); - str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, - SPIDER_SQL_CLOSE_PAREN_LEN); - str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, - SPIDER_SQL_CLOSE_PAREN_LEN); - } else { - if (str->reserve(SPIDER_SQL_CLOSE_PAREN_LEN * 2)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, - SPIDER_SQL_CLOSE_PAREN_LEN); - str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, - SPIDER_SQL_CLOSE_PAREN_LEN); - } - } - break; - case INTERVAL_WEEK: - case INTERVAL_DAY: - case INTERVAL_HOUR: - case INTERVAL_MINUTE: - case INTERVAL_SECOND: - case INTERVAL_MICROSECOND: - if ((error_num = spider_db_print_item_type(item_list[0], NULL, - spider, str, alias, alias_length, dbton_id, use_fields, - fields))) - DBUG_RETURN(error_num); - if (str) - { - if (item_date_add_interval->date_sub_interval) - { - if (str->reserve(SPIDER_SQL_MINUS_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_MINUS_STR, SPIDER_SQL_MINUS_LEN); - } else { - if (str->reserve(SPIDER_SQL_PLUS_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_PLUS_STR, SPIDER_SQL_PLUS_LEN); - } - } - if ((error_num = spider_db_print_item_type(item_list[1], NULL, - spider, str, alias, alias_length, dbton_id, use_fields, - fields))) - DBUG_RETURN(error_num); - if (str) - { - if (item_date_add_interval->int_type == INTERVAL_WEEK) - { - func_name = " * 7"; - func_name_length = sizeof(" * 7") - 1; - if (str->reserve(func_name_length + - (SPIDER_SQL_CLOSE_PAREN_LEN))) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(func_name, func_name_length); - str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, - SPIDER_SQL_CLOSE_PAREN_LEN); - } else if (item_date_add_interval->int_type == INTERVAL_HOUR) - { - func_name = " / 24"; - func_name_length = sizeof(" / 24") - 1; - if (str->reserve(func_name_length + - (SPIDER_SQL_CLOSE_PAREN_LEN))) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(func_name, func_name_length); - str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, - SPIDER_SQL_CLOSE_PAREN_LEN); - } else if (item_date_add_interval->int_type == INTERVAL_MINUTE) - { - func_name = " / 1440"; - func_name_length = sizeof(" / 1440") - 1; - if (str->reserve(func_name_length + - (SPIDER_SQL_CLOSE_PAREN_LEN))) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(func_name, func_name_length); - str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, - SPIDER_SQL_CLOSE_PAREN_LEN); - } else if (item_date_add_interval->int_type == INTERVAL_SECOND) - { - func_name = " / 86400"; - func_name_length = sizeof(" / 86400") - 1; - if (str->reserve(func_name_length + - (SPIDER_SQL_CLOSE_PAREN_LEN))) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(func_name, func_name_length); - str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, - SPIDER_SQL_CLOSE_PAREN_LEN); - } else if (item_date_add_interval->int_type == - INTERVAL_MICROSECOND) - { - func_name = " / 86400000000"; - func_name_length = sizeof(" / 86400000000") - 1; - if (str->reserve(func_name_length + - (SPIDER_SQL_CLOSE_PAREN_LEN))) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(func_name, func_name_length); - str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, - SPIDER_SQL_CLOSE_PAREN_LEN); - } else { - if (str->reserve(SPIDER_SQL_CLOSE_PAREN_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, - SPIDER_SQL_CLOSE_PAREN_LEN); - } - } - break; - default: - DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM); - } - DBUG_RETURN(0); - break; - } - } - if (str) - { - if (str->reserve(func_name_length + SPIDER_SQL_OPEN_PAREN_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(func_name, func_name_length); - str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN); - } - func_name = SPIDER_SQL_COMMA_STR; - func_name_length = SPIDER_SQL_COMMA_LEN; - separator_str = SPIDER_SQL_COMMA_STR; - separator_str_length = SPIDER_SQL_COMMA_LEN; - last_str = SPIDER_SQL_CLOSE_PAREN_STR; - last_str_length = SPIDER_SQL_CLOSE_PAREN_LEN; - break; - case Item_func::NOW_FUNC: - if (str) - str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN); - DBUG_RETURN(spider_db_open_item_string(item_func, NULL, spider, str, - alias, alias_length, dbton_id, use_fields, fields)); - case Item_func::CHAR_TYPECAST_FUNC: - DBUG_PRINT("info",("spider CHAR_TYPECAST_FUNC")); - { - item = item_list[0]; - if (item->type() == Item::FUNC_ITEM) - { - DBUG_PRINT("info",("spider child is FUNC_ITEM")); - Item_func *ifunc = (Item_func *) item; - if (ifunc->functype() == Item_func::UNKNOWN_FUNC) - { - LEX_CSTRING child_func_name_c; - const char *child_func_name; - int child_func_name_length; - DBUG_PRINT("info",("spider child is UNKNOWN_FUNC")); - child_func_name_c = ifunc->func_name_cstring(); - child_func_name = child_func_name_c.str; - child_func_name_length = child_func_name_c.length; - DBUG_PRINT("info",("spider child func_name is %s", child_func_name)); - if ( - child_func_name_length == 10 && - !strncasecmp("column_get", child_func_name, child_func_name_length) - ) { - DBUG_PRINT("info",("spider this is merge func")); - merge_func = TRUE; - } - } - } - - if (str) - { - char tmp_buf[MAX_FIELD_WIDTH], *tmp_ptr, *tmp_ptr2; - spider_string tmp_str(tmp_buf, MAX_FIELD_WIDTH, str->charset()); - tmp_str.init_calc_mem(125); - tmp_str.length(0); - str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN); - if (!merge_func) - { - if (str->reserve(SPIDER_SQL_CAST_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN); - } -#if MYSQL_VERSION_ID < 50500 - item_func->print(tmp_str.get_str(), QT_IS); -#else - item_func->print(tmp_str.get_str(), QT_TO_SYSTEM_CHARSET); -#endif - tmp_str.mem_calc(); - if (tmp_str.reserve(1)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - tmp_ptr = tmp_str.c_ptr_quick(); - DBUG_PRINT("info",("spider tmp_ptr = %s", tmp_ptr)); - while ((tmp_ptr2 = strstr(tmp_ptr, SPIDER_SQL_AS_CHAR_STR))) - tmp_ptr = tmp_ptr2 + 1; - last_str = tmp_ptr - 1; - last_str_length = strlen(last_str) - SPIDER_SQL_CLOSE_PAREN_LEN; - } - } - break; - case Item_func::NOT_FUNC: - DBUG_PRINT("info",("spider NOT_FUNC")); - if (item_list[0]->type() == Item::COND_ITEM) - { - DBUG_PRINT("info",("spider item_list[0] is COND_ITEM")); - Item_cond *item_cond = (Item_cond *) item_list[0]; - if (item_cond->functype() == Item_func::COND_AND_FUNC) - { - DBUG_PRINT("info",("spider item_cond is COND_AND_FUNC")); - List_iterator_fast<Item> lif(*(item_cond->argument_list())); - bool has_expr_cache_item = FALSE; - bool has_isnotnull_func = FALSE; - bool has_other_item = FALSE; - while((item = lif++)) - { -#ifdef SPIDER_HAS_EXPR_CACHE_ITEM - if ( - item->type() == Item::EXPR_CACHE_ITEM - ) { - DBUG_PRINT("info",("spider EXPR_CACHE_ITEM")); - has_expr_cache_item = TRUE; - } else -#endif - if ( - item->type() == Item::FUNC_ITEM && - ((Item_func *) item)->functype() == Item_func::ISNOTNULL_FUNC - ) { - DBUG_PRINT("info",("spider ISNOTNULL_FUNC")); - has_isnotnull_func = TRUE; - } else { - DBUG_PRINT("info",("spider has other item")); - DBUG_PRINT("info",("spider COND type=%d", item->type())); - has_other_item = TRUE; - } - } - if (has_expr_cache_item && has_isnotnull_func && !has_other_item) - { - DBUG_PRINT("info",("spider NOT EXISTS skip")); - DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM); - } - } - } - if (str) - { - func_name_c = item_func->func_name_cstring(); - func_name = func_name_c.str; - func_name_length = func_name_c.lengthstr; - if (str->reserve(func_name_length + SPIDER_SQL_SPACE_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(func_name, func_name_length); - str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN); - } - break; - case Item_func::NEG_FUNC: - if (str) - { - func_name_c = item_func->func_name_cstring(); - func_name = func_name_c.str; - func_name_length = func_name_c.lengthstr; - if (str->reserve(func_name_length + SPIDER_SQL_SPACE_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(func_name, func_name_length); - str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN); - } - break; - case Item_func::IN_FUNC: - if (((Item_func_opt_neg *) item_func)->negated) - { - func_name = SPIDER_SQL_NOT_IN_STR; - func_name_length = SPIDER_SQL_NOT_IN_LEN; - separator_str = SPIDER_SQL_COMMA_STR; - separator_str_length = SPIDER_SQL_COMMA_LEN; - last_str = SPIDER_SQL_CLOSE_PAREN_STR; - last_str_length = SPIDER_SQL_CLOSE_PAREN_LEN; - } else { - func_name = SPIDER_SQL_IN_STR; - func_name_length = SPIDER_SQL_IN_LEN; - separator_str = SPIDER_SQL_COMMA_STR; - separator_str_length = SPIDER_SQL_COMMA_LEN; - last_str = SPIDER_SQL_CLOSE_PAREN_STR; - last_str_length = SPIDER_SQL_CLOSE_PAREN_LEN; - } - break; - case Item_func::BETWEEN: - if (((Item_func_opt_neg *) item_func)->negated) - { - func_name = SPIDER_SQL_NOT_BETWEEN_STR; - func_name_length = SPIDER_SQL_NOT_BETWEEN_LEN; - separator_str = SPIDER_SQL_AND_STR; - separator_str_length = SPIDER_SQL_AND_LEN; - } else { - func_name_c = item_func->func_name_cstring(); - func_name = func_name_c.str; - func_name_length = func_name_c.lengthstr; - separator_str = SPIDER_SQL_AND_STR; - separator_str_length = SPIDER_SQL_AND_LEN; - } - break; - case Item_func::UDF_FUNC: - use_pushdown_udf = spider_param_use_pushdown_udf( - spider->wide_handler->trx->thd, - spider->share->use_pushdown_udf); - if (!use_pushdown_udf) - DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM); - if (str) - { - func_name_c = item_func->func_name_cstring(); - func_name = func_name_c.str; - func_name_length = func_name_c.lengthstr; - DBUG_PRINT("info",("spider func_name = %s", func_name)); - DBUG_PRINT("info",("spider func_name_length = %d", func_name_length)); - if (str->reserve(func_name_length + SPIDER_SQL_OPEN_PAREN_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(func_name, func_name_length); - str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN); - } - func_name = SPIDER_SQL_COMMA_STR; - func_name_length = SPIDER_SQL_COMMA_LEN; - separator_str = SPIDER_SQL_COMMA_STR; - separator_str_length = SPIDER_SQL_COMMA_LEN; - last_str = SPIDER_SQL_CLOSE_PAREN_STR; - last_str_length = SPIDER_SQL_CLOSE_PAREN_LEN; - break; -#ifdef MARIADB_BASE_VERSION - case Item_func::XOR_FUNC: -#else - case Item_func::COND_XOR_FUNC: -#endif - if (str) - str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN); - DBUG_RETURN( - spider_db_open_item_cond((Item_cond *) item_func, spider, str, - alias, alias_length, dbton_id, use_fields, fields)); - case Item_func::TRIG_COND_FUNC: - DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM); - case Item_func::GUSERVAR_FUNC: - if (str) - str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN); - if (item_func->result_type() == STRING_RESULT) - DBUG_RETURN(spider_db_open_item_string(item_func, NULL, spider, str, - alias, alias_length, dbton_id, use_fields, fields)); - else - DBUG_RETURN(spider_db_open_item_int(item_func, NULL, spider, str, - alias, alias_length, dbton_id, use_fields, fields)); - case Item_func::FT_FUNC: - if (spider_db_check_ft_idx(item_func, spider) == MAX_KEY) - DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM); - start_item = 1; - if (str) - { - if (str->reserve(SPIDER_SQL_MATCH_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_MATCH_STR, SPIDER_SQL_MATCH_LEN); - } - separator_str = SPIDER_SQL_COMMA_STR; - separator_str_length = SPIDER_SQL_COMMA_LEN; - last_str = SPIDER_SQL_CLOSE_PAREN_STR; - last_str_length = SPIDER_SQL_CLOSE_PAREN_LEN; - break; - case Item_func::SP_EQUALS_FUNC: - if (str) - { - func_name = SPIDER_SQL_MBR_EQUAL_STR; - func_name_length = SPIDER_SQL_MBR_EQUAL_LEN; - DBUG_PRINT("info",("spider func_name = %s", func_name)); - DBUG_PRINT("info",("spider func_name_length = %d", func_name_length)); - if (str->reserve(func_name_length)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(func_name, func_name_length); - } - func_name = SPIDER_SQL_COMMA_STR; - func_name_length = SPIDER_SQL_COMMA_LEN; - separator_str = SPIDER_SQL_COMMA_STR; - separator_str_length = SPIDER_SQL_COMMA_LEN; - last_str = SPIDER_SQL_CLOSE_PAREN_STR; - last_str_length = SPIDER_SQL_CLOSE_PAREN_LEN; - break; - case Item_func::SP_DISJOINT_FUNC: - case Item_func::SP_INTERSECTS_FUNC: - case Item_func::SP_TOUCHES_FUNC: - case Item_func::SP_CROSSES_FUNC: - case Item_func::SP_WITHIN_FUNC: - case Item_func::SP_CONTAINS_FUNC: - case Item_func::SP_OVERLAPS_FUNC: - if (str) - { - func_name_c = item_func->func_name_cstring(); - func_name = func_name_c.str; - func_name_length = func_name_c.lengthstr; - DBUG_PRINT("info",("spider func_name = %s", func_name)); - DBUG_PRINT("info",("spider func_name_length = %d", func_name_length)); - if (str->reserve( -#ifndef SPIDER_ITEM_GEOFUNC_NAME_HAS_MBR - SPIDER_SQL_MBR_LEN + -#endif - func_name_length + SPIDER_SQL_OPEN_PAREN_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); -#ifndef SPIDER_ITEM_GEOFUNC_NAME_HAS_MBR - str->q_append(SPIDER_SQL_MBR_STR, SPIDER_SQL_MBR_LEN); -#endif - str->q_append(func_name, func_name_length); - str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN); - } - func_name = SPIDER_SQL_COMMA_STR; - func_name_length = SPIDER_SQL_COMMA_LEN; - separator_str = SPIDER_SQL_COMMA_STR; - separator_str_length = SPIDER_SQL_COMMA_LEN; - last_str = SPIDER_SQL_CLOSE_PAREN_STR; - last_str_length = SPIDER_SQL_CLOSE_PAREN_LEN; - break; - case Item_func::EQ_FUNC: - case Item_func::EQUAL_FUNC: - case Item_func::NE_FUNC: - case Item_func::LT_FUNC: - case Item_func::LE_FUNC: - case Item_func::GE_FUNC: - case Item_func::GT_FUNC: - if (str) - { - func_name_c = item_func->func_name_cstring(); - func_name = func_name_c.str; - func_name_length = func_name_c.lengthstr; - } - break; - case Item_func::LIKE_FUNC: -#ifdef SPIDER_LIKE_FUNC_HAS_GET_NEGATED - if (str) - { - if (((Item_func_like *)item_func)->get_negated()) - { - func_name = SPIDER_SQL_NOT_LIKE_STR; - func_name_length = SPIDER_SQL_NOT_LIKE_LEN; - } - else - { - func_name_c = item_func->func_name_cstring(); - func_name = func_name_c.str; - func_name_length = func_name_c.lengthstr; - } - } - break; -#else - DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM); -#endif - default: - THD *thd = spider->wide_handler->trx->thd; - SPIDER_SHARE *share = spider->share; - if (spider_param_skip_default_condition(thd, - share->skip_default_condition)) - DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM); - if (str) - { - func_name_c = item_func->func_name_cstring(); - func_name = func_name_c.str; - func_name_length = func_name_c.lengthstr; - } - break; - } - DBUG_PRINT("info",("spider func_name = %s", func_name)); - DBUG_PRINT("info",("spider func_name_length = %d", func_name_length)); - DBUG_PRINT("info",("spider separator_str = %s", separator_str)); - DBUG_PRINT("info",("spider separator_str_length = %d", separator_str_length)); - DBUG_PRINT("info",("spider last_str = %s", last_str)); - DBUG_PRINT("info",("spider last_str_length = %d", last_str_length)); - if (item_count) - { - /* Find the field in the list of items of the expression tree */ - field = spider_db_find_field_in_item_list(item_list, - item_count, start_item, - str, - func_name, func_name_length); - item_count--; - for (roop_count = start_item; roop_count < item_count; roop_count++) - { - item = item_list[roop_count]; - if ((error_num = spider_db_print_item_type(item, field, spider, str, - alias, alias_length, dbton_id, use_fields, fields))) - DBUG_RETURN(error_num); - if (roop_count == 1) - { - func_name = separator_str; - func_name_length = separator_str_length; - } - if (str) - { - if (str->reserve(func_name_length + SPIDER_SQL_SPACE_LEN * 2)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN); - str->q_append(func_name, func_name_length); - str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN); - } - } - item = item_list[roop_count]; - if ((error_num = spider_db_print_item_type(item, field, spider, str, - alias, alias_length, dbton_id, use_fields, fields))) - DBUG_RETURN(error_num); - } - if (item_func->functype() == Item_func::FT_FUNC) - { - Item_func_match *item_func_match = (Item_func_match *)item_func; - if (str) - { - if (str->reserve(SPIDER_SQL_AGAINST_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_AGAINST_STR, SPIDER_SQL_AGAINST_LEN); - } - item = item_list[0]; - if ((error_num = spider_db_print_item_type(item, NULL, spider, str, - alias, alias_length, dbton_id, use_fields, fields))) - DBUG_RETURN(error_num); - if (str) - { - if (str->reserve( - ((item_func_match->match_flags & FT_BOOL) ? - SPIDER_SQL_IN_BOOLEAN_MODE_LEN : 0) + - ((item_func_match->match_flags & FT_EXPAND) ? - SPIDER_SQL_WITH_QUERY_EXPANSION_LEN : 0) - )) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - if (item_func_match->match_flags & FT_BOOL) - str->q_append(SPIDER_SQL_IN_BOOLEAN_MODE_STR, - SPIDER_SQL_IN_BOOLEAN_MODE_LEN); - if (item_func_match->match_flags & FT_EXPAND) - str->q_append(SPIDER_SQL_WITH_QUERY_EXPANSION_STR, - SPIDER_SQL_WITH_QUERY_EXPANSION_LEN); - } - } else if (item_func->functype() == Item_func::UNKNOWN_FUNC) - { - if ( - func_name_length == 7 && - !strncasecmp("convert", func_name, func_name_length) - ) { - if (str) - { - Item_func_conv_charset *item_func_conv_charset = - (Item_func_conv_charset *)item_func; - CHARSET_INFO *conv_charset = - item_func_conv_charset->SPIDER_Item_func_conv_charset_conv_charset; - uint cset_length = strlen(conv_charset->csname); - if (str->reserve(SPIDER_SQL_USING_LEN + cset_length)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_USING_STR, SPIDER_SQL_USING_LEN); - str->q_append(conv_charset->csname, cset_length); - } - } - } - if (str) - { - if (merge_func) - str->length(str->length() - SPIDER_SQL_CLOSE_PAREN_LEN); - if (str->reserve(last_str_length + SPIDER_SQL_CLOSE_PAREN_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(last_str, last_str_length); - str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN); - } - DBUG_RETURN(0); -} - -#ifdef HANDLER_HAS_DIRECT_AGGREGATE -int spider_db_oracle_util::open_item_sum_func( - Item_sum *item_sum, - ha_spider *spider, - spider_string *str, - const char *alias, - uint alias_length, - bool use_fields, - spider_fields *fields -) { - uint dbton_id = spider_dbton_oracle.dbton_id; - uint roop_count, item_count = item_sum->get_arg_count(); - int error_num; - DBUG_ENTER("spider_db_oracle_util::open_item_sum_func"); - DBUG_PRINT("info",("spider Sumfunctype = %d", item_sum->sum_func())); - switch (item_sum->sum_func()) - { - case Item_sum::COUNT_FUNC: - case Item_sum::SUM_FUNC: - case Item_sum::MIN_FUNC: - case Item_sum::MAX_FUNC: - { - LEX_CSTRING func_name_c= item_sum->func_name_cstring(); - const char *func_name = func_name_c.str; - uint func_name_length = func_name_c.length; - Item *item, **args = item_sum->get_args(); - if (str) - { - if (str->reserve(func_name_length)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(func_name, func_name_length); - } - if (item_count) - { - item_count--; - for (roop_count = 0; roop_count < item_count; roop_count++) - { - item = args[roop_count]; - if ((error_num = spider_db_print_item_type(item, NULL, spider, str, - alias, alias_length, dbton_id, use_fields, fields))) - DBUG_RETURN(error_num); - if (str) - { - if (str->reserve(SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } - } - item = args[roop_count]; - if ((error_num = spider_db_print_item_type(item, NULL, spider, str, - alias, alias_length, dbton_id, use_fields, fields))) - DBUG_RETURN(error_num); - } - if (str) - { - if (str->reserve(SPIDER_SQL_CLOSE_PAREN_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, - SPIDER_SQL_CLOSE_PAREN_LEN); - } - } - break; - case Item_sum::COUNT_DISTINCT_FUNC: - case Item_sum::SUM_DISTINCT_FUNC: - case Item_sum::AVG_FUNC: - case Item_sum::AVG_DISTINCT_FUNC: - case Item_sum::STD_FUNC: - case Item_sum::VARIANCE_FUNC: - case Item_sum::SUM_BIT_FUNC: - case Item_sum::UDF_SUM_FUNC: - case Item_sum::GROUP_CONCAT_FUNC: - default: - DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM); - } - DBUG_RETURN(0); -} -#endif - -size_t spider_db_oracle_util::escape_string( - char *to, - const char *from, - size_t from_length, - CHARSET_INFO *access_charset -) { - my_bool overflow; - DBUG_ENTER("spider_db_oracle::escape_string"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(escape_quotes_for_mysql(access_charset, to, 0, - from, from_length, &overflow)); -} - -int spider_db_oracle_util::append_escaped_util( - spider_string *to, - String *from -) { - size_t copy_length; - DBUG_ENTER("spider_db_oracle_util::append_escaped_util"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_PRINT("info",("spider to=%s", to->c_ptr_safe())); - DBUG_PRINT("info",("spider from=%s", from->c_ptr_safe())); - copy_length = escape_string((char *) to->ptr() + to->length(), from->ptr(), - from->length(), to->charset()); - DBUG_PRINT("info",("spider copy_length=%zu", copy_length)); - to->length(to->length() + copy_length); - to->mem_calc(); - DBUG_RETURN(0); -} - -#ifdef SPIDER_HAS_GROUP_BY_HANDLER -int spider_db_oracle_util::append_from_and_tables( - ha_spider *spider, - spider_fields *fields, - spider_string *str, - TABLE_LIST *table_list, - uint table_count -) { - SPIDER_TABLE_HOLDER *table_holder; - int error_num; - uint dbton_id = spider_dbton_oracle.dbton_id, from_length; - spider_oracle_share *db_share; - spider_oracle_handler *dbton_hdl; - ha_spider *spider; - DBUG_ENTER("spider_db_oracle_util::append_from_and_tables"); - DBUG_PRINT("info",("spider this=%p", this)); - - /* calculate from size */ - from_length = SPIDER_SQL_FROM_LEN; - fields->set_pos_to_first_table_holder(); - while ((table_holder = fields->get_next_table_holder())) - { - spider = table_holder->spider; - db_share = (spider_oracle_share *) - spider->share->dbton_share[dbton_id]; - from_length += - db_share->db_nm_max_length + - SPIDER_SQL_DOT_LEN + /* SPIDER_SQL_NAME_QUOTE_LEN */ 4 + - db_share->table_nm_max_length + - SPIDER_SQL_SPACE_LEN + SPIDER_SQL_COMMA_LEN + - table_holder->alias->length() - SPIDER_SQL_DOT_LEN; - } - - if (str->reserve(from_length)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_FROM_STR, SPIDER_SQL_FROM_LEN); - - fields->set_pos_to_first_table_holder(); - while ((table_holder = fields->get_next_table_holder())) - { - spider = table_holder->spider; - db_share = (spider_oracle_share *) - spider->share->dbton_share[dbton_id]; - dbton_hdl = (spider_oracle_handler *) spider->dbton_handler[dbton_id]; - dbton_hdl->table_name_pos = str->length(); - if ((error_num = db_share->append_table_name_with_adjusting(str, - spider->conn_link_idx[dbton_hdl->first_link_idx]))) - { - DBUG_RETURN(error_num); - } - str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN); - str->q_append(table_holder->alias->ptr(), - table_holder->alias->length() - SPIDER_SQL_DOT_LEN); - str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } - str->length(str->length() - SPIDER_SQL_COMMA_LEN); - DBUG_RETURN(0); -} - -int spider_db_oracle_util::reappend_tables( - spider_fields *fields, - SPIDER_LINK_IDX_CHAIN *link_idx_chain, - spider_string *str -) { - int error_num; - uint dbton_id = spider_dbton_oracle.dbton_id, length; - ha_spider *spider; - spider_oracle_share *db_share; - spider_oracle_handler *dbton_hdl; - SPIDER_TABLE_HOLDER *table_holder; - SPIDER_LINK_IDX_HOLDER *link_idx_holder; - DBUG_ENTER("spider_db_oracle_util::reappend_tables"); - DBUG_PRINT("info",("spider this=%p", this)); - length = str->length(); - fields->set_pos_to_first_table_on_link_idx_chain(link_idx_chain); - fields->set_pos_to_first_table_holder(); - while ((table_holder = fields->get_next_table_holder())) - { - link_idx_holder = fields->get_next_table_on_link_idx_chain(link_idx_chain); - spider = table_holder->spider; - db_share = (spider_oracle_share *) - spider->share->dbton_share[dbton_id]; - if (!db_share->same_db_table_name) - { - dbton_hdl = (spider_oracle_handler *) spider->dbton_handler[dbton_id]; - str->length(dbton_hdl->table_name_pos); - if ((error_num = db_share->append_table_name_with_adjusting(str, - spider->conn_link_idx[link_idx_holder->link_idx]))) - { - DBUG_RETURN(error_num); - } - } - } - str->length(length); - DBUG_RETURN(0); -} - -int spider_db_oracle_util::append_where( - spider_string *str -) { - DBUG_ENTER("spider_db_oracle_util::append_where"); - DBUG_PRINT("info",("spider this=%p", this)); - if (str->reserve(SPIDER_SQL_WHERE_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_WHERE_STR, SPIDER_SQL_WHERE_LEN); - DBUG_RETURN(0); -} - -int spider_db_oracle_util::append_having( - spider_string *str -) { - DBUG_ENTER("spider_db_oracle_util::append_having"); - DBUG_PRINT("info",("spider this=%p", this)); - if (str->reserve(SPIDER_SQL_HAVING_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_HAVING_STR, SPIDER_SQL_HAVING_LEN); - DBUG_RETURN(0); -} -#endif - -spider_oracle_share::spider_oracle_share( - st_spider_share *share -) : spider_db_share( - share, - spider_dbton_oracle.dbton_id -), - table_select(NULL), - table_select_pos(0), - key_select(NULL), - key_select_pos(NULL), - key_hint(NULL), - show_table_status(NULL), - show_records(NULL), - show_autoinc(NULL), - show_last_insert_id(NULL), - show_index(NULL), - table_names_str(NULL), - db_names_str(NULL), - db_table_str(NULL), - nextval_str(NULL), -#ifdef SPIDER_HAS_HASH_VALUE_TYPE - db_table_str_hash_value(NULL), -#endif - table_nm_max_length(0), - db_nm_max_length(0), - nextval_max_length(0), - column_name_str(NULL), - same_db_table_name(TRUE), - first_all_link_idx(-1) -{ - DBUG_ENTER("spider_oracle_share::spider_oracle_share"); - DBUG_PRINT("info",("spider this=%p", this)); - spider_alloc_calc_mem_init(mem_calc, 220); - spider_alloc_calc_mem(spider_current_trx, mem_calc, sizeof(*this)); - DBUG_VOID_RETURN; -} - -spider_oracle_share::~spider_oracle_share() -{ - DBUG_ENTER("spider_oracle_share::~spider_oracle_share"); - DBUG_PRINT("info",("spider this=%p", this)); - if (table_select) - delete [] table_select; - if (key_select) - delete [] key_select; - if (key_hint) - delete [] key_hint; - free_show_table_status(); - free_show_records(); - free_show_autoinc(); - free_show_last_insert_id(); - free_show_index(); - free_column_name_str(); - free_table_names_str(); - if (key_select_pos) - { - spider_free(spider_current_trx, key_select_pos, MYF(0)); - } - spider_free_mem_calc(spider_current_trx, mem_calc_id, sizeof(*this)); - DBUG_VOID_RETURN; -} - -int spider_oracle_share::init() -{ - int error_num; - uint roop_count; - TABLE_SHARE *table_share = spider_share->table_share; - uint keys = table_share ? table_share->keys : 0; - DBUG_ENTER("spider_oracle_share::init"); - DBUG_PRINT("info",("spider this=%p", this)); - if (!(key_select_pos = (int *) - spider_bulk_alloc_mem(spider_current_trx, 221, - __func__, __FILE__, __LINE__, MYF(MY_WME | MY_ZEROFILL), - &key_select_pos, - sizeof(int) * keys, -#ifdef SPIDER_HAS_HASH_VALUE_TYPE - &db_table_str_hash_value, - sizeof(my_hash_value_type) * spider_share->all_link_count, -#endif - NullS)) - ) { - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - - if (keys > 0 && - !(key_hint = new spider_string[keys]) - ) { - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - for (roop_count = 0; roop_count < keys; roop_count++) - { - key_hint[roop_count].init_calc_mem(190); - key_hint[roop_count].set_charset(spider_share->access_charset); - } - DBUG_PRINT("info",("spider key_hint=%p", key_hint)); - - if ( - !(table_select = new spider_string[1]) || - (keys > 0 && - !(key_select = new spider_string[keys]) - ) || - (error_num = create_table_names_str()) || - (table_share && - ( - (error_num = create_column_name_str()) || - (error_num = convert_key_hint_str()) || - (error_num = append_show_table_status()) || - (error_num = append_show_records()) || - (error_num = append_show_autoinc()) || - (error_num = append_show_last_insert_id()) || - (error_num = append_show_index()) - ) - ) - ) { - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - - table_select->init_calc_mem(191); - if (table_share && (error_num = append_table_select())) - DBUG_RETURN(error_num); - - for (roop_count = 0; roop_count < keys; roop_count++) - { - key_select[roop_count].init_calc_mem(192); - if ((error_num = append_key_select(roop_count))) - DBUG_RETURN(error_num); - } - - DBUG_RETURN(error_num); -} - -uint spider_oracle_share::get_column_name_length( - uint field_index -) { - DBUG_ENTER("spider_oracle_share::get_column_name_length"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(column_name_str[field_index].length()); -} - -int spider_oracle_share::append_column_name( - spider_string *str, - uint field_index -) { - int error_num; - DBUG_ENTER("spider_oracle_share::append_column_name"); - DBUG_PRINT("info",("spider this=%p", this)); - error_num = spider_db_oracle_utility.append_name(str, - column_name_str[field_index].ptr(), column_name_str[field_index].length()); - DBUG_RETURN(error_num); -} - -int spider_oracle_share::append_column_name_with_alias( - spider_string *str, - uint field_index, - const char *alias, - uint alias_length -) { - DBUG_ENTER("spider_oracle_share::append_column_name_with_alias"); - DBUG_PRINT("info",("spider this=%p", this)); - if (str->reserve( - alias_length + - column_name_str[field_index].length() + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 2)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(alias, alias_length); - append_column_name(str, field_index); - DBUG_RETURN(0); -} - -int spider_oracle_share::append_table_name( - spider_string *str, - int all_link_idx -) { - const char *db_nm = db_names_str[all_link_idx].ptr(); - uint db_nm_len = db_names_str[all_link_idx].length(); - const char *table_nm = table_names_str[all_link_idx].ptr(); - uint table_nm_len = table_names_str[all_link_idx].length(); - DBUG_ENTER("spider_oracle_share::append_table_name"); - DBUG_PRINT("info",("spider this=%p", this)); - if (str->reserve(db_nm_len + SPIDER_SQL_DOT_LEN + table_nm_len + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 4)) - { - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - spider_db_oracle_utility.append_name(str, db_nm, db_nm_len); - str->q_append(SPIDER_SQL_DOT_STR, SPIDER_SQL_DOT_LEN); - spider_db_oracle_utility.append_name(str, table_nm, table_nm_len); - DBUG_RETURN(0); -} - -int spider_oracle_share::append_table_name_with_adjusting( - spider_string *str, - int all_link_idx -) { - const char *db_nm = db_names_str[all_link_idx].ptr(); - uint db_nm_len = db_names_str[all_link_idx].length(); - uint db_nm_max_len = db_nm_max_length; - const char *table_nm = table_names_str[all_link_idx].ptr(); - uint table_nm_len = table_names_str[all_link_idx].length(); - uint table_nm_max_len = table_nm_max_length; - DBUG_ENTER("spider_oracle_share::append_table_name_with_adjusting"); - DBUG_PRINT("info",("spider this=%p", this)); - spider_db_oracle_utility.append_name(str, db_nm, db_nm_len); - str->q_append(SPIDER_SQL_DOT_STR, SPIDER_SQL_DOT_LEN); - spider_db_oracle_utility.append_name(str, table_nm, table_nm_len); - uint length = - db_nm_max_len - db_nm_len + - table_nm_max_len - table_nm_len; - memset((char *) str->ptr() + str->length(), ' ', length); - str->length(str->length() + length); - DBUG_RETURN(0); -} - -int spider_oracle_share::append_from_with_adjusted_table_name( - spider_string *str, - int *table_name_pos -) { - const char *db_nm = db_names_str[0].ptr(); - uint db_nm_len = db_names_str[0].length(); - uint db_nm_max_len = db_nm_max_length; - const char *table_nm = table_names_str[0].ptr(); - uint table_nm_len = table_names_str[0].length(); - uint table_nm_max_len = table_nm_max_length; - DBUG_ENTER("spider_oracle_share::append_from_with_adjusted_table_name"); - DBUG_PRINT("info",("spider this=%p", this)); - if (str->reserve(SPIDER_SQL_FROM_LEN + db_nm_max_length + - SPIDER_SQL_DOT_LEN + table_nm_max_length + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 4)) - { - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - str->q_append(SPIDER_SQL_FROM_STR, SPIDER_SQL_FROM_LEN); - *table_name_pos = str->length(); - spider_db_oracle_utility.append_name(str, db_nm, db_nm_len); - str->q_append(SPIDER_SQL_DOT_STR, SPIDER_SQL_DOT_LEN); - spider_db_oracle_utility.append_name(str, table_nm, table_nm_len); - uint length = - db_nm_max_len - db_nm_len + - table_nm_max_len - table_nm_len; - memset((char *) str->ptr() + str->length(), ' ', length); - str->length(str->length() + length); - DBUG_RETURN(0); -} - -int spider_oracle_share::create_table_names_str() -{ - int error_num, roop_count; - uint table_nm_len, db_nm_len; - spider_string *str, *first_tbl_nm_str, *first_db_nm_str, *first_db_tbl_str; - char *first_tbl_nm, *first_db_nm; - uint dbton_id = spider_dbton_oracle.dbton_id; - DBUG_ENTER("spider_oracle_share::create_table_names_str"); - table_names_str = NULL; - db_names_str = NULL; - db_table_str = NULL; - if ( - !(table_names_str = new spider_string[spider_share->all_link_count]) || - !(db_names_str = new spider_string[spider_share->all_link_count]) || - !(db_table_str = new spider_string[spider_share->all_link_count]) - ) { - error_num = HA_ERR_OUT_OF_MEM; - goto error; - } - - same_db_table_name = TRUE; - first_tbl_nm = spider_share->tgt_table_names[0]; - first_db_nm = spider_share->tgt_dbs[0]; - table_nm_len = spider_share->tgt_table_names_lengths[0]; - db_nm_len = spider_share->tgt_dbs_lengths[0]; - first_tbl_nm_str = &table_names_str[0]; - first_db_nm_str = &db_names_str[0]; - first_db_tbl_str = &db_table_str[0]; - for (roop_count = 0; roop_count < (int) spider_share->all_link_count; - roop_count++) - { - table_names_str[roop_count].init_calc_mem(193); - db_names_str[roop_count].init_calc_mem(194); - db_table_str[roop_count].init_calc_mem(195); - if (spider_share->sql_dbton_ids[roop_count] != dbton_id) - continue; - if (first_all_link_idx == -1) - first_all_link_idx = roop_count; - - str = &table_names_str[roop_count]; - if ( - roop_count != 0 && - same_db_table_name && - spider_share->tgt_table_names_lengths[roop_count] == table_nm_len && - !memcmp(first_tbl_nm, spider_share->tgt_table_names[roop_count], - table_nm_len) - ) { - if (str->copy(*first_tbl_nm_str)) - { - error_num = HA_ERR_OUT_OF_MEM; - goto error; - } - } else { - str->set_charset(spider_share->access_charset); - if ((error_num = spider_db_append_name_with_quote_str(str, - spider_share->tgt_table_names[roop_count], dbton_id))) - goto error; - if (roop_count) - { - same_db_table_name = FALSE; - DBUG_PRINT("info", ("spider found different table name %s", - spider_share->tgt_table_names[roop_count])); - if (str->length() > table_nm_max_length) - table_nm_max_length = str->length(); - } else - table_nm_max_length = str->length(); - } - - str = &db_names_str[roop_count]; - if ( - roop_count != 0 && - same_db_table_name && - spider_share->tgt_dbs_lengths[roop_count] == db_nm_len && - !memcmp(first_db_nm, spider_share->tgt_dbs[roop_count], - db_nm_len) - ) { - if (str->copy(*first_db_nm_str)) - { - error_num = HA_ERR_OUT_OF_MEM; - goto error; - } - } else { - str->set_charset(spider_share->access_charset); - if ((error_num = spider_db_append_name_with_quote_str(str, - spider_share->tgt_dbs[roop_count], dbton_id))) - goto error; - if (roop_count) - { - same_db_table_name = FALSE; - DBUG_PRINT("info", ("spider found different db name %s", - spider_share->tgt_dbs[roop_count])); - if (str->length() > db_nm_max_length) - db_nm_max_length = str->length(); - } else - db_nm_max_length = str->length(); - } - - str = &db_table_str[roop_count]; - if ( - roop_count != 0 && - same_db_table_name - ) { - if (str->copy(*first_db_tbl_str)) - { - error_num = HA_ERR_OUT_OF_MEM; - goto error; - } - } else { - str->set_charset(spider_share->access_charset); - if ((error_num = append_table_name(str, roop_count))) - goto error; - } -#ifdef SPIDER_HAS_HASH_VALUE_TYPE - db_table_str_hash_value[roop_count] = my_calc_hash( - &spider_open_connections, (uchar*) str->ptr(), str->length()); -#endif - } - DBUG_RETURN(0); - -error: - if (db_table_str) - { - delete [] db_table_str; - db_table_str = NULL; - } - if (db_names_str) - { - delete [] db_names_str; - db_names_str = NULL; - } - if (table_names_str) - { - delete [] table_names_str; - table_names_str = NULL; - } - DBUG_RETURN(error_num); -} - -void spider_oracle_share::free_table_names_str() -{ - DBUG_ENTER("spider_oracle_share::free_table_names_str"); - if (db_table_str) - { - delete [] db_table_str; - db_table_str = NULL; - } - if (db_names_str) - { - delete [] db_names_str; - db_names_str = NULL; - } - if (table_names_str) - { - delete [] table_names_str; - table_names_str = NULL; - } - DBUG_VOID_RETURN; -} - -int spider_oracle_share::create_column_name_str() -{ - spider_string *str; - int error_num; - Field **field; - TABLE_SHARE *table_share = spider_share->table_share; - uint dbton_id = spider_dbton_oracle.dbton_id; - DBUG_ENTER("spider_oracle_share::create_column_name_str"); - if ( - table_share->fields && - !(column_name_str = new spider_string[table_share->fields]) - ) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - for (field = table_share->field, str = column_name_str; - *field; field++, str++) - { - str->init_calc_mem(196); - str->set_charset(spider_share->access_charset); - if ((error_num = spider_db_append_name_with_quote_str(str, - (*field)->field_name, dbton_id))) - goto error; - } - DBUG_RETURN(0); - -error: - if (column_name_str) - { - delete [] column_name_str; - column_name_str = NULL; - } - DBUG_RETURN(error_num); -} - -void spider_oracle_share::free_column_name_str() -{ - DBUG_ENTER("spider_oracle_share::free_column_name_str"); - if (column_name_str) - { - delete [] column_name_str; - column_name_str = NULL; - } - DBUG_VOID_RETURN; -} - -int spider_oracle_share::convert_key_hint_str() -{ - spider_string *tmp_key_hint; - int roop_count; - TABLE_SHARE *table_share = spider_share->table_share; - DBUG_ENTER("spider_oracle_share::convert_key_hint_str"); - if (spider_share->access_charset->cset != system_charset_info->cset) - { - /* need conversion */ - for (roop_count = 0, tmp_key_hint = key_hint; - roop_count < (int) table_share->keys; roop_count++, tmp_key_hint++) - { - tmp_key_hint->length(0); - if (tmp_key_hint->append(spider_share->key_hint->ptr(), - spider_share->key_hint->length(), system_charset_info)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - } else { - for (roop_count = 0, tmp_key_hint = key_hint; - roop_count < (int) table_share->keys; roop_count++, tmp_key_hint++) - { - if (tmp_key_hint->copy(spider_share->key_hint[roop_count])) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - } - DBUG_RETURN(0); -} - -int spider_oracle_share::append_show_table_status() -{ - int roop_count; - spider_string *str; - uint dbton_id = spider_dbton_oracle.dbton_id; - DBUG_ENTER("spider_oracle_append_show_table_status"); - if (!(show_table_status = - new spider_string[2 * spider_share->all_link_count])) - goto error; - - for (roop_count = 0; roop_count < (int) spider_share->all_link_count; - roop_count++) - { - show_table_status[0 + (2 * roop_count)].init_calc_mem(197); - show_table_status[1 + (2 * roop_count)].init_calc_mem(207); - if (spider_share->sql_dbton_ids[roop_count] != dbton_id) - continue; - - if ( - show_table_status[0 + (2 * roop_count)].reserve( - SPIDER_SQL_SHOW_TABLE_STATUS_LEN + - db_names_str[roop_count].length() + - SPIDER_SQL_LIKE_LEN + table_names_str[roop_count].length() + - ((SPIDER_SQL_NAME_QUOTE_LEN) * 2) + - ((SPIDER_SQL_VALUE_QUOTE_LEN) * 2)) || - show_table_status[1 + (2 * roop_count)].reserve( - SPIDER_SQL_SELECT_TABLES_STATUS_LEN + - db_names_str[roop_count].length() + - SPIDER_SQL_AND_LEN + SPIDER_SQL_TABLE_NAME_LEN + SPIDER_SQL_EQUAL_LEN + - table_names_str[roop_count].length() + - ((SPIDER_SQL_VALUE_QUOTE_LEN) * 4)) - ) - goto error; - str = &show_table_status[0 + (2 * roop_count)]; - str->q_append( - SPIDER_SQL_SHOW_TABLE_STATUS_STR, SPIDER_SQL_SHOW_TABLE_STATUS_LEN); - str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN); - str->q_append(db_names_str[roop_count].ptr(), - db_names_str[roop_count].length()); - str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN); - str->q_append(SPIDER_SQL_LIKE_STR, SPIDER_SQL_LIKE_LEN); - str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN); - str->q_append(table_names_str[roop_count].ptr(), - table_names_str[roop_count].length()); - str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN); - str = &show_table_status[1 + (2 * roop_count)]; - str->q_append( - SPIDER_SQL_SELECT_TABLES_STATUS_STR, - SPIDER_SQL_SELECT_TABLES_STATUS_LEN); - str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN); - str->q_append(db_names_str[roop_count].ptr(), - db_names_str[roop_count].length()); - str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN); - str->q_append(SPIDER_SQL_AND_STR, SPIDER_SQL_AND_LEN); - str->q_append(SPIDER_SQL_TABLE_NAME_STR, SPIDER_SQL_TABLE_NAME_LEN); - str->q_append(SPIDER_SQL_EQUAL_STR, SPIDER_SQL_EQUAL_LEN); - str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN); - str->q_append(table_names_str[roop_count].ptr(), - table_names_str[roop_count].length()); - str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN); - } - DBUG_RETURN(0); - -error: - if (show_table_status) - { - delete [] show_table_status; - show_table_status = NULL; - } - DBUG_RETURN(HA_ERR_OUT_OF_MEM); -} - -void spider_oracle_share::free_show_table_status() -{ - DBUG_ENTER("spider_oracle_free_show_table_status"); - if (show_table_status) - { - delete [] show_table_status; - show_table_status = NULL; - } - DBUG_VOID_RETURN; -} - -int spider_oracle_share::append_show_records() -{ - int roop_count; - spider_string *str; - uint dbton_id = spider_dbton_oracle.dbton_id; - DBUG_ENTER("spider_oracle_share::append_show_records"); - if (!(show_records = new spider_string[spider_share->all_link_count])) - goto error; - - for (roop_count = 0; roop_count < (int) spider_share->all_link_count; - roop_count++) - { - show_records[roop_count].init_calc_mem(208); - if (spider_share->sql_dbton_ids[roop_count] != dbton_id) - continue; - - if ( - show_records[roop_count].reserve( - SPIDER_SQL_SHOW_RECORDS_LEN + - db_names_str[roop_count].length() + - SPIDER_SQL_DOT_LEN + - table_names_str[roop_count].length() + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 4) - ) - goto error; - str = &show_records[roop_count]; - str->q_append(SPIDER_SQL_SHOW_RECORDS_STR, SPIDER_SQL_SHOW_RECORDS_LEN); - append_table_name(str, roop_count); - } - DBUG_RETURN(0); - -error: - if (show_records) - { - delete [] show_records; - show_records = NULL; - } - DBUG_RETURN(HA_ERR_OUT_OF_MEM); -} - -void spider_oracle_share::free_show_records() -{ - DBUG_ENTER("spider_oracle_share::free_show_records"); - if (show_records) - { - delete [] show_records; - show_records = NULL; - } - DBUG_VOID_RETURN; -} - -int spider_oracle_share::append_show_autoinc() -{ - uint roop_count, field_length; - spider_string *str; - uint dbton_id = spider_dbton_oracle.dbton_id; - Field **found_next_number_field = - spider_share->table_share->found_next_number_field; - DBUG_ENTER("spider_oracle_share::append_show_autoinc"); - if (!found_next_number_field) - DBUG_RETURN(0); - - if (!(show_autoinc = new spider_string[spider_share->all_link_count])) - goto error; - - field_length = - column_name_str[(*found_next_number_field)->field_index].length(); - for (roop_count = 0; roop_count < spider_share->all_link_count; - roop_count++) - { - show_autoinc[roop_count].init_calc_mem(224); - if (spider_share->sql_dbton_ids[roop_count] != dbton_id) - continue; - - if ( - show_autoinc[roop_count].reserve( - SPIDER_SQL_SELECT_LEN + - SPIDER_SQL_MAX_LEN + - SPIDER_SQL_OPEN_PAREN_LEN + - field_length + - SPIDER_SQL_CLOSE_PAREN_LEN + - SPIDER_SQL_FROM_LEN + - db_names_str[roop_count].length() + - SPIDER_SQL_DOT_LEN + - table_names_str[roop_count].length() + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 6) - ) - goto error; - str = &show_autoinc[roop_count]; - str->q_append(SPIDER_SQL_SELECT_STR, SPIDER_SQL_SELECT_LEN); - str->q_append(SPIDER_SQL_MAX_STR, SPIDER_SQL_MAX_LEN); - str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN); - append_column_name(str, (*found_next_number_field)->field_index); - str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN); - str->q_append(SPIDER_SQL_FROM_STR, SPIDER_SQL_FROM_LEN); - append_table_name(str, roop_count); - } - DBUG_RETURN(0); - -error: - if (show_autoinc) - { - delete [] show_autoinc; - show_autoinc = NULL; - } - DBUG_RETURN(HA_ERR_OUT_OF_MEM); -} - -void spider_oracle_share::free_show_autoinc() -{ - DBUG_ENTER("spider_oracle_share::free_show_autoinc"); - if (show_autoinc) - { - delete [] show_autoinc; - show_autoinc = NULL; - } - DBUG_VOID_RETURN; -} - -int spider_oracle_share::append_show_last_insert_id() -{ - uint roop_count; - spider_string *str; - uint dbton_id = spider_dbton_oracle.dbton_id; - Field **found_next_number_field = - spider_share->table_share->found_next_number_field; - uint seq_nm_max_length = 0; - DBUG_ENTER("spider_oracle_share::append_show_last_insert_id"); - if (!found_next_number_field) - DBUG_RETURN(0); - - if ( - !(show_last_insert_id = new spider_string[spider_share->all_link_count]) || - !(nextval_str = new spider_string[spider_share->all_link_count]) - ) - goto error; - - for (roop_count = 0; roop_count < spider_share->all_link_count; - roop_count++) - { - show_last_insert_id[roop_count].init_calc_mem(225); - nextval_str[roop_count].init_calc_mem(226); - if (spider_share->sql_dbton_ids[roop_count] != dbton_id) - continue; - - if ( - show_last_insert_id[roop_count].reserve( - SPIDER_SQL_SELECT_LEN + - spider_share->tgt_sequence_names_lengths[roop_count] + - SPIDER_SQL_CURRVAL_LEN + - SPIDER_SQL_FROM_DUAL_LEN + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 2) - ) - goto error; - str = &show_last_insert_id[roop_count]; - str->q_append(SPIDER_SQL_SELECT_STR, SPIDER_SQL_SELECT_LEN); - spider_db_oracle_utility.append_name(str, - spider_share->tgt_sequence_names[roop_count], - spider_share->tgt_sequence_names_lengths[roop_count]); - str->q_append(SPIDER_SQL_CURRVAL_STR, SPIDER_SQL_CURRVAL_LEN); - str->q_append(SPIDER_SQL_FROM_DUAL_STR, SPIDER_SQL_FROM_DUAL_LEN); - - if (seq_nm_max_length < - spider_share->tgt_sequence_names_lengths[roop_count]) - { - seq_nm_max_length = - spider_share->tgt_sequence_names_lengths[roop_count]; - } - } - for (roop_count = 0; roop_count < spider_share->all_link_count; - roop_count++) - { - if (spider_share->sql_dbton_ids[roop_count] != dbton_id) - continue; - - if ( - nextval_str[roop_count].reserve( - seq_nm_max_length + - SPIDER_SQL_NEXTVAL_LEN + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 2) - ) - goto error; - str = &nextval_str[roop_count]; - spider_db_oracle_utility.append_name(str, - spider_share->tgt_sequence_names[roop_count], - spider_share->tgt_sequence_names_lengths[roop_count]); - str->q_append(SPIDER_SQL_NEXTVAL_STR, SPIDER_SQL_NEXTVAL_LEN); - uint length = - seq_nm_max_length - spider_share->tgt_sequence_names_lengths[roop_count]; - memset((char *) str->ptr() + str->length(), ' ', length); - str->length(str->length() + length); - nextval_max_length = str->length(); - } - DBUG_RETURN(0); - -error: - if (show_last_insert_id) - { - delete [] show_last_insert_id; - show_last_insert_id = NULL; - } - if (nextval_str) - { - delete [] nextval_str; - nextval_str = NULL; - } - DBUG_RETURN(HA_ERR_OUT_OF_MEM); -} - -void spider_oracle_share::free_show_last_insert_id() -{ - DBUG_ENTER("spider_oracle_share::free_show_last_insert_id"); - if (show_last_insert_id) - { - delete [] show_last_insert_id; - show_last_insert_id = NULL; - } - if (nextval_str) - { - delete [] nextval_str; - nextval_str = NULL; - } - DBUG_VOID_RETURN; -} - -int spider_oracle_share::append_show_index() -{ - int roop_count; - spider_string *str; - uint dbton_id = spider_dbton_oracle.dbton_id; - DBUG_ENTER("spider_oracle_share::append_show_index"); - if (!(show_index = new spider_string[2 * spider_share->all_link_count])) - goto error; - - for (roop_count = 0; roop_count < (int) spider_share->all_link_count; - roop_count++) - { - show_index[0 + (2 * roop_count)].init_calc_mem(209); - show_index[1 + (2 * roop_count)].init_calc_mem(210); - if (spider_share->sql_dbton_ids[roop_count] != dbton_id) - continue; - - if ( - show_index[0 + (2 * roop_count)].reserve( - SPIDER_SQL_SHOW_INDEX_LEN + db_names_str[roop_count].length() + - SPIDER_SQL_DOT_LEN + - table_names_str[roop_count].length() + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 4) || - show_index[1 + (2 * roop_count)].reserve( - SPIDER_SQL_SELECT_STATISTICS_LEN + - db_names_str[roop_count].length() + - SPIDER_SQL_AND_LEN + SPIDER_SQL_TABLE_NAME_LEN + SPIDER_SQL_EQUAL_LEN + - table_names_str[roop_count].length() + - ((SPIDER_SQL_VALUE_QUOTE_LEN) * 4) + - SPIDER_SQL_GROUP_LEN + SPIDER_SQL_COLUMN_NAME_LEN) - ) - goto error; - str = &show_index[0 + (2 * roop_count)]; - str->q_append( - SPIDER_SQL_SHOW_INDEX_STR, SPIDER_SQL_SHOW_INDEX_LEN); - append_table_name(str, roop_count); - str = &show_index[1 + (2 * roop_count)]; - str->q_append( - SPIDER_SQL_SELECT_STATISTICS_STR, SPIDER_SQL_SELECT_STATISTICS_LEN); - str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN); - str->q_append(db_names_str[roop_count].ptr(), - db_names_str[roop_count].length()); - str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN); - str->q_append(SPIDER_SQL_AND_STR, SPIDER_SQL_AND_LEN); - str->q_append(SPIDER_SQL_TABLE_NAME_STR, SPIDER_SQL_TABLE_NAME_LEN); - str->q_append(SPIDER_SQL_EQUAL_STR, SPIDER_SQL_EQUAL_LEN); - str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN); - str->q_append(table_names_str[roop_count].ptr(), - table_names_str[roop_count].length()); - str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN); - str->q_append(SPIDER_SQL_GROUP_STR, SPIDER_SQL_GROUP_LEN); - str->q_append(SPIDER_SQL_COLUMN_NAME_STR, SPIDER_SQL_COLUMN_NAME_LEN); - } - DBUG_RETURN(0); - -error: - if (show_index) - { - delete [] show_index; - show_index = NULL; - } - DBUG_RETURN(HA_ERR_OUT_OF_MEM); -} - -void spider_oracle_share::free_show_index() -{ - DBUG_ENTER("spider_oracle_share::free_show_index"); - if (show_index) - { - delete [] show_index; - show_index = NULL; - } - DBUG_VOID_RETURN; -} - -int spider_oracle_share::append_table_select() -{ - Field **field; - uint field_length; - spider_string *str = table_select; - TABLE_SHARE *table_share = spider_share->table_share; - DBUG_ENTER("spider_oracle_share::append_table_select"); - - if (!*table_share->field) - DBUG_RETURN(0); - - for (field = table_share->field; *field; field++) - { - field_length = column_name_str[(*field)->field_index].length(); - if (str->reserve(field_length + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - append_column_name(str, (*field)->field_index); - str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } - str->length(str->length() - SPIDER_SQL_COMMA_LEN); - DBUG_RETURN(append_from_with_adjusted_table_name(str, &table_select_pos)); -} - -int spider_oracle_share::append_key_select( - uint idx -) { - KEY_PART_INFO *key_part; - Field *field; - uint part_num; - uint field_length; - spider_string *str = &key_select[idx]; - TABLE_SHARE *table_share = spider_share->table_share; - const KEY *key_info = &table_share->key_info[idx]; - DBUG_ENTER("spider_oracle_share::append_key_select"); - - if (!spider_user_defined_key_parts(key_info)) - DBUG_RETURN(0); - - for (key_part = key_info->key_part, part_num = 0; - part_num < spider_user_defined_key_parts(key_info); key_part++, part_num++) - { - field = key_part->field; - field_length = column_name_str[field->field_index].length(); - if (str->reserve(field_length + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - append_column_name(str, field->field_index); - str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } - str->length(str->length() - SPIDER_SQL_COMMA_LEN); - DBUG_RETURN(append_from_with_adjusted_table_name(str, &key_select_pos[idx])); -} - -bool spider_oracle_share::need_change_db_table_name() -{ - DBUG_ENTER("spider_oracle_share::need_change_db_table_name"); - DBUG_RETURN(!same_db_table_name); -} - -#ifdef SPIDER_HAS_DISCOVER_TABLE_STRUCTURE -int spider_oracle_share::discover_table_structure( - SPIDER_TRX *trx, - SPIDER_SHARE *spider_share, - spider_string *str -) { - DBUG_ENTER("spider_oracle_share::discover_table_structure"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(HA_ERR_WRONG_COMMAND); -} -#endif - -spider_oracle_handler::spider_oracle_handler( - ha_spider *spider, - spider_oracle_share *db_share -) : spider_db_handler( - spider, - db_share -), - where_pos(0), - order_pos(0), - limit_pos(0), - table_name_pos(0), - update_set_pos(0), - ha_read_pos(0), - ha_next_pos(0), - ha_where_pos(0), - ha_limit_pos(0), - ha_table_name_pos(0), - insert_pos(0), - insert_table_name_pos(0), - upd_tmp_tbl(NULL), - tmp_sql_pos1(0), - tmp_sql_pos2(0), - tmp_sql_pos3(0), - tmp_sql_pos4(0), - tmp_sql_pos5(0), - table_lock_mode(0), - reading_from_bulk_tmp_table(FALSE), - filled_up(FALSE), - select_rownum_appended(FALSE), - update_rownum_appended(FALSE), - union_table_name_pos_first(NULL), - union_table_name_pos_current(NULL), - oracle_share(db_share), - link_for_hash(NULL) -{ - DBUG_ENTER("spider_oracle_handler::spider_oracle_handler"); - DBUG_PRINT("info",("spider this=%p", this)); - spider_alloc_calc_mem_init(mem_calc, 222); - spider_alloc_calc_mem(spider_current_trx, mem_calc, sizeof(*this)); - DBUG_VOID_RETURN; -} - -spider_oracle_handler::~spider_oracle_handler() -{ - DBUG_ENTER("spider_oracle_handler::~spider_oracle_handler"); - DBUG_PRINT("info",("spider this=%p", this)); - while (union_table_name_pos_first) - { - SPIDER_INT_HLD *tmp_pos = union_table_name_pos_first; - union_table_name_pos_first = tmp_pos->next; - spider_free(spider_current_trx, tmp_pos, MYF(0)); - } - if (link_for_hash) - { - spider_free(spider_current_trx, link_for_hash, MYF(0)); - } - spider_free_mem_calc(spider_current_trx, mem_calc_id, sizeof(*this)); - DBUG_VOID_RETURN; -} - -int spider_oracle_handler::init() -{ - uint roop_count; - THD *thd = spider->wide_handler->trx->thd; - st_spider_share *share = spider->share; - int init_sql_alloc_size = - spider_param_init_sql_alloc_size(thd, share->init_sql_alloc_size); - TABLE *table = spider->get_table(); - DBUG_ENTER("spider_oracle_handler::init"); - DBUG_PRINT("info",("spider this=%p", this)); - sql.init_calc_mem(67); - sql_part.init_calc_mem(68); - sql_part2.init_calc_mem(69); - ha_sql.init_calc_mem(70); - insert_sql.init_calc_mem(72); - update_sql.init_calc_mem(73); - tmp_sql.init_calc_mem(74); - dup_update_sql.init_calc_mem(167); - if ( - (sql.real_alloc(init_sql_alloc_size)) || - (insert_sql.real_alloc(init_sql_alloc_size)) || - (update_sql.real_alloc(init_sql_alloc_size)) || - (tmp_sql.real_alloc(init_sql_alloc_size)) - ) { - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - sql.set_charset(share->access_charset); - sql_part.set_charset(share->access_charset); - sql_part2.set_charset(share->access_charset); - ha_sql.set_charset(share->access_charset); - insert_sql.set_charset(share->access_charset); - update_sql.set_charset(share->access_charset); - tmp_sql.set_charset(share->access_charset); - dup_update_sql.set_charset(share->access_charset); - upd_tmp_tbl_prm.init(); - upd_tmp_tbl_prm.field_count = 1; - if (!(link_for_hash = (SPIDER_LINK_FOR_HASH *) - spider_bulk_alloc_mem(spider_current_trx, 223, - __func__, __FILE__, __LINE__, MYF(MY_WME | MY_ZEROFILL), - &link_for_hash, - sizeof(SPIDER_LINK_FOR_HASH) * share->link_count, - &minimum_select_bitmap, - table ? sizeof(uchar) * no_bytes_in_map(table->read_set) : 0, - NullS)) - ) { - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - for (roop_count = 0; roop_count < share->link_count; roop_count++) - { - link_for_hash[roop_count].spider = spider; - link_for_hash[roop_count].link_idx = roop_count; - link_for_hash[roop_count].db_table_str = - &oracle_share->db_table_str[roop_count]; -#ifdef SPIDER_HAS_HASH_VALUE_TYPE - link_for_hash[roop_count].db_table_str_hash_value = - oracle_share->db_table_str_hash_value[roop_count]; -#endif - } - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_index_hint( - spider_string *str, - int link_idx, - ulong sql_type - ) -{ - DBUG_ENTER("spider_oracle_handler::append_index_hint"); - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_table_name_with_adjusting( - spider_string *str, - int link_idx, - ulong sql_type -) { - int error_num = 0; - DBUG_ENTER("spider_oracle_handler::append_table_name_with_adjusting"); - DBUG_PRINT("info",("spider this=%p", this)); - if (sql_type == SPIDER_SQL_TYPE_HANDLER) - { - str->q_append(spider->m_handler_cid[link_idx], SPIDER_SQL_HANDLER_CID_LEN); - } else { - error_num = oracle_share->append_table_name_with_adjusting(str, - spider->conn_link_idx[link_idx]); - } - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_key_column_types( - const key_range *start_key, - spider_string *str -) { - SPIDER_RESULT_LIST *result_list = &spider->result_list; - KEY *key_info = result_list->key_info; - uint key_name_length, key_count; - key_part_map full_key_part_map = - make_prev_keypart_map(spider_user_defined_key_parts(key_info)); - key_part_map start_key_part_map; - KEY_PART_INFO *key_part; - Field *field; - char tmp_buf[MAX_FIELD_WIDTH]; - spider_string tmp_str(tmp_buf, sizeof(tmp_buf), system_charset_info); - DBUG_ENTER("spider_oracle_handler::append_key_column_types"); - DBUG_PRINT("info",("spider this=%p", this)); - tmp_str.init_calc_mem(227); - - start_key_part_map = start_key->keypart_map & full_key_part_map; - DBUG_PRINT("info", ("spider spider_user_defined_key_parts=%u", - spider_user_defined_key_parts(key_info))); - DBUG_PRINT("info", ("spider full_key_part_map=%lu", full_key_part_map)); - DBUG_PRINT("info", ("spider start_key_part_map=%lu", start_key_part_map)); - - if (!start_key_part_map) - DBUG_RETURN(0); - - for ( - key_part = key_info->key_part, - key_count = 0; - start_key_part_map; - start_key_part_map >>= 1, - key_part++, - key_count++ - ) { - field = key_part->field; - key_name_length = my_sprintf(tmp_buf, (tmp_buf, "c%u", key_count)); - if (str->reserve(key_name_length + SPIDER_SQL_SPACE_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(tmp_buf, key_name_length); - str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN); - - if (tmp_str.ptr() != tmp_buf) - tmp_str.set(tmp_buf, sizeof(tmp_buf), system_charset_info); - else - tmp_str.set_charset(system_charset_info); - field->sql_type(*tmp_str.get_str()); - tmp_str.mem_calc(); - str->append(tmp_str); - - if (str->reserve(SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } - str->length(str->length() - SPIDER_SQL_COMMA_LEN); - - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_key_join_columns_for_bka( - const key_range *start_key, - spider_string *str, - const char **table_aliases, - uint *table_alias_lengths -) { - KEY *key_info = spider->result_list.key_info; - uint length, key_name_length, key_count; - key_part_map full_key_part_map = - make_prev_keypart_map(spider_user_defined_key_parts(key_info)); - key_part_map start_key_part_map; - KEY_PART_INFO *key_part; - Field *field; - char tmp_buf[MAX_FIELD_WIDTH]; - bool start_where = ((int) str->length() == where_pos); - DBUG_ENTER("spider_oracle_handler::append_key_join_columns_for_bka"); - DBUG_PRINT("info",("spider this=%p", this)); - start_key_part_map = start_key->keypart_map & full_key_part_map; - DBUG_PRINT("info", ("spider spider_user_defined_key_parts=%u", - spider_user_defined_key_parts(key_info))); - DBUG_PRINT("info", ("spider full_key_part_map=%lu", full_key_part_map)); - DBUG_PRINT("info", ("spider start_key_part_map=%lu", start_key_part_map)); - - if (!start_key_part_map) - DBUG_RETURN(0); - - if (start_where) - { - if (str->reserve(SPIDER_SQL_WHERE_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_WHERE_STR, SPIDER_SQL_WHERE_LEN); - } else { - if (str->reserve(SPIDER_SQL_AND_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_AND_STR, SPIDER_SQL_AND_LEN); - } - - for ( - key_part = key_info->key_part, - key_count = 0; - start_key_part_map; - start_key_part_map >>= 1, - key_part++, - key_count++ - ) { - field = key_part->field; - key_name_length = - oracle_share->column_name_str[field->field_index].length(); - length = my_sprintf(tmp_buf, (tmp_buf, "c%u", key_count)); - if (str->reserve(length + table_alias_lengths[0] + key_name_length + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + - table_alias_lengths[1] + SPIDER_SQL_PF_EQUAL_LEN + SPIDER_SQL_AND_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(table_aliases[0], table_alias_lengths[0]); - str->q_append(tmp_buf, length); - str->q_append(SPIDER_SQL_PF_EQUAL_STR, SPIDER_SQL_PF_EQUAL_LEN); - str->q_append(table_aliases[1], table_alias_lengths[1]); - oracle_share->append_column_name(str, field->field_index); - str->q_append(SPIDER_SQL_AND_STR, SPIDER_SQL_AND_LEN); - } - str->length(str->length() - SPIDER_SQL_AND_LEN); - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_tmp_table_and_sql_for_bka( - const key_range *start_key -) { - int error_num; - DBUG_ENTER("spider_oracle_handler::append_tmp_table_and_sql_for_bka"); - DBUG_PRINT("info",("spider this=%p", this)); - char tmp_table_name[MAX_FIELD_WIDTH * 2], - tgt_table_name[MAX_FIELD_WIDTH * 2]; - int tmp_table_name_length; - spider_string tgt_table_name_str(tgt_table_name, MAX_FIELD_WIDTH * 2, - oracle_share->db_names_str[0].charset()); - const char *table_names[2], *table_aliases[2], *table_dot_aliases[2]; - uint table_name_lengths[2], table_alias_lengths[2], - table_dot_alias_lengths[2]; - tgt_table_name_str.init_calc_mem(200); - tgt_table_name_str.length(0); - create_tmp_bka_table_name(tmp_table_name, &tmp_table_name_length, - first_link_idx); - if ((error_num = append_table_name_with_adjusting(&tgt_table_name_str, - first_link_idx, SPIDER_SQL_TYPE_SELECT_SQL))) - { - DBUG_RETURN(error_num); - } - table_names[0] = tmp_table_name; - table_names[1] = tgt_table_name_str.c_ptr_safe(); - table_name_lengths[0] = tmp_table_name_length; - table_name_lengths[1] = tgt_table_name_str.length(); - table_aliases[0] = SPIDER_SQL_A_STR; - table_aliases[1] = SPIDER_SQL_B_STR; - table_alias_lengths[0] = SPIDER_SQL_A_LEN; - table_alias_lengths[1] = SPIDER_SQL_B_LEN; - table_dot_aliases[0] = SPIDER_SQL_A_DOT_STR; - table_dot_aliases[1] = SPIDER_SQL_B_DOT_STR; - table_dot_alias_lengths[0] = SPIDER_SQL_A_DOT_LEN; - table_dot_alias_lengths[1] = SPIDER_SQL_B_DOT_LEN; - if ( - (error_num = append_drop_tmp_bka_table( - &tmp_sql, tmp_table_name, tmp_table_name_length, - &tmp_sql_pos1, &tmp_sql_pos5, TRUE)) || - (error_num = append_create_tmp_bka_table( - start_key, - &tmp_sql, tmp_table_name, - tmp_table_name_length, - &tmp_sql_pos2, spider->share->table_share->table_charset)) || - (error_num = append_insert_tmp_bka_table( - start_key, - &tmp_sql, tmp_table_name, - tmp_table_name_length, &tmp_sql_pos3)) - ) - DBUG_RETURN(error_num); - tmp_sql_pos4 = tmp_sql.length(); - if ((error_num = spider_db_append_select(spider))) - DBUG_RETURN(error_num); - if (sql.reserve(SPIDER_SQL_A_DOT_LEN + SPIDER_SQL_ID_LEN + - SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql.q_append(SPIDER_SQL_A_DOT_STR, SPIDER_SQL_A_DOT_LEN); - sql.q_append(SPIDER_SQL_ID_STR, SPIDER_SQL_ID_LEN); - sql.q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - if ( - (error_num = append_select_columns_with_alias(&sql, - SPIDER_SQL_B_DOT_STR, SPIDER_SQL_B_DOT_LEN)) || - (error_num = spider_db_oracle_utility.append_from_with_alias(&sql, - table_names, table_name_lengths, - table_aliases, table_alias_lengths, 2, - &table_name_pos, FALSE)) - ) - DBUG_RETURN(error_num); - if ( - oracle_share->key_hint && - (error_num = spider_db_append_hint_after_table(spider, - &sql, &oracle_share->key_hint[spider->active_index])) - ) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - where_pos = sql.length(); - if ( - (error_num = append_key_join_columns_for_bka( - start_key, &sql, - table_dot_aliases, table_dot_alias_lengths)) || - (error_num = append_condition_part( - SPIDER_SQL_B_DOT_STR, SPIDER_SQL_B_DOT_LEN, - SPIDER_SQL_TYPE_SELECT_SQL, FALSE)) - ) - DBUG_RETURN(error_num); - if (spider->result_list.direct_order_limit) - { - if ((error_num = append_key_order_for_direct_order_limit_with_alias(&sql, - SPIDER_SQL_B_DOT_STR, SPIDER_SQL_B_DOT_LEN))) - DBUG_RETURN(error_num); - } -#ifdef HANDLER_HAS_DIRECT_AGGREGATE - else if (spider->result_list.direct_aggregate) - { - if ((error_num = - append_group_by(&sql, SPIDER_SQL_B_DOT_STR, SPIDER_SQL_B_DOT_LEN))) - DBUG_RETURN(error_num); - } -#endif - - DBUG_RETURN(0); -} - -int spider_oracle_handler::reuse_tmp_table_and_sql_for_bka() -{ - DBUG_ENTER("spider_oracle_handler::reuse_tmp_table_and_sql_for_bka"); - DBUG_PRINT("info",("spider this=%p", this)); - tmp_sql.length(tmp_sql_pos4); - sql.length(limit_pos); - ha_sql.length(ha_limit_pos); - DBUG_RETURN(0); -} - -void spider_oracle_handler::create_tmp_bka_table_name( - char *tmp_table_name, - int *tmp_table_name_length, - int link_idx -) { - uint adjust_length, length; - DBUG_ENTER("spider_oracle_handler::create_tmp_bka_table_name"); - if (spider_param_bka_table_name_type(current_thd, - oracle_share->spider_share-> - bka_table_name_types[spider->conn_link_idx[link_idx]]) == 1) - { - adjust_length = - oracle_share->db_nm_max_length - - oracle_share->db_names_str[spider->conn_link_idx[link_idx]].length() + - oracle_share->table_nm_max_length - - oracle_share->table_names_str[spider->conn_link_idx[link_idx]].length(); - *tmp_table_name_length = oracle_share->db_nm_max_length + - oracle_share->table_nm_max_length; - memset(tmp_table_name, ' ', adjust_length); - tmp_table_name += adjust_length; - memcpy(tmp_table_name, oracle_share->db_names_str[link_idx].c_ptr(), - oracle_share->db_names_str[link_idx].length()); - tmp_table_name += oracle_share->db_names_str[link_idx].length(); - length = my_sprintf(tmp_table_name, (tmp_table_name, - "%s%s%p%s", SPIDER_SQL_DOT_STR, SPIDER_SQL_TMP_BKA_STR, spider, - SPIDER_SQL_UNDERSCORE_STR)); - *tmp_table_name_length += length; - tmp_table_name += length; - memcpy(tmp_table_name, - oracle_share->table_names_str[spider->conn_link_idx[link_idx]].c_ptr(), - oracle_share->table_names_str[spider->conn_link_idx[link_idx]].length()); - } else { - adjust_length = - oracle_share->db_nm_max_length - - oracle_share->db_names_str[spider->conn_link_idx[link_idx]].length(); - *tmp_table_name_length = oracle_share->db_nm_max_length; - memset(tmp_table_name, ' ', adjust_length); - tmp_table_name += adjust_length; - memcpy(tmp_table_name, oracle_share->db_names_str[link_idx].c_ptr(), - oracle_share->db_names_str[link_idx].length()); - tmp_table_name += oracle_share->db_names_str[link_idx].length(); - length = my_sprintf(tmp_table_name, (tmp_table_name, - "%s%s%p", SPIDER_SQL_DOT_STR, SPIDER_SQL_TMP_BKA_STR, spider)); - *tmp_table_name_length += length; - } - DBUG_VOID_RETURN; -} - -int spider_oracle_handler::append_create_tmp_bka_table( - const key_range *start_key, - spider_string *str, - char *tmp_table_name, - int tmp_table_name_length, - int *db_name_pos, - CHARSET_INFO *table_charset -) { - int error_num; - SPIDER_SHARE *share = spider->share; - THD *thd = spider->wide_handler->trx->thd; - char *bka_engine = spider_param_bka_engine(thd, share->bka_engine); - uint bka_engine_length = strlen(bka_engine), - cset_length = strlen(table_charset->csname); - DBUG_ENTER("spider_oracle_handler::append_create_tmp_bka_table"); - if (str->reserve(SPIDER_SQL_CREATE_TMP_LEN + tmp_table_name_length + - SPIDER_SQL_OPEN_PAREN_LEN + SPIDER_SQL_ID_LEN + SPIDER_SQL_ID_TYPE_LEN + - SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_CREATE_TMP_STR, SPIDER_SQL_CREATE_TMP_LEN); - *db_name_pos = str->length(); - str->q_append(tmp_table_name, tmp_table_name_length); - str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN); - str->q_append(SPIDER_SQL_ID_STR, SPIDER_SQL_ID_LEN); - str->q_append(SPIDER_SQL_ID_TYPE_STR, SPIDER_SQL_ID_TYPE_LEN); - str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - if ((error_num = append_key_column_types(start_key, str))) - DBUG_RETURN(error_num); - if (str->reserve(SPIDER_SQL_ENGINE_LEN + bka_engine_length + - SPIDER_SQL_DEF_CHARSET_LEN + cset_length + SPIDER_SQL_SEMICOLON_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_ENGINE_STR, SPIDER_SQL_ENGINE_LEN); - str->q_append(bka_engine, bka_engine_length); - str->q_append(SPIDER_SQL_DEF_CHARSET_STR, SPIDER_SQL_DEF_CHARSET_LEN); - str->q_append(table_charset->csname, cset_length); - str->q_append(SPIDER_SQL_SEMICOLON_STR, SPIDER_SQL_SEMICOLON_LEN); - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_drop_tmp_bka_table( - spider_string *str, - char *tmp_table_name, - int tmp_table_name_length, - int *db_name_pos, - int *drop_table_end_pos, - bool with_semicolon -) { - DBUG_ENTER("spider_oracle_handler::append_drop_tmp_bka_table"); - if (str->reserve(SPIDER_SQL_DROP_TMP_LEN + tmp_table_name_length + - (with_semicolon ? SPIDER_SQL_SEMICOLON_LEN : 0))) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_DROP_TMP_STR, SPIDER_SQL_DROP_TMP_LEN); - *db_name_pos = str->length(); - str->q_append(tmp_table_name, tmp_table_name_length); - *drop_table_end_pos = str->length(); - if (with_semicolon) - str->q_append(SPIDER_SQL_SEMICOLON_STR, SPIDER_SQL_SEMICOLON_LEN); - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_insert_tmp_bka_table( - const key_range *start_key, - spider_string *str, - char *tmp_table_name, - int tmp_table_name_length, - int *db_name_pos -) { - int error_num; - DBUG_ENTER("spider_oracle_handler::append_insert_tmp_bka_table"); - if (str->reserve(SPIDER_SQL_INSERT_LEN + SPIDER_SQL_INTO_LEN + - tmp_table_name_length + SPIDER_SQL_OPEN_PAREN_LEN + SPIDER_SQL_ID_LEN + - SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_INSERT_STR, SPIDER_SQL_INSERT_LEN); - str->q_append(SPIDER_SQL_INTO_STR, SPIDER_SQL_INTO_LEN); - *db_name_pos = str->length(); - str->q_append(tmp_table_name, tmp_table_name_length); - str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN); - str->q_append(SPIDER_SQL_ID_STR, SPIDER_SQL_ID_LEN); - str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - if ((error_num = spider_db_append_key_columns(start_key, spider, str))) - DBUG_RETURN(error_num); - if (str->reserve(SPIDER_SQL_CLOSE_PAREN_LEN + SPIDER_SQL_VALUES_LEN + - SPIDER_SQL_OPEN_PAREN_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN); - str->q_append(SPIDER_SQL_VALUES_STR, SPIDER_SQL_VALUES_LEN); - str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN); - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_union_table_and_sql_for_bka( - const key_range *start_key -) { - int error_num; - DBUG_ENTER("spider_oracle_handler::append_union_table_and_sql_for_bka"); - DBUG_PRINT("info",("spider this=%p", this)); - char tgt_table_name[MAX_FIELD_WIDTH * 2]; - spider_string tgt_table_name_str(tgt_table_name, MAX_FIELD_WIDTH * 2, - oracle_share->db_names_str[0].charset()); - const char *table_names[2], *table_aliases[2], *table_dot_aliases[2]; - uint table_name_lengths[2], table_alias_lengths[2], - table_dot_alias_lengths[2]; - tgt_table_name_str.init_calc_mem(234); - tgt_table_name_str.length(0); - if ((error_num = append_table_name_with_adjusting(&tgt_table_name_str, - first_link_idx, SPIDER_SQL_TYPE_SELECT_SQL))) - { - DBUG_RETURN(error_num); - } - table_names[0] = ""; - table_names[1] = tgt_table_name_str.c_ptr_safe(); - table_name_lengths[0] = 0; - table_name_lengths[1] = tgt_table_name_str.length(); - table_aliases[0] = SPIDER_SQL_A_STR; - table_aliases[1] = SPIDER_SQL_B_STR; - table_alias_lengths[0] = SPIDER_SQL_A_LEN; - table_alias_lengths[1] = SPIDER_SQL_B_LEN; - table_dot_aliases[0] = SPIDER_SQL_A_DOT_STR; - table_dot_aliases[1] = SPIDER_SQL_B_DOT_STR; - table_dot_alias_lengths[0] = SPIDER_SQL_A_DOT_LEN; - table_dot_alias_lengths[1] = SPIDER_SQL_B_DOT_LEN; - - if ((error_num = spider_db_append_select(spider))) - DBUG_RETURN(error_num); - if (sql.reserve(SPIDER_SQL_A_DOT_LEN + SPIDER_SQL_ID_LEN + - SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql.q_append(SPIDER_SQL_A_DOT_STR, SPIDER_SQL_A_DOT_LEN); - sql.q_append(SPIDER_SQL_ID_STR, SPIDER_SQL_ID_LEN); - sql.q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - if ((error_num = append_select_columns_with_alias(&sql, - SPIDER_SQL_B_DOT_STR, SPIDER_SQL_B_DOT_LEN))) - DBUG_RETURN(error_num); - if (sql.reserve(SPIDER_SQL_FROM_LEN + (SPIDER_SQL_OPEN_PAREN_LEN * 2))) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql.q_append(SPIDER_SQL_FROM_STR, SPIDER_SQL_FROM_LEN); - sql.q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN); - sql.q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN); - tmp_sql_pos1 = sql.length(); - - if ( - (error_num = spider_db_oracle_utility.append_from_with_alias(&tmp_sql, - table_names, table_name_lengths, - table_aliases, table_alias_lengths, 2, - &table_name_pos, FALSE)) - ) - DBUG_RETURN(error_num); - if ( - oracle_share->key_hint && - (error_num = spider_db_append_hint_after_table(spider, - &tmp_sql, &oracle_share->key_hint[spider->active_index])) - ) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - where_pos = tmp_sql.length(); - if ( - (error_num = append_key_join_columns_for_bka( - start_key, &tmp_sql, - table_dot_aliases, table_dot_alias_lengths)) || - (error_num = append_condition_part( - SPIDER_SQL_B_DOT_STR, SPIDER_SQL_B_DOT_LEN, - SPIDER_SQL_TYPE_TMP_SQL, FALSE)) - ) - DBUG_RETURN(error_num); - if (spider->result_list.direct_order_limit) - { - if ((error_num = append_key_order_for_direct_order_limit_with_alias( - &tmp_sql, SPIDER_SQL_B_DOT_STR, SPIDER_SQL_B_DOT_LEN))) - DBUG_RETURN(error_num); - } -#ifdef HANDLER_HAS_DIRECT_AGGREGATE - else if (spider->result_list.direct_aggregate) - { - if ((error_num = - append_group_by(&tmp_sql, SPIDER_SQL_B_DOT_STR, SPIDER_SQL_B_DOT_LEN))) - DBUG_RETURN(error_num); - } -#endif - - DBUG_RETURN(0); -} - -int spider_oracle_handler::reuse_union_table_and_sql_for_bka() -{ - DBUG_ENTER("spider_oracle_handler::reuse_union_table_and_sql_for_bka"); - DBUG_PRINT("info",("spider this=%p", this)); - sql.length(tmp_sql_pos1); - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_insert_for_recovery( - ulong sql_type, - int link_idx -) { - const TABLE *table = spider->get_table(); - SPIDER_SHARE *share = spider->share; - Field **field; - uint field_name_length = 0; - bool add_value = FALSE; - spider_string *insert_sql; - DBUG_ENTER("spider_oracle_handler::append_insert_for_recovery"); - DBUG_PRINT("info",("spider this=%p", this)); - if (sql_type == SPIDER_SQL_TYPE_INSERT_SQL) - { - insert_sql = &spider->result_list.insert_sqls[link_idx]; - insert_sql->length(0); - } else { - insert_sql = &spider->result_list.update_sqls[link_idx]; - } - if (insert_sql->reserve( - SPIDER_SQL_INSERT_LEN + SPIDER_SQL_SQL_IGNORE_LEN + - SPIDER_SQL_INTO_LEN + oracle_share->db_nm_max_length + - SPIDER_SQL_DOT_LEN + oracle_share->table_nm_max_length + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 4 + SPIDER_SQL_OPEN_PAREN_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - insert_sql->q_append(SPIDER_SQL_INSERT_STR, SPIDER_SQL_INSERT_LEN); - insert_sql->q_append(SPIDER_SQL_SQL_IGNORE_STR, SPIDER_SQL_SQL_IGNORE_LEN); - insert_sql->q_append(SPIDER_SQL_INTO_STR, SPIDER_SQL_INTO_LEN); - oracle_share->append_table_name(insert_sql, spider->conn_link_idx[link_idx]); - insert_sql->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN); - for (field = table->field; *field; field++) - { - field_name_length = - oracle_share->column_name_str[(*field)->field_index].length(); - if (insert_sql->reserve(field_name_length + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - oracle_share->append_column_name(insert_sql, (*field)->field_index); - insert_sql->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } - if (field_name_length) - insert_sql->length(insert_sql->length() - SPIDER_SQL_COMMA_LEN); - if (insert_sql->reserve(SPIDER_SQL_CLOSE_PAREN_LEN + SPIDER_SQL_VALUES_LEN + - SPIDER_SQL_OPEN_PAREN_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - insert_sql->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN); - insert_sql->q_append(SPIDER_SQL_VALUES_STR, SPIDER_SQL_VALUES_LEN); - insert_sql->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN); - for (field = table->field; *field; field++) - { - add_value = TRUE; - if ((*field)->is_null()) - { - if (insert_sql->reserve(SPIDER_SQL_NULL_LEN + SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - insert_sql->q_append(SPIDER_SQL_NULL_STR, SPIDER_SQL_NULL_LEN); - } else { - if ( - spider_db_oracle_utility. - append_column_value(spider, insert_sql, *field, NULL, - share->access_charset) || - insert_sql->reserve(SPIDER_SQL_COMMA_LEN) - ) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - insert_sql->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } - if (add_value) - insert_sql->length(insert_sql->length() - SPIDER_SQL_COMMA_LEN); - if (insert_sql->reserve(SPIDER_SQL_CLOSE_PAREN_LEN, SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - insert_sql->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN); - if (sql_type == SPIDER_SQL_TYPE_INSERT_SQL) - { - exec_insert_sql = insert_sql; - } - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_update( - const TABLE *table, - my_ptrdiff_t ptr_diff -) { - int error_num; - spider_string *str = &update_sql; - DBUG_ENTER("spider_oracle_handler::append_update"); - DBUG_PRINT("info",("spider this=%p", this)); - if (str->length() > 0) - { - if (str->reserve(SPIDER_SQL_SEMICOLON_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_SEMICOLON_STR, SPIDER_SQL_SEMICOLON_LEN); - } - - if ( - (error_num = append_update(str, 0)) || - (error_num = append_update_set(str)) || - (error_num = append_update_where(str, table, ptr_diff)) - ) - DBUG_RETURN(error_num); - filled_up = (str->length() >= (uint) spider->result_list.bulk_update_size); - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_update( - const TABLE *table, - my_ptrdiff_t ptr_diff, - int link_idx -) { - int error_num; - SPIDER_SHARE *share = spider->share; - spider_string *str = &spider->result_list.update_sqls[link_idx]; - DBUG_ENTER("spider_oracle_handler::append_update"); - DBUG_PRINT("info",("spider this=%p", this)); - if (str->length() > 0) - { - if (str->reserve(SPIDER_SQL_SEMICOLON_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_SEMICOLON_STR, SPIDER_SQL_SEMICOLON_LEN); - } - - if ( - (error_num = append_update(str, link_idx)) || - (error_num = append_update_set(str)) || - (error_num = append_update_where(str, table, ptr_diff)) - ) - DBUG_RETURN(error_num); - - if ( - spider->pk_update && - share->link_statuses[link_idx] == SPIDER_LINK_STATUS_RECOVERY - ) { - if (str->reserve(SPIDER_SQL_SEMICOLON_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_SEMICOLON_STR, SPIDER_SQL_SEMICOLON_LEN); - if ((error_num = append_insert_for_recovery( - SPIDER_SQL_TYPE_UPDATE_SQL, link_idx))) - DBUG_RETURN(error_num); - } - - if (!filled_up) - filled_up = (str->length() >= (uint) spider->result_list.bulk_update_size); - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_delete( - const TABLE *table, - my_ptrdiff_t ptr_diff -) { - int error_num; - spider_string *str = &update_sql; - DBUG_ENTER("spider_oracle_handler::append_delete"); - DBUG_PRINT("info",("spider this=%p", this)); - if (str->length() > 0) - { - if (str->reserve(SPIDER_SQL_SEMICOLON_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_SEMICOLON_STR, SPIDER_SQL_SEMICOLON_LEN); - } - - if ( - (error_num = append_delete(str)) || - (error_num = append_from(str, SPIDER_SQL_TYPE_DELETE_SQL, - first_link_idx)) || - (error_num = append_update_where(str, table, ptr_diff)) - ) - DBUG_RETURN(error_num); - filled_up = (str->length() >= (uint) spider->result_list.bulk_update_size); - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_delete( - const TABLE *table, - my_ptrdiff_t ptr_diff, - int link_idx -) { - int error_num; - spider_string *str = &spider->result_list.update_sqls[link_idx]; - DBUG_ENTER("spider_oracle_handler::append_delete"); - DBUG_PRINT("info",("spider this=%p", this)); - if (str->length() > 0) - { - if (str->reserve(SPIDER_SQL_SEMICOLON_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_SEMICOLON_STR, SPIDER_SQL_SEMICOLON_LEN); - } - - if ( - (error_num = append_delete(str)) || - (error_num = append_from(str, SPIDER_SQL_TYPE_DELETE_SQL, link_idx)) || - (error_num = append_update_where(str, table, ptr_diff)) - ) - DBUG_RETURN(error_num); - if (!filled_up) - filled_up = (str->length() >= (uint) spider->result_list.bulk_update_size); - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_insert_part() -{ - int error_num; - DBUG_ENTER("spider_oracle_handler::append_insert_part"); - DBUG_PRINT("info",("spider this=%p", this)); - error_num = append_insert(&insert_sql, 0); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_insert( - spider_string *str, - int link_idx -) { - DBUG_ENTER("spider_oracle_handler::append_insert"); - if (str->reserve(SPIDER_SQL_INSERT_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_INSERT_STR, SPIDER_SQL_INSERT_LEN); - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_update_part() -{ - int error_num; - DBUG_ENTER("spider_oracle_handler::append_update_part"); - DBUG_PRINT("info",("spider this=%p", this)); - error_num = append_update(&update_sql, 0); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_update( - spider_string *str, - int link_idx -) { - DBUG_ENTER("spider_oracle_handler::append_update"); - if (str->reserve(SPIDER_SQL_UPDATE_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_UPDATE_STR, SPIDER_SQL_UPDATE_LEN); - if (str->reserve(oracle_share->db_nm_max_length + - SPIDER_SQL_DOT_LEN + oracle_share->table_nm_max_length + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 4)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - table_name_pos = str->length(); - append_table_name_with_adjusting(str, link_idx, SPIDER_SQL_TYPE_UPDATE_SQL); - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_delete_part() -{ - int error_num; - DBUG_ENTER("spider_oracle_handler::append_delete_part"); - DBUG_PRINT("info",("spider this=%p", this)); - error_num = append_delete(&update_sql); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_delete( - spider_string *str -) { - DBUG_ENTER("spider_oracle_handler::append_delete"); - if (str->reserve(SPIDER_SQL_DELETE_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_DELETE_STR, SPIDER_SQL_DELETE_LEN); - str->length(str->length() - 1); - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_update_set_part() -{ - int error_num; - DBUG_ENTER("spider_oracle_handler::append_update_set_part"); - DBUG_PRINT("info",("spider this=%p", this)); - update_set_pos = update_sql.length(); - error_num = append_update_set(&update_sql); - where_pos = update_sql.length(); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_update_set( - spider_string *str -) { - uint field_name_length; - SPIDER_SHARE *share = spider->share; - TABLE *table = spider->get_table(); - Field **fields; - DBUG_ENTER("spider_oracle_handler::append_update_set"); - if (str->reserve(SPIDER_SQL_SET_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_SET_STR, SPIDER_SQL_SET_LEN); - for (fields = table->field; *fields; fields++) - { - if (bitmap_is_set(table->write_set, (*fields)->field_index)) - { - field_name_length = - oracle_share->column_name_str[(*fields)->field_index].length(); - if ((*fields)->is_null()) - { - if (str->reserve(field_name_length + /* SPIDER_SQL_NAME_QUOTE_LEN */ - 2 + SPIDER_SQL_EQUAL_LEN + SPIDER_SQL_NULL_LEN + - SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - oracle_share->append_column_name(str, (*fields)->field_index); - str->q_append(SPIDER_SQL_EQUAL_STR, SPIDER_SQL_EQUAL_LEN); - str->q_append(SPIDER_SQL_NULL_STR, SPIDER_SQL_NULL_LEN); - } else { - if (str->reserve(field_name_length + /* SPIDER_SQL_NAME_QUOTE_LEN */ - 2 + SPIDER_SQL_EQUAL_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - oracle_share->append_column_name(str, (*fields)->field_index); - str->q_append(SPIDER_SQL_EQUAL_STR, SPIDER_SQL_EQUAL_LEN); -#ifndef DBUG_OFF - my_bitmap_map *tmp_map = dbug_tmp_use_all_columns(table, - table->read_set); -#endif - if ( - spider_db_oracle_utility. - append_column_value(spider, str, *fields, NULL, - share->access_charset) || - str->reserve(SPIDER_SQL_COMMA_LEN) - ) { -#ifndef DBUG_OFF - dbug_tmp_restore_column_map(table->read_set, tmp_map); -#endif - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } -#ifndef DBUG_OFF - dbug_tmp_restore_column_map(table->read_set, tmp_map); -#endif - } - str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } - } - str->length(str->length() - SPIDER_SQL_COMMA_LEN); - DBUG_RETURN(0); -} - -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS -int spider_oracle_handler::append_direct_update_set_part() -{ - int error_num; - DBUG_ENTER("spider_oracle_handler::append_direct_update_set_part"); - DBUG_PRINT("info",("spider this=%p", this)); - update_set_pos = update_sql.length(); - error_num = append_direct_update_set(&update_sql); - where_pos = update_sql.length(); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_direct_update_set( - spider_string *str -) { - DBUG_ENTER("spider_oracle_handler::append_direct_update_set"); - if ( - spider->direct_update_kinds == SPIDER_SQL_KIND_SQL && - spider->wide_handler->direct_update_fields - ) { - if (str->reserve(SPIDER_SQL_SET_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_SET_STR, SPIDER_SQL_SET_LEN); - DBUG_RETURN(append_update_columns(str, NULL, 0)); - } - - if ( - (spider->direct_update_kinds & SPIDER_SQL_KIND_SQL) - ) { - DBUG_ASSERT(0); - } - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_dup_update_pushdown_part( - const char *alias, - uint alias_length -) { - int error_num; - DBUG_ENTER("spider_oracle_handler::append_dup_update_pushdown_part"); - DBUG_PRINT("info",("spider this=%p", this)); - dup_update_sql.length(0); - error_num = append_update_columns(&dup_update_sql, alias, alias_length); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_update_columns_part( - const char *alias, - uint alias_length -) { - int error_num; - DBUG_ENTER("spider_oracle_handler::append_update_columns_part"); - DBUG_PRINT("info",("spider this=%p", this)); - error_num = append_update_columns(&update_sql, alias, alias_length); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::check_update_columns_part() -{ - int error_num; - DBUG_ENTER("spider_oracle_handler::check_update_columns_part"); - DBUG_PRINT("info",("spider this=%p", this)); - error_num = append_update_columns(NULL, NULL, 0); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_update_columns( - spider_string *str, - const char *alias, - uint alias_length -) { - int error_num; - List_iterator_fast<Item> fi(*spider->wide_handler->direct_update_fields), - vi(*spider->wide_handler->direct_update_values); - Item *field, *value; - DBUG_ENTER("spider_oracle_handler::append_update_columns"); - while ((field = fi++)) - { - value = vi++; - if ((error_num = spider_db_print_item_type( - (Item *) field, NULL, spider, str, alias, alias_length, - spider_dbton_oracle.dbton_id, FALSE, NULL))) - { - if ( - error_num == ER_SPIDER_COND_SKIP_NUM && - field->type() == Item::FIELD_ITEM && - ((Item_field *) field)->field - ) - continue; - DBUG_RETURN(error_num); - } - if (str) - { - if (str->reserve(SPIDER_SQL_EQUAL_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_EQUAL_STR, SPIDER_SQL_EQUAL_LEN); - } - if ((error_num = spider_db_print_item_type( - (Item *) value, ((Item_field *) field)->field, spider, str, - alias, alias_length, spider_dbton_oracle.dbton_id, FALSE, NULL))) - DBUG_RETURN(error_num); - if (str) - { - if (str->reserve(SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } - } - if (str) - str->length(str->length() - SPIDER_SQL_COMMA_LEN); - DBUG_RETURN(0); -/* - error_num = spider_db_append_update_columns(spider, str, - alias, alias_length, spider_dbton_oracle.dbton_id); - DBUG_RETURN(error_num); -*/ -} -#endif - -int spider_oracle_handler::append_select_part( - ulong sql_type -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_select_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - str = &sql; - break; - case SPIDER_SQL_TYPE_HANDLER: - str = &ha_sql; - break; - default: - DBUG_RETURN(0); - } - error_num = append_select(str, sql_type); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_select( - spider_string *str, - ulong sql_type -) { - DBUG_ENTER("spider_oracle_handler::append_select"); - if (sql_type == SPIDER_SQL_TYPE_HANDLER) - { - if (str->reserve(SPIDER_SQL_HANDLER_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_HANDLER_STR, SPIDER_SQL_HANDLER_LEN); - } else { - if (str->reserve(SPIDER_SQL_SELECT_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_SELECT_STR, SPIDER_SQL_SELECT_LEN); - if (spider->result_list.direct_distinct) - { - if (str->reserve(SPIDER_SQL_DISTINCT_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_DISTINCT_STR, SPIDER_SQL_DISTINCT_LEN); - } - } - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_table_select_part( - ulong sql_type -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_table_select_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - str = &sql; - break; - default: - DBUG_RETURN(0); - } - error_num = append_table_select(str); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_table_select( - spider_string *str -) { - DBUG_ENTER("spider_oracle_handler::append_table_select"); - table_name_pos = str->length() + oracle_share->table_select_pos; - if (str->append(*(oracle_share->table_select))) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_key_select_part( - ulong sql_type, - uint idx -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_key_select_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - str = &sql; - break; - default: - DBUG_RETURN(0); - } - error_num = append_key_select(str, idx); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_key_select( - spider_string *str, - uint idx -) { - DBUG_ENTER("spider_oracle_handler::append_key_select"); - table_name_pos = str->length() + oracle_share->key_select_pos[idx]; - if (str->append(oracle_share->key_select[idx])) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_minimum_select_part( - ulong sql_type -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_minimum_select_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - str = &sql; - break; - default: - DBUG_RETURN(0); - } - error_num = append_minimum_select(str, sql_type); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_minimum_select( - spider_string *str, - ulong sql_type -) { - TABLE *table = spider->get_table(); - Field **field; - int field_length; - bool appended = FALSE; - DBUG_ENTER("spider_oracle_handler::append_minimum_select"); - minimum_select_bitmap_create(); - for (field = table->field; *field; field++) - { - if (minimum_select_bit_is_set((*field)->field_index)) - { -/* - spider_set_bit(minimum_select_bitmap, (*field)->field_index); -*/ - field_length = - oracle_share->column_name_str[(*field)->field_index].length(); - if (str->reserve(field_length + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - oracle_share->append_column_name(str, (*field)->field_index); - str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - appended = TRUE; - } - } - if (appended) - str->length(str->length() - SPIDER_SQL_COMMA_LEN); - else { - if (str->reserve(SPIDER_SQL_ONE_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_ONE_STR, SPIDER_SQL_ONE_LEN); - } - DBUG_RETURN(append_from(str, sql_type, first_link_idx)); -} - -int spider_oracle_handler::append_table_select_with_alias( - spider_string *str, - const char *alias, - uint alias_length -) { - TABLE *table = spider->get_table(); - Field **field; - int field_length; - DBUG_ENTER("spider_oracle_handler::append_table_select_with_alias"); - for (field = table->field; *field; field++) - { - field_length = - oracle_share->column_name_str[(*field)->field_index].length(); - if (str->reserve(alias_length + field_length + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(alias, alias_length); - oracle_share->append_column_name(str, (*field)->field_index); - str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } - str->length(str->length() - SPIDER_SQL_COMMA_LEN); - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_key_select_with_alias( - spider_string *str, - const KEY *key_info, - const char *alias, - uint alias_length -) { - KEY_PART_INFO *key_part; - Field *field; - uint part_num; - int field_length; - DBUG_ENTER("spider_oracle_handler::append_key_select_with_alias"); - for (key_part = key_info->key_part, part_num = 0; - part_num < spider_user_defined_key_parts(key_info); key_part++, part_num++) - { - field = key_part->field; - field_length = oracle_share->column_name_str[field->field_index].length(); - if (str->reserve(alias_length + field_length + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(alias, alias_length); - oracle_share->append_column_name(str, field->field_index); - str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } - str->length(str->length() - SPIDER_SQL_COMMA_LEN); - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_minimum_select_with_alias( - spider_string *str, - const char *alias, - uint alias_length -) { - TABLE *table = spider->get_table(); - Field **field; - int field_length; - bool appended = FALSE; - DBUG_ENTER("spider_oracle_handler::append_minimum_select_with_alias"); - minimum_select_bitmap_create(); - for (field = table->field; *field; field++) - { - if (minimum_select_bit_is_set((*field)->field_index)) - { -/* - spider_set_bit(minimum_select_bitmap, (*field)->field_index); -*/ - field_length = - oracle_share->column_name_str[(*field)->field_index].length(); - if (str->reserve(alias_length + field_length + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(alias, alias_length); - oracle_share->append_column_name(str, (*field)->field_index); - str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - appended = TRUE; - } - } - if (appended) - str->length(str->length() - SPIDER_SQL_COMMA_LEN); - else { - if (str->reserve(SPIDER_SQL_ONE_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_ONE_STR, SPIDER_SQL_ONE_LEN); - } - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_select_columns_with_alias( - spider_string *str, - const char *alias, - uint alias_length -) { - int error_num; - SPIDER_RESULT_LIST *result_list = &spider->result_list; - DBUG_ENTER("spider_oracle_handler::append_select_columns_with_alias"); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE - if ( - result_list->direct_aggregate && - (error_num = append_sum_select(str, alias, alias_length)) - ) - DBUG_RETURN(error_num); -#endif - if ((error_num = append_match_select(str, alias, alias_length))) - DBUG_RETURN(error_num); - if (!spider->select_column_mode) - { - if (result_list->keyread) - DBUG_RETURN(append_key_select_with_alias( - str, result_list->key_info, alias, alias_length)); - else - DBUG_RETURN(append_table_select_with_alias( - str, alias, alias_length)); - } - DBUG_RETURN(append_minimum_select_with_alias(str, alias, alias_length)); -} - -int spider_oracle_handler::append_hint_after_table_part( - ulong sql_type -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_hint_after_table_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - case SPIDER_SQL_TYPE_TMP_SQL: - str = &sql; - break; - case SPIDER_SQL_TYPE_INSERT_SQL: - case SPIDER_SQL_TYPE_UPDATE_SQL: - case SPIDER_SQL_TYPE_DELETE_SQL: - case SPIDER_SQL_TYPE_BULK_UPDATE_SQL: - str = &update_sql; - break; - case SPIDER_SQL_TYPE_HANDLER: - str = &ha_sql; - break; - default: - DBUG_RETURN(0); - } - error_num = append_hint_after_table(str); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_hint_after_table( - spider_string *str -) { - int error_num; - DBUG_ENTER("spider_oracle_handler::append_hint_after_table"); - DBUG_PRINT("info",("spider this=%p", this)); - if ( - oracle_share->key_hint && - (error_num = spider_db_append_hint_after_table(spider, - str, &oracle_share->key_hint[spider->active_index])) - ) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - DBUG_RETURN(0); -} - -void spider_oracle_handler::set_where_pos( - ulong sql_type -) { - DBUG_ENTER("spider_oracle_handler::set_where_pos"); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - case SPIDER_SQL_TYPE_TMP_SQL: - where_pos = sql.length(); - break; - case SPIDER_SQL_TYPE_INSERT_SQL: - case SPIDER_SQL_TYPE_UPDATE_SQL: - case SPIDER_SQL_TYPE_DELETE_SQL: - case SPIDER_SQL_TYPE_BULK_UPDATE_SQL: - where_pos = update_sql.length(); - break; - case SPIDER_SQL_TYPE_HANDLER: - ha_read_pos = ha_sql.length(); - break; - default: - break; - } - DBUG_VOID_RETURN; -} - -void spider_oracle_handler::set_where_to_pos( - ulong sql_type -) { - DBUG_ENTER("spider_oracle_handler::set_where_to_pos"); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - case SPIDER_SQL_TYPE_TMP_SQL: - sql.length(where_pos); - break; - case SPIDER_SQL_TYPE_INSERT_SQL: - case SPIDER_SQL_TYPE_UPDATE_SQL: - case SPIDER_SQL_TYPE_DELETE_SQL: - case SPIDER_SQL_TYPE_BULK_UPDATE_SQL: - update_sql.length(where_pos); - break; - case SPIDER_SQL_TYPE_HANDLER: - ha_sql.length(ha_read_pos); - break; - default: - break; - } - DBUG_VOID_RETURN; -} - -int spider_oracle_handler::check_item_type( - Item *item -) { - int error_num; - DBUG_ENTER("spider_oracle_handler::check_item_type"); - DBUG_PRINT("info",("spider this=%p", this)); - error_num = spider_db_print_item_type(item, NULL, spider, NULL, NULL, 0, - spider_dbton_oracle.dbton_id, FALSE, NULL); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_values_connector_part( - ulong sql_type -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_values_connector_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - str = &sql; - break; - case SPIDER_SQL_TYPE_TMP_SQL: - str = &tmp_sql; - break; - default: - DBUG_RETURN(0); - } - error_num = append_values_connector(str); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_values_connector( - spider_string *str -) { - DBUG_ENTER("spider_oracle_handler::append_values_connector"); - DBUG_PRINT("info",("spider this=%p", this)); - if (str->reserve(SPIDER_SQL_CLOSE_PAREN_LEN + - SPIDER_SQL_COMMA_LEN + SPIDER_SQL_OPEN_PAREN_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN); - str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN); - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_values_terminator_part( - ulong sql_type -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_values_terminator_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - str = &sql; - break; - case SPIDER_SQL_TYPE_TMP_SQL: - str = &tmp_sql; - break; - default: - DBUG_RETURN(0); - } - error_num = append_values_terminator(str); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_values_terminator( - spider_string *str -) { - DBUG_ENTER("spider_oracle_handler::append_values_terminator"); - DBUG_PRINT("info",("spider this=%p", this)); - str->length(str->length() - - SPIDER_SQL_COMMA_LEN - SPIDER_SQL_OPEN_PAREN_LEN); - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_union_table_connector_part( - ulong sql_type -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_union_table_connector_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - str = &sql; - break; - case SPIDER_SQL_TYPE_TMP_SQL: - str = &tmp_sql; - break; - default: - DBUG_RETURN(0); - } - error_num = append_union_table_connector(str); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_union_table_connector( - spider_string *str -) { - DBUG_ENTER("spider_oracle_handler::append_union_table_connector"); - DBUG_PRINT("info",("spider this=%p", this)); - if (str->reserve((SPIDER_SQL_SPACE_LEN * 2) + SPIDER_SQL_UNION_ALL_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN); - str->q_append(SPIDER_SQL_UNION_ALL_STR, SPIDER_SQL_UNION_ALL_LEN); - str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN); - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_union_table_terminator_part( - ulong sql_type -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_union_table_terminator_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - str = &sql; - break; - default: - DBUG_RETURN(0); - } - error_num = append_union_table_terminator(str); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_union_table_terminator( - spider_string *str -) { - DBUG_ENTER("spider_oracle_handler::append_union_table_terminator"); - DBUG_PRINT("info",("spider this=%p", this)); - str->length(str->length() - - ((SPIDER_SQL_SPACE_LEN * 2) + SPIDER_SQL_UNION_ALL_LEN)); - str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN); - str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN); - table_name_pos = str->length() + SPIDER_SQL_SPACE_LEN + SPIDER_SQL_A_LEN + - SPIDER_SQL_COMMA_LEN; - if (str->reserve(tmp_sql.length() - SPIDER_SQL_FROM_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(tmp_sql.ptr() + SPIDER_SQL_FROM_LEN, - tmp_sql.length() - SPIDER_SQL_FROM_LEN); - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_key_column_values_part( - const key_range *start_key, - ulong sql_type -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_key_column_values_part"); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - str = &sql; - break; - case SPIDER_SQL_TYPE_TMP_SQL: - str = &tmp_sql; - break; - default: - DBUG_RETURN(0); - } - error_num = append_key_column_values(str, start_key); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_key_column_values( - spider_string *str, - const key_range *start_key -) { - int error_num; - const uchar *ptr; - SPIDER_RESULT_LIST *result_list = &spider->result_list; - SPIDER_SHARE *share = spider->share; - KEY *key_info = result_list->key_info; - uint length; - uint store_length; - key_part_map full_key_part_map = - make_prev_keypart_map(spider_user_defined_key_parts(key_info)); - key_part_map start_key_part_map; - KEY_PART_INFO *key_part; - Field *field; - DBUG_ENTER("spider_oracle_handler::append_key_column_values"); - start_key_part_map = start_key->keypart_map & full_key_part_map; - DBUG_PRINT("info", ("spider spider_user_defined_key_parts=%u", - spider_user_defined_key_parts(key_info))); - DBUG_PRINT("info", ("spider full_key_part_map=%lu", full_key_part_map)); - DBUG_PRINT("info", ("spider start_key_part_map=%lu", start_key_part_map)); - - if (!start_key_part_map) - DBUG_RETURN(0); - - for ( - key_part = key_info->key_part, - length = 0; - start_key_part_map; - start_key_part_map >>= 1, - key_part++, - length += store_length - ) { - store_length = key_part->store_length; - ptr = start_key->key + length; - field = key_part->field; - if ((error_num = spider_db_append_null_value(str, key_part, &ptr))) - { - if (error_num > 0) - DBUG_RETURN(error_num); - } else { - if (spider_db_oracle_utility.append_column_value(spider, str, field, ptr, - share->access_charset)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - - if (str->reserve(SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } - str->length(str->length() - SPIDER_SQL_COMMA_LEN); - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_key_column_values_with_name_part( - const key_range *start_key, - ulong sql_type -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_key_column_values_with_name_part"); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - str = &sql; - break; - case SPIDER_SQL_TYPE_TMP_SQL: - str = &tmp_sql; - break; - default: - DBUG_RETURN(0); - } - error_num = append_key_column_values_with_name(str, start_key); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_key_column_values_with_name( - spider_string *str, - const key_range *start_key -) { - int error_num; - const uchar *ptr; - SPIDER_RESULT_LIST *result_list = &spider->result_list; - SPIDER_SHARE *share = spider->share; - KEY *key_info = result_list->key_info; - uint length; - uint key_name_length, key_count; - uint store_length; - key_part_map full_key_part_map = - make_prev_keypart_map(spider_user_defined_key_parts(key_info)); - key_part_map start_key_part_map; - KEY_PART_INFO *key_part; - Field *field; - char tmp_buf[MAX_FIELD_WIDTH]; - DBUG_ENTER("spider_oracle_handler::append_key_column_values_with_name"); - start_key_part_map = start_key->keypart_map & full_key_part_map; - DBUG_PRINT("info", ("spider spider_user_defined_key_parts=%u", - spider_user_defined_key_parts(key_info))); - DBUG_PRINT("info", ("spider full_key_part_map=%lu", full_key_part_map)); - DBUG_PRINT("info", ("spider start_key_part_map=%lu", start_key_part_map)); - - if (!start_key_part_map) - DBUG_RETURN(0); - - for ( - key_part = key_info->key_part, - length = 0, - key_count = 0; - start_key_part_map; - start_key_part_map >>= 1, - key_part++, - length += store_length, - key_count++ - ) { - store_length = key_part->store_length; - ptr = start_key->key + length; - field = key_part->field; - if ((error_num = spider_db_append_null_value(str, key_part, &ptr))) - { - if (error_num > 0) - DBUG_RETURN(error_num); - } else { - if (spider_db_oracle_utility.append_column_value(spider, str, field, ptr, - share->access_charset)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - - key_name_length = my_sprintf(tmp_buf, (tmp_buf, "c%u", key_count)); - if (str->reserve(SPIDER_SQL_SPACE_LEN + key_name_length + - SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN); - str->q_append(tmp_buf, key_name_length); - str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } - str->length(str->length() - SPIDER_SQL_COMMA_LEN); - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_key_where_part( - const key_range *start_key, - const key_range *end_key, - ulong sql_type -) { - int error_num; - spider_string *str, *str_part = NULL, *str_part2 = NULL; - bool set_order; - DBUG_ENTER("spider_oracle_handler::append_key_where_part"); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - str = &sql; - set_order = FALSE; - break; - case SPIDER_SQL_TYPE_TMP_SQL: - str = &tmp_sql; - set_order = FALSE; - break; - case SPIDER_SQL_TYPE_INSERT_SQL: - case SPIDER_SQL_TYPE_UPDATE_SQL: - case SPIDER_SQL_TYPE_DELETE_SQL: - case SPIDER_SQL_TYPE_BULK_UPDATE_SQL: - str = &update_sql; - set_order = FALSE; - break; - case SPIDER_SQL_TYPE_HANDLER: - str = &ha_sql; - ha_read_pos = str->length(); - str_part = &sql_part; - str_part2 = &sql_part2; - str_part->length(0); - str_part2->length(0); - set_order = TRUE; - break; - default: - DBUG_RETURN(0); - } - error_num = append_key_where(str, str_part, str_part2, start_key, end_key, - sql_type, set_order); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_key_where( - spider_string *str, - spider_string *str_part, - spider_string *str_part2, - const key_range *start_key, - const key_range *end_key, - ulong sql_type, - bool set_order -) { - int error_num; - DBUG_ENTER("spider_oracle_handler::append_key_where"); - error_num = spider_db_append_key_where_internal(str, str_part, str_part2, - start_key, end_key, spider, set_order, sql_type, - spider_dbton_oracle.dbton_id); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_is_null_part( - ulong sql_type, - KEY_PART_INFO *key_part, - const key_range *key, - const uchar **ptr, - bool key_eq, - bool tgt_final -) { - int error_num; - spider_string *str, *str_part = NULL, *str_part2 = NULL; - DBUG_ENTER("spider_oracle_handler::append_is_null_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - case SPIDER_SQL_TYPE_TMP_SQL: - str = &sql; - break; - case SPIDER_SQL_TYPE_INSERT_SQL: - case SPIDER_SQL_TYPE_UPDATE_SQL: - case SPIDER_SQL_TYPE_DELETE_SQL: - case SPIDER_SQL_TYPE_BULK_UPDATE_SQL: - str = &update_sql; - break; - case SPIDER_SQL_TYPE_HANDLER: - str = &ha_sql; - str_part = &sql_part; - str_part2 = &sql_part2; - break; - default: - DBUG_RETURN(0); - } - error_num = append_is_null(sql_type, str, str_part, str_part2, - key_part, key, ptr, key_eq, tgt_final); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_is_null( - ulong sql_type, - spider_string *str, - spider_string *str_part, - spider_string *str_part2, - KEY_PART_INFO *key_part, - const key_range *key, - const uchar **ptr, - bool key_eq, - bool tgt_final -) { - DBUG_ENTER("spider_oracle_handler::append_is_null"); - DBUG_PRINT("info",("spider this=%p", this)); - if (key_part->null_bit) - { - if (*(*ptr)++) - { - if (sql_type == SPIDER_SQL_TYPE_HANDLER) - { - str = str_part; - if ( - key_eq || - key->flag == HA_READ_KEY_EXACT || - key->flag == HA_READ_KEY_OR_NEXT - ) { - if (str->reserve(SPIDER_SQL_IS_NULL_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_IS_NULL_STR, SPIDER_SQL_IS_NULL_LEN); - } else { - str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN); - ha_next_pos = str->length(); - if (str->reserve(SPIDER_SQL_FIRST_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_FIRST_STR, SPIDER_SQL_FIRST_LEN); - spider->result_list.ha_read_kind = 1; - } - str = str_part2; - } - if ( - key_eq || - key->flag == HA_READ_KEY_EXACT || - key->flag == HA_READ_KEY_OR_NEXT - ) { - if (str->reserve(SPIDER_SQL_IS_NULL_LEN + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + - oracle_share->column_name_str[key_part->field->field_index].length())) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - oracle_share->append_column_name(str, key_part->field->field_index); - str->q_append(SPIDER_SQL_IS_NULL_STR, SPIDER_SQL_IS_NULL_LEN); - } else { - if (str->reserve(SPIDER_SQL_IS_NOT_NULL_LEN + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + - oracle_share->column_name_str[key_part->field->field_index].length())) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - oracle_share->append_column_name(str, key_part->field->field_index); - str->q_append(SPIDER_SQL_IS_NOT_NULL_STR, SPIDER_SQL_IS_NOT_NULL_LEN); - } - DBUG_RETURN(-1); - } - } - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_where_terminator_part( - ulong sql_type, - bool set_order, - int key_count -) { - int error_num; - spider_string *str, *str_part = NULL, *str_part2 = NULL; - DBUG_ENTER("spider_oracle_handler::append_where_terminator_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - case SPIDER_SQL_TYPE_TMP_SQL: - str = &sql; - break; - case SPIDER_SQL_TYPE_INSERT_SQL: - case SPIDER_SQL_TYPE_UPDATE_SQL: - case SPIDER_SQL_TYPE_DELETE_SQL: - case SPIDER_SQL_TYPE_BULK_UPDATE_SQL: - str = &update_sql; - break; - case SPIDER_SQL_TYPE_HANDLER: - str = &ha_sql; - str_part = &sql_part; - str_part2 = &sql_part2; - break; - default: - DBUG_RETURN(0); - } - error_num = append_where_terminator(sql_type, str, str_part, str_part2, - set_order, key_count); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_where_terminator( - ulong sql_type, - spider_string *str, - spider_string *str_part, - spider_string *str_part2, - bool set_order, - int key_count -) { - SPIDER_RESULT_LIST *result_list = &spider->result_list; - DBUG_ENTER("spider_oracle_handler::append_where_terminator"); - DBUG_PRINT("info",("spider this=%p", this)); - if (sql_type != SPIDER_SQL_TYPE_HANDLER) - { - str->length(str->length() - SPIDER_SQL_AND_LEN); - if (!set_order) - result_list->key_order = key_count; - } else { - str_part2->length(str_part2->length() - SPIDER_SQL_AND_LEN); - - str_part->length(str_part->length() - SPIDER_SQL_COMMA_LEN); - if (!result_list->ha_read_kind) - str_part->q_append(SPIDER_SQL_CLOSE_PAREN_STR, - SPIDER_SQL_CLOSE_PAREN_LEN); - if (str->append(*str_part)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - uint clause_length = str->length() - ha_next_pos; - if (clause_length < SPIDER_SQL_NEXT_LEN) - { - int roop_count; - clause_length = SPIDER_SQL_NEXT_LEN - clause_length; - if (str->reserve(clause_length)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - for (roop_count = 0; roop_count < (int) clause_length; roop_count++) - str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN); - } - } - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_match_where_part( - ulong sql_type -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_match_where_part"); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - str = &sql; - break; - default: - DBUG_ASSERT(0); - DBUG_RETURN(0); - } - error_num = append_match_where(str); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_match_where( - spider_string *str -) { - int error_num; - bool first = TRUE; - st_spider_ft_info *ft_info = spider->ft_first; - DBUG_ENTER("spider_oracle_handler::append_match_where"); - if (spider->ft_current) - { - while (TRUE) - { - if (ft_info->used_in_where) - { - if (first) - { - if (str->reserve(SPIDER_SQL_WHERE_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_WHERE_STR, SPIDER_SQL_WHERE_LEN); - first = FALSE; - } - if ((error_num = append_match_against(str, ft_info, NULL, 0))) - DBUG_RETURN(error_num); - if (str->reserve(SPIDER_SQL_AND_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_AND_STR, SPIDER_SQL_AND_LEN); - } - - if (ft_info == spider->ft_current) - break; - ft_info = ft_info->next; - } - if (!first) - str->length(str->length() - SPIDER_SQL_AND_LEN); - } - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_update_where( - spider_string *str, - const TABLE *table, - my_ptrdiff_t ptr_diff -) { - uint field_name_length; - Field **field; - THD *thd = spider->wide_handler->trx->thd; - SPIDER_SHARE *share = spider->share; - bool no_pk = (table->s->primary_key == MAX_KEY); - DBUG_ENTER("spider_oracle_handler::append_update_where"); - uint str_len_bakup = str->length(); - if (str->reserve(SPIDER_SQL_WHERE_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_WHERE_STR, SPIDER_SQL_WHERE_LEN); - if ( - no_pk || - spider_param_use_cond_other_than_pk_for_update(thd) - ) { - for (field = table->field; *field; field++) - { - if ( - no_pk || - bitmap_is_set(table->read_set, (*field)->field_index) - ) { - field_name_length = - oracle_share->column_name_str[(*field)->field_index].length(); - if ((*field)->is_null(ptr_diff)) - { - if (str->reserve(field_name_length + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + - SPIDER_SQL_IS_NULL_LEN + SPIDER_SQL_AND_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - oracle_share->append_column_name(str, (*field)->field_index); - str->q_append(SPIDER_SQL_IS_NULL_STR, SPIDER_SQL_IS_NULL_LEN); - } else { - if (str->reserve(field_name_length + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + - SPIDER_SQL_EQUAL_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - oracle_share->append_column_name(str, (*field)->field_index); - str->q_append(SPIDER_SQL_EQUAL_STR, SPIDER_SQL_EQUAL_LEN); - (*field)->move_field_offset(ptr_diff); - if ( - spider_db_oracle_utility. - append_column_value(spider, str, *field, NULL, - share->access_charset) || - str->reserve(SPIDER_SQL_AND_LEN) - ) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - (*field)->move_field_offset(-ptr_diff); - } - str->q_append(SPIDER_SQL_AND_STR, SPIDER_SQL_AND_LEN); - } - } - } else { - KEY *key_info = &table->key_info[table->s->primary_key]; - KEY_PART_INFO *key_part; - uint part_num; - for ( - key_part = key_info->key_part, part_num = 0; - part_num < spider_user_defined_key_parts(key_info); - key_part++, part_num++ - ) { - field = &key_part->field; - field_name_length = - oracle_share->column_name_str[(*field)->field_index].length(); - if ((*field)->is_null(ptr_diff)) - { - if (str->reserve(field_name_length + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + - SPIDER_SQL_IS_NULL_LEN + SPIDER_SQL_AND_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - oracle_share->append_column_name(str, (*field)->field_index); - str->q_append(SPIDER_SQL_IS_NULL_STR, SPIDER_SQL_IS_NULL_LEN); - } else { - if (str->reserve(field_name_length + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + - SPIDER_SQL_EQUAL_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - oracle_share->append_column_name(str, (*field)->field_index); - str->q_append(SPIDER_SQL_EQUAL_STR, SPIDER_SQL_EQUAL_LEN); - (*field)->move_field_offset(ptr_diff); - if ( - spider_db_oracle_utility. - append_column_value(spider, str, *field, NULL, - share->access_charset) || - str->reserve(SPIDER_SQL_AND_LEN) - ) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - (*field)->move_field_offset(-ptr_diff); - } - str->q_append(SPIDER_SQL_AND_STR, SPIDER_SQL_AND_LEN); - } - } - if (str->length() == str_len_bakup + SPIDER_SQL_WHERE_LEN) - { - /* no condition */ - str->length(str_len_bakup); - } else { - str->length(str->length() - SPIDER_SQL_AND_LEN); - } - if (str->reserve(SPIDER_SQL_LIMIT1_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_LIMIT1_STR, SPIDER_SQL_LIMIT1_LEN); - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_condition_part( - const char *alias, - uint alias_length, - ulong sql_type, - bool test_flg -) { - int error_num; - spider_string *str; - bool start_where = FALSE; - DBUG_ENTER("spider_oracle_handler::append_condition_part"); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - DBUG_PRINT("info",("spider case1 sql_type=%lu", sql_type)); - if (test_flg) - { - str = NULL; - } else { - str = &sql; - start_where = ((int) str->length() == where_pos); - } - break; - case SPIDER_SQL_TYPE_TMP_SQL: - DBUG_PRINT("info",("spider case1 sql_type=%lu", sql_type)); - if (test_flg) - { - str = NULL; - } else { - str = &tmp_sql; - start_where = ((int) str->length() == where_pos); - } - break; - case SPIDER_SQL_TYPE_INSERT_SQL: - case SPIDER_SQL_TYPE_UPDATE_SQL: - case SPIDER_SQL_TYPE_DELETE_SQL: - case SPIDER_SQL_TYPE_BULK_UPDATE_SQL: - DBUG_PRINT("info",("spider case2 sql_type=%lu", sql_type)); - if (test_flg) - { - str = NULL; - } else { - str = &update_sql; - start_where = ((int) str->length() == where_pos); - } - break; - case SPIDER_SQL_TYPE_HANDLER: - DBUG_PRINT("info",("spider case3 sql_type=%lu", sql_type)); - if (test_flg) - { - str = NULL; - } else { - str = &ha_sql; - start_where = TRUE; - if (spider->active_index == MAX_KEY) - { - set_where_pos(SPIDER_SQL_TYPE_HANDLER); - if (str->reserve(SPIDER_SQL_READ_LEN + SPIDER_SQL_FIRST_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_READ_STR, SPIDER_SQL_READ_LEN); - ha_next_pos = str->length(); - str->q_append(SPIDER_SQL_FIRST_STR, SPIDER_SQL_FIRST_LEN); - sql_part2.length(0); - } - ha_where_pos = str->length(); - - if (sql_part2.length()) - { - str->append(sql_part2); - start_where = FALSE; - } - } - break; - default: - DBUG_PRINT("info",("spider default sql_type=%lu", sql_type)); - DBUG_RETURN(0); - } - error_num = append_condition(str, alias, alias_length, start_where, - sql_type); - DBUG_PRINT("info",("spider str=%s", str ? str->c_ptr_safe() : "NULL")); - DBUG_PRINT("info",("spider length=%u", str ? str->length() : 0)); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_condition( - spider_string *str, - const char *alias, - uint alias_length, - bool start_where, - ulong sql_type -) { - int error_num, restart_pos = 0, start_where_pos; - SPIDER_CONDITION *tmp_cond = spider->condition; - DBUG_ENTER("spider_oracle_handler::append_condition"); - DBUG_PRINT("info",("spider str=%p", str)); - DBUG_PRINT("info",("spider alias=%p", alias)); - DBUG_PRINT("info",("spider alias_length=%u", alias_length)); - DBUG_PRINT("info",("spider start_where=%s", start_where ? "TRUE" : "FALSE")); - DBUG_PRINT("info",("spider sql_type=%lu", sql_type)); - if (str && start_where) - { - start_where_pos = str->length(); - } else { - start_where_pos = 0; - } - - if (spider->is_clone && !tmp_cond) - { - tmp_cond = spider->pt_clone_source_handler->condition; - } - - while (tmp_cond) - { - if (str) - { - restart_pos = str->length(); - if (start_where) - { - if (str->reserve(SPIDER_SQL_WHERE_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_WHERE_STR, SPIDER_SQL_WHERE_LEN); - start_where = FALSE; - } else { - if (str->reserve(SPIDER_SQL_AND_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_AND_STR, SPIDER_SQL_AND_LEN); - } - } - if ((error_num = spider_db_print_item_type( - (Item *) tmp_cond->cond, NULL, spider, str, alias, alias_length, - spider_dbton_oracle.dbton_id, FALSE, NULL))) - { - if (str && error_num == ER_SPIDER_COND_SKIP_NUM) - { - DBUG_PRINT("info",("spider COND skip")); - str->length(restart_pos); - start_where = (restart_pos == start_where_pos); - } else - DBUG_RETURN(error_num); - } - tmp_cond = tmp_cond->next; - } - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_match_against_part( - ulong sql_type, - st_spider_ft_info *ft_info, - const char *alias, - uint alias_length -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_match_against_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - str = &sql; - break; - default: - DBUG_RETURN(0); - } - error_num = append_match_against(str, ft_info, alias, alias_length); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_match_against( - spider_string *str, - st_spider_ft_info *ft_info, - const char *alias, - uint alias_length -) { - SPIDER_SHARE *share = spider->share; - TABLE *table = spider->get_table(); - String *ft_init_key; - KEY *key_info; - uint key_name_length; - int key_count; - KEY_PART_INFO *key_part; - Field *field; - DBUG_ENTER("spider_oracle_handler::append_match_against"); - DBUG_PRINT("info",("spider this=%p", this)); - if (str->reserve(SPIDER_SQL_MATCH_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_MATCH_STR, SPIDER_SQL_MATCH_LEN); - - ft_init_key = ft_info->key; - key_info = &table->key_info[ft_info->inx]; - DBUG_PRINT("info", ("spider spider_user_defined_key_parts=%u", - spider_user_defined_key_parts(key_info))); - - for ( - key_part = key_info->key_part, - key_count = 0; - key_count < (int) spider_user_defined_key_parts(key_info); - key_part++, - key_count++ - ) { - field = key_part->field; - key_name_length = - oracle_share->column_name_str[field->field_index].length(); - if (alias_length) - { - if (str->reserve(alias_length + key_name_length + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(alias, alias_length); - } else { - if (str->reserve(key_name_length + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - oracle_share->append_column_name(str, field->field_index); - str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } - str->length(str->length() - SPIDER_SQL_COMMA_LEN); - if (str->reserve(SPIDER_SQL_AGAINST_LEN + SPIDER_SQL_VALUE_QUOTE_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_AGAINST_STR, SPIDER_SQL_AGAINST_LEN); - str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN); - - char buf[MAX_FIELD_WIDTH]; - spider_string tmp_str(buf, MAX_FIELD_WIDTH, share->access_charset); - tmp_str.init_calc_mem(211); - tmp_str.length(0); - if ( - tmp_str.append(ft_init_key->ptr(), ft_init_key->length(), - ft_init_key->charset()) || - str->reserve(tmp_str.length() * 2) || - spider_db_oracle_utility.append_escaped_util(str, tmp_str.get_str()) - ) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - - if (str->reserve( - SPIDER_SQL_VALUE_QUOTE_LEN + SPIDER_SQL_CLOSE_PAREN_LEN + - ((ft_info->match_flags & FT_BOOL) ? SPIDER_SQL_IN_BOOLEAN_MODE_LEN : 0) + - ((ft_info->match_flags & FT_EXPAND) ? - SPIDER_SQL_WITH_QUERY_EXPANSION_LEN : 0) - )) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN); - if (ft_info->match_flags & FT_BOOL) - str->q_append(SPIDER_SQL_IN_BOOLEAN_MODE_STR, - SPIDER_SQL_IN_BOOLEAN_MODE_LEN); - if (ft_info->match_flags & FT_EXPAND) - str->q_append(SPIDER_SQL_WITH_QUERY_EXPANSION_STR, - SPIDER_SQL_WITH_QUERY_EXPANSION_LEN); - str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN); - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_match_select_part( - ulong sql_type, - const char *alias, - uint alias_length -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_match_select_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - str = &sql; - break; - default: - DBUG_RETURN(0); - } - error_num = append_match_select(str, alias, alias_length); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_match_select( - spider_string *str, - const char *alias, - uint alias_length -) { - int error_num; - DBUG_ENTER("spider_oracle_handler::append_match_select"); - DBUG_PRINT("info",("spider this=%p", this)); - if (spider->ft_current) - { - st_spider_ft_info *ft_info = spider->ft_first; - while (TRUE) - { - if ((error_num = append_match_against(str, ft_info, - alias, alias_length))) - DBUG_RETURN(error_num); - if (str->reserve(SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - if (ft_info == spider->ft_current) - break; - ft_info = ft_info->next; - } - } - DBUG_RETURN(0); -} - -#ifdef HANDLER_HAS_DIRECT_AGGREGATE -int spider_oracle_handler::append_sum_select_part( - ulong sql_type, - const char *alias, - uint alias_length -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_sum_select_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - str = &sql; - break; - default: - DBUG_RETURN(0); - } - error_num = append_sum_select(str, alias, alias_length); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_sum_select( - spider_string *str, - const char *alias, - uint alias_length -) { - int error_num; - st_select_lex *select_lex; - DBUG_ENTER("spider_oracle_handler::append_sum_select"); - DBUG_PRINT("info",("spider this=%p", this)); - select_lex = spider_get_select_lex(spider); - JOIN *join = select_lex->join; - Item_sum **item_sum_ptr; - for (item_sum_ptr = join->sum_funcs; *item_sum_ptr; ++item_sum_ptr) - { - if ((error_num = spider_db_oracle_utility.open_item_sum_func(*item_sum_ptr, - spider, str, alias, alias_length, FALSE, NULL))) - { - DBUG_RETURN(error_num); - } - if (str->reserve(SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } - DBUG_RETURN(0); -} -#endif - -void spider_oracle_handler::set_order_pos( - ulong sql_type -) { - DBUG_ENTER("spider_oracle_handler::set_order_pos"); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - case SPIDER_SQL_TYPE_TMP_SQL: - order_pos = sql.length(); - break; - case SPIDER_SQL_TYPE_INSERT_SQL: - case SPIDER_SQL_TYPE_UPDATE_SQL: - case SPIDER_SQL_TYPE_DELETE_SQL: - case SPIDER_SQL_TYPE_BULK_UPDATE_SQL: - order_pos = update_sql.length(); - break; - case SPIDER_SQL_TYPE_HANDLER: - ha_next_pos = ha_sql.length(); - break; - default: - DBUG_ASSERT(0); - break; - } - DBUG_VOID_RETURN; -} - -void spider_oracle_handler::set_order_to_pos( - ulong sql_type -) { - DBUG_ENTER("spider_oracle_handler::set_order_to_pos"); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - case SPIDER_SQL_TYPE_TMP_SQL: - sql.length(order_pos); - break; - case SPIDER_SQL_TYPE_INSERT_SQL: - case SPIDER_SQL_TYPE_UPDATE_SQL: - case SPIDER_SQL_TYPE_DELETE_SQL: - case SPIDER_SQL_TYPE_BULK_UPDATE_SQL: - update_sql.length(order_pos); - break; - case SPIDER_SQL_TYPE_HANDLER: - ha_sql.length(ha_next_pos); - break; - default: - DBUG_ASSERT(0); - break; - } - DBUG_VOID_RETURN; -} - -#ifdef HANDLER_HAS_DIRECT_AGGREGATE -int spider_oracle_handler::append_group_by_part( - const char *alias, - uint alias_length, - ulong sql_type -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_group_by_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - case SPIDER_SQL_TYPE_TMP_SQL: - str = &sql; - break; - case SPIDER_SQL_TYPE_INSERT_SQL: - case SPIDER_SQL_TYPE_UPDATE_SQL: - case SPIDER_SQL_TYPE_DELETE_SQL: - case SPIDER_SQL_TYPE_BULK_UPDATE_SQL: - str = &update_sql; - break; - case SPIDER_SQL_TYPE_HANDLER: - str = &ha_sql; - break; - default: - DBUG_RETURN(0); - } - error_num = append_group_by(str, alias, alias_length); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_group_by( - spider_string *str, - const char *alias, - uint alias_length -) { - int error_num; - st_select_lex *select_lex; - DBUG_ENTER("spider_oracle_handler::append_group_by"); - DBUG_PRINT("info",("spider this=%p", this)); - select_lex = spider_get_select_lex(spider); - ORDER *group = (ORDER *) select_lex->group_list.first; - if (group) - { - if (str->reserve(SPIDER_SQL_GROUP_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_GROUP_STR, SPIDER_SQL_GROUP_LEN); - for (; group; group = group->next) - { - if ((error_num = spider_db_print_item_type((*group->item), NULL, spider, - str, alias, alias_length, spider_dbton_oracle.dbton_id, FALSE, NULL))) - { - DBUG_RETURN(error_num); - } - if (str->reserve(SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } - str->length(str->length() - SPIDER_SQL_COMMA_LEN); - } - DBUG_RETURN(0); -} -#endif - -int spider_oracle_handler::append_key_order_for_merge_with_alias_part( - const char *alias, - uint alias_length, - ulong sql_type -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_key_order_for_merge_with_alias_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - case SPIDER_SQL_TYPE_TMP_SQL: - str = &sql; - break; - case SPIDER_SQL_TYPE_INSERT_SQL: - case SPIDER_SQL_TYPE_UPDATE_SQL: - case SPIDER_SQL_TYPE_DELETE_SQL: - case SPIDER_SQL_TYPE_BULK_UPDATE_SQL: - str = &update_sql; - break; - case SPIDER_SQL_TYPE_HANDLER: - str = &ha_sql; - ha_limit_pos = ha_sql.length(); - break; - default: - DBUG_RETURN(0); - } - error_num = append_key_order_for_merge_with_alias(str, alias, alias_length); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_key_order_for_merge_with_alias( - spider_string *str, - const char *alias, - uint alias_length -) { - /* sort for index merge */ - TABLE *table = spider->get_table(); - int length; - Field *field; - uint key_name_length; - DBUG_ENTER("spider_oracle_handler::append_key_order_for_merge_with_alias"); - DBUG_PRINT("info",("spider this=%p", this)); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE - if (spider->result_list.direct_aggregate) - { - int error_num; - if ((error_num = append_group_by(str, alias, alias_length))) - DBUG_RETURN(error_num); - } -#endif - if ( - spider->result_list.direct_order_limit || - spider->result_list.internal_limit < 9223372036854775807LL || - spider->result_list.split_read < 9223372036854775807LL || - spider->result_list.internal_offset - ) { - if (update_rownum_appended || select_rownum_appended) - { - if (str->reserve(SPIDER_SQL_SELECT_WRAPPER_TAIL_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_SELECT_WRAPPER_TAIL_STR, - SPIDER_SQL_SELECT_WRAPPER_TAIL_LEN); - order_pos = str->length(); - limit_pos = str->length(); - DBUG_RETURN(0); - } - sql_part.length(0); - if (str == &update_sql) - { - if (sql_part.reserve(str->length() + SPIDER_SQL_UPDATE_WRAPPER_HEAD_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql_part.q_append(str->ptr(), where_pos); - sql_part.q_append(SPIDER_SQL_UPDATE_WRAPPER_HEAD_STR, - SPIDER_SQL_UPDATE_WRAPPER_HEAD_LEN); - } else { - if (sql_part.reserve(str->length() + SPIDER_SQL_SELECT_WRAPPER_HEAD_LEN + - SPIDER_SQL_ROW_NUMBER_HEAD_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql_part.q_append(SPIDER_SQL_SELECT_WRAPPER_HEAD_STR, - SPIDER_SQL_SELECT_WRAPPER_HEAD_LEN); - sql_part.q_append(str->ptr(), table_name_pos - SPIDER_SQL_FROM_LEN); - sql_part.q_append(SPIDER_SQL_ROW_NUMBER_HEAD_STR, - SPIDER_SQL_ROW_NUMBER_HEAD_LEN); - } - if (table->s->primary_key < MAX_KEY) - { - /* sort by primary key */ - KEY *key_info = &table->key_info[table->s->primary_key]; - KEY_PART_INFO *key_part; - for ( - key_part = key_info->key_part, - length = 1; - length <= (int) spider_user_defined_key_parts(key_info); - key_part++, - length++ - ) { - field = key_part->field; - key_name_length = - oracle_share->column_name_str[field->field_index].length(); - if (sql_part.reserve(alias_length + key_name_length + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql_part.q_append(alias, alias_length); - oracle_share->append_column_name(&sql_part, field->field_index); - sql_part.q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } - } else { - /* sort by all columns */ - Field **fieldp; - for ( - fieldp = table->field, length = 1; - *fieldp; - fieldp++, length++ - ) { - key_name_length = - oracle_share->column_name_str[(*fieldp)->field_index].length(); - if (sql_part.reserve(alias_length + key_name_length + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql_part.q_append(alias, alias_length); - oracle_share->append_column_name(&sql_part, (*fieldp)->field_index); - sql_part.q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } - } - uint pos_diff; - if (str == &update_sql) - { - uint table_name_size = (update_set_pos ? update_set_pos : where_pos) - - table_name_pos; - if (sql_part.reserve(SPIDER_SQL_ROW_NUMBER_TAIL_LEN + - SPIDER_SQL_SELECT_WRAPPER_TAIL_LEN + str->length() - where_pos + - SPIDER_SQL_FROM_LEN + table_name_size)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql_part.q_append(SPIDER_SQL_ROW_NUMBER_TAIL_STR, - SPIDER_SQL_ROW_NUMBER_TAIL_LEN); - sql_part.q_append(SPIDER_SQL_FROM_STR, SPIDER_SQL_FROM_LEN); - sql_part.q_append(str->ptr() + table_name_pos, table_name_size); - pos_diff = sql_part.length() - where_pos; - sql_part.q_append(str->ptr() + where_pos, str->length() - where_pos); - sql_part.q_append(SPIDER_SQL_SELECT_WRAPPER_TAIL_STR, - SPIDER_SQL_SELECT_WRAPPER_TAIL_LEN); - update_rownum_appended = TRUE; - } else { - if (sql_part.reserve(SPIDER_SQL_ROW_NUMBER_TAIL_LEN + - SPIDER_SQL_SELECT_WRAPPER_TAIL_LEN + str->length() - table_name_pos + - SPIDER_SQL_FROM_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql_part.q_append(SPIDER_SQL_ROW_NUMBER_TAIL_STR, - SPIDER_SQL_ROW_NUMBER_TAIL_LEN); - pos_diff = sql_part.length() + SPIDER_SQL_FROM_LEN - table_name_pos; - sql_part.q_append(str->ptr() + table_name_pos - SPIDER_SQL_FROM_LEN, - str->length() - table_name_pos + SPIDER_SQL_FROM_LEN); - sql_part.q_append(SPIDER_SQL_SELECT_WRAPPER_TAIL_STR, - SPIDER_SQL_SELECT_WRAPPER_TAIL_LEN); - select_rownum_appended = TRUE; - table_name_pos = table_name_pos + pos_diff; - } - if (str->copy(sql_part)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - where_pos = where_pos + pos_diff; - order_pos = str->length(); - limit_pos = str->length(); - DBUG_RETURN(0); - } - if (table->s->primary_key < MAX_KEY) - { - /* sort by primary key */ - KEY *key_info = &table->key_info[table->s->primary_key]; - KEY_PART_INFO *key_part; - for ( - key_part = key_info->key_part, - length = 1; - length <= (int) spider_user_defined_key_parts(key_info); - key_part++, - length++ - ) { - field = key_part->field; - key_name_length = - oracle_share->column_name_str[field->field_index].length(); - if (length == 1) - { - if (str->reserve(SPIDER_SQL_ORDER_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_ORDER_STR, SPIDER_SQL_ORDER_LEN); - } - if (str->reserve(alias_length + key_name_length + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(alias, alias_length); - oracle_share->append_column_name(str, field->field_index); - str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } - if (length > 1) - { - str->length(str->length() - SPIDER_SQL_COMMA_LEN); - } - } else { - /* sort by all columns */ - Field **fieldp; - for ( - fieldp = table->field, length = 1; - *fieldp; - fieldp++, length++ - ) { - key_name_length = - oracle_share->column_name_str[(*fieldp)->field_index].length(); - if (length == 1) - { - if (str->reserve(SPIDER_SQL_ORDER_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_ORDER_STR, SPIDER_SQL_ORDER_LEN); - } - if (str->reserve(alias_length + key_name_length + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(alias, alias_length); - oracle_share->append_column_name(str, (*fieldp)->field_index); - str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } - if (length > 1) - { - str->length(str->length() - SPIDER_SQL_COMMA_LEN); - } - } - limit_pos = str->length(); - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_key_order_for_direct_order_limit_with_alias_part( - const char *alias, - uint alias_length, - ulong sql_type -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_key_order_for_direct_order_limit_with_alias_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - case SPIDER_SQL_TYPE_TMP_SQL: - str = &sql; - break; - case SPIDER_SQL_TYPE_INSERT_SQL: - case SPIDER_SQL_TYPE_UPDATE_SQL: - case SPIDER_SQL_TYPE_DELETE_SQL: - case SPIDER_SQL_TYPE_BULK_UPDATE_SQL: - str = &update_sql; - break; - case SPIDER_SQL_TYPE_HANDLER: - str = &ha_sql; - break; - default: - DBUG_RETURN(0); - } - error_num = append_key_order_for_direct_order_limit_with_alias( - str, alias, alias_length); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_key_order_for_direct_order_limit_with_alias( - spider_string *str, - const char *alias, - uint alias_length -) { - int error_num; - ORDER *order; - st_select_lex *select_lex; - longlong select_limit; - longlong offset_limit; - DBUG_ENTER("spider_oracle_handler::append_key_order_for_direct_order_limit_with_alias"); - DBUG_PRINT("info",("spider this=%p", this)); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE - if (spider->result_list.direct_aggregate) - { - if ((error_num = append_group_by(str, alias, alias_length))) - DBUG_RETURN(error_num); - } -#endif - spider_get_select_limit(spider, &select_lex, &select_limit, - &offset_limit); - if ( - spider->result_list.direct_order_limit || - spider->result_list.internal_limit < 9223372036854775807LL || - spider->result_list.split_read < 9223372036854775807LL || - spider->result_list.internal_offset - ) { - if (update_rownum_appended || select_rownum_appended) - { - if (str->reserve(SPIDER_SQL_SELECT_WRAPPER_TAIL_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_SELECT_WRAPPER_TAIL_STR, - SPIDER_SQL_SELECT_WRAPPER_TAIL_LEN); - order_pos = str->length(); - limit_pos = str->length(); - DBUG_RETURN(0); - } - sql_part.length(0); - if (str == &update_sql) - { - if (sql_part.reserve(str->length() + SPIDER_SQL_UPDATE_WRAPPER_HEAD_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql_part.q_append(str->ptr(), where_pos); - sql_part.q_append(SPIDER_SQL_UPDATE_WRAPPER_HEAD_STR, - SPIDER_SQL_UPDATE_WRAPPER_HEAD_LEN); - } else { - if (sql_part.reserve(str->length() + SPIDER_SQL_SELECT_WRAPPER_HEAD_LEN + - SPIDER_SQL_ROW_NUMBER_HEAD_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql_part.q_append(SPIDER_SQL_SELECT_WRAPPER_HEAD_STR, - SPIDER_SQL_SELECT_WRAPPER_HEAD_LEN); - sql_part.q_append(str->ptr(), table_name_pos - SPIDER_SQL_FROM_LEN); - sql_part.q_append(SPIDER_SQL_ROW_NUMBER_HEAD_STR, - SPIDER_SQL_ROW_NUMBER_HEAD_LEN); - } - bool all_desc = TRUE; - if (select_lex->order_list.first) - { - for (order = (ORDER *) select_lex->order_list.first; order; - order = order->next) - { - if ((error_num = - spider_db_print_item_type((*order->item), NULL, spider, &sql_part, - alias, alias_length, spider_dbton_oracle.dbton_id, FALSE, NULL))) - { - DBUG_PRINT("info",("spider error=%d", error_num)); - DBUG_RETURN(error_num); - } - if (SPIDER_order_direction_is_asc(order)) - { - if (sql_part.reserve(SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql_part.q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - all_desc = FALSE; - } else { - if (sql_part.reserve(SPIDER_SQL_DESC_LEN + SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql_part.q_append(SPIDER_SQL_DESC_STR, SPIDER_SQL_DESC_LEN); - sql_part.q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } - } - } else { - all_desc = FALSE; - } - uint pos_diff; - if (str == &update_sql) - { - uint table_name_size = (update_set_pos ? update_set_pos : where_pos) - - table_name_pos; - if (all_desc) - { - if (sql_part.reserve(SPIDER_SQL_ROW_NUMBER_DESC_TAIL_LEN + - SPIDER_SQL_SELECT_WRAPPER_TAIL_LEN + str->length() - where_pos + - SPIDER_SQL_FROM_LEN + table_name_size)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql_part.q_append(SPIDER_SQL_ROW_NUMBER_DESC_TAIL_STR, - SPIDER_SQL_ROW_NUMBER_DESC_TAIL_LEN); - } else { - if (sql_part.reserve(SPIDER_SQL_ROW_NUMBER_TAIL_LEN + - SPIDER_SQL_SELECT_WRAPPER_TAIL_LEN + str->length() - where_pos + - SPIDER_SQL_FROM_LEN + table_name_size)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql_part.q_append(SPIDER_SQL_ROW_NUMBER_TAIL_STR, - SPIDER_SQL_ROW_NUMBER_TAIL_LEN); - } - sql_part.q_append(SPIDER_SQL_FROM_STR, SPIDER_SQL_FROM_LEN); - sql_part.q_append(str->ptr() + table_name_pos, table_name_size); - pos_diff = sql_part.length() - where_pos; - sql_part.q_append(str->ptr() + where_pos, str->length() - where_pos); - sql_part.q_append(SPIDER_SQL_SELECT_WRAPPER_TAIL_STR, - SPIDER_SQL_SELECT_WRAPPER_TAIL_LEN); - update_rownum_appended = TRUE; - } else { - if (all_desc) - { - if (sql_part.reserve(SPIDER_SQL_ROW_NUMBER_DESC_TAIL_LEN + - SPIDER_SQL_SELECT_WRAPPER_TAIL_LEN + str->length() - table_name_pos + - SPIDER_SQL_FROM_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql_part.q_append(SPIDER_SQL_ROW_NUMBER_DESC_TAIL_STR, - SPIDER_SQL_ROW_NUMBER_DESC_TAIL_LEN); - } else { - if (sql_part.reserve(SPIDER_SQL_ROW_NUMBER_TAIL_LEN + - SPIDER_SQL_SELECT_WRAPPER_TAIL_LEN + str->length() - table_name_pos + - SPIDER_SQL_FROM_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql_part.q_append(SPIDER_SQL_ROW_NUMBER_TAIL_STR, - SPIDER_SQL_ROW_NUMBER_TAIL_LEN); - } - pos_diff = sql_part.length() + SPIDER_SQL_FROM_LEN - table_name_pos; - sql_part.q_append(str->ptr() + table_name_pos - SPIDER_SQL_FROM_LEN, - str->length() - table_name_pos + SPIDER_SQL_FROM_LEN); - sql_part.q_append(SPIDER_SQL_SELECT_WRAPPER_TAIL_STR, - SPIDER_SQL_SELECT_WRAPPER_TAIL_LEN); - select_rownum_appended = TRUE; - table_name_pos = table_name_pos + pos_diff; - } - if (str->copy(sql_part)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - where_pos = where_pos + pos_diff; - order_pos = str->length(); - limit_pos = str->length(); - DBUG_RETURN(0); - } - if (select_lex->order_list.first) - { - if (str->reserve(SPIDER_SQL_ORDER_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_ORDER_STR, SPIDER_SQL_ORDER_LEN); - for (order = (ORDER *) select_lex->order_list.first; order; - order = order->next) - { - if ((error_num = - spider_db_print_item_type((*order->item), NULL, spider, str, alias, - alias_length, spider_dbton_oracle.dbton_id, FALSE, NULL))) - { - DBUG_PRINT("info",("spider error=%d", error_num)); - DBUG_RETURN(error_num); - } - if (SPIDER_order_direction_is_asc(order)) - { - if (str->reserve(SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } else { - if (str->reserve(SPIDER_SQL_DESC_LEN + SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_DESC_STR, SPIDER_SQL_DESC_LEN); - str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } - } - str->length(str->length() - SPIDER_SQL_COMMA_LEN); - } - limit_pos = str->length(); - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_key_order_with_alias_part( - const char *alias, - uint alias_length, - ulong sql_type -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_key_order_with_alias_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - case SPIDER_SQL_TYPE_TMP_SQL: - str = &sql; - break; - case SPIDER_SQL_TYPE_INSERT_SQL: - case SPIDER_SQL_TYPE_UPDATE_SQL: - case SPIDER_SQL_TYPE_DELETE_SQL: - case SPIDER_SQL_TYPE_BULK_UPDATE_SQL: - str = &update_sql; - break; - case SPIDER_SQL_TYPE_HANDLER: - str = &ha_sql; - error_num = append_key_order_for_handler(str, alias, alias_length); - DBUG_RETURN(error_num); - default: - DBUG_RETURN(0); - } - error_num = append_key_order_with_alias(str, alias, alias_length); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_key_order_for_handler( - spider_string *str, - const char *alias, - uint alias_length -) { - DBUG_ENTER("spider_oracle_handler::append_key_order_for_handler"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_PRINT("info",("spider ha_next_pos=%d", ha_next_pos)); - DBUG_PRINT("info",("spider ha_where_pos=%d", ha_where_pos)); - str->q_append(alias, alias_length); - memset((char *) str->ptr() + str->length(), ' ', - ha_where_pos - ha_next_pos - alias_length); - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_key_order_with_alias( - spider_string *str, - const char *alias, - uint alias_length -) { - SPIDER_RESULT_LIST *result_list = &spider->result_list; - KEY *key_info = result_list->key_info; - int length; - KEY_PART_INFO *key_part; - Field *field; - uint key_name_length; - DBUG_ENTER("spider_oracle_handler::append_key_order_with_alias"); - DBUG_PRINT("info",("spider this=%p", this)); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE - if (spider->result_list.direct_aggregate) - { - int error_num; - if ((error_num = append_group_by(str, alias, alias_length))) - DBUG_RETURN(error_num); - } -#endif - if ( - spider->result_list.direct_order_limit || - spider->result_list.internal_limit < 9223372036854775807LL || - spider->result_list.split_read < 9223372036854775807LL || - spider->result_list.internal_offset - ) { - if (update_rownum_appended || select_rownum_appended) - { - if (str->reserve(SPIDER_SQL_SELECT_WRAPPER_TAIL_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_SELECT_WRAPPER_TAIL_STR, - SPIDER_SQL_SELECT_WRAPPER_TAIL_LEN); - order_pos = str->length(); - limit_pos = str->length(); - DBUG_RETURN(0); - } - sql_part.length(0); - if (str == &update_sql) - { - if (sql_part.reserve(str->length() + SPIDER_SQL_UPDATE_WRAPPER_HEAD_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql_part.q_append(str->ptr(), where_pos); - sql_part.q_append(SPIDER_SQL_UPDATE_WRAPPER_HEAD_STR, - SPIDER_SQL_UPDATE_WRAPPER_HEAD_LEN); - } else { - if (sql_part.reserve(str->length() + SPIDER_SQL_SELECT_WRAPPER_HEAD_LEN + - SPIDER_SQL_ROW_NUMBER_HEAD_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql_part.q_append(SPIDER_SQL_SELECT_WRAPPER_HEAD_STR, - SPIDER_SQL_SELECT_WRAPPER_HEAD_LEN); - sql_part.q_append(str->ptr(), table_name_pos - SPIDER_SQL_FROM_LEN); - sql_part.q_append(SPIDER_SQL_ROW_NUMBER_HEAD_STR, - SPIDER_SQL_ROW_NUMBER_HEAD_LEN); - } - if (result_list->sorted == TRUE) - { - if (result_list->desc_flg == TRUE) - { - for ( - key_part = key_info->key_part + result_list->key_order, - length = 1; - length + result_list->key_order <= - (int) spider_user_defined_key_parts(key_info) && - length <= result_list->max_order; - key_part++, - length++ - ) { - field = key_part->field; - key_name_length = - oracle_share->column_name_str[field->field_index].length(); - if (key_part->key_part_flag & HA_REVERSE_SORT) - { - if (sql_part.reserve(alias_length + key_name_length + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql_part.q_append(alias, alias_length); - oracle_share->append_column_name(&sql_part, field->field_index); - sql_part.q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } else { - if (sql_part.reserve(alias_length + key_name_length + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + - SPIDER_SQL_DESC_LEN + SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql_part.q_append(alias, alias_length); - oracle_share->append_column_name(&sql_part, field->field_index); - sql_part.q_append(SPIDER_SQL_DESC_STR, SPIDER_SQL_DESC_LEN); - sql_part.q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } - } - } else { - for ( - key_part = key_info->key_part + result_list->key_order, - length = 1; - length + result_list->key_order <= - (int) spider_user_defined_key_parts(key_info) && - length <= result_list->max_order; - key_part++, - length++ - ) { - field = key_part->field; - key_name_length = - oracle_share->column_name_str[field->field_index].length(); - if (key_part->key_part_flag & HA_REVERSE_SORT) - { - if (sql_part.reserve(alias_length + key_name_length + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + - SPIDER_SQL_DESC_LEN + SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql_part.q_append(alias, alias_length); - oracle_share->append_column_name(&sql_part, field->field_index); - sql_part.q_append(SPIDER_SQL_DESC_STR, SPIDER_SQL_DESC_LEN); - sql_part.q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } else { - if (sql_part.reserve(alias_length + key_name_length + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql_part.q_append(alias, alias_length); - oracle_share->append_column_name(&sql_part, field->field_index); - sql_part.q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } - } - } - } - uint pos_diff; - if (str == &update_sql) - { - uint table_name_size = (update_set_pos ? update_set_pos : where_pos) - - table_name_pos; - if (result_list->sorted == TRUE && result_list->desc_flg == TRUE) - { - if (sql_part.reserve(SPIDER_SQL_ROW_NUMBER_DESC_TAIL_LEN + - SPIDER_SQL_SELECT_WRAPPER_TAIL_LEN + str->length() - where_pos + - SPIDER_SQL_FROM_LEN + table_name_size)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql_part.q_append(SPIDER_SQL_ROW_NUMBER_DESC_TAIL_STR, - SPIDER_SQL_ROW_NUMBER_DESC_TAIL_LEN); - } else { - if (sql_part.reserve(SPIDER_SQL_ROW_NUMBER_TAIL_LEN + - SPIDER_SQL_SELECT_WRAPPER_TAIL_LEN + str->length() - where_pos + - SPIDER_SQL_FROM_LEN + table_name_size)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql_part.q_append(SPIDER_SQL_ROW_NUMBER_TAIL_STR, - SPIDER_SQL_ROW_NUMBER_TAIL_LEN); - } - sql_part.q_append(SPIDER_SQL_FROM_STR, SPIDER_SQL_FROM_LEN); - sql_part.q_append(str->ptr() + table_name_pos, - table_name_size); - pos_diff = sql_part.length() - where_pos; - sql_part.q_append(str->ptr() + where_pos, str->length() - where_pos); - sql_part.q_append(SPIDER_SQL_SELECT_WRAPPER_TAIL_STR, - SPIDER_SQL_SELECT_WRAPPER_TAIL_LEN); - update_rownum_appended = TRUE; - } else { - if (result_list->sorted == TRUE && result_list->desc_flg == TRUE) - { - if (sql_part.reserve(SPIDER_SQL_ROW_NUMBER_DESC_TAIL_LEN + - SPIDER_SQL_SELECT_WRAPPER_TAIL_LEN + str->length() - table_name_pos + - SPIDER_SQL_FROM_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql_part.q_append(SPIDER_SQL_ROW_NUMBER_DESC_TAIL_STR, - SPIDER_SQL_ROW_NUMBER_DESC_TAIL_LEN); - } else { - if (sql_part.reserve(SPIDER_SQL_ROW_NUMBER_TAIL_LEN + - SPIDER_SQL_SELECT_WRAPPER_TAIL_LEN + str->length() - table_name_pos + - SPIDER_SQL_FROM_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql_part.q_append(SPIDER_SQL_ROW_NUMBER_TAIL_STR, - SPIDER_SQL_ROW_NUMBER_TAIL_LEN); - } - pos_diff = sql_part.length() + SPIDER_SQL_FROM_LEN - table_name_pos; - sql_part.q_append(str->ptr() + table_name_pos - SPIDER_SQL_FROM_LEN, - str->length() - table_name_pos + SPIDER_SQL_FROM_LEN); - sql_part.q_append(SPIDER_SQL_SELECT_WRAPPER_TAIL_STR, - SPIDER_SQL_SELECT_WRAPPER_TAIL_LEN); - select_rownum_appended = TRUE; - table_name_pos = table_name_pos + pos_diff; - } - if (str->copy(sql_part)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - where_pos = where_pos + pos_diff; - order_pos = str->length(); - limit_pos = str->length(); - DBUG_RETURN(0); - } - if (result_list->sorted == TRUE) - { - if (result_list->desc_flg == TRUE) - { - for ( - key_part = key_info->key_part + result_list->key_order, - length = 1; - length + result_list->key_order < - (int) spider_user_defined_key_parts(key_info) && - length < result_list->max_order; - key_part++, - length++ - ) { - field = key_part->field; - key_name_length = - oracle_share->column_name_str[field->field_index].length(); - if (length == 1) - { - if (str->reserve(SPIDER_SQL_ORDER_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_ORDER_STR, SPIDER_SQL_ORDER_LEN); - } - if (key_part->key_part_flag & HA_REVERSE_SORT) - { - if (str->reserve(alias_length + key_name_length + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(alias, alias_length); - oracle_share->append_column_name(str, field->field_index); - str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } else { - if (str->reserve(alias_length + key_name_length + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + - SPIDER_SQL_DESC_LEN + SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(alias, alias_length); - oracle_share->append_column_name(str, field->field_index); - str->q_append(SPIDER_SQL_DESC_STR, SPIDER_SQL_DESC_LEN); - str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } - } - if ( - length + result_list->key_order <= - (int) spider_user_defined_key_parts(key_info) && - length <= result_list->max_order - ) { - field = key_part->field; - key_name_length = - oracle_share->column_name_str[field->field_index].length(); - if (length == 1) - { - if (str->reserve(SPIDER_SQL_ORDER_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_ORDER_STR, SPIDER_SQL_ORDER_LEN); - } - if (key_part->key_part_flag & HA_REVERSE_SORT) - { - if (str->reserve(alias_length + key_name_length + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 2)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(alias, alias_length); - oracle_share->append_column_name(str, field->field_index); - } else { - if (str->reserve(alias_length + key_name_length + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_DESC_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(alias, alias_length); - oracle_share->append_column_name(str, field->field_index); - str->q_append(SPIDER_SQL_DESC_STR, SPIDER_SQL_DESC_LEN); - } - } - } else { - for ( - key_part = key_info->key_part + result_list->key_order, - length = 1; - length + result_list->key_order < - (int) spider_user_defined_key_parts(key_info) && - length < result_list->max_order; - key_part++, - length++ - ) { - field = key_part->field; - key_name_length = - oracle_share->column_name_str[field->field_index].length(); - if (length == 1) - { - if (str->reserve(SPIDER_SQL_ORDER_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_ORDER_STR, SPIDER_SQL_ORDER_LEN); - } - if (key_part->key_part_flag & HA_REVERSE_SORT) - { - if (str->reserve(alias_length + key_name_length + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + - SPIDER_SQL_DESC_LEN + SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(alias, alias_length); - oracle_share->append_column_name(str, field->field_index); - str->q_append(SPIDER_SQL_DESC_STR, SPIDER_SQL_DESC_LEN); - str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } else { - if (str->reserve(alias_length + key_name_length + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(alias, alias_length); - oracle_share->append_column_name(str, field->field_index); - str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } - } - if ( - length + result_list->key_order <= - (int) spider_user_defined_key_parts(key_info) && - length <= result_list->max_order - ) { - field = key_part->field; - key_name_length = - oracle_share->column_name_str[field->field_index].length(); - if (length == 1) - { - if (str->reserve(SPIDER_SQL_ORDER_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_ORDER_STR, SPIDER_SQL_ORDER_LEN); - } - if (key_part->key_part_flag & HA_REVERSE_SORT) - { - if (str->reserve(alias_length + key_name_length + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_DESC_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(alias, alias_length); - oracle_share->append_column_name(str, field->field_index); - str->q_append(SPIDER_SQL_DESC_STR, SPIDER_SQL_DESC_LEN); - } else { - if (str->reserve(alias_length + key_name_length + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 2)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(alias, alias_length); - oracle_share->append_column_name(str, field->field_index); - } - } - } - } - limit_pos = str->length(); - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_limit_part( - longlong offset, - longlong limit, - ulong sql_type -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_limit_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - str = &sql; - limit_pos = str->length(); - break; - case SPIDER_SQL_TYPE_TMP_SQL: - str = &tmp_sql; - limit_pos = str->length(); - break; - case SPIDER_SQL_TYPE_INSERT_SQL: - case SPIDER_SQL_TYPE_UPDATE_SQL: - case SPIDER_SQL_TYPE_DELETE_SQL: - case SPIDER_SQL_TYPE_BULK_UPDATE_SQL: - str = &update_sql; - limit_pos = str->length(); - break; - case SPIDER_SQL_TYPE_HANDLER: - str = &ha_sql; - ha_limit_pos = str->length(); - break; - default: - DBUG_RETURN(0); - } - error_num = append_limit(str, offset, limit); - DBUG_PRINT("info",("spider str=%s", str->c_ptr_safe())); - DBUG_PRINT("info",("spider length=%u", str->length())); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::reappend_limit_part( - longlong offset, - longlong limit, - ulong sql_type -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::reappend_limit_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - str = &sql; - str->length(limit_pos); - break; - case SPIDER_SQL_TYPE_TMP_SQL: - str = &tmp_sql; - str->length(limit_pos); - break; - case SPIDER_SQL_TYPE_INSERT_SQL: - case SPIDER_SQL_TYPE_UPDATE_SQL: - case SPIDER_SQL_TYPE_DELETE_SQL: - case SPIDER_SQL_TYPE_BULK_UPDATE_SQL: - str = &update_sql; - str->length(limit_pos); - break; - case SPIDER_SQL_TYPE_HANDLER: - str = &ha_sql; - str->length(ha_limit_pos); - break; - default: - DBUG_RETURN(0); - } - error_num = append_limit(str, offset, limit); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_limit( - spider_string *str, - longlong offset, - longlong limit -) { - char buf[SPIDER_LONGLONG_LEN + 1]; - uint32 length; - DBUG_ENTER("spider_oracle_handler::append_limit"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_PRINT("info", ("spider offset=%lld", offset)); - DBUG_PRINT("info", ("spider limit=%lld", limit)); - if (offset || limit < 9223372036854775807LL) - { - if ((int) str->length() == where_pos) - { - if (offset) - { - int error_num; - if ((error_num = append_key_order_for_direct_order_limit_with_alias( - str, NULL, 0))) - DBUG_RETURN(error_num); - } else { - if (str->reserve(SPIDER_SQL_WHERE_LEN + SPIDER_SQL_ROWNUM_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_WHERE_STR, SPIDER_SQL_WHERE_LEN); - str->q_append(SPIDER_SQL_ROWNUM_STR, SPIDER_SQL_ROWNUM_LEN); - } - } - if (offset) - { - if (str->reserve(SPIDER_SQL_BETWEEN_LEN + SPIDER_SQL_AND_LEN + - ((SPIDER_LONGLONG_LEN) * 2))) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_BETWEEN_STR, SPIDER_SQL_BETWEEN_LEN); - length = (uint32) (my_charset_bin.longlong10_to_str)( - buf, SPIDER_LONGLONG_LEN + 1, -10, offset + 1); - str->q_append(buf, length); - str->q_append(SPIDER_SQL_AND_STR, SPIDER_SQL_AND_LEN); - length = (uint32) (my_charset_bin.longlong10_to_str)( - buf, SPIDER_LONGLONG_LEN + 1, -10, limit + offset); - str->q_append(buf, length); - } else { - if (str->reserve(SPIDER_SQL_HS_LTEQUAL_LEN + - (SPIDER_LONGLONG_LEN))) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_HS_LTEQUAL_STR, SPIDER_SQL_HS_LTEQUAL_LEN); - length = (uint32) (my_charset_bin.longlong10_to_str)( - buf, SPIDER_LONGLONG_LEN + 1, -10, limit); - str->q_append(buf, length); - } - if (update_rownum_appended) - { - if (str->reserve(SPIDER_SQL_CLOSE_PAREN_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN); - } - } - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_select_lock_part( - ulong sql_type -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_select_lock_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - str = &sql; - break; - default: - DBUG_RETURN(0); - } - error_num = append_select_lock(str); - DBUG_PRINT("info",("spider str=%s", str->c_ptr_safe())); - DBUG_PRINT("info",("spider length=%u", str->length())); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_select_lock( - spider_string *str -) { - int lock_mode = spider_conn_lock_mode(spider); - DBUG_ENTER("spider_oracle_handler::append_select_lock"); - DBUG_PRINT("info",("spider this=%p", this)); - if (select_rownum_appended) - { - table_lock_mode = lock_mode; - } else { - if (lock_mode == SPIDER_LOCK_MODE_EXCLUSIVE) - { - if (str->reserve(SPIDER_SQL_FOR_UPDATE_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_FOR_UPDATE_STR, SPIDER_SQL_FOR_UPDATE_LEN); - } else if (lock_mode == SPIDER_LOCK_MODE_SHARED) - { - if (str->reserve(SPIDER_SQL_FOR_UPDATE_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_FOR_UPDATE_STR, SPIDER_SQL_FOR_UPDATE_LEN); - } - } - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_union_all_start_part( - ulong sql_type -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_union_all_start_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - str = &sql; - break; - default: - DBUG_RETURN(0); - } - error_num = append_union_all_start(str); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_union_all_start( - spider_string *str -) { - DBUG_ENTER("spider_oracle_handler::append_union_all_start"); - DBUG_PRINT("info",("spider this=%p", this)); - if (str->reserve(SPIDER_SQL_OPEN_PAREN_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN); - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_union_all_part( - ulong sql_type -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_union_all_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - str = &sql; - break; - default: - DBUG_RETURN(0); - } - error_num = append_union_all(str); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_union_all( - spider_string *str -) { - DBUG_ENTER("spider_oracle_handler::append_union_all"); - DBUG_PRINT("info",("spider this=%p", this)); - if (str->reserve(SPIDER_SQL_UNION_ALL_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_UNION_ALL_STR, SPIDER_SQL_UNION_ALL_LEN); - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_union_all_end_part( - ulong sql_type -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_union_all_end_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - str = &sql; - break; - default: - DBUG_RETURN(0); - } - error_num = append_union_all_end(str); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_union_all_end( - spider_string *str -) { - DBUG_ENTER("spider_oracle_handler::append_union_all_end"); - DBUG_PRINT("info",("spider this=%p", this)); - str->length(str->length() - - SPIDER_SQL_UNION_ALL_LEN + SPIDER_SQL_CLOSE_PAREN_LEN); - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_multi_range_cnt_part( - ulong sql_type, - uint multi_range_cnt, - bool with_comma -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_multi_range_cnt_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - str = &sql; - break; - case SPIDER_SQL_TYPE_TMP_SQL: - str = &tmp_sql; - break; - default: - DBUG_RETURN(0); - } - error_num = append_multi_range_cnt(str, multi_range_cnt, with_comma); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_multi_range_cnt( - spider_string *str, - uint multi_range_cnt, - bool with_comma -) { - int range_cnt_length; - char range_cnt_str[SPIDER_SQL_INT_LEN]; - DBUG_ENTER("spider_oracle_handler::append_multi_range_cnt"); - DBUG_PRINT("info",("spider this=%p", this)); - range_cnt_length = my_sprintf(range_cnt_str, (range_cnt_str, "%u", - multi_range_cnt)); - if (with_comma) - { - if (str->reserve(range_cnt_length + SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(range_cnt_str, range_cnt_length); - str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } else { - if (str->reserve(range_cnt_length)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(range_cnt_str, range_cnt_length); - } - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_multi_range_cnt_with_name_part( - ulong sql_type, - uint multi_range_cnt -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_multi_range_cnt_with_name_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - str = &sql; - break; - case SPIDER_SQL_TYPE_TMP_SQL: - str = &tmp_sql; - break; - default: - DBUG_RETURN(0); - } - error_num = append_multi_range_cnt_with_name(str, multi_range_cnt); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_multi_range_cnt_with_name( - spider_string *str, - uint multi_range_cnt -) { - int range_cnt_length; - char range_cnt_str[SPIDER_SQL_INT_LEN]; - DBUG_ENTER("spider_oracle_handler::append_multi_range_cnt_with_name"); - DBUG_PRINT("info",("spider this=%p", this)); - range_cnt_length = my_sprintf(range_cnt_str, (range_cnt_str, "%u", - multi_range_cnt)); - if (str->reserve(range_cnt_length + SPIDER_SQL_SPACE_LEN + - SPIDER_SQL_ID_LEN + SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(range_cnt_str, range_cnt_length); - str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN); - str->q_append(SPIDER_SQL_ID_STR, SPIDER_SQL_ID_LEN); - str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_open_handler_part( - ulong sql_type, - uint handler_id, - SPIDER_CONN *conn, - int link_idx -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_open_handler_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_HANDLER: - str = &ha_sql; - break; - default: - DBUG_RETURN(0); - } - error_num = append_open_handler(str, handler_id, conn, link_idx); - exec_ha_sql = str; - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_open_handler( - spider_string *str, - uint handler_id, - SPIDER_CONN *conn, - int link_idx -) { - int error_num; - DBUG_ENTER("spider_oracle_handler::append_open_handler"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_PRINT("info",("spider link_idx=%d", link_idx)); - DBUG_PRINT("info",("spider m_handler_cid=%s", - spider->m_handler_cid[link_idx])); - if (str->reserve(SPIDER_SQL_HANDLER_LEN)) - { - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - str->q_append(SPIDER_SQL_HANDLER_STR, SPIDER_SQL_HANDLER_LEN); - if ((error_num = oracle_share->append_table_name(str, - spider->conn_link_idx[link_idx]))) - DBUG_RETURN(error_num); - if (str->reserve(SPIDER_SQL_OPEN_LEN + SPIDER_SQL_AS_LEN + - SPIDER_SQL_HANDLER_CID_LEN)) - { - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - str->q_append(SPIDER_SQL_OPEN_STR, SPIDER_SQL_OPEN_LEN); - str->q_append(SPIDER_SQL_AS_STR, SPIDER_SQL_AS_LEN); - str->q_append(spider->m_handler_cid[link_idx], SPIDER_SQL_HANDLER_CID_LEN); - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_close_handler_part( - ulong sql_type, - int link_idx -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_close_handler_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_HANDLER: - str = &ha_sql; - break; - default: - DBUG_RETURN(0); - } - error_num = append_close_handler(str, link_idx); - exec_ha_sql = str; - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_close_handler( - spider_string *str, - int link_idx -) { - DBUG_ENTER("spider_oracle_handler::append_close_handler"); - DBUG_PRINT("info",("spider this=%p", this)); - if (str->reserve(SPIDER_SQL_HANDLER_LEN + SPIDER_SQL_CLOSE_LEN + - SPIDER_SQL_HANDLER_CID_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_HANDLER_STR, SPIDER_SQL_HANDLER_LEN); - str->q_append(spider->m_handler_cid[link_idx], - SPIDER_SQL_HANDLER_CID_LEN); - str->q_append(SPIDER_SQL_CLOSE_STR, SPIDER_SQL_CLOSE_LEN); - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_insert_terminator_part( - ulong sql_type -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_insert_terminator_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_INSERT_SQL: - str = &insert_sql; - break; - default: - DBUG_RETURN(0); - } - error_num = append_insert_terminator(str); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_insert_terminator( - spider_string *str -) { - DBUG_ENTER("spider_oracle_handler::append_insert_terminator"); - DBUG_PRINT("info",("spider this=%p", this)); - if (spider->result_list.insert_dup_update_pushdown) - { - DBUG_PRINT("info",("spider add duplicate key update")); - str->length(str->length() - SPIDER_SQL_COMMA_LEN); - if (str->reserve(SPIDER_SQL_DUPLICATE_KEY_UPDATE_LEN + - dup_update_sql.length())) - { - str->length(0); - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - str->q_append(SPIDER_SQL_DUPLICATE_KEY_UPDATE_STR, - SPIDER_SQL_DUPLICATE_KEY_UPDATE_LEN); - if (str->append(dup_update_sql)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } else { - str->length(str->length() - SPIDER_SQL_COMMA_LEN); - } - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_insert_values_part( - ulong sql_type -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_insert_values_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_INSERT_SQL: - str = &insert_sql; - break; - default: - DBUG_RETURN(0); - } - error_num = append_insert_values(str); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_insert_values( - spider_string *str -) { - SPIDER_SHARE *share = spider->share; - TABLE *table = spider->get_table(); - Field **field; - bool add_value = FALSE; - DBUG_ENTER("spider_oracle_handler::append_insert_values"); - DBUG_PRINT("info",("spider this=%p", this)); - nextval_pos = 0; - if (str->reserve(SPIDER_SQL_OPEN_PAREN_LEN)) - { - str->length(0); - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN); - for (field = table->field; *field; field++) - { - DBUG_PRINT("info",("spider field_index=%u", (*field)->field_index)); - if ( - bitmap_is_set(table->write_set, (*field)->field_index) || - bitmap_is_set(table->read_set, (*field)->field_index) - ) { -#ifndef DBUG_OFF - my_bitmap_map *tmp_map = - dbug_tmp_use_all_columns(table, table->read_set); -#endif - add_value = TRUE; - DBUG_PRINT("info",("spider is_null()=%s", - (*field)->is_null() ? "TRUE" : "FALSE")); - DBUG_PRINT("info",("spider table->next_number_field=%p", - table->next_number_field)); - DBUG_PRINT("info",("spider *field=%p", *field)); - DBUG_PRINT("info",("spider force_auto_increment=%s", - (table->next_number_field && spider->force_auto_increment) ? - "TRUE" : "FALSE")); - if ( - table->next_number_field == *field && - !table->auto_increment_field_not_null && - !spider->force_auto_increment - ) { - nextval_pos = str->length(); - if (str->reserve(oracle_share->nextval_max_length + - SPIDER_SQL_COMMA_LEN)) - { -#ifndef DBUG_OFF - dbug_tmp_restore_column_map(table->read_set, tmp_map); -#endif - str->length(0); - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - str->length(str->length() + oracle_share->nextval_max_length); - } else if ((*field)->is_null()) - { - if (str->reserve(SPIDER_SQL_NULL_LEN + SPIDER_SQL_COMMA_LEN)) - { -#ifndef DBUG_OFF - dbug_tmp_restore_column_map(table->read_set, tmp_map); -#endif - str->length(0); - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - str->q_append(SPIDER_SQL_NULL_STR, SPIDER_SQL_NULL_LEN); - } else { - if ( - spider_db_oracle_utility. - append_column_value(spider, str, *field, NULL, - share->access_charset) || - str->reserve(SPIDER_SQL_COMMA_LEN) - ) { -#ifndef DBUG_OFF - dbug_tmp_restore_column_map(table->read_set, tmp_map); -#endif - str->length(0); - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - } - str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); -#ifndef DBUG_OFF - dbug_tmp_restore_column_map(table->read_set, tmp_map); -#endif - } - } - if (add_value) - str->length(str->length() - SPIDER_SQL_COMMA_LEN); - if (str->reserve(SPIDER_SQL_CLOSE_PAREN_LEN + SPIDER_SQL_COMMA_LEN)) - { - str->length(0); - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN); - str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_into_part( - ulong sql_type -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_into_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_INSERT_SQL: - str = &insert_sql; - break; - default: - DBUG_RETURN(0); - } - error_num = append_into(str); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_into( - spider_string *str -) { - const TABLE *table = spider->get_table(); - Field **field; - uint field_name_length = 0; - DBUG_ENTER("spider_oracle_handler::append_into"); - DBUG_PRINT("info",("spider this=%p", this)); - if (str->reserve(SPIDER_SQL_INTO_LEN + oracle_share->db_nm_max_length + - SPIDER_SQL_DOT_LEN + oracle_share->table_nm_max_length + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 4 + SPIDER_SQL_OPEN_PAREN_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_INTO_STR, SPIDER_SQL_INTO_LEN); - insert_table_name_pos = str->length(); - append_table_name_with_adjusting(str, first_link_idx, - SPIDER_SQL_TYPE_INSERT_SQL); - str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN); - for (field = table->field; *field; field++) - { - if ( - bitmap_is_set(table->write_set, (*field)->field_index) || - bitmap_is_set(table->read_set, (*field)->field_index) - ) { - field_name_length = - oracle_share->column_name_str[(*field)->field_index].length(); - if (str->reserve(field_name_length + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - oracle_share->append_column_name(str, (*field)->field_index); - str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } - } - if (field_name_length) - str->length(str->length() - SPIDER_SQL_COMMA_LEN); - if (str->reserve(SPIDER_SQL_CLOSE_PAREN_LEN + SPIDER_SQL_VALUES_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN); - str->q_append(SPIDER_SQL_VALUES_STR, SPIDER_SQL_VALUES_LEN); - insert_pos = str->length(); - DBUG_RETURN(0); -} - -void spider_oracle_handler::set_insert_to_pos( - ulong sql_type -) { - DBUG_ENTER("spider_oracle_handler::set_insert_to_pos"); - switch (sql_type) - { - case SPIDER_SQL_TYPE_INSERT_SQL: - insert_sql.length(insert_pos); - break; - default: - DBUG_ASSERT(0); - break; - } - DBUG_VOID_RETURN; -} - -int spider_oracle_handler::append_from_part( - ulong sql_type, - int link_idx -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_from_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_HANDLER: - str = &ha_sql; - break; - case SPIDER_SQL_TYPE_UPDATE_SQL: - case SPIDER_SQL_TYPE_DELETE_SQL: - case SPIDER_SQL_TYPE_BULK_UPDATE_SQL: - str = &update_sql; - break; - default: - str = &sql; - break; - } - error_num = append_from(str, sql_type, link_idx); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_from( - spider_string *str, - ulong sql_type, - int link_idx -) { - DBUG_ENTER("spider_oracle_handler::append_from"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_PRINT("info",("spider link_idx=%d", link_idx)); - if (sql_type == SPIDER_SQL_TYPE_HANDLER) - { - ha_table_name_pos = str->length(); - DBUG_PRINT("info",("spider ha_table_name_pos=%u", ha_table_name_pos)); - ha_sql_handler_id = spider->m_handler_id[link_idx]; - DBUG_PRINT("info",("spider ha_sql_handler_id=%u", ha_sql_handler_id)); - if (str->reserve(SPIDER_SQL_HANDLER_CID_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(spider->m_handler_cid[link_idx], SPIDER_SQL_HANDLER_CID_LEN); - DBUG_PRINT("info",("spider m_handler_cid=%s", - spider->m_handler_cid[link_idx])); - } else { - if (str->reserve(SPIDER_SQL_FROM_LEN + oracle_share->db_nm_max_length + - SPIDER_SQL_DOT_LEN + oracle_share->table_nm_max_length + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 4 + SPIDER_SQL_OPEN_PAREN_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_FROM_STR, SPIDER_SQL_FROM_LEN); - table_name_pos = str->length(); - append_table_name_with_adjusting(str, link_idx, sql_type); - } - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_flush_tables_part( - ulong sql_type, - int link_idx, - bool lock -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_flush_tables_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_OTHER_SQL: - str = &spider->result_list.sqls[link_idx]; - break; - default: - DBUG_RETURN(0); - } - error_num = append_flush_tables(str, link_idx, lock); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_flush_tables( - spider_string *str, - int link_idx, - bool lock -) { - DBUG_ENTER("spider_oracle_handler::append_flush_tables"); - DBUG_PRINT("info",("spider this=%p", this)); - if (lock) - { - if (str->reserve(SPIDER_SQL_FLUSH_TABLES_LEN + - SPIDER_SQL_WITH_READ_LOCK_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_FLUSH_TABLES_STR, SPIDER_SQL_FLUSH_TABLES_LEN); - str->q_append(SPIDER_SQL_WITH_READ_LOCK_STR, - SPIDER_SQL_WITH_READ_LOCK_LEN); - } else { - if (str->reserve(SPIDER_SQL_FLUSH_TABLES_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_FLUSH_TABLES_STR, SPIDER_SQL_FLUSH_TABLES_LEN); - } - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_optimize_table_part( - ulong sql_type, - int link_idx -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_optimize_table_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_OTHER_SQL: - str = &spider->result_list.sqls[link_idx]; - break; - default: - DBUG_RETURN(0); - } - error_num = append_optimize_table(str, link_idx); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_optimize_table( - spider_string *str, - int link_idx -) { - SPIDER_SHARE *share = spider->share; - int conn_link_idx = spider->conn_link_idx[link_idx]; - int local_length = spider_param_internal_optimize_local( - spider->wide_handler->trx->thd, - share->internal_optimize_local) * SPIDER_SQL_SQL_LOCAL_LEN; - DBUG_ENTER("spider_oracle_handler::append_optimize_table"); - DBUG_PRINT("info",("spider this=%p", this)); - if (str->reserve(SPIDER_SQL_SQL_OPTIMIZE_LEN + SPIDER_SQL_SQL_TABLE_LEN + - local_length + - oracle_share->db_names_str[conn_link_idx].length() + - SPIDER_SQL_DOT_LEN + - oracle_share->table_names_str[conn_link_idx].length() + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 4)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_SQL_OPTIMIZE_STR, SPIDER_SQL_SQL_OPTIMIZE_LEN); - if (local_length) - str->q_append(SPIDER_SQL_SQL_LOCAL_STR, SPIDER_SQL_SQL_LOCAL_LEN); - str->q_append(SPIDER_SQL_SQL_TABLE_STR, SPIDER_SQL_SQL_TABLE_LEN); - oracle_share->append_table_name(str, conn_link_idx); - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_analyze_table_part( - ulong sql_type, - int link_idx -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_analyze_table_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_OTHER_SQL: - str = &spider->result_list.sqls[link_idx]; - break; - default: - DBUG_RETURN(0); - } - error_num = append_analyze_table(str, link_idx); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_analyze_table( - spider_string *str, - int link_idx -) { - SPIDER_SHARE *share = spider->share; - int conn_link_idx = spider->conn_link_idx[link_idx]; - int local_length = spider_param_internal_optimize_local( - spider->wide_handler->trx->thd, - share->internal_optimize_local) * SPIDER_SQL_SQL_LOCAL_LEN; - DBUG_ENTER("spider_oracle_handler::append_analyze_table"); - DBUG_PRINT("info",("spider this=%p", this)); - if (str->reserve(SPIDER_SQL_SQL_ANALYZE_LEN + SPIDER_SQL_SQL_TABLE_LEN + - local_length + - oracle_share->db_names_str[conn_link_idx].length() + - SPIDER_SQL_DOT_LEN + - oracle_share->table_names_str[conn_link_idx].length() + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 4)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_SQL_ANALYZE_STR, SPIDER_SQL_SQL_ANALYZE_LEN); - if (local_length) - str->q_append(SPIDER_SQL_SQL_LOCAL_STR, SPIDER_SQL_SQL_LOCAL_LEN); - str->q_append(SPIDER_SQL_SQL_TABLE_STR, SPIDER_SQL_SQL_TABLE_LEN); - oracle_share->append_table_name(str, conn_link_idx); - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_repair_table_part( - ulong sql_type, - int link_idx, - HA_CHECK_OPT* check_opt -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_repair_table_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_OTHER_SQL: - str = &spider->result_list.sqls[link_idx]; - break; - default: - DBUG_RETURN(0); - } - error_num = append_repair_table(str, link_idx, check_opt); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_repair_table( - spider_string *str, - int link_idx, - HA_CHECK_OPT* check_opt -) { - SPIDER_SHARE *share = spider->share; - int conn_link_idx = spider->conn_link_idx[link_idx]; - int local_length = spider_param_internal_optimize_local( - spider->wide_handler->trx->thd, - share->internal_optimize_local) * SPIDER_SQL_SQL_LOCAL_LEN; - DBUG_ENTER("spider_oracle_handler::append_repair_table"); - DBUG_PRINT("info",("spider this=%p", this)); - if (str->reserve(SPIDER_SQL_SQL_REPAIR_LEN + SPIDER_SQL_SQL_TABLE_LEN + - local_length + - oracle_share->db_names_str[conn_link_idx].length() + - SPIDER_SQL_DOT_LEN + - oracle_share->table_names_str[conn_link_idx].length() + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 4)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_SQL_REPAIR_STR, SPIDER_SQL_SQL_REPAIR_LEN); - if (local_length) - str->q_append(SPIDER_SQL_SQL_LOCAL_STR, SPIDER_SQL_SQL_LOCAL_LEN); - str->q_append(SPIDER_SQL_SQL_TABLE_STR, SPIDER_SQL_SQL_TABLE_LEN); - oracle_share->append_table_name(str, conn_link_idx); - if (check_opt->flags & T_QUICK) - { - if (str->reserve(SPIDER_SQL_SQL_QUICK_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_SQL_QUICK_STR, SPIDER_SQL_SQL_QUICK_LEN); - } - if (check_opt->flags & T_EXTEND) - { - if (str->reserve(SPIDER_SQL_SQL_EXTENDED_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_SQL_EXTENDED_STR, SPIDER_SQL_SQL_EXTENDED_LEN); - } - if (check_opt->sql_flags & TT_USEFRM) - { - if (str->reserve(SPIDER_SQL_SQL_USE_FRM_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_SQL_USE_FRM_STR, SPIDER_SQL_SQL_USE_FRM_LEN); - } - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_check_table_part( - ulong sql_type, - int link_idx, - HA_CHECK_OPT* check_opt -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_check_table_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_OTHER_SQL: - str = &spider->result_list.sqls[link_idx]; - break; - default: - DBUG_RETURN(0); - } - error_num = append_check_table(str, link_idx, check_opt); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_check_table( - spider_string *str, - int link_idx, - HA_CHECK_OPT* check_opt -) { - int conn_link_idx = spider->conn_link_idx[link_idx]; - DBUG_ENTER("spider_oracle_handler::append_check_table"); - DBUG_PRINT("info",("spider this=%p", this)); - if (str->reserve(SPIDER_SQL_SQL_CHECK_TABLE_LEN + - oracle_share->db_names_str[conn_link_idx].length() + - SPIDER_SQL_DOT_LEN + - oracle_share->table_names_str[conn_link_idx].length() + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 4)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_SQL_CHECK_TABLE_STR, - SPIDER_SQL_SQL_CHECK_TABLE_LEN); - oracle_share->append_table_name(str, conn_link_idx); - if (check_opt->flags & T_QUICK) - { - if (str->reserve(SPIDER_SQL_SQL_QUICK_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_SQL_QUICK_STR, SPIDER_SQL_SQL_QUICK_LEN); - } - if (check_opt->flags & T_FAST) - { - if (str->reserve(SPIDER_SQL_SQL_FAST_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_SQL_FAST_STR, SPIDER_SQL_SQL_FAST_LEN); - } - if (check_opt->flags & T_MEDIUM) - { - if (str->reserve(SPIDER_SQL_SQL_MEDIUM_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_SQL_MEDIUM_STR, SPIDER_SQL_SQL_MEDIUM_LEN); - } - if (check_opt->flags & T_EXTEND) - { - if (str->reserve(SPIDER_SQL_SQL_EXTENDED_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_SQL_EXTENDED_STR, SPIDER_SQL_SQL_EXTENDED_LEN); - } - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_enable_keys_part( - ulong sql_type, - int link_idx -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_enable_keys_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_OTHER_SQL: - str = &spider->result_list.sqls[link_idx]; - break; - default: - DBUG_RETURN(0); - } - error_num = append_enable_keys(str, link_idx); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_enable_keys( - spider_string *str, - int link_idx -) { - int conn_link_idx = spider->conn_link_idx[link_idx]; - DBUG_ENTER("spider_oracle_handler::append_enable_keys"); - DBUG_PRINT("info",("spider this=%p", this)); - if (str->reserve(SPIDER_SQL_SQL_ALTER_TABLE_LEN + - oracle_share->db_names_str[conn_link_idx].length() + - SPIDER_SQL_DOT_LEN + - oracle_share->table_names_str[conn_link_idx].length() + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 4 + SPIDER_SQL_SQL_ENABLE_KEYS_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_SQL_ALTER_TABLE_STR, - SPIDER_SQL_SQL_ALTER_TABLE_LEN); - oracle_share->append_table_name(str, conn_link_idx); - str->q_append(SPIDER_SQL_SQL_ENABLE_KEYS_STR, - SPIDER_SQL_SQL_ENABLE_KEYS_LEN); - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_disable_keys_part( - ulong sql_type, - int link_idx -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_disable_keys_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_OTHER_SQL: - str = &spider->result_list.sqls[link_idx]; - break; - default: - DBUG_RETURN(0); - } - error_num = append_disable_keys(str, link_idx); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_disable_keys( - spider_string *str, - int link_idx -) { - int conn_link_idx = spider->conn_link_idx[link_idx]; - DBUG_ENTER("spider_oracle_handler::append_disable_keys"); - DBUG_PRINT("info",("spider this=%p", this)); - if (str->reserve(SPIDER_SQL_SQL_ALTER_TABLE_LEN + - oracle_share->db_names_str[conn_link_idx].length() + - SPIDER_SQL_DOT_LEN + - oracle_share->table_names_str[conn_link_idx].length() + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 4 + SPIDER_SQL_SQL_DISABLE_KEYS_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_SQL_ALTER_TABLE_STR, - SPIDER_SQL_SQL_ALTER_TABLE_LEN); - oracle_share->append_table_name(str, conn_link_idx); - str->q_append(SPIDER_SQL_SQL_DISABLE_KEYS_STR, - SPIDER_SQL_SQL_DISABLE_KEYS_LEN); - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_delete_all_rows_part( - ulong sql_type -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_delete_all_rows_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_DELETE_SQL: - str = &update_sql; - break; - default: - DBUG_RETURN(0); - } - error_num = append_delete_all_rows(str, sql_type); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_delete_all_rows( - spider_string *str, - ulong sql_type -) { - int error_num; - DBUG_ENTER("spider_oracle_handler::append_delete_all_rows"); - DBUG_PRINT("info",("spider this=%p", this)); - if (spider->sql_command == SQLCOM_TRUNCATE) - { - if ((error_num = append_truncate(str, sql_type, first_link_idx))) - DBUG_RETURN(error_num); - } else { - if ( - (error_num = append_delete(str)) || - (error_num = append_from(str, sql_type, first_link_idx)) - ) - DBUG_RETURN(error_num); - } - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_truncate( - spider_string *str, - ulong sql_type, - int link_idx -) { - DBUG_ENTER("spider_oracle_handler::append_truncate"); - if (str->reserve(SPIDER_SQL_TRUNCATE_TABLE_LEN + - oracle_share->db_nm_max_length + - SPIDER_SQL_DOT_LEN + oracle_share->table_nm_max_length + - /* SPIDER_SQL_NAME_QUOTE_LEN */ 4 + SPIDER_SQL_OPEN_PAREN_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_TRUNCATE_TABLE_STR, SPIDER_SQL_TRUNCATE_TABLE_LEN); - table_name_pos = str->length(); - append_table_name_with_adjusting(str, link_idx, sql_type); - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_explain_select_part( - const key_range *start_key, - const key_range *end_key, - ulong sql_type, - int link_idx -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_explain_select_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_OTHER_SQL: - str = &spider->result_list.sqls[link_idx]; - break; - default: - DBUG_RETURN(0); - } - error_num = - append_explain_select(str, start_key, end_key, sql_type, link_idx); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_explain_select( - spider_string *str, - const key_range *start_key, - const key_range *end_key, - ulong sql_type, - int link_idx -) { - int error_num; - DBUG_ENTER("spider_oracle_handler::append_explain_select"); - DBUG_PRINT("info",("spider this=%p", this)); - if (str->reserve(SPIDER_SQL_EXPLAIN_SELECT_LEN)) - { - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - str->q_append(SPIDER_SQL_EXPLAIN_SELECT_STR, SPIDER_SQL_EXPLAIN_SELECT_LEN); - if ( - (error_num = append_from(str, sql_type, link_idx)) || - (error_num = append_key_where(str, NULL, NULL, start_key, end_key, - sql_type, FALSE)) - ) { - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - DBUG_RETURN(0); -} - -/******************************************************************** - * Determine whether the current query's projection list - * consists solely of the specified column. - * - * Params IN - field_index: - * Field index of the column of interest within - * its table. - * - * Returns TRUE - if the query's projection list consists - * solely of the specified column. - * FALSE - otherwise. - ********************************************************************/ -bool spider_oracle_handler::is_sole_projection_field( uint16 field_index ) -{ - // Determine whether the projection list consists solely of the field of interest - bool is_field_in_projection_list = FALSE; - TABLE* table = spider->get_table(); - uint16 projection_field_count = 0; - uint16 projection_field_index; - Field** field; - DBUG_ENTER( "spider_oracle_handler::is_sole_projection_field" ); - - for ( field = table->field; *field; field++ ) - { - projection_field_index = ( *field )->field_index; - - if ( !( minimum_select_bit_is_set( projection_field_index ) ) ) - { - // Current field is not in the projection list - continue; - } - - projection_field_count++; - - if ( !is_field_in_projection_list ) - { - if (field_index == projection_field_index) - { - // Field of interest is in the projection list - is_field_in_projection_list = TRUE; - } - } - - if ( is_field_in_projection_list && ( projection_field_count != 1 ) ) - { - // Field of interest is not the sole column in the projection list - DBUG_RETURN( FALSE ); - } - } - - if ( is_field_in_projection_list && ( projection_field_count == 1 ) ) - { - // Field of interest is the only column in the projection list - DBUG_RETURN( TRUE ); - } - - DBUG_RETURN( FALSE ); -} - -bool spider_oracle_handler::is_bulk_insert_exec_period( - bool bulk_end -) { - DBUG_ENTER("spider_oracle_handler::is_bulk_insert_exec_period"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_PRINT("info",("spider insert_sql.length=%u", insert_sql.length())); - DBUG_PRINT("info",("spider insert_pos=%d", insert_pos)); - DBUG_PRINT("info",("spider insert_sql=%s", insert_sql.c_ptr_safe())); - if ( -/* - (bulk_end || (int) insert_sql.length() >= spider->bulk_size) && -*/ - (int) insert_sql.length() > insert_pos - ) { - DBUG_RETURN(TRUE); - } - DBUG_RETURN(FALSE); -} - -bool spider_oracle_handler::sql_is_filled_up( - ulong sql_type -) { - DBUG_ENTER("spider_oracle_handler::sql_is_filled_up"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(filled_up); -} - -bool spider_oracle_handler::sql_is_empty( - ulong sql_type -) { - bool is_empty; - DBUG_ENTER("spider_oracle_handler::sql_is_empty"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - is_empty = (sql.length() == 0); - break; - case SPIDER_SQL_TYPE_INSERT_SQL: - is_empty = (insert_sql.length() == 0); - break; - case SPIDER_SQL_TYPE_UPDATE_SQL: - case SPIDER_SQL_TYPE_DELETE_SQL: - case SPIDER_SQL_TYPE_BULK_UPDATE_SQL: - is_empty = (update_sql.length() == 0); - break; - case SPIDER_SQL_TYPE_TMP_SQL: - is_empty = (tmp_sql.length() == 0); - break; - case SPIDER_SQL_TYPE_HANDLER: - is_empty = (ha_sql.length() == 0); - break; - default: - is_empty = TRUE; - break; - } - DBUG_RETURN(is_empty); -} - -bool spider_oracle_handler::support_multi_split_read() -{ - DBUG_ENTER("spider_oracle_handler::support_multi_split_read"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(FALSE); -} - -bool spider_oracle_handler::support_bulk_update() -{ - DBUG_ENTER("spider_oracle_handler::support_bulk_update"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(FALSE); -} - -int spider_oracle_handler::bulk_tmp_table_insert() -{ - int error_num; - DBUG_ENTER("spider_oracle_handler::bulk_tmp_table_insert"); - DBUG_PRINT("info",("spider this=%p", this)); - error_num = store_sql_to_bulk_tmp_table(&update_sql, upd_tmp_tbl); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::bulk_tmp_table_insert( - int link_idx -) { - int error_num; - DBUG_ENTER("spider_oracle_handler::bulk_tmp_table_insert"); - DBUG_PRINT("info",("spider this=%p", this)); - error_num = store_sql_to_bulk_tmp_table( - &spider->result_list.update_sqls[link_idx], - spider->result_list.upd_tmp_tbls[link_idx]); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::bulk_tmp_table_end_bulk_insert() -{ - int error_num; - DBUG_ENTER("spider_oracle_handler::bulk_tmp_table_end_bulk_insert"); - DBUG_PRINT("info",("spider this=%p", this)); - if ((error_num = upd_tmp_tbl->file->ha_end_bulk_insert())) - { - DBUG_RETURN(error_num); - } - DBUG_RETURN(0); -} - -int spider_oracle_handler::bulk_tmp_table_rnd_init() -{ - int error_num; - DBUG_ENTER("spider_oracle_handler::bulk_tmp_table_rnd_init"); - DBUG_PRINT("info",("spider this=%p", this)); - upd_tmp_tbl->file->extra(HA_EXTRA_CACHE); - if ((error_num = upd_tmp_tbl->file->ha_rnd_init(TRUE))) - { - DBUG_RETURN(error_num); - } - reading_from_bulk_tmp_table = TRUE; - DBUG_RETURN(0); -} - -int spider_oracle_handler::bulk_tmp_table_rnd_next() -{ - int error_num; - DBUG_ENTER("spider_oracle_handler::bulk_tmp_table_rnd_next"); - DBUG_PRINT("info",("spider this=%p", this)); -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 50200 - error_num = upd_tmp_tbl->file->ha_rnd_next(upd_tmp_tbl->record[0]); -#else - error_num = upd_tmp_tbl->file->rnd_next(upd_tmp_tbl->record[0]); -#endif - if (!error_num) - { - error_num = restore_sql_from_bulk_tmp_table(&insert_sql, upd_tmp_tbl); - } - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::bulk_tmp_table_rnd_end() -{ - int error_num; - DBUG_ENTER("spider_oracle_handler::bulk_tmp_table_rnd_end"); - DBUG_PRINT("info",("spider this=%p", this)); - reading_from_bulk_tmp_table = FALSE; - if ((error_num = upd_tmp_tbl->file->ha_rnd_end())) - { - DBUG_RETURN(error_num); - } - DBUG_RETURN(0); -} - -bool spider_oracle_handler::need_copy_for_update( - int link_idx -) { - int all_link_idx = spider->conn_link_idx[link_idx]; - DBUG_ENTER("spider_oracle_handler::need_copy_for_update"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(!oracle_share->same_db_table_name || - spider->share->link_statuses[all_link_idx] == SPIDER_LINK_STATUS_RECOVERY); -} - -bool spider_oracle_handler::bulk_tmp_table_created() -{ - DBUG_ENTER("spider_oracle_handler::bulk_tmp_table_created"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(upd_tmp_tbl); -} - -int spider_oracle_handler::mk_bulk_tmp_table_and_bulk_start() -{ - THD *thd = spider->wide_handler->trx->thd; - TABLE *table = spider->get_table(); - DBUG_ENTER("spider_oracle_handler::mk_bulk_tmp_table_and_bulk_start"); - DBUG_PRINT("info",("spider this=%p", this)); - if (!upd_tmp_tbl) - { -#ifdef SPIDER_use_LEX_CSTRING_for_Field_blob_constructor - LEX_CSTRING field_name = {STRING_WITH_LEN("a")}; - if (!(upd_tmp_tbl = spider_mk_sys_tmp_table( - thd, table, &upd_tmp_tbl_prm, &field_name, update_sql.charset()))) -#else - if (!(upd_tmp_tbl = spider_mk_sys_tmp_table( - thd, table, &upd_tmp_tbl_prm, "a", update_sql.charset()))) -#endif - { - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - upd_tmp_tbl->file->extra(HA_EXTRA_WRITE_CACHE); - upd_tmp_tbl->file->ha_start_bulk_insert((ha_rows) 0); - } - DBUG_RETURN(0); -} - -void spider_oracle_handler::rm_bulk_tmp_table() -{ - DBUG_ENTER("spider_oracle_handler::rm_bulk_tmp_table"); - DBUG_PRINT("info",("spider this=%p", this)); - if (upd_tmp_tbl) - { - spider_rm_sys_tmp_table(spider->wide_handler->trx->thd, upd_tmp_tbl, - &upd_tmp_tbl_prm); - upd_tmp_tbl = NULL; - } - DBUG_VOID_RETURN; -} - -int spider_oracle_handler::store_sql_to_bulk_tmp_table( - spider_string *str, - TABLE *tmp_table -) { - int error_num; - DBUG_ENTER("spider_oracle_handler::store_sql_to_bulk_tmp_table"); - DBUG_PRINT("info",("spider this=%p", this)); - tmp_table->field[0]->set_notnull(); - tmp_table->field[0]->store(str->ptr(), str->length(), str->charset()); - if ((error_num = tmp_table->file->ha_write_row(tmp_table->record[0]))) - DBUG_RETURN(error_num); - DBUG_RETURN(0); -} - -int spider_oracle_handler::restore_sql_from_bulk_tmp_table( - spider_string *str, - TABLE *tmp_table -) { - DBUG_ENTER("spider_oracle_handler::restore_sql_from_bulk_tmp_table"); - DBUG_PRINT("info",("spider this=%p", this)); - tmp_table->field[0]->val_str(str->get_str()); - str->mem_calc(); - DBUG_RETURN(0); -} - -int spider_oracle_handler::insert_lock_tables_list( - SPIDER_CONN *conn, - int link_idx -) { - spider_db_oracle *db_conn = (spider_db_oracle *) conn->db_conn; - SPIDER_LINK_FOR_HASH *tmp_link_for_hash2 = &link_for_hash[link_idx]; - DBUG_ENTER("spider_oracle_handler::insert_lock_tables_list"); - DBUG_PRINT("info",("spider this=%p", this)); - uint old_elements = - db_conn->lock_table_hash.array.max_element; -#ifdef HASH_UPDATE_WITH_HASH_VALUE - if (my_hash_insert_with_hash_value( - &db_conn->lock_table_hash, - tmp_link_for_hash2->db_table_str_hash_value, - (uchar*) tmp_link_for_hash2)) -#else - if (my_hash_insert(&db_conn->lock_table_hash, - (uchar*) tmp_link_for_hash2)) -#endif - { - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - if (db_conn->lock_table_hash.array.max_element > old_elements) - { - spider_alloc_calc_mem(spider_current_trx, - db_conn->lock_table_hash, - (db_conn->lock_table_hash.array.max_element - old_elements) * - db_conn->lock_table_hash.array.size_of_element); - } - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_lock_tables_list( - SPIDER_CONN *conn, - int link_idx, - int *appended -) { - int error_num; - SPIDER_LINK_FOR_HASH *tmp_link_for_hash, *tmp_link_for_hash2; - int conn_link_idx = spider->conn_link_idx[link_idx]; - spider_db_oracle *db_conn = (spider_db_oracle *) conn->db_conn; - DBUG_ENTER("spider_oracle_handler::append_lock_tables_list"); - DBUG_PRINT("info",("spider this=%p", this)); - tmp_link_for_hash2 = &link_for_hash[link_idx]; - tmp_link_for_hash2->db_table_str = - &oracle_share->db_table_str[conn_link_idx]; -#ifdef SPIDER_HAS_HASH_VALUE_TYPE - tmp_link_for_hash2->db_table_str_hash_value = - oracle_share->db_table_str_hash_value[conn_link_idx]; - if (!(tmp_link_for_hash = (SPIDER_LINK_FOR_HASH *) - my_hash_search_using_hash_value( - &db_conn->lock_table_hash, - tmp_link_for_hash2->db_table_str_hash_value, - (uchar*) tmp_link_for_hash2->db_table_str->ptr(), - tmp_link_for_hash2->db_table_str->length()))) -#else - if (!(tmp_link_for_hash = (SPIDER_LINK_FOR_HASH *) my_hash_search( - &db_conn->lock_table_hash, - (uchar*) tmp_link_for_hash2->db_table_str->ptr(), - tmp_link_for_hash2->db_table_str->length()))) -#endif - { - if ((error_num = insert_lock_tables_list(conn, link_idx))) - DBUG_RETURN(error_num); - *appended = 1; - } else { - if (tmp_link_for_hash->spider->wide_handler->lock_type < - spider->wide_handler->lock_type) - { -#ifdef HASH_UPDATE_WITH_HASH_VALUE - my_hash_delete_with_hash_value( - &db_conn->lock_table_hash, - tmp_link_for_hash->db_table_str_hash_value, - (uchar*) tmp_link_for_hash); -#else - my_hash_delete(&db_conn->lock_table_hash, - (uchar*) tmp_link_for_hash); -#endif - uint old_elements = - db_conn->lock_table_hash.array.max_element; -#ifdef HASH_UPDATE_WITH_HASH_VALUE - if (my_hash_insert_with_hash_value( - &db_conn->lock_table_hash, - tmp_link_for_hash2->db_table_str_hash_value, - (uchar*) tmp_link_for_hash2)) -#else - if (my_hash_insert(&db_conn->lock_table_hash, - (uchar*) tmp_link_for_hash2)) -#endif - { - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - if (db_conn->lock_table_hash.array.max_element > old_elements) - { - spider_alloc_calc_mem(spider_current_trx, - db_conn->lock_table_hash, - (db_conn->lock_table_hash.array.max_element - old_elements) * - db_conn->lock_table_hash.array.size_of_element); - } - } - } - DBUG_RETURN(0); -} - -int spider_oracle_handler::realloc_sql( - ulong *realloced -) { - THD *thd = spider->wide_handler->trx->thd; - st_spider_share *share = spider->share; - int init_sql_alloc_size = - spider_param_init_sql_alloc_size(thd, share->init_sql_alloc_size); - DBUG_ENTER("spider_oracle_handler::realloc_sql"); - DBUG_PRINT("info",("spider this=%p", this)); - if ((int) sql.alloced_length() > init_sql_alloc_size * 2) - { - sql.free(); - if (sql.real_alloc(init_sql_alloc_size)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - *realloced |= SPIDER_SQL_TYPE_SELECT_SQL; - } - if ((int) ha_sql.alloced_length() > init_sql_alloc_size * 2) - { - ha_sql.free(); - if (ha_sql.real_alloc(init_sql_alloc_size)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - *realloced |= SPIDER_SQL_TYPE_SELECT_SQL; - } - if ((int) dup_update_sql.alloced_length() > init_sql_alloc_size * 2) - { - dup_update_sql.free(); - if (dup_update_sql.real_alloc(init_sql_alloc_size)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - if ((int) insert_sql.alloced_length() > init_sql_alloc_size * 2) - { - insert_sql.free(); - if (insert_sql.real_alloc(init_sql_alloc_size)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - *realloced |= SPIDER_SQL_TYPE_INSERT_SQL; - } - if ((int) update_sql.alloced_length() > init_sql_alloc_size * 2) - { - update_sql.free(); - if (update_sql.real_alloc(init_sql_alloc_size)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - *realloced |= (SPIDER_SQL_TYPE_UPDATE_SQL | SPIDER_SQL_TYPE_DELETE_SQL); - } - update_sql.length(0); - if ((int) tmp_sql.alloced_length() > init_sql_alloc_size * 2) - { - tmp_sql.free(); - if (tmp_sql.real_alloc(init_sql_alloc_size)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - *realloced |= SPIDER_SQL_TYPE_TMP_SQL; - } - DBUG_RETURN(0); -} - -int spider_oracle_handler::reset_sql( - ulong sql_type -) { - DBUG_ENTER("spider_oracle_handler::reset_sql"); - DBUG_PRINT("info",("spider this=%p", this)); - if (sql_type & SPIDER_SQL_TYPE_SELECT_SQL) - { - table_lock_mode = 0; - select_rownum_appended = FALSE; - sql.length(0); - } - if (sql_type & SPIDER_SQL_TYPE_INSERT_SQL) - { - insert_sql.length(0); - } - if (sql_type & (SPIDER_SQL_TYPE_UPDATE_SQL | SPIDER_SQL_TYPE_DELETE_SQL | - SPIDER_SQL_TYPE_BULK_UPDATE_SQL)) - { - update_rownum_appended = FALSE; - update_set_pos = 0; - update_sql.length(0); - } - if (sql_type & SPIDER_SQL_TYPE_TMP_SQL) - { - tmp_sql.length(0); - } - if (sql_type & SPIDER_SQL_TYPE_HANDLER) - { - ha_sql.length(0); - } - DBUG_RETURN(0); -} - -bool spider_oracle_handler::need_lock_before_set_sql_for_exec( - ulong sql_type -) { - DBUG_ENTER("spider_oracle_handler::need_lock_before_set_sql_for_exec"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(FALSE); -} - -#ifdef SPIDER_HAS_GROUP_BY_HANDLER -int spider_oracle_handler::set_sql_for_exec( - ulong sql_type, - int link_idx, - SPIDER_LINK_IDX_CHAIN *link_idx_chain -) { - int error_num; - SPIDER_RESULT_LIST *result_list = &spider->result_list; - int all_link_idx = spider->conn_link_idx[link_idx]; - DBUG_ENTER("spider_oracle_handler::set_sql_for_exec"); - DBUG_PRINT("info",("spider this=%p", this)); - if (sql_type & SPIDER_SQL_TYPE_SELECT_SQL) - { - if (table_lock_mode) - { - spider_string *str = &result_list->insert_sqls[link_idx]; - str->length(0); - if (str->reserve(SPIDER_SQL_LOCK_TABLE_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_LOCK_TABLE_STR, SPIDER_SQL_LOCK_TABLE_LEN); - if ((error_num = oracle_share->append_table_name(str, all_link_idx))) - DBUG_RETURN(error_num); - if (table_lock_mode == SPIDER_LOCK_MODE_EXCLUSIVE) - { - if (str->reserve(SPIDER_SQL_LOCK_TABLE_EXCLUSIVE_MODE_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_LOCK_TABLE_EXCLUSIVE_MODE_STR, - SPIDER_SQL_LOCK_TABLE_EXCLUSIVE_MODE_LEN); - } else if (table_lock_mode == SPIDER_LOCK_MODE_SHARED) - { - if (str->reserve(SPIDER_SQL_LOCK_TABLE_SHARE_MODE_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_LOCK_TABLE_SHARE_MODE_STR, - SPIDER_SQL_LOCK_TABLE_SHARE_MODE_LEN); - } - exec_lock_sql = str; - } - - if ((error_num = spider_db_oracle_utility.reappend_tables( - spider->fields, link_idx_chain, &sql))) - DBUG_RETURN(error_num); - exec_sql = &sql; - } - DBUG_RETURN(0); -} -#endif - -int spider_oracle_handler::set_sql_for_exec( - ulong sql_type, - int link_idx -) { - int error_num; - uint tmp_pos; - SPIDER_SHARE *share = spider->share; - SPIDER_RESULT_LIST *result_list = &spider->result_list; - int all_link_idx = spider->conn_link_idx[link_idx]; - DBUG_ENTER("spider_oracle_handler::set_sql_for_exec"); - DBUG_PRINT("info",("spider this=%p", this)); - if (sql_type & (SPIDER_SQL_TYPE_SELECT_SQL | SPIDER_SQL_TYPE_TMP_SQL)) - { - if (table_lock_mode) - { - spider_string *str = &result_list->insert_sqls[link_idx]; - str->length(0); - if (str->reserve(SPIDER_SQL_LOCK_TABLE_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_LOCK_TABLE_STR, SPIDER_SQL_LOCK_TABLE_LEN); - if ((error_num = oracle_share->append_table_name(str, all_link_idx))) - DBUG_RETURN(error_num); - if (table_lock_mode == SPIDER_LOCK_MODE_EXCLUSIVE) - { - if (str->reserve(SPIDER_SQL_LOCK_TABLE_EXCLUSIVE_MODE_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_LOCK_TABLE_EXCLUSIVE_MODE_STR, - SPIDER_SQL_LOCK_TABLE_EXCLUSIVE_MODE_LEN); - } else if (table_lock_mode == SPIDER_LOCK_MODE_SHARED) - { - if (str->reserve(SPIDER_SQL_LOCK_TABLE_SHARE_MODE_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_LOCK_TABLE_SHARE_MODE_STR, - SPIDER_SQL_LOCK_TABLE_SHARE_MODE_LEN); - } - exec_lock_sql = str; - } - - if (oracle_share->same_db_table_name || link_idx == first_link_idx) - { - if (sql_type & SPIDER_SQL_TYPE_SELECT_SQL) - exec_sql = &sql; - if (sql_type & SPIDER_SQL_TYPE_TMP_SQL) - exec_tmp_sql = &tmp_sql; - } else { - char tmp_table_name[MAX_FIELD_WIDTH * 2], - tgt_table_name[MAX_FIELD_WIDTH * 2]; - int tmp_table_name_length; - spider_string tgt_table_name_str(tgt_table_name, - MAX_FIELD_WIDTH * 2, - oracle_share->db_names_str[link_idx].charset()); - const char *table_names[2], *table_aliases[2]; - uint table_name_lengths[2], table_alias_lengths[2]; - tgt_table_name_str.init_calc_mem(212); - tgt_table_name_str.length(0); - if (result_list->tmp_table_join && spider->bka_mode != 2) - { - create_tmp_bka_table_name(tmp_table_name, &tmp_table_name_length, - link_idx); - append_table_name_with_adjusting(&tgt_table_name_str, link_idx, - SPIDER_SQL_TYPE_TMP_SQL); - table_names[0] = tmp_table_name; - table_names[1] = tgt_table_name_str.ptr(); - table_name_lengths[0] = tmp_table_name_length; - table_name_lengths[1] = tgt_table_name_str.length(); - table_aliases[0] = SPIDER_SQL_A_STR; - table_aliases[1] = SPIDER_SQL_B_STR; - table_alias_lengths[0] = SPIDER_SQL_A_LEN; - table_alias_lengths[1] = SPIDER_SQL_B_LEN; - } - if (sql_type & SPIDER_SQL_TYPE_SELECT_SQL) - { - exec_sql = &result_list->sqls[link_idx]; - if (exec_sql->copy(sql)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - else if (result_list->use_union) - { - if ((error_num = reset_union_table_name(exec_sql, link_idx, - SPIDER_SQL_TYPE_SELECT_SQL))) - DBUG_RETURN(error_num); - } else { - tmp_pos = exec_sql->length(); - exec_sql->length(table_name_pos); - if (result_list->tmp_table_join && spider->bka_mode != 2) - { - if ((error_num = spider_db_oracle_utility.append_from_with_alias( - exec_sql, table_names, table_name_lengths, - table_aliases, table_alias_lengths, 2, - &table_name_pos, TRUE)) - ) - DBUG_RETURN(error_num); - exec_sql->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN); - } else { - append_table_name_with_adjusting(exec_sql, link_idx, - SPIDER_SQL_TYPE_SELECT_SQL); - } - exec_sql->length(tmp_pos); - } - } - if (sql_type & SPIDER_SQL_TYPE_TMP_SQL) - { - exec_tmp_sql = &result_list->tmp_sqls[link_idx]; - if (result_list->tmp_table_join && spider->bka_mode != 2) - { - if (exec_tmp_sql->copy(tmp_sql)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - else { - tmp_pos = exec_tmp_sql->length(); - exec_tmp_sql->length(tmp_sql_pos1); - exec_tmp_sql->q_append(tmp_table_name, tmp_table_name_length); - exec_tmp_sql->length(tmp_sql_pos2); - exec_tmp_sql->q_append(tmp_table_name, tmp_table_name_length); - exec_tmp_sql->length(tmp_sql_pos3); - exec_tmp_sql->q_append(tmp_table_name, tmp_table_name_length); - exec_tmp_sql->length(tmp_pos); - } - } - } - } - } - if (sql_type & SPIDER_SQL_TYPE_INSERT_SQL) - { - if (oracle_share->same_db_table_name || link_idx == first_link_idx) - exec_insert_sql = &insert_sql; - else { - exec_insert_sql = &result_list->insert_sqls[link_idx]; - if (exec_insert_sql->copy(insert_sql)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - DBUG_PRINT("info",("spider exec_insert_sql=%s", - exec_insert_sql->c_ptr_safe())); - tmp_pos = exec_insert_sql->length(); - exec_insert_sql->length(insert_table_name_pos); - append_table_name_with_adjusting(exec_insert_sql, link_idx, - sql_type); - exec_insert_sql->length(tmp_pos); - DBUG_PRINT("info",("spider exec_insert_sql->length=%u", - exec_insert_sql->length())); - DBUG_PRINT("info",("spider exec_insert_sql=%s", - exec_insert_sql->c_ptr_safe())); - } - if (nextval_pos) - { - memcpy((uchar *) exec_insert_sql->ptr() + nextval_pos, - oracle_share->nextval_str[all_link_idx].ptr(), - oracle_share->nextval_max_length); - } - } - if (sql_type & SPIDER_SQL_TYPE_BULK_UPDATE_SQL) - { - if (reading_from_bulk_tmp_table) - { - if ( - oracle_share->same_db_table_name && - share->link_statuses[all_link_idx] != SPIDER_LINK_STATUS_RECOVERY - ) { - exec_update_sql = &insert_sql; - } else if (!spider->result_list.upd_tmp_tbls[link_idx]) - { - DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM); - } else { - exec_update_sql = &spider->result_list.insert_sqls[link_idx]; - if ((error_num = restore_sql_from_bulk_tmp_table(exec_update_sql, - spider->result_list.upd_tmp_tbls[link_idx]))) - { - DBUG_RETURN(error_num); - } - } - } else { - if ( - oracle_share->same_db_table_name && - share->link_statuses[all_link_idx] != SPIDER_LINK_STATUS_RECOVERY - ) { - exec_update_sql = &update_sql; - } else { - exec_update_sql = &spider->result_list.update_sqls[link_idx]; - } - } - DBUG_PRINT("info",("spider exec_update_sql=%s", - exec_update_sql->c_ptr_safe())); - } else if (sql_type & - (SPIDER_SQL_TYPE_UPDATE_SQL | SPIDER_SQL_TYPE_DELETE_SQL)) - { - if (oracle_share->same_db_table_name || link_idx == first_link_idx) - exec_update_sql = &update_sql; - else { - exec_update_sql = &spider->result_list.update_sqls[link_idx]; - if (exec_update_sql->copy(update_sql)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - tmp_pos = exec_update_sql->length(); - exec_update_sql->length(table_name_pos); - append_table_name_with_adjusting(exec_update_sql, link_idx, - sql_type); - exec_update_sql->length(tmp_pos); - } - DBUG_PRINT("info",("spider exec_update_sql=%s", - exec_update_sql->c_ptr_safe())); - } - if (sql_type & SPIDER_SQL_TYPE_HANDLER) - { - if (spider->m_handler_id[link_idx] == ha_sql_handler_id) - exec_ha_sql = &ha_sql; - else { - exec_ha_sql = &result_list->sqls[link_idx]; - if (exec_ha_sql->copy(ha_sql)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - else { - tmp_pos = exec_ha_sql->length(); - exec_ha_sql->length(ha_table_name_pos); - append_table_name_with_adjusting(exec_ha_sql, link_idx, - SPIDER_SQL_TYPE_HANDLER); - exec_ha_sql->length(tmp_pos); - } - } - DBUG_PRINT("info",("spider exec_ha_sql=%s", - exec_ha_sql->c_ptr_safe())); - } - DBUG_RETURN(0); -} - -int spider_oracle_handler::set_sql_for_exec( - spider_db_copy_table *tgt_ct, - ulong sql_type -) { - spider_oracle_copy_table *oracle_ct = (spider_oracle_copy_table *) tgt_ct; - DBUG_ENTER("spider_oracle_handler::set_sql_for_exec"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_INSERT_SQL: - exec_insert_sql = &oracle_ct->sql; - break; - default: - DBUG_ASSERT(0); - break; - } - DBUG_RETURN(0); -} - -int spider_oracle_handler::execute_sql( - ulong sql_type, - SPIDER_CONN *conn, - int quick_mode, - int *need_mon -) { - spider_string *tgt_sql; - uint tgt_length; - DBUG_ENTER("spider_oracle_handler::execute_sql"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - DBUG_PRINT("info",("spider SPIDER_SQL_TYPE_SELECT_SQL")); - tgt_sql = exec_sql; - tgt_length = tgt_sql->length(); - if (table_lock_mode) - { - DBUG_PRINT("info",("spider table_lock_mode=%d", table_lock_mode)); - spider_db_oracle *db_conn = (spider_db_oracle *) conn->db_conn; - db_conn->table_lock_mode = table_lock_mode; - db_conn->exec_lock_sql = exec_lock_sql; - table_lock_mode = 0; - } - break; - case SPIDER_SQL_TYPE_INSERT_SQL: - DBUG_PRINT("info",("spider SPIDER_SQL_TYPE_SELECT_SQL")); - tgt_sql = exec_insert_sql; - tgt_length = tgt_sql->length(); - break; - case SPIDER_SQL_TYPE_UPDATE_SQL: - case SPIDER_SQL_TYPE_DELETE_SQL: - case SPIDER_SQL_TYPE_BULK_UPDATE_SQL: - DBUG_PRINT("info",("spider %s", - sql_type == SPIDER_SQL_TYPE_UPDATE_SQL ? "SPIDER_SQL_TYPE_UPDATE_SQL" : - sql_type == SPIDER_SQL_TYPE_DELETE_SQL ? "SPIDER_SQL_TYPE_DELETE_SQL" : - "SPIDER_SQL_TYPE_BULK_UPDATE_SQL" - )); - tgt_sql = exec_update_sql; - tgt_length = tgt_sql->length(); - break; - case SPIDER_SQL_TYPE_TMP_SQL: - DBUG_PRINT("info",("spider SPIDER_SQL_TYPE_TMP_SQL")); - tgt_sql = exec_tmp_sql; - tgt_length = tgt_sql->length(); - break; - case SPIDER_SQL_TYPE_DROP_TMP_TABLE_SQL: - DBUG_PRINT("info",("spider SPIDER_SQL_TYPE_DROP_TMP_TABLE_SQL")); - tgt_sql = exec_tmp_sql; - tgt_length = tmp_sql_pos5; - break; - case SPIDER_SQL_TYPE_HANDLER: - DBUG_PRINT("info",("spider SPIDER_SQL_TYPE_HANDLER")); - tgt_sql = exec_ha_sql; - tgt_length = tgt_sql->length(); - break; - default: - /* nothing to do */ - DBUG_PRINT("info",("spider default")); - DBUG_RETURN(0); - } - DBUG_RETURN(spider_db_query( - conn, - tgt_sql->ptr(), - tgt_length, - quick_mode, - need_mon - )); -} - -int spider_oracle_handler::reset() -{ - DBUG_ENTER("spider_oracle_handler::reset"); - DBUG_PRINT("info",("spider this=%p", this)); - update_sql.length(0); - DBUG_RETURN(0); -} - -int spider_oracle_handler::sts_mode_exchange( - int sts_mode -) { - DBUG_ENTER("spider_oracle_handler::sts_mode_exchange"); - DBUG_PRINT("info",("spider sts_mode=%d", sts_mode)); - DBUG_RETURN(1); -} - -int spider_oracle_handler::show_table_status( - int link_idx, - int sts_mode, - uint flag -) { - int error_num; - SPIDER_CONN *conn = spider->conns[link_idx]; - SPIDER_DB_RESULT *res; - SPIDER_SHARE *share = spider->share; - uint pos = (2 * spider->conn_link_idx[link_idx]); - ulonglong auto_increment_value = 0; - DBUG_ENTER("spider_oracle_handler::show_table_status"); - DBUG_PRINT("info",("spider sts_mode=%d", sts_mode)); - if ( - (flag & HA_STATUS_AUTO) && - (error_num = show_autoinc(link_idx)) - ) { - DBUG_RETURN(error_num); - } - - if (sts_mode == 1) - { - if (!share->stat.records) - share->stat.records = 10000; - share->stat.mean_rec_length = 65535; - share->stat.data_file_length = 65535; - share->stat.max_data_file_length = 65535; - share->stat.index_file_length = 65535; - share->stat.create_time = (time_t) 0; - share->stat.update_time = (time_t) 0; - share->stat.check_time = (time_t) 0; - } else { - pthread_mutex_assert_not_owner(&conn->mta_conn_mutex); - pthread_mutex_lock(&conn->mta_conn_mutex); - SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos); - conn->need_mon = &spider->need_mons[link_idx]; - DBUG_ASSERT(!conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = TRUE; - conn->mta_conn_mutex_unlock_later = TRUE; - spider_conn_set_timeout_from_share(conn, link_idx, - spider->wide_handler->trx->thd, - share); - if ( - (error_num = spider_db_set_names(spider, conn, link_idx)) || - ( - spider_db_query( - conn, - oracle_share->show_table_status[1 + pos].ptr(), - oracle_share->show_table_status[1 + pos].length(), - -1, - &spider->need_mons[link_idx]) && - (error_num = spider_db_errorno(conn)) - ) - ) { - if ( - error_num == ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM && - !conn->disable_reconnect - ) { - /* retry */ - if ((error_num = spider_db_ping(spider, conn, link_idx))) - { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - DBUG_RETURN(error_num); - } - if ((error_num = spider_db_set_names(spider, conn, link_idx))) - { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - DBUG_RETURN(error_num); - } - spider_conn_set_timeout_from_share(conn, link_idx, - spider->wide_handler->trx->thd, - share); - if (spider_db_query( - conn, - oracle_share->show_table_status[1 + pos].ptr(), - oracle_share->show_table_status[1 + pos].length(), - -1, - &spider->need_mons[link_idx]) - ) { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - DBUG_RETURN(spider_db_errorno(conn)); - } - } else { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - DBUG_RETURN(error_num); - } - } - st_spider_db_request_key request_key; - request_key.spider_thread_id = spider->wide_handler->trx->spider_thread_id; - request_key.query_id = spider->wide_handler->trx->thd->query_id; - request_key.handler = spider; - request_key.request_id = 1; - request_key.next = NULL; - if (!(res = conn->db_conn->store_result(NULL, &request_key, &error_num))) - { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - if (error_num || (error_num = spider_db_errorno(conn))) - DBUG_RETURN(error_num); - else - DBUG_RETURN(ER_QUERY_ON_FOREIGN_DATA_SOURCE); - } - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - error_num = res->fetch_table_status( - sts_mode, - share->stat - ); - auto_increment_value = share->stat.auto_increment_value; - res->free_result(); - delete res; - if (error_num) - DBUG_RETURN(error_num); - } - if (auto_increment_value > share->lgtm_tblhnd_share->auto_increment_value) - { - share->lgtm_tblhnd_share->auto_increment_value = auto_increment_value; - DBUG_PRINT("info",("spider auto_increment_value=%llu", - share->lgtm_tblhnd_share->auto_increment_value)); - } - DBUG_RETURN(0); -} - -int spider_oracle_handler::crd_mode_exchange( - int crd_mode -) { - DBUG_ENTER("spider_oracle_handler::crd_mode_exchange"); - DBUG_PRINT("info",("spider crd_mode=%d", crd_mode)); - DBUG_RETURN(1); -} - -int spider_oracle_handler::show_index( - int link_idx, - int crd_mode -) { - int error_num; - SPIDER_CONN *conn = spider->conns[link_idx]; - SPIDER_SHARE *share = spider->share; - TABLE *table = spider->get_table(); - SPIDER_DB_RESULT *res; - int roop_count; - longlong *tmp_cardinality; - uint pos = (2 * spider->conn_link_idx[link_idx]); - DBUG_ENTER("spider_oracle_handler::show_index"); - DBUG_PRINT("info",("spider crd_mode=%d", crd_mode)); - if (crd_mode == 1) - { - for (roop_count = 0, tmp_cardinality = share->cardinality; - roop_count < (int) table->s->fields; - roop_count++, tmp_cardinality++) - { - if (!spider_bit_is_set(share->cardinality_upd, roop_count)) - { - DBUG_PRINT("info", - ("spider init column cardinality id=%d", roop_count)); - *tmp_cardinality = 1; - } - } - } else { - pthread_mutex_assert_not_owner(&conn->mta_conn_mutex); - pthread_mutex_lock(&conn->mta_conn_mutex); - SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos); - conn->need_mon = &spider->need_mons[link_idx]; - DBUG_ASSERT(!conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = TRUE; - conn->mta_conn_mutex_unlock_later = TRUE; - spider_conn_set_timeout_from_share(conn, link_idx, - spider->wide_handler->trx->thd, - share); - if ( - (error_num = spider_db_set_names(spider, conn, link_idx)) || - ( - spider_db_query( - conn, - oracle_share->show_index[1 + pos].ptr(), - oracle_share->show_index[1 + pos].length(), - -1, - &spider->need_mons[link_idx]) && - (error_num = spider_db_errorno(conn)) - ) - ) { - if ( - error_num == ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM && - !conn->disable_reconnect - ) { - /* retry */ - if ((error_num = spider_db_ping(spider, conn, link_idx))) - { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - DBUG_RETURN(error_num); - } - if ((error_num = spider_db_set_names(spider, conn, link_idx))) - { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - DBUG_RETURN(error_num); - } - spider_conn_set_timeout_from_share(conn, link_idx, - spider->wide_handler->trx->thd, - share); - if (spider_db_query( - conn, - oracle_share->show_index[1 + pos].ptr(), - oracle_share->show_index[1 + pos].length(), - -1, - &spider->need_mons[link_idx]) - ) { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - DBUG_RETURN(spider_db_errorno(conn)); - } - } else { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - DBUG_RETURN(error_num); - } - } - st_spider_db_request_key request_key; - request_key.spider_thread_id = spider->wide_handler->trx->spider_thread_id; - request_key.query_id = spider->wide_handler->trx->thd->query_id; - request_key.handler = spider; - request_key.request_id = 1; - request_key.next = NULL; - if (!(res = conn->db_conn->store_result(NULL, &request_key, &error_num))) - { - if (error_num || (error_num = spider_db_errorno(conn))) - { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - DBUG_RETURN(error_num); - } - /* no record is ok */ - } - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - if (res) - { - error_num = res->fetch_table_cardinality( - crd_mode, - table, - share->cardinality, - share->cardinality_upd, - share->bitmap_size - ); - } - for (roop_count = 0, tmp_cardinality = share->cardinality; - roop_count < (int) table->s->fields; - roop_count++, tmp_cardinality++) - { - if (!spider_bit_is_set(share->cardinality_upd, roop_count)) - { - DBUG_PRINT("info", - ("spider init column cardinality id=%d", roop_count)); - *tmp_cardinality = 1; - } - } - if (res) - { - res->free_result(); - delete res; - } - if (error_num) - DBUG_RETURN(error_num); - } - DBUG_RETURN(0); -} - -int spider_oracle_handler::show_records( - int link_idx -) { - int error_num; - SPIDER_CONN *conn = spider->conns[link_idx]; - SPIDER_DB_RESULT *res; - SPIDER_SHARE *share = spider->share; - uint pos = spider->conn_link_idx[link_idx]; - DBUG_ENTER("spider_oracle_handler::show_records"); - pthread_mutex_assert_not_owner(&conn->mta_conn_mutex); - pthread_mutex_lock(&conn->mta_conn_mutex); - SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos); - conn->need_mon = &spider->need_mons[link_idx]; - DBUG_ASSERT(!conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = TRUE; - conn->mta_conn_mutex_unlock_later = TRUE; - spider_conn_set_timeout_from_share(conn, link_idx, - spider->wide_handler->trx->thd, - share); - if ( - (error_num = spider_db_set_names(spider, conn, link_idx)) || - ( - spider_db_query( - conn, - oracle_share->show_records[pos].ptr(), - oracle_share->show_records[pos].length(), - -1, - &spider->need_mons[link_idx]) && - (error_num = spider_db_errorno(conn)) - ) - ) { - if ( - error_num == ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM && - !conn->disable_reconnect - ) { - /* retry */ - if ((error_num = spider_db_ping(spider, conn, link_idx))) - { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - DBUG_PRINT("info", ("spider error_num=%d 1", error_num)); - DBUG_RETURN(error_num); - } - if ((error_num = spider_db_set_names(spider, conn, link_idx))) - { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - DBUG_PRINT("info", ("spider error_num=%d 2", error_num)); - DBUG_RETURN(error_num); - } - spider_conn_set_timeout_from_share(conn, link_idx, - spider->wide_handler->trx->thd, - share); - if (spider_db_query( - conn, - oracle_share->show_records[pos].ptr(), - oracle_share->show_records[pos].length(), - -1, - &spider->need_mons[link_idx]) - ) { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - DBUG_PRINT("info", ("spider error_num=%d 3", error_num)); - DBUG_RETURN(spider_db_errorno(conn)); - } - } else { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - DBUG_PRINT("info", ("spider error_num=%d 4", error_num)); - DBUG_RETURN(error_num); - } - } - st_spider_db_request_key request_key; - request_key.spider_thread_id = spider->wide_handler->trx->spider_thread_id; - request_key.query_id = spider->wide_handler->trx->thd->query_id; - request_key.handler = spider; - request_key.request_id = 1; - request_key.next = NULL; - if (!(res = conn->db_conn->store_result(NULL, &request_key, &error_num))) - { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - if (error_num) - { - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - DBUG_PRINT("info", ("spider error_num=%d 5", error_num)); - DBUG_RETURN(error_num); - } - else if (error_num || (error_num = spider_db_errorno(conn))) - { - DBUG_PRINT("info", ("spider error_num=%d 6", error_num)); - DBUG_RETURN(error_num); - } else { - DBUG_PRINT("info", ("spider error_num=%d 7", - ER_QUERY_ON_FOREIGN_DATA_SOURCE)); - DBUG_RETURN(ER_QUERY_ON_FOREIGN_DATA_SOURCE); - } - } - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - error_num = res->fetch_table_records( - 1, - spider->table_rows - ); - res->free_result(); - delete res; - if (error_num) - { - DBUG_PRINT("info", ("spider error_num=%d 7", error_num)); - DBUG_RETURN(error_num); - } - spider->wide_handler->trx->direct_aggregate_count++; - DBUG_RETURN(0); -} - -int spider_oracle_handler::show_autoinc( - int link_idx -) { - int error_num; - SPIDER_CONN *conn = spider->conns[link_idx]; - SPIDER_DB_RESULT *res; - SPIDER_SHARE *share = spider->share; - uint pos = spider->conn_link_idx[link_idx]; - ulonglong auto_increment_value; - DBUG_ENTER("spider_oracle_handler::show_autoinc"); - if (!oracle_share->show_autoinc) - DBUG_RETURN(0); - - pthread_mutex_assert_not_owner(&conn->mta_conn_mutex); - pthread_mutex_lock(&conn->mta_conn_mutex); - SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos); - conn->need_mon = &spider->need_mons[link_idx]; - DBUG_ASSERT(!conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = TRUE; - conn->mta_conn_mutex_unlock_later = TRUE; - spider_conn_set_timeout_from_share(conn, link_idx, - spider->wide_handler->trx->thd, - share); - if ( - (error_num = spider_db_set_names(spider, conn, link_idx)) || - ( - spider_db_query( - conn, - oracle_share->show_autoinc[pos].ptr(), - oracle_share->show_autoinc[pos].length(), - -1, - &spider->need_mons[link_idx]) && - (error_num = spider_db_errorno(conn)) - ) - ) { - if ( - error_num == ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM && - !conn->disable_reconnect - ) { - /* retry */ - if ((error_num = spider_db_ping(spider, conn, link_idx))) - { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - DBUG_PRINT("info", ("spider error_num=%d 1", error_num)); - DBUG_RETURN(error_num); - } - if ((error_num = spider_db_set_names(spider, conn, link_idx))) - { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - DBUG_PRINT("info", ("spider error_num=%d 2", error_num)); - DBUG_RETURN(error_num); - } - spider_conn_set_timeout_from_share(conn, link_idx, - spider->wide_handler->trx->thd, - share); - if (spider_db_query( - conn, - oracle_share->show_records[pos].ptr(), - oracle_share->show_records[pos].length(), - -1, - &spider->need_mons[link_idx]) - ) { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - DBUG_PRINT("info", ("spider error_num=%d 3", error_num)); - DBUG_RETURN(spider_db_errorno(conn)); - } - } else { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - DBUG_PRINT("info", ("spider error_num=%d 4", error_num)); - DBUG_RETURN(error_num); - } - } - st_spider_db_request_key request_key; - request_key.spider_thread_id = spider->wide_handler->trx->spider_thread_id; - request_key.query_id = spider->wide_handler->trx->thd->query_id; - request_key.handler = spider; - request_key.request_id = 1; - request_key.next = NULL; - if (!(res = conn->db_conn->store_result(NULL, &request_key, &error_num))) - { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - if (error_num) - { - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - DBUG_PRINT("info", ("spider error_num=%d 5", error_num)); - DBUG_RETURN(error_num); - } - else if ((error_num = spider_db_errorno(conn))) - { - DBUG_PRINT("info", ("spider error_num=%d 6", error_num)); - DBUG_RETURN(error_num); - } else { - DBUG_PRINT("info", ("spider error_num=%d 7", - ER_QUERY_ON_FOREIGN_DATA_SOURCE)); - DBUG_RETURN(ER_QUERY_ON_FOREIGN_DATA_SOURCE); - } - } - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - error_num = res->fetch_table_records( - 1, - auto_increment_value - ); - res->free_result(); - delete res; - if (error_num) - { - DBUG_PRINT("info", ("spider error_num=%d 7", error_num)); - DBUG_RETURN(error_num); - } - if (auto_increment_value >= - share->lgtm_tblhnd_share->auto_increment_value) - { - share->lgtm_tblhnd_share->auto_increment_value = - auto_increment_value + 1; - DBUG_PRINT("info",("spider auto_increment_value=%llu", - share->lgtm_tblhnd_share->auto_increment_value)); - } - DBUG_RETURN(0); -} - -int spider_oracle_handler::show_last_insert_id( - int link_idx, - ulonglong &last_insert_id -) { - int error_num; - SPIDER_CONN *conn = spider->conns[link_idx]; - SPIDER_DB_RESULT *res; - uint pos = spider->conn_link_idx[link_idx]; - spider_db_oracle *db_oracle = (spider_db_oracle *) conn->db_conn; - DBUG_ENTER("spider_oracle_handler::show_last_insert_id"); - if (!oracle_share->show_last_insert_id) - { - DBUG_ASSERT(0); - last_insert_id = 0; - db_oracle->stored_last_insert_id = 0; - DBUG_RETURN(0); - } - - if ( - spider_db_query( - conn, - oracle_share->show_last_insert_id[pos].ptr(), - oracle_share->show_last_insert_id[pos].length(), - -1, - &spider->need_mons[link_idx]) && - (error_num = spider_db_errorno(conn)) - ) { - DBUG_PRINT("info", ("spider error_num=%d 4", error_num)); - DBUG_RETURN(error_num); - } - st_spider_db_request_key request_key; - request_key.spider_thread_id = spider->wide_handler->trx->spider_thread_id; - request_key.query_id = spider->wide_handler->trx->thd->query_id; - request_key.handler = spider; - request_key.request_id = 1; - request_key.next = NULL; - if (!(res = conn->db_conn->store_result(NULL, &request_key, &error_num))) - { - if (error_num || (error_num = spider_db_errorno(conn))) - { - DBUG_PRINT("info", ("spider error_num=%d 5", error_num)); - DBUG_RETURN(error_num); - } else { - DBUG_PRINT("info", ("spider error_num=%d 6", - ER_QUERY_ON_FOREIGN_DATA_SOURCE)); - DBUG_RETURN(ER_QUERY_ON_FOREIGN_DATA_SOURCE); - } - } - error_num = res->fetch_table_records( - 1, - last_insert_id - ); - res->free_result(); - delete res; - if (error_num) - { - DBUG_PRINT("info", ("spider error_num=%d 7", error_num)); - DBUG_RETURN(error_num); - } - db_oracle->stored_last_insert_id = last_insert_id; - DBUG_RETURN(0); -} - -ha_rows spider_oracle_handler::explain_select( - const key_range *start_key, - const key_range *end_key, - int link_idx -) { - int error_num; - SPIDER_CONN *conn = spider->conns[link_idx]; - SPIDER_RESULT_LIST *result_list = &spider->result_list; - spider_string *str = &result_list->sqls[link_idx]; - SPIDER_DB_RESULT *res; - ha_rows rows; - spider_db_handler *dbton_hdl = spider->dbton_handler[conn->dbton_id]; - DBUG_ENTER("spider_oracle_handler::explain_select"); - if ((error_num = dbton_hdl->append_explain_select_part( - start_key, end_key, SPIDER_SQL_TYPE_OTHER_SQL, link_idx))) - { - my_errno = error_num; - DBUG_RETURN(HA_POS_ERROR); - } - - pthread_mutex_assert_not_owner(&conn->mta_conn_mutex); - pthread_mutex_lock(&conn->mta_conn_mutex); - SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos); - conn->need_mon = &spider->need_mons[link_idx]; - DBUG_ASSERT(!conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = TRUE; - conn->mta_conn_mutex_unlock_later = TRUE; - spider_conn_set_timeout_from_share(conn, link_idx, - spider->wide_handler->trx->thd, - spider->share); - if ( - (error_num = spider_db_set_names(spider, conn, link_idx)) || - ( - spider_db_query( - conn, - str->ptr(), - str->length(), - -1, - &spider->need_mons[link_idx]) && - (error_num = spider_db_errorno(conn)) - ) - ) { - if ( - error_num == ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM && - !conn->disable_reconnect - ) { - /* retry */ - if ((error_num = spider_db_ping(spider, conn, link_idx))) - { - if (spider->check_error_mode(error_num)) - my_errno = error_num; - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - DBUG_RETURN(HA_POS_ERROR); - } - if ((error_num = spider_db_set_names(spider, conn, link_idx))) - { - if (spider->check_error_mode(error_num)) - my_errno = error_num; - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - DBUG_RETURN(HA_POS_ERROR); - } - spider_conn_set_timeout_from_share(conn, link_idx, - spider->wide_handler->trx->thd, - spider->share); - if (spider_db_query( - conn, - str->ptr(), - str->length(), - -1, - &spider->need_mons[link_idx]) - ) { - error_num = spider_db_errorno(conn); - if (spider->check_error_mode(error_num)) - my_errno = error_num; - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - DBUG_RETURN(HA_POS_ERROR); - } - } else { - if (spider->check_error_mode(error_num)) - my_errno = error_num; - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - DBUG_RETURN(HA_POS_ERROR); - } - } - st_spider_db_request_key request_key; - request_key.spider_thread_id = spider->wide_handler->trx->spider_thread_id; - request_key.query_id = spider->wide_handler->trx->thd->query_id; - request_key.handler = spider; - request_key.request_id = 1; - request_key.next = NULL; - if (!(res = conn->db_conn->store_result(NULL, &request_key, &error_num))) - { - if (error_num || (error_num = spider_db_errorno(conn))) - { - if (spider->check_error_mode(error_num)) - my_errno = error_num; - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - DBUG_RETURN(HA_POS_ERROR); - } else { - my_errno = ER_QUERY_ON_FOREIGN_DATA_SOURCE; - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - DBUG_RETURN(HA_POS_ERROR); - } - } - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - error_num = res->fetch_table_records( - 2, - rows - ); - res->free_result(); - delete res; - if (error_num) - { - my_errno = error_num; - DBUG_RETURN(HA_POS_ERROR); - } - DBUG_RETURN(rows); -} - -int spider_oracle_handler::lock_tables( - int link_idx -) { - int error_num; - SPIDER_CONN *conn = spider->conns[link_idx]; - spider_string *str = &sql; - DBUG_ENTER("spider_oracle_handler::lock_tables"); - do { - str->length(0); - if ((error_num = conn->db_conn->append_lock_tables(str))) - { - DBUG_RETURN(error_num); - } - if (str->length()) - { - pthread_mutex_assert_not_owner(&conn->mta_conn_mutex); - pthread_mutex_lock(&conn->mta_conn_mutex); - SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos); - conn->need_mon = &spider->need_mons[link_idx]; - DBUG_ASSERT(!conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = TRUE; - conn->mta_conn_mutex_unlock_later = TRUE; - if ((error_num = spider_db_set_names(spider, conn, link_idx))) - { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - DBUG_RETURN(error_num); - } - spider_conn_set_timeout_from_share(conn, link_idx, - spider->wide_handler->trx->thd, - spider->share); - if (spider_db_query( - conn, - str->ptr(), - str->length(), - -1, - &spider->need_mons[link_idx]) - ) { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - DBUG_RETURN(spider_db_errorno(conn)); - } - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - } - if (!conn->table_locked) - { - conn->table_locked = TRUE; - spider->wide_handler->trx->locked_connections++; - } - } while (str->length()); - DBUG_RETURN(0); -} - -int spider_oracle_handler::unlock_tables( - int link_idx -) { - int error_num; - SPIDER_CONN *conn = spider->conns[link_idx]; - DBUG_ENTER("spider_oracle_handler::unlock_tables"); - if (conn->table_locked) - { - if ((error_num = conn->db_conn->commit(&spider->need_mons[link_idx]))) - { - DBUG_RETURN(error_num); - } - } - DBUG_RETURN(0); -} - -int spider_oracle_handler::disable_keys( - SPIDER_CONN *conn, - int link_idx -) { - int error_num; - SPIDER_SHARE *share = spider->share; - spider_string *str = &spider->result_list.sqls[link_idx]; - DBUG_ENTER("spider_oracle_handler::disable_keys"); - DBUG_PRINT("info",("spider this=%p", this)); - str->length(0); - if ((error_num = append_disable_keys_part(SPIDER_SQL_TYPE_OTHER_HS, - link_idx))) - { - DBUG_RETURN(error_num); - } - pthread_mutex_assert_not_owner(&conn->mta_conn_mutex); - pthread_mutex_lock(&conn->mta_conn_mutex); - SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos); - conn->need_mon = &spider->need_mons[link_idx]; - DBUG_ASSERT(!conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = TRUE; - conn->mta_conn_mutex_unlock_later = TRUE; - if ((error_num = spider_db_set_names(spider, conn, link_idx))) - { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - DBUG_RETURN(error_num); - } - spider_conn_set_timeout_from_share(conn, link_idx, - spider->wide_handler->trx->thd, - share); - if (spider_db_query( - conn, - str->ptr(), - str->length(), - -1, - &spider->need_mons[link_idx]) - ) { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - error_num = spider_db_errorno(conn); - DBUG_RETURN(error_num); - } - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - DBUG_RETURN(0); -} - -int spider_oracle_handler::enable_keys( - SPIDER_CONN *conn, - int link_idx -) { - int error_num; - SPIDER_SHARE *share = spider->share; - spider_string *str = &spider->result_list.sqls[link_idx]; - DBUG_ENTER("spider_oracle_handler::enable_keys"); - DBUG_PRINT("info",("spider this=%p", this)); - str->length(0); - if ((error_num = append_enable_keys_part(SPIDER_SQL_TYPE_OTHER_HS, - link_idx))) - { - DBUG_RETURN(error_num); - } - pthread_mutex_assert_not_owner(&conn->mta_conn_mutex); - pthread_mutex_lock(&conn->mta_conn_mutex); - SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos); - conn->need_mon = &spider->need_mons[link_idx]; - DBUG_ASSERT(!conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = TRUE; - conn->mta_conn_mutex_unlock_later = TRUE; - if ((error_num = spider_db_set_names(spider, conn, link_idx))) - { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - DBUG_RETURN(error_num); - } - spider_conn_set_timeout_from_share(conn, link_idx, - spider->wide_handler->trx->thd, - share); - if (spider_db_query( - conn, - str->ptr(), - str->length(), - -1, - &spider->need_mons[link_idx]) - ) { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - error_num = spider_db_errorno(conn); - DBUG_RETURN(error_num); - } - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - DBUG_RETURN(0); -} - -int spider_oracle_handler::check_table( - SPIDER_CONN *conn, - int link_idx, - HA_CHECK_OPT* check_opt -) { - int error_num; - SPIDER_SHARE *share = spider->share; - spider_string *str = &spider->result_list.sqls[link_idx]; - DBUG_ENTER("spider_oracle_handler::check_table"); - DBUG_PRINT("info",("spider this=%p", this)); - str->length(0); - if ((error_num = append_check_table_part(SPIDER_SQL_TYPE_OTHER_HS, - link_idx, check_opt))) - { - DBUG_RETURN(error_num); - } - pthread_mutex_assert_not_owner(&conn->mta_conn_mutex); - pthread_mutex_lock(&conn->mta_conn_mutex); - SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos); - conn->need_mon = &spider->need_mons[link_idx]; - DBUG_ASSERT(!conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = TRUE; - conn->mta_conn_mutex_unlock_later = TRUE; - if ((error_num = spider_db_set_names(spider, conn, link_idx))) - { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - DBUG_RETURN(error_num); - } - spider_conn_set_timeout_from_share(conn, link_idx, - spider->wide_handler->trx->thd, - share); - if (spider_db_query( - conn, - str->ptr(), - str->length(), - -1, - &spider->need_mons[link_idx]) - ) { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - error_num = spider_db_errorno(conn); - DBUG_RETURN(error_num); - } - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - DBUG_RETURN(0); -} - -int spider_oracle_handler::repair_table( - SPIDER_CONN *conn, - int link_idx, - HA_CHECK_OPT* check_opt -) { - int error_num; - SPIDER_SHARE *share = spider->share; - spider_string *str = &spider->result_list.sqls[link_idx]; - DBUG_ENTER("spider_oracle_handler::repair_table"); - DBUG_PRINT("info",("spider this=%p", this)); - str->length(0); - if ((error_num = append_repair_table_part(SPIDER_SQL_TYPE_OTHER_HS, - link_idx, check_opt))) - { - DBUG_RETURN(error_num); - } - pthread_mutex_assert_not_owner(&conn->mta_conn_mutex); - pthread_mutex_lock(&conn->mta_conn_mutex); - SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos); - conn->need_mon = &spider->need_mons[link_idx]; - DBUG_ASSERT(!conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = TRUE; - conn->mta_conn_mutex_unlock_later = TRUE; - if ((error_num = spider_db_set_names(spider, conn, link_idx))) - { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - DBUG_RETURN(error_num); - } - spider_conn_set_timeout_from_share(conn, link_idx, - spider->wide_handler->trx->thd, - share); - if (spider_db_query( - conn, - str->ptr(), - str->length(), - -1, - &spider->need_mons[link_idx]) - ) { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - error_num = spider_db_errorno(conn); - DBUG_RETURN(error_num); - } - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - DBUG_RETURN(0); -} - -int spider_oracle_handler::analyze_table( - SPIDER_CONN *conn, - int link_idx -) { - int error_num; - SPIDER_SHARE *share = spider->share; - spider_string *str = &spider->result_list.sqls[link_idx]; - DBUG_ENTER("spider_oracle_handler::analyze_table"); - DBUG_PRINT("info",("spider this=%p", this)); - str->length(0); - if ((error_num = append_analyze_table_part(SPIDER_SQL_TYPE_OTHER_HS, - link_idx))) - { - DBUG_RETURN(error_num); - } - pthread_mutex_assert_not_owner(&conn->mta_conn_mutex); - pthread_mutex_lock(&conn->mta_conn_mutex); - SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos); - conn->need_mon = &spider->need_mons[link_idx]; - DBUG_ASSERT(!conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = TRUE; - conn->mta_conn_mutex_unlock_later = TRUE; - if ((error_num = spider_db_set_names(spider, conn, link_idx))) - { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - DBUG_RETURN(error_num); - } - spider_conn_set_timeout_from_share(conn, link_idx, - spider->wide_handler->trx->thd, - share); - if (spider_db_query( - conn, - str->ptr(), - str->length(), - -1, - &spider->need_mons[link_idx]) - ) { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - error_num = spider_db_errorno(conn); - DBUG_RETURN(error_num); - } - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - DBUG_RETURN(0); -} - -int spider_oracle_handler::optimize_table( - SPIDER_CONN *conn, - int link_idx -) { - int error_num; - SPIDER_SHARE *share = spider->share; - spider_string *str = &spider->result_list.sqls[link_idx]; - DBUG_ENTER("spider_oracle_handler::optimize_table"); - DBUG_PRINT("info",("spider this=%p", this)); - str->length(0); - if ((error_num = append_optimize_table_part(SPIDER_SQL_TYPE_OTHER_HS, - link_idx))) - { - DBUG_RETURN(error_num); - } - pthread_mutex_assert_not_owner(&conn->mta_conn_mutex); - pthread_mutex_lock(&conn->mta_conn_mutex); - SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos); - conn->need_mon = &spider->need_mons[link_idx]; - DBUG_ASSERT(!conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = TRUE; - conn->mta_conn_mutex_unlock_later = TRUE; - if ((error_num = spider_db_set_names(spider, conn, link_idx))) - { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - DBUG_RETURN(error_num); - } - spider_conn_set_timeout_from_share(conn, link_idx, - spider->wide_handler->trx->thd, - share); - if (spider_db_query( - conn, - str->ptr(), - str->length(), - -1, - &spider->need_mons[link_idx]) - ) { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - error_num = spider_db_errorno(conn); - DBUG_RETURN(error_num); - } - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - DBUG_RETURN(0); -} - -int spider_oracle_handler::flush_tables( - SPIDER_CONN *conn, - int link_idx, - bool lock -) { - int error_num; - SPIDER_SHARE *share = spider->share; - spider_string *str = &spider->result_list.sqls[link_idx]; - DBUG_ENTER("spider_oracle_handler::flush_tables"); - DBUG_PRINT("info",("spider this=%p", this)); - str->length(0); - if ((error_num = append_flush_tables_part(SPIDER_SQL_TYPE_OTHER_HS, - link_idx, lock))) - { - DBUG_RETURN(error_num); - } - spider_conn_set_timeout_from_share(conn, link_idx, - spider->wide_handler->trx->thd, - share); - pthread_mutex_assert_not_owner(&conn->mta_conn_mutex); - pthread_mutex_lock(&conn->mta_conn_mutex); - SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos); - conn->need_mon = &spider->need_mons[link_idx]; - DBUG_ASSERT(!conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = TRUE; - conn->mta_conn_mutex_unlock_later = TRUE; - if (spider_db_query( - conn, - str->ptr(), - str->length(), - -1, - &spider->need_mons[link_idx]) - ) { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - error_num = spider_db_errorno(conn); - DBUG_RETURN(error_num); - } - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - DBUG_RETURN(0); -} - -int spider_oracle_handler::flush_logs( - SPIDER_CONN *conn, - int link_idx -) { - int error_num; - SPIDER_SHARE *share = spider->share; - DBUG_ENTER("spider_oracle_handler::flush_logs"); - DBUG_PRINT("info",("spider this=%p", this)); - spider_conn_set_timeout_from_share(conn, link_idx, - spider->wide_handler->trx->thd, - share); - pthread_mutex_assert_not_owner(&conn->mta_conn_mutex); - pthread_mutex_lock(&conn->mta_conn_mutex); - SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos); - conn->need_mon = &spider->need_mons[link_idx]; - DBUG_ASSERT(!conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = TRUE; - conn->mta_conn_mutex_unlock_later = TRUE; - if (spider_db_query( - conn, - SPIDER_SQL_FLUSH_LOGS_STR, - SPIDER_SQL_FLUSH_LOGS_LEN, - -1, - &spider->need_mons[link_idx]) - ) { - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - error_num = spider_db_errorno(conn); - DBUG_RETURN(error_num); - } - DBUG_ASSERT(conn->mta_conn_mutex_lock_already); - DBUG_ASSERT(conn->mta_conn_mutex_unlock_later); - conn->mta_conn_mutex_lock_already = FALSE; - conn->mta_conn_mutex_unlock_later = FALSE; - SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); - pthread_mutex_unlock(&conn->mta_conn_mutex); - DBUG_RETURN(0); -} - -int spider_oracle_handler::insert_opened_handler( - SPIDER_CONN *conn, - int link_idx -) { - spider_db_oracle *db_conn = (spider_db_oracle *) conn->db_conn; - SPIDER_LINK_FOR_HASH *tmp_link_for_hash = &link_for_hash[link_idx]; - DBUG_ASSERT(tmp_link_for_hash->spider == spider); - DBUG_ASSERT(tmp_link_for_hash->link_idx == link_idx); - uint old_elements = db_conn->handler_open_array.max_element; - DBUG_ENTER("spider_oracle_handler::insert_opened_handler"); - DBUG_PRINT("info",("spider this=%p", this)); - if (insert_dynamic(&db_conn->handler_open_array, - (uchar*) &tmp_link_for_hash)) - { - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - if (db_conn->handler_open_array.max_element > old_elements) - { - spider_alloc_calc_mem(spider_current_trx, - db_conn->handler_open_array, - (db_conn->handler_open_array.max_element - old_elements) * - db_conn->handler_open_array.size_of_element); - } - DBUG_RETURN(0); -} - -int spider_oracle_handler::delete_opened_handler( - SPIDER_CONN *conn, - int link_idx -) { - spider_db_oracle *db_conn = (spider_db_oracle *) conn->db_conn; - uint roop_count, elements = db_conn->handler_open_array.elements; - SPIDER_LINK_FOR_HASH *tmp_link_for_hash; - DBUG_ENTER("spider_oracle_handler::delete_opened_handler"); - DBUG_PRINT("info",("spider this=%p", this)); - for (roop_count = 0; roop_count < elements; roop_count++) - { - get_dynamic(&db_conn->handler_open_array, (uchar *) &tmp_link_for_hash, - roop_count); - if (tmp_link_for_hash == &link_for_hash[link_idx]) - { - delete_dynamic_element(&db_conn->handler_open_array, roop_count); - break; - } - } - DBUG_ASSERT(roop_count < elements); - DBUG_RETURN(0); -} - -int spider_oracle_handler::sync_from_clone_source( - spider_db_handler *dbton_hdl -) { - DBUG_ENTER("spider_oracle_handler::sync_from_clone_source"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(0); -} - -bool spider_oracle_handler::support_use_handler( - int use_handler -) { - DBUG_ENTER("spider_oracle_handler::support_use_handler"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(FALSE); -} - -void spider_oracle_handler::minimum_select_bitmap_create() -{ - TABLE *table = spider->get_table(); - Field **field_p; - DBUG_ENTER("spider_oracle_handler::minimum_select_bitmap_create"); - memset(minimum_select_bitmap, 0, no_bytes_in_map(table->read_set)); - if ( - spider->use_index_merge || -#ifdef HA_CAN_BULK_ACCESS - (spider->is_clone && !spider->is_bulk_access_clone) -#else - spider->is_clone -#endif - ) { - /* need preparing for cmp_ref */ - TABLE_SHARE *table_share = table->s; - if ( - table_share->primary_key == MAX_KEY - ) { - /* need all columns */ - memset(minimum_select_bitmap, 0xFF, no_bytes_in_map(table->read_set)); - DBUG_VOID_RETURN; - } else { - /* need primary key columns */ - uint roop_count; - KEY *key_info; - KEY_PART_INFO *key_part; - Field *field; - key_info = &table_share->key_info[table_share->primary_key]; - key_part = key_info->key_part; - for (roop_count = 0; - roop_count < spider_user_defined_key_parts(key_info); - roop_count++) - { - field = key_part[roop_count].field; - spider_set_bit(minimum_select_bitmap, field->field_index); - } - } - } - for (field_p = table->field; *field_p; field_p++) - { - uint field_index = (*field_p)->field_index; - if ( - spider_bit_is_set(spider->searched_bitmap, field_index) || - bitmap_is_set(table->read_set, field_index) || - bitmap_is_set(table->write_set, field_index) - ) { - spider_set_bit(minimum_select_bitmap, field_index); - } - } - DBUG_VOID_RETURN; -} - -bool spider_oracle_handler::minimum_select_bit_is_set( - uint field_index -) { - DBUG_ENTER("spider_oracle_handler::minimum_select_bit_is_set"); - DBUG_PRINT("info",("spider field_index=%u", field_index)); - DBUG_PRINT("info",("spider minimum_select_bitmap=%s", - spider_bit_is_set(minimum_select_bitmap, field_index) ? - "TRUE" : "FALSE")); - DBUG_RETURN(spider_bit_is_set(minimum_select_bitmap, field_index)); -} - -void spider_oracle_handler::copy_minimum_select_bitmap( - uchar *bitmap -) { - int roop_count; - TABLE *table = spider->get_table(); - DBUG_ENTER("spider_oracle_handler::copy_minimum_select_bitmap"); - for (roop_count = 0; - roop_count < (int) ((table->s->fields + 7) / 8); - roop_count++) - { - bitmap[roop_count] = - minimum_select_bitmap[roop_count]; - DBUG_PRINT("info",("spider roop_count=%d", roop_count)); - DBUG_PRINT("info",("spider bitmap=%d", - bitmap[roop_count])); - } - DBUG_VOID_RETURN; -} - -int spider_oracle_handler::init_union_table_name_pos() -{ - DBUG_ENTER("spider_oracle_handler::init_union_table_name_pos"); - DBUG_PRINT("info",("spider this=%p", this)); - if (!union_table_name_pos_first) - { - if (!spider_bulk_malloc(spider_current_trx, 238, MYF(MY_WME), - &union_table_name_pos_first, (uint) (sizeof(SPIDER_INT_HLD)), - NullS) - ) { - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - union_table_name_pos_first->next = NULL; - } - union_table_name_pos_current = union_table_name_pos_first; - union_table_name_pos_current->tgt_num = 0; - DBUG_RETURN(0); -} - -int spider_oracle_handler::set_union_table_name_pos() -{ - DBUG_ENTER("spider_oracle_handler::set_union_table_name_pos"); - DBUG_PRINT("info",("spider this=%p", this)); - if (union_table_name_pos_current->tgt_num >= SPIDER_INT_HLD_TGT_SIZE) - { - if (!union_table_name_pos_current->next) - { - if (!spider_bulk_malloc(spider_current_trx, 239, MYF(MY_WME), - &union_table_name_pos_current->next, (uint) (sizeof(SPIDER_INT_HLD)), - NullS) - ) { - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - union_table_name_pos_current->next->next = NULL; - } - union_table_name_pos_current = union_table_name_pos_current->next; - union_table_name_pos_current->tgt_num = 0; - } - union_table_name_pos_current->tgt[union_table_name_pos_current->tgt_num] = - table_name_pos; - ++union_table_name_pos_current->tgt_num; - DBUG_RETURN(0); -} - -int spider_oracle_handler::reset_union_table_name( - spider_string *str, - int link_idx, - ulong sql_type -) { - DBUG_ENTER("spider_oracle_handler::reset_union_table_name"); - DBUG_PRINT("info",("spider this=%p", this)); - if (!union_table_name_pos_current) - DBUG_RETURN(0); - - SPIDER_INT_HLD *tmp_pos = union_table_name_pos_first; - uint cur_num, pos_backup = str->length(); - while(TRUE) - { - for (cur_num = 0; cur_num < tmp_pos->tgt_num; ++cur_num) - { - str->length(tmp_pos->tgt[cur_num]); - append_table_name_with_adjusting(str, link_idx, sql_type); - } - if (tmp_pos == union_table_name_pos_current) - break; - tmp_pos = tmp_pos->next; - } - str->length(pos_backup); - DBUG_RETURN(0); -} - -#ifdef SPIDER_HAS_GROUP_BY_HANDLER -int spider_oracle_handler::append_from_and_tables_part( - spider_fields *fields, - ulong sql_type -) { - int error_num; - spider_string *str; - SPIDER_TABLE_HOLDER *table_holder; - TABLE_LIST *table_list; - DBUG_ENTER("spider_oracle_handler::append_from_and_tables_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - str = &sql; - break; - default: - DBUG_RETURN(0); - } - fields->set_pos_to_first_table_holder(); - table_holder = fields->get_next_table_holder(); - table_list = table_holder->table->pos_in_table_list; - error_num = spider_db_oracle_utility.append_from_and_tables(fields, str, - table_list); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::reappend_tables_part( - spider_fields *fields, - ulong sql_type -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::reappend_tables_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - str = &sql; - break; - default: - DBUG_RETURN(0); - } - error_num = spider_db_oracle_utility.reappend_tables(fields, - link_idx_chain, str); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_where_part( - ulong sql_type -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_where_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - str = &sql; - break; - default: - DBUG_RETURN(0); - } - error_num = spider_db_oracle_utility.append_where(str); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_having_part( - ulong sql_type -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_having_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - str = &sql; - break; - default: - DBUG_RETURN(0); - } - error_num = spider_db_oracle_utility.append_having(str); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_item_type_part( - Item *item, - const char *alias, - uint alias_length, - bool use_fields, - spider_fields *fields, - ulong sql_type -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_item_type_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - str = &sql; - break; - default: - DBUG_RETURN(0); - } - error_num = spider_db_print_item_type(item, NULL, spider, str, - alias, alias_length, spider_dbton_oracle.dbton_id, use_fields, fields); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_list_item_select_part( - List<Item> *select, - const char *alias, - uint alias_length, - bool use_fields, - spider_fields *fields, - ulong sql_type -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_list_item_select_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - str = &sql; - break; - default: - DBUG_RETURN(0); - } - error_num = append_list_item_select(select, str, alias, alias_length, - use_fields, fields); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_list_item_select( - List<Item> *select, - spider_string *str, - const char *alias, - uint alias_length, - bool use_fields, - spider_fields *fields -) { - int error_num; - uint dbton_id = spider_dbton_oracle.dbton_id, length; - uint32 begin; - List_iterator_fast<Item> it(*select); - Item *item; - Field *field; - const char *item_name; - DBUG_ENTER("spider_oracle_handler::append_list_item_select"); - DBUG_PRINT("info",("spider this=%p", this)); - begin = str->length(); - while ((item = it++)) - { - if (item->const_item()) - { - DBUG_PRINT("info",("spider const item")); - continue; - } - if ((error_num = spider_db_print_item_type(item, NULL, spider, str, - alias, alias_length, dbton_id, use_fields, fields))) - { - DBUG_RETURN(error_num); - } - field = *(fields->get_next_field_ptr()); - if (field) - { - item_name = SPIDER_field_name_str(field); - length = SPIDER_field_name_length(field); - } else { - item_name = SPIDER_item_name_str(item); - length = SPIDER_item_name_length(item); - } - if (str->reserve( - SPIDER_SQL_COMMA_LEN + /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + - SPIDER_SQL_SPACE_LEN + length - )) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN); - if ((error_num = spider_db_oracle_utility.append_escaped_name(str, - item_name, length))) - { - DBUG_RETURN(error_num); - } - str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } - if (begin == str->length()) - { - /* no columns */ - if (str->reserve(SPIDER_SQL_ONE_LEN)) - { - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - str->q_append(SPIDER_SQL_ONE_STR, SPIDER_SQL_ONE_LEN); - } else { - str->length(str->length() - SPIDER_SQL_COMMA_LEN); - } - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_group_by_part( - ORDER *order, - const char *alias, - uint alias_length, - bool use_fields, - spider_fields *fields, - ulong sql_type -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_group_by_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - str = &sql; - break; - default: - DBUG_RETURN(0); - } - error_num = append_group_by(order, str, alias, alias_length, - use_fields, fields); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_group_by( - ORDER *order, - spider_string *str, - const char *alias, - uint alias_length, - bool use_fields, - spider_fields *fields -) { - int error_num; - uint dbton_id = spider_dbton_oracle.dbton_id; - DBUG_ENTER("spider_oracle_handler::append_group_by"); - DBUG_PRINT("info",("spider this=%p", this)); - if (order) - { - if (str->reserve(SPIDER_SQL_GROUP_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_GROUP_STR, SPIDER_SQL_GROUP_LEN); - for (; order; order = order->next) - { - if ((error_num = spider_db_print_item_type((*order->item), NULL, spider, - str, alias, alias_length, dbton_id, use_fields, fields))) - { - DBUG_RETURN(error_num); - } - if (str->reserve(SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } - str->length(str->length() - SPIDER_SQL_COMMA_LEN); - } - DBUG_RETURN(0); -} - -int spider_oracle_handler::append_order_by_part( - ORDER *order, - const char *alias, - uint alias_length, - bool use_fields, - spider_fields *fields, - ulong sql_type -) { - int error_num; - spider_string *str; - DBUG_ENTER("spider_oracle_handler::append_order_by_part"); - DBUG_PRINT("info",("spider this=%p", this)); - switch (sql_type) - { - case SPIDER_SQL_TYPE_SELECT_SQL: - str = &sql; - break; - default: - DBUG_RETURN(0); - } - error_num = append_order_by(order, str, alias, alias_length, - use_fields, fields); - DBUG_RETURN(error_num); -} - -int spider_oracle_handler::append_order_by( - ORDER *order, - spider_string *str, - const char *alias, - uint alias_length, - bool use_fields, - spider_fields *fields -) { - int error_num; - uint dbton_id = spider_dbton_oracle.dbton_id; - DBUG_ENTER("spider_oracle_handler::append_order_by"); - DBUG_PRINT("info",("spider this=%p", this)); - if (order) - { - if (str->reserve(SPIDER_SQL_ORDER_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_ORDER_STR, SPIDER_SQL_ORDER_LEN); - for (; order; order = order->next) - { - if ((error_num = spider_db_print_item_type((*order->item), NULL, spider, - str, alias, alias_length, dbton_id, use_fields, fields))) - { - DBUG_RETURN(error_num); - } -#ifdef SPIDER_ORDER_HAS_ENUM_ORDER - if (order->direction == ORDER::ORDER_DESC) -#else - if (!order->asc) -#endif - { - if (str->reserve(SPIDER_SQL_COMMA_LEN + SPIDER_SQL_DESC_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_DESC_STR, SPIDER_SQL_DESC_LEN); - str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } else { - if (str->reserve(SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } - } - str->length(str->length() - SPIDER_SQL_COMMA_LEN); - } - DBUG_RETURN(0); -} -#endif - -spider_oracle_copy_table::spider_oracle_copy_table( - spider_oracle_share *db_share -) : spider_db_copy_table( - db_share -), - oracle_share(db_share), - pos(0), - table_name_pos(0), - pos_diff(0), - table_lock_mode(0), - select_rownum_appended(FALSE), - first_str(NULL), - current_str(NULL) -{ - DBUG_ENTER("spider_oracle_copy_table::spider_oracle_copy_table"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_VOID_RETURN; -} - -spider_oracle_copy_table::~spider_oracle_copy_table() -{ - DBUG_ENTER("spider_oracle_copy_table::~spider_oracle_copy_table"); - DBUG_PRINT("info",("spider this=%p", this)); - while (first_str) - { - current_str = first_str; - first_str = first_str->next; - delete [] current_str; - } - DBUG_VOID_RETURN; -} - -int spider_oracle_copy_table::init() -{ - DBUG_ENTER("spider_oracle_copy_table::init"); - DBUG_PRINT("info",("spider this=%p", this)); - sql.init_calc_mem(213); - sql_part.init_calc_mem(215); - DBUG_RETURN(0); -} - -void spider_oracle_copy_table::set_sql_charset( - CHARSET_INFO *cs -) { - DBUG_ENTER("spider_oracle_copy_table::set_sql_charset"); - DBUG_PRINT("info",("spider this=%p", this)); - sql.set_charset(cs); - DBUG_VOID_RETURN; -} - -int spider_oracle_copy_table::append_select_str() -{ - DBUG_ENTER("spider_oracle_copy_table::append_select_str"); - DBUG_PRINT("info",("spider this=%p", this)); - if (sql.reserve(SPIDER_SQL_SELECT_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql.q_append(SPIDER_SQL_SELECT_STR, SPIDER_SQL_SELECT_LEN); - DBUG_RETURN(0); -} - -int spider_oracle_copy_table::append_insert_str( - int insert_flg -) { - DBUG_ENTER("spider_oracle_copy_table::append_insert_str"); - DBUG_PRINT("info",("spider this=%p", this)); - if (sql.reserve(SPIDER_SQL_INSERT_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql.q_append(SPIDER_SQL_INSERT_STR, SPIDER_SQL_INSERT_LEN); - DBUG_RETURN(0); -} - -int spider_oracle_copy_table::append_table_columns( - TABLE_SHARE *table_share -) { - int error_num; - Field **field; - DBUG_ENTER("spider_oracle_copy_table::append_table_columns"); - DBUG_PRINT("info",("spider this=%p", this)); - for (field = table_share->field; *field; field++) - { - if (sql.reserve(SPIDER_SQL_NAME_QUOTE_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql.q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN); - if ((error_num = spider_db_append_name_with_quote_str(&sql, - (*field)->field_name, spider_dbton_oracle.dbton_id))) - DBUG_RETURN(error_num); - if (sql.reserve(SPIDER_SQL_NAME_QUOTE_LEN + SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql.q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN); - sql.q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } - sql.length(sql.length() - SPIDER_SQL_COMMA_LEN); - DBUG_RETURN(0); -} - -int spider_oracle_copy_table::append_from_str() -{ - DBUG_ENTER("spider_oracle_copy_table::append_from_str"); - DBUG_PRINT("info",("spider this=%p", this)); - if (sql.reserve(SPIDER_SQL_FROM_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql.q_append(SPIDER_SQL_FROM_STR, SPIDER_SQL_FROM_LEN); - DBUG_RETURN(0); -} - -int spider_oracle_copy_table::append_table_name( - int link_idx -) { - int error_num; - DBUG_ENTER("spider_oracle_copy_table::append_table_name"); - DBUG_PRINT("info",("spider this=%p", this)); - table_name_pos = sql.length(); - error_num = oracle_share->append_table_name(&sql, link_idx); - store_link_idx = link_idx; - DBUG_RETURN(error_num); -} - -void spider_oracle_copy_table::set_sql_pos() -{ - DBUG_ENTER("spider_oracle_copy_table::set_sql_pos"); - DBUG_PRINT("info",("spider this=%p", this)); - pos = sql.length(); - DBUG_VOID_RETURN; -} - -void spider_oracle_copy_table::set_sql_to_pos() -{ - DBUG_ENTER("spider_oracle_copy_table::set_sql_to_pos"); - DBUG_PRINT("info",("spider this=%p", this)); - sql.length(pos); - DBUG_VOID_RETURN; -} - -int spider_oracle_copy_table::append_copy_where( - spider_db_copy_table *source_ct, - KEY *key_info, - ulong *last_row_pos, - ulong *last_lengths -) { - int error_num, roop_count, roop_count2; - DBUG_ENTER("spider_oracle_copy_table::append_copy_where"); - DBUG_PRINT("info",("spider this=%p", this)); - if (sql.reserve(SPIDER_SQL_WHERE_LEN + SPIDER_SQL_OPEN_PAREN_LEN)) - { - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - sql.q_append(SPIDER_SQL_WHERE_STR, SPIDER_SQL_WHERE_LEN); - sql.q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN); - Field *field; - KEY_PART_INFO *key_part = key_info->key_part; - for (roop_count = spider_user_defined_key_parts(key_info) - 1; - roop_count >= 0; roop_count--) - { - for (roop_count2 = 0; roop_count2 < roop_count; roop_count2++) - { - field = key_part[roop_count2].field; - if ((error_num = copy_key_row(source_ct, - field, &last_row_pos[field->field_index], - &last_lengths[field->field_index], - SPIDER_SQL_EQUAL_STR, SPIDER_SQL_EQUAL_LEN))) - { - DBUG_RETURN(error_num); - } - } - field = key_part[roop_count2].field; - if ((error_num = copy_key_row(source_ct, - field, &last_row_pos[field->field_index], - &last_lengths[field->field_index], - SPIDER_SQL_GT_STR, SPIDER_SQL_GT_LEN))) - { - DBUG_RETURN(error_num); - } - sql.length(sql.length() - SPIDER_SQL_AND_LEN); - if (sql.reserve(SPIDER_SQL_CLOSE_PAREN_LEN + - SPIDER_SQL_OR_LEN + SPIDER_SQL_OPEN_PAREN_LEN)) - { - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - sql.q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN); - sql.q_append(SPIDER_SQL_OR_STR, SPIDER_SQL_OR_LEN); - sql.q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN); - } - sql.length(sql.length() - SPIDER_SQL_OR_LEN - SPIDER_SQL_OPEN_PAREN_LEN); - DBUG_RETURN(0); -} - -int spider_oracle_copy_table::append_key_order_str( - KEY *key_info, - int start_pos, - bool desc_flg -) { - int length, error_num; - KEY_PART_INFO *key_part; - Field *field; - DBUG_ENTER("spider_oracle_copy_table::append_key_order_str"); - DBUG_PRINT("info",("spider this=%p", this)); - if (select_rownum_appended) - { - if (sql.reserve(SPIDER_SQL_SELECT_WRAPPER_TAIL_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql.q_append(SPIDER_SQL_SELECT_WRAPPER_TAIL_STR, - SPIDER_SQL_SELECT_WRAPPER_TAIL_LEN); - DBUG_RETURN(0); - } - sql_part.length(0); - if (sql_part.reserve(sql.length() + SPIDER_SQL_SELECT_WRAPPER_HEAD_LEN + - SPIDER_SQL_ROW_NUMBER_HEAD_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql_part.q_append(SPIDER_SQL_SELECT_WRAPPER_HEAD_STR, - SPIDER_SQL_SELECT_WRAPPER_HEAD_LEN); - sql_part.q_append(sql.ptr(), table_name_pos - SPIDER_SQL_FROM_LEN); - sql_part.q_append(SPIDER_SQL_ROW_NUMBER_HEAD_STR, - SPIDER_SQL_ROW_NUMBER_HEAD_LEN); - if ((int) spider_user_defined_key_parts(key_info) > start_pos) - { - if (desc_flg == TRUE) - { - for ( - key_part = key_info->key_part + start_pos, - length = 0; - length + start_pos < (int) spider_user_defined_key_parts(key_info); - key_part++, - length++ - ) { - field = key_part->field; - if (sql_part.reserve(SPIDER_SQL_NAME_QUOTE_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql_part.q_append(SPIDER_SQL_NAME_QUOTE_STR, - SPIDER_SQL_NAME_QUOTE_LEN); - if ((error_num = spider_db_append_name_with_quote_str(&sql_part, - field->field_name, spider_dbton_oracle.dbton_id))) - DBUG_RETURN(error_num); - if (key_part->key_part_flag & HA_REVERSE_SORT) - { - if (sql_part.reserve(SPIDER_SQL_NAME_QUOTE_LEN + - SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql_part.q_append(SPIDER_SQL_NAME_QUOTE_STR, - SPIDER_SQL_NAME_QUOTE_LEN); - sql_part.q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } else { - if (sql_part.reserve(SPIDER_SQL_NAME_QUOTE_LEN + - SPIDER_SQL_DESC_LEN + SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql_part.q_append(SPIDER_SQL_NAME_QUOTE_STR, - SPIDER_SQL_NAME_QUOTE_LEN); - sql_part.q_append(SPIDER_SQL_DESC_STR, SPIDER_SQL_DESC_LEN); - sql_part.q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } - } - } else { - for ( - key_part = key_info->key_part + start_pos, - length = 0; - length + start_pos < (int) spider_user_defined_key_parts(key_info); - key_part++, - length++ - ) { - field = key_part->field; - if (sql_part.reserve(SPIDER_SQL_NAME_QUOTE_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql_part.q_append(SPIDER_SQL_NAME_QUOTE_STR, - SPIDER_SQL_NAME_QUOTE_LEN); - if ((error_num = spider_db_append_name_with_quote_str(&sql_part, - field->field_name, spider_dbton_oracle.dbton_id))) - DBUG_RETURN(error_num); - if (key_part->key_part_flag & HA_REVERSE_SORT) - { - if (sql_part.reserve(SPIDER_SQL_NAME_QUOTE_LEN + - SPIDER_SQL_DESC_LEN + SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql_part.q_append(SPIDER_SQL_NAME_QUOTE_STR, - SPIDER_SQL_NAME_QUOTE_LEN); - sql_part.q_append(SPIDER_SQL_DESC_STR, SPIDER_SQL_DESC_LEN); - sql_part.q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } else { - if (sql_part.reserve(SPIDER_SQL_NAME_QUOTE_LEN + - SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql_part.q_append(SPIDER_SQL_NAME_QUOTE_STR, - SPIDER_SQL_NAME_QUOTE_LEN); - sql_part.q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } - } - } - } - if (desc_flg == TRUE) - { - if (sql_part.reserve(SPIDER_SQL_ROW_NUMBER_DESC_TAIL_LEN + - SPIDER_SQL_SELECT_WRAPPER_TAIL_LEN + sql.length() - table_name_pos + - SPIDER_SQL_FROM_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql_part.q_append(SPIDER_SQL_ROW_NUMBER_DESC_TAIL_STR, - SPIDER_SQL_ROW_NUMBER_DESC_TAIL_LEN); - } else { - if (sql_part.reserve(SPIDER_SQL_ROW_NUMBER_TAIL_LEN + - SPIDER_SQL_SELECT_WRAPPER_TAIL_LEN + sql.length() - table_name_pos + - SPIDER_SQL_FROM_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql_part.q_append(SPIDER_SQL_ROW_NUMBER_TAIL_STR, - SPIDER_SQL_ROW_NUMBER_TAIL_LEN); - } - pos_diff = sql_part.length() + SPIDER_SQL_FROM_LEN - table_name_pos; - sql_part.q_append(sql.ptr() + table_name_pos - SPIDER_SQL_FROM_LEN, - sql.length() - table_name_pos + SPIDER_SQL_FROM_LEN); - sql_part.q_append(SPIDER_SQL_SELECT_WRAPPER_TAIL_STR, - SPIDER_SQL_SELECT_WRAPPER_TAIL_LEN); - - if ((int) spider_user_defined_key_parts(key_info) > start_pos) - { - if (sql.reserve(SPIDER_SQL_ORDER_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql.q_append(SPIDER_SQL_ORDER_STR, SPIDER_SQL_ORDER_LEN); - if (desc_flg == TRUE) - { - for ( - key_part = key_info->key_part + start_pos, - length = 0; - length + start_pos < (int) spider_user_defined_key_parts(key_info); - key_part++, - length++ - ) { - field = key_part->field; - if (sql.reserve(SPIDER_SQL_NAME_QUOTE_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql.q_append(SPIDER_SQL_NAME_QUOTE_STR, - SPIDER_SQL_NAME_QUOTE_LEN); - if ((error_num = spider_db_append_name_with_quote_str(&sql, - field->field_name, spider_dbton_oracle.dbton_id))) - DBUG_RETURN(error_num); - if (key_part->key_part_flag & HA_REVERSE_SORT) - { - if (sql.reserve(SPIDER_SQL_NAME_QUOTE_LEN + SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql.q_append(SPIDER_SQL_NAME_QUOTE_STR, - SPIDER_SQL_NAME_QUOTE_LEN); - sql.q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } else { - if (sql.reserve(SPIDER_SQL_NAME_QUOTE_LEN + SPIDER_SQL_DESC_LEN + - SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql.q_append(SPIDER_SQL_NAME_QUOTE_STR, - SPIDER_SQL_NAME_QUOTE_LEN); - sql.q_append(SPIDER_SQL_DESC_STR, SPIDER_SQL_DESC_LEN); - sql.q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } - } - } else { - for ( - key_part = key_info->key_part + start_pos, - length = 0; - length + start_pos < (int) spider_user_defined_key_parts(key_info); - key_part++, - length++ - ) { - field = key_part->field; - if (sql.reserve(SPIDER_SQL_NAME_QUOTE_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql.q_append(SPIDER_SQL_NAME_QUOTE_STR, - SPIDER_SQL_NAME_QUOTE_LEN); - if ((error_num = spider_db_append_name_with_quote_str(&sql, - field->field_name, spider_dbton_oracle.dbton_id))) - DBUG_RETURN(error_num); - if (key_part->key_part_flag & HA_REVERSE_SORT) - { - if (sql.reserve(SPIDER_SQL_NAME_QUOTE_LEN + SPIDER_SQL_DESC_LEN + - SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql.q_append(SPIDER_SQL_NAME_QUOTE_STR, - SPIDER_SQL_NAME_QUOTE_LEN); - sql.q_append(SPIDER_SQL_DESC_STR, SPIDER_SQL_DESC_LEN); - sql.q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } else { - if (sql.reserve(SPIDER_SQL_NAME_QUOTE_LEN + SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql.q_append(SPIDER_SQL_NAME_QUOTE_STR, - SPIDER_SQL_NAME_QUOTE_LEN); - sql.q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - } - } - } - sql.length(sql.length() - SPIDER_SQL_COMMA_LEN); - } - DBUG_RETURN(0); -} - -int spider_oracle_copy_table::append_limit( - longlong offset, - longlong limit -) { - char buf[SPIDER_LONGLONG_LEN + 1]; - uint32 length; - DBUG_ENTER("spider_oracle_copy_table::append_limit"); - DBUG_PRINT("info",("spider this=%p", this)); - if (offset || limit < 9223372036854775807LL) - { - if (!select_rownum_appended) - { - select_rownum_appended = TRUE; - table_name_pos = table_name_pos + pos_diff; - if (sql.copy(sql_part)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - pos = pos + pos_diff; - } - if (offset) - { - if (sql.reserve(SPIDER_SQL_BETWEEN_LEN + SPIDER_SQL_AND_LEN + - ((SPIDER_LONGLONG_LEN) * 2))) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql.q_append(SPIDER_SQL_BETWEEN_STR, SPIDER_SQL_BETWEEN_LEN); - length = (uint32) (my_charset_bin.longlong10_to_str)( - buf, SPIDER_LONGLONG_LEN + 1, -10, offset); - sql.q_append(buf, length); - sql.q_append(SPIDER_SQL_AND_STR, SPIDER_SQL_AND_LEN); - length = (uint32) (my_charset_bin.longlong10_to_str)( - buf, SPIDER_LONGLONG_LEN + 1, -10, limit); - sql.q_append(buf, length); - } else { - if (sql.reserve(SPIDER_SQL_HS_LTEQUAL_LEN + - (SPIDER_LONGLONG_LEN))) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql.q_append(SPIDER_SQL_HS_LTEQUAL_STR, SPIDER_SQL_HS_LTEQUAL_LEN); - length = (uint32) (my_charset_bin.longlong10_to_str)( - buf, SPIDER_LONGLONG_LEN + 1, -10, limit); - sql.q_append(buf, length); - } - } - DBUG_RETURN(0); -} - -int spider_oracle_copy_table::append_into_str() -{ - DBUG_ENTER("spider_oracle_copy_table::append_into_str"); - DBUG_PRINT("info",("spider this=%p", this)); - if (sql.reserve(SPIDER_SQL_INTO_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql.q_append(SPIDER_SQL_INTO_STR, SPIDER_SQL_INTO_LEN); - DBUG_RETURN(0); -} - -int spider_oracle_copy_table::append_open_paren_str() -{ - DBUG_ENTER("spider_oracle_copy_table::append_open_paren_str"); - DBUG_PRINT("info",("spider this=%p", this)); - if (sql.reserve(SPIDER_SQL_OPEN_PAREN_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql.q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN); - DBUG_RETURN(0); -} - -int spider_oracle_copy_table::append_values_str() -{ - DBUG_ENTER("spider_oracle_copy_table::append_values_str"); - DBUG_PRINT("info",("spider this=%p", this)); - if (sql.reserve(SPIDER_SQL_CLOSE_PAREN_LEN + SPIDER_SQL_VALUES_LEN + - SPIDER_SQL_OPEN_PAREN_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql.q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN); - sql.q_append(SPIDER_SQL_VALUES_STR, SPIDER_SQL_VALUES_LEN); - sql.q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN); - DBUG_RETURN(0); -} - -int spider_oracle_copy_table::append_select_lock_str( - int lock_mode -) { - DBUG_ENTER("spider_oracle_copy_table::append_select_lock_str"); - DBUG_PRINT("info",("spider this=%p", this)); - if (select_rownum_appended) - { - int error_num; - table_lock_mode = lock_mode; - sql_part.length(0); - if (sql_part.reserve(SPIDER_SQL_LOCK_TABLE_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql_part.q_append(SPIDER_SQL_LOCK_TABLE_STR, SPIDER_SQL_LOCK_TABLE_LEN); - if ((error_num = oracle_share->append_table_name(&sql_part, - store_link_idx))) - DBUG_RETURN(error_num); - if (lock_mode == SPIDER_LOCK_MODE_EXCLUSIVE) - { - if (sql_part.reserve(SPIDER_SQL_LOCK_TABLE_EXCLUSIVE_MODE_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql_part.q_append(SPIDER_SQL_LOCK_TABLE_EXCLUSIVE_MODE_STR, - SPIDER_SQL_LOCK_TABLE_EXCLUSIVE_MODE_LEN); - } else if (lock_mode == SPIDER_LOCK_MODE_SHARED) - { - if (sql_part.reserve(SPIDER_SQL_LOCK_TABLE_SHARE_MODE_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql_part.q_append(SPIDER_SQL_LOCK_TABLE_SHARE_MODE_STR, - SPIDER_SQL_LOCK_TABLE_SHARE_MODE_LEN); - } - } else { - if (lock_mode == SPIDER_LOCK_MODE_EXCLUSIVE) - { - if (sql.reserve(SPIDER_SQL_FOR_UPDATE_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql.q_append(SPIDER_SQL_FOR_UPDATE_STR, SPIDER_SQL_FOR_UPDATE_LEN); - } else if (lock_mode == SPIDER_LOCK_MODE_SHARED) - { - if (sql.reserve(SPIDER_SQL_FOR_UPDATE_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql.q_append(SPIDER_SQL_FOR_UPDATE_STR, SPIDER_SQL_FOR_UPDATE_LEN); - } - } - DBUG_RETURN(0); -} - -int spider_oracle_copy_table::exec_query( - SPIDER_CONN *conn, - int quick_mode, - int *need_mon -) { - int error_num = 0; - DBUG_ENTER("spider_oracle_copy_table::exec_query"); - DBUG_PRINT("info",("spider this=%p", this)); - if (current_str) - { - spider_string *tmp_str = first_str; - while (tmp_str && tmp_str != current_str) - { - if ( - (error_num = spider_db_query(conn, tmp_str->ptr(), tmp_str->length(), - quick_mode, need_mon)) && - error_num != HA_ERR_FOUND_DUPP_KEY - ) { - break; - } - tmp_str = tmp_str->next; - } - if (tmp_str == current_str) - { - error_num = spider_db_query(conn, tmp_str->ptr(), tmp_str->length(), - quick_mode, need_mon); - } - if (error_num == HA_ERR_FOUND_DUPP_KEY) - error_num = 0; - current_str = NULL; - } else { - if (table_lock_mode) - { - DBUG_PRINT("info",("spider table_lock_mode=%d", table_lock_mode)); - spider_db_oracle *db_conn = (spider_db_oracle *) conn->db_conn; - db_conn->table_lock_mode = table_lock_mode; - db_conn->exec_lock_sql = &sql_part; - table_lock_mode = 0; - } - error_num = spider_db_query(conn, sql.ptr(), sql.length(), quick_mode, - need_mon); - } - DBUG_RETURN(error_num); -} - -int spider_oracle_copy_table::copy_key_row( - spider_db_copy_table *source_ct, - Field *field, - ulong *row_pos, - ulong *length, - const char *joint_str, - const int joint_length -) { - int error_num; - spider_string *source_str = &((spider_oracle_copy_table *) source_ct)->sql; - DBUG_ENTER("spider_oracle_copy_table::copy_key_row"); - DBUG_PRINT("info",("spider this=%p", this)); - if (sql.reserve(SPIDER_SQL_NAME_QUOTE_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql.q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN); - if ((error_num = spider_db_append_name_with_quote_str(&sql, - field->field_name, spider_dbton_oracle.dbton_id))) - DBUG_RETURN(error_num); - if (sql.reserve(SPIDER_SQL_NAME_QUOTE_LEN + joint_length + *length + - SPIDER_SQL_AND_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - sql.q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN); - sql.q_append(joint_str, joint_length); - sql.q_append(source_str->ptr() + *row_pos, *length); - sql.q_append(SPIDER_SQL_AND_STR, SPIDER_SQL_AND_LEN); - DBUG_RETURN(0); -} - -int spider_oracle_copy_table::copy_row( - Field *field, - SPIDER_DB_ROW *row -) { - int error_num; - DBUG_ENTER("spider_oracle_copy_table::copy_row"); - DBUG_PRINT("info",("spider this=%p", this)); - if (row->is_null()) - { - DBUG_PRINT("info",("spider column is null")); - if (current_str->reserve(SPIDER_SQL_NULL_LEN + SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - current_str->q_append(SPIDER_SQL_NULL_STR, SPIDER_SQL_NULL_LEN); - } else if (field->str_needs_quotes()) - { - DBUG_PRINT("info",("spider str_needs_quotes")); - if (current_str->reserve(SPIDER_SQL_VALUE_QUOTE_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - current_str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, - SPIDER_SQL_VALUE_QUOTE_LEN); - if ((error_num = row->append_escaped_to_str(current_str, - spider_dbton_oracle.dbton_id))) - DBUG_RETURN(error_num); - if (current_str->reserve(SPIDER_SQL_VALUE_QUOTE_LEN + - SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - current_str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, - SPIDER_SQL_VALUE_QUOTE_LEN); - } else { - DBUG_PRINT("info",("spider without_quotes")); - if ((error_num = row->append_to_str(current_str))) - DBUG_RETURN(error_num); - if (current_str->reserve(SPIDER_SQL_COMMA_LEN)) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - current_str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN); - DBUG_RETURN(0); -} - -int spider_oracle_copy_table::copy_rows( - TABLE *table, - SPIDER_DB_ROW *row, - ulong **last_row_pos, - ulong **last_lengths -) { - int error_num; - Field **field; - ulong *lengths2, *row_pos2; - DBUG_ENTER("spider_oracle_copy_table::copy_rows"); - DBUG_PRINT("info",("spider this=%p", this)); - if (!current_str) - { - if (!first_str) - { - if (!(first_str = new spider_string[1])) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - first_str->init_calc_mem(216); - first_str->set_charset(sql.charset()); - if (first_str->reserve(sql.length())) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - first_str->q_append(sql.ptr(), sql.length()); - } else { - first_str->length(sql.length()); - } - current_str = first_str; - } else { - if (!current_str->next) - { - if (!(current_str->next = new spider_string[1])) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - current_str->next->init_calc_mem(217); - current_str->next->set_charset(sql.charset()); - if (current_str->next->reserve(sql.length())) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - current_str->next->q_append(sql.ptr(), sql.length()); - } else { - current_str->next->length(sql.length()); - } - current_str = current_str->next; - } - row_pos2 = *last_row_pos; - lengths2 = *last_lengths; - - for ( - field = table->field; - *field; - field++, - lengths2++ - ) { - *row_pos2 = current_str->length(); - if ((error_num = - copy_row(*field, row))) - DBUG_RETURN(error_num); - *lengths2 = current_str->length() - *row_pos2 - SPIDER_SQL_COMMA_LEN; - row->next(); - row_pos2++; - } - current_str->length(current_str->length() - SPIDER_SQL_COMMA_LEN); - if (current_str->reserve(SPIDER_SQL_CLOSE_PAREN_LEN)) - { - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - current_str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, - SPIDER_SQL_CLOSE_PAREN_LEN); - DBUG_PRINT("info",("spider current_str=%s", current_str->c_ptr_safe())); - DBUG_RETURN(0); -} - -int spider_oracle_copy_table::copy_rows( - TABLE *table, - SPIDER_DB_ROW *row -) { - int error_num; - Field **field; - DBUG_ENTER("spider_oracle_copy_table::copy_rows"); - DBUG_PRINT("info",("spider this=%p", this)); - if (!current_str) - { - if (!first_str) - { - if (!(first_str = new spider_string[1])) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - first_str->init_calc_mem(218); - first_str->set_charset(sql.charset()); - if (first_str->reserve(sql.length())) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - first_str->q_append(sql.ptr(), sql.length()); - } else { - first_str->length(sql.length()); - } - current_str = first_str; - } else { - if (!current_str->next) - { - if (!(current_str->next = new spider_string[1])) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - current_str->next->init_calc_mem(219); - current_str->next->set_charset(sql.charset()); - if (current_str->next->reserve(sql.length())) - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - current_str->next->q_append(sql.ptr(), sql.length()); - } else { - current_str->next->length(sql.length()); - } - current_str = current_str->next; - } - - for ( - field = table->field; - *field; - field++ - ) { - if ((error_num = - copy_row(*field, row))) - DBUG_RETURN(error_num); - row->next(); - } - current_str->length(current_str->length() - SPIDER_SQL_COMMA_LEN); - if (current_str->reserve(SPIDER_SQL_CLOSE_PAREN_LEN)) - { - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - current_str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, - SPIDER_SQL_CLOSE_PAREN_LEN); - DBUG_PRINT("info",("spider current_str=%s", current_str->c_ptr_safe())); - DBUG_RETURN(0); -} - -int spider_oracle_copy_table::append_insert_terminator() -{ - DBUG_ENTER("spider_oracle_copy_table::append_insert_terminator"); - DBUG_PRINT("info",("spider this=%p", this)); - DBUG_RETURN(0); -} - -int spider_oracle_copy_table::copy_insert_values( - spider_db_copy_table *source_ct -) { - spider_oracle_copy_table *tmp_ct = (spider_oracle_copy_table *) source_ct; - spider_string *source_str = &tmp_ct->sql; - int values_length = source_str->length() - tmp_ct->pos; - const char *values_ptr = source_str->ptr() + tmp_ct->pos; - DBUG_ENTER("spider_oracle_copy_table::copy_insert_values"); - DBUG_PRINT("info",("spider this=%p", this)); - if (sql.reserve(values_length)) - { - DBUG_RETURN(HA_ERR_OUT_OF_MEM); - } - sql.q_append(values_ptr, values_length); - DBUG_RETURN(0); -} -#endif diff --git a/storage/spider/spd_db_oracle.h b/storage/spider/spd_db_oracle.h deleted file mode 100644 index 357fee35c67..00000000000 --- a/storage/spider/spd_db_oracle.h +++ /dev/null @@ -1,1559 +0,0 @@ -/* Copyright (C) 2012-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 */ - -class spider_db_oracle; -class spider_db_oracle_result; - -class spider_db_oracle_util: public spider_db_util -{ -public: - spider_db_oracle_util(); - ~spider_db_oracle_util(); - int append_name( - spider_string *str, - const char *name, - uint name_length - ); - int append_name_with_charset( - spider_string *str, - const char *name, - uint name_length, - CHARSET_INFO *name_charset - ); - int append_escaped_name( - spider_string *str, - const char *name, - uint name_length - ); - int append_escaped_name_with_charset( - spider_string *str, - const char *name, - uint name_length, - CHARSET_INFO *name_charset - ); - bool is_name_quote( - const char head_code - ); - int append_escaped_name_quote( - spider_string *str - ); - int append_column_value( - ha_spider *spider, - spider_string *str, - Field *field, - const uchar *new_ptr, - CHARSET_INFO *access_charset - ); - int append_from_with_alias( - spider_string *str, - const char **table_names, - uint *table_name_lengths, - const char **table_aliases, - uint *table_alias_lengths, - uint table_count, - int *table_name_pos, - bool over_write - ); - int append_trx_isolation( - spider_string *str, - int trx_isolation - ); - int append_autocommit( - spider_string *str, - bool autocommit - ); - int append_sql_log_off( - spider_string *str, - bool sql_log_off - ); - int append_wait_timeout( - spider_string *str, - int wait_timeout - ); - int append_sql_mode( - spider_string *str, - sql_mode_t sql_mode - ); - int append_time_zone( - spider_string *str, - Time_zone *time_zone - ); - int append_start_transaction( - spider_string *str - ); - int append_xa_start( - spider_string *str, - XID *xid - ); - int append_lock_table_head( - spider_string *str - ); - int append_lock_table_body( - spider_string *str, - const char *db_name, - uint db_name_length, - CHARSET_INFO *db_name_charset, - const char *table_name, - uint table_name_length, - CHARSET_INFO *table_name_charset, - int lock_type - ); - int append_lock_table_tail( - spider_string *str - ); - int append_unlock_table( - spider_string *str - ); - int open_item_func( - Item_func *item_func, - ha_spider *spider, - spider_string *str, - const char *alias, - uint alias_length, - bool use_fields, - spider_fields *fields - ); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE - int open_item_sum_func( - Item_sum *item_sum, - ha_spider *spider, - spider_string *str, - const char *alias, - uint alias_length, - bool use_fields, - spider_fields *fields - ); -#endif - size_t escape_string( - char *to, - const char *from, - size_t from_length, - CHARSET_INFO *access_charset - ); - int append_escaped_util( - spider_string *to, - String *from - ); -#ifdef SPIDER_HAS_GROUP_BY_HANDLER - int append_from_and_tables( - ha_spider *spider, - spider_fields *fields, - spider_string *str, - TABLE_LIST *table_list, - uint table_count - ); - int reappend_tables( - spider_fields *fields, - SPIDER_LINK_IDX_CHAIN *link_idx_chain, - spider_string *str - ); - int append_where( - spider_string *str - ); - int append_having( - spider_string *str - ); -#endif -}; - -class spider_db_oracle_row: public spider_db_row -{ -public: - spider_db_oracle *db_conn; - spider_db_oracle_result *result; - sb2 *ind; - char **val; - ub2 *rlen; - sb2 *ind_first; - char **val_first; - ub2 *rlen_first; - spider_string *val_str; - spider_string *val_str_first; - OCIDefine **defnp; - OCILobLocator **lobhp; - OCIParam **colhp; - ub2 *coltp; - ub2 *colsz; - uint field_count; - uint record_size; - ulong *row_size; - ulong *row_size_first; - CHARSET_INFO *access_charset; - bool cloned; - spider_db_oracle_util util; - - spider_db_oracle_row(); - ~spider_db_oracle_row(); - int store_to_field( - Field *field, - CHARSET_INFO *access_charset - ); - int append_to_str( - spider_string *str - ); - int append_escaped_to_str( - spider_string *str, - uint dbton_id - ); - void first(); - void next(); - bool is_null(); - int val_int(); - double val_real(); - my_decimal *val_decimal( - my_decimal *decimal_value, - CHARSET_INFO *access_charset - ); - SPIDER_DB_ROW *clone(); - int store_to_tmp_table( - TABLE *tmp_table, - spider_string *str - ); - uint get_byte_size(); - /* for oracle */ - int init(); - void deinit(); - int define(); - int fetch(); -}; - -class spider_db_oracle_result: public spider_db_result -{ -public: - spider_db_oracle *db_conn; - OCIStmt *stmtp; - uint field_count; - CHARSET_INFO *access_charset; - bool fetched; - spider_db_oracle_row row; - int store_error_num; - - spider_db_oracle_result(SPIDER_DB_CONN *in_db_conn); - ~spider_db_oracle_result(); - bool has_result(); - void free_result(); - SPIDER_DB_ROW *current_row(); - SPIDER_DB_ROW *fetch_row(); - SPIDER_DB_ROW *fetch_row_from_result_buffer( - spider_db_result_buffer *spider_res_buf - ); - SPIDER_DB_ROW *fetch_row_from_tmp_table( - TABLE *tmp_table - ); - int fetch_table_status( - int mode, - ha_statistics &stat - ); - int fetch_table_records( - int mode, - ha_rows &records - ); - int fetch_table_cardinality( - int mode, - TABLE *table, - longlong *cardinality, - uchar *cardinality_upd, - int bitmap_size - ); - int fetch_table_mon_status( - int &status - ); - longlong num_rows(); - uint num_fields(); - void move_to_pos( - longlong pos - ); - int get_errno(); -#ifdef SPIDER_HAS_DISCOVER_TABLE_STRUCTURE - int fetch_columns_for_discover_table_structure( - spider_string *str, - CHARSET_INFO *access_charset - ); - int fetch_index_for_discover_table_structure( - spider_string *str, - CHARSET_INFO *access_charset - ); - int fetch_table_for_discover_table_structure( - spider_string *str, - SPIDER_SHARE *spider_share, - CHARSET_INFO *access_charset - ); -#endif - /* for oracle */ - int set_column_info(); -}; - -class spider_db_oracle: public spider_db_conn -{ -public: - OCIEnv *envhp; - OCIError *errhp; - OCIServer *srvhp; - OCISvcCtx *svchp; - OCISession *usrhp; - OCIStmt *stmtp; - OCITrans *txnhp; - spider_db_oracle_result *result; - int stored_error_num; - const char *stored_error; - uint update_rows; - int table_lock_mode; - spider_string *exec_lock_sql; - spider_db_oracle_util util; - ulonglong stored_last_insert_id; - HASH lock_table_hash; - bool lock_table_hash_inited; - uint lock_table_hash_id; - const char *lock_table_hash_func_name; - const char *lock_table_hash_file_name; - ulong lock_table_hash_line_no; - DYNAMIC_ARRAY handler_open_array; - bool handler_open_array_inited; - uint handler_open_array_id; - const char *handler_open_array_func_name; - const char *handler_open_array_file_name; - ulong handler_open_array_line_no; - - /* for bg_connect */ - char stored_error_msg[MYSQL_ERRMSG_SIZE]; - char *tgt_host; - char *tgt_username; - char *tgt_password; - long tgt_port; - char *tgt_socket; - char *server_name; - int connect_retry_count; - longlong connect_retry_interval; - - spider_db_oracle( - SPIDER_CONN *conn - ); - ~spider_db_oracle(); - int init(); - bool is_connected(); - void bg_connect(); - int connect( - char *tgt_host, - char *tgt_username, - char *tgt_password, - long tgt_port, - char *tgt_socket, - char *server_name, - int connect_retry_count, - longlong connect_retry_interval - ); - int ping(); - void bg_disconnect(); - void disconnect(); - int set_net_timeout(); - int exec_query( - const char *query, - uint length, - int quick_mode - ); - int get_errno(); - const char *get_error(); - bool is_server_gone_error( - int error_num - ); - bool is_dup_entry_error( - int error_num - ); - bool is_xa_nota_error( - int error_num - ); - spider_db_result *store_result( - spider_db_result_buffer **spider_res_buf, - st_spider_db_request_key *request_key, - int *error_num - ); - spider_db_result *use_result( - ha_spider *spider, - st_spider_db_request_key *request_key, - int *error_num - ); - int next_result(); - uint affected_rows(); - uint matched_rows(); - bool inserted_info( - spider_db_handler *handler, - ha_copy_info *copy_info - ); - ulonglong last_insert_id(); - int set_character_set( - const char *csname - ); - int select_db( - const char *dbname - ); - int consistent_snapshot( - int *need_mon - ); - bool trx_start_in_bulk_sql(); - int start_transaction( - int *need_mon - ); - int commit( - int *need_mon - ); - int rollback( - int *need_mon - ); - bool xa_start_in_bulk_sql(); - int xa_start( - XID *xid, - int *need_mon - ); - int xa_end( - XID *xid, - int *need_mon - ); - int xa_prepare( - XID *xid, - int *need_mon - ); - int xa_commit( - XID *xid, - int *need_mon - ); - int xa_rollback( - XID *xid, - int *need_mon - ); - bool set_trx_isolation_in_bulk_sql(); - int set_trx_isolation( - int trx_isolation, - int *need_mon - ); - bool set_autocommit_in_bulk_sql(); - int set_autocommit( - bool autocommit, - int *need_mon - ); - bool set_sql_log_off_in_bulk_sql(); - int set_sql_log_off( - bool sql_log_off, - int *need_mon - ); - bool set_wait_timeout_in_bulk_sql(); - int set_wait_timeout( - int wait_timeout, - int *need_mon - ); - bool set_sql_mode_in_bulk_sql(); - int set_sql_mode( - sql_mode_t sql_mode, - int *need_mon - ); - bool set_time_zone_in_bulk_sql(); - int set_time_zone( - Time_zone *time_zone, - int *need_mon - ); - int show_master_status( - SPIDER_TRX *trx, - SPIDER_SHARE *share, - int all_link_idx, - int *need_mon, - TABLE *table, - spider_string *str, - int mode, - SPIDER_DB_RESULT **res1, - SPIDER_DB_RESULT **res2 - ); - size_t escape_string( - char *to, - const char *from, - size_t from_length - ); - bool have_lock_table_list(); - int append_lock_tables( - spider_string *str - ); - int append_unlock_tables( - spider_string *str - ); - uint get_lock_table_hash_count(); - void reset_lock_table_hash(); - uint get_opened_handler_count(); - void reset_opened_handler(); - void set_dup_key_idx( - ha_spider *spider, - int link_idx - ); - bool cmp_request_key_to_snd( - st_spider_db_request_key *request_key - ); -private: - int set_error( - sword res, - dvoid *hndlp, - int error_num, - const char *error1, - const char *error2 - ); -}; - -class spider_oracle_share: public spider_db_share -{ -public: - spider_string *table_select; - int table_select_pos; - spider_string *key_select; - int *key_select_pos; - spider_string *key_hint; - spider_string *show_table_status; - spider_string *show_records; - spider_string *show_autoinc; - spider_string *show_last_insert_id; - spider_string *show_index; - spider_string *table_names_str; - spider_string *db_names_str; - spider_string *db_table_str; - spider_string *nextval_str; -#ifdef SPIDER_HAS_HASH_VALUE_TYPE - my_hash_value_type *db_table_str_hash_value; -#endif - uint table_nm_max_length; - uint db_nm_max_length; - uint nextval_max_length; - spider_string *column_name_str; - bool same_db_table_name; - int first_all_link_idx; - - spider_oracle_share( - st_spider_share *share - ); - ~spider_oracle_share(); - int init(); - uint get_column_name_length( - uint field_index - ); - int append_column_name( - spider_string *str, - uint field_index - ); - int append_column_name_with_alias( - spider_string *str, - uint field_index, - const char *alias, - uint alias_length - ); - int append_table_name( - spider_string *str, - int all_link_idx - ); - int append_table_name_with_adjusting( - spider_string *str, - int all_link_idx - ); - int append_from_with_adjusted_table_name( - spider_string *str, - int *table_name_pos - ); - bool need_change_db_table_name(); -#ifdef SPIDER_HAS_DISCOVER_TABLE_STRUCTURE - int discover_table_structure( - SPIDER_TRX *trx, - SPIDER_SHARE *spider_share, - spider_string *str - ); -#endif -private: - int create_table_names_str(); - void free_table_names_str(); - int create_column_name_str(); - void free_column_name_str(); - int convert_key_hint_str(); - int append_show_table_status(); - void free_show_table_status(); - int append_show_records(); - void free_show_records(); - int append_show_autoinc(); - void free_show_autoinc(); - int append_show_last_insert_id(); - void free_show_last_insert_id(); - int append_show_index(); - void free_show_index(); - int append_table_select(); - int append_key_select( - uint idx - ); -}; - -class spider_oracle_handler: public spider_db_handler -{ - spider_string sql; - spider_string sql_part; - spider_string sql_part2; - spider_string ha_sql; - int where_pos; - int order_pos; - int limit_pos; -public: - int table_name_pos; -private: - int update_set_pos; - int ha_read_pos; - int ha_next_pos; - int ha_where_pos; - int ha_limit_pos; - int ha_table_name_pos; - uint ha_sql_handler_id; - spider_string insert_sql; - int insert_pos; - int insert_table_name_pos; - int nextval_pos; - spider_string update_sql; - TABLE *upd_tmp_tbl; - TMP_TABLE_PARAM upd_tmp_tbl_prm; - spider_string tmp_sql; - int tmp_sql_pos1; /* drop db nm pos at tmp_table_join */ - int tmp_sql_pos2; /* create db nm pos at tmp_table_join */ - int tmp_sql_pos3; /* insert db nm pos at tmp_table_join */ - int tmp_sql_pos4; /* insert val pos at tmp_table_join */ - int tmp_sql_pos5; /* end of drop tbl at tmp_table_join */ - spider_string dup_update_sql; - spider_string *exec_sql; - spider_string *exec_insert_sql; - spider_string *exec_update_sql; - spider_string *exec_tmp_sql; - spider_string *exec_ha_sql; - spider_string *exec_lock_sql; - int table_lock_mode; - bool reading_from_bulk_tmp_table; - bool filled_up; - bool select_rownum_appended; - bool update_rownum_appended; - SPIDER_INT_HLD *union_table_name_pos_first; - SPIDER_INT_HLD *union_table_name_pos_current; -public: - spider_oracle_share *oracle_share; - SPIDER_LINK_FOR_HASH *link_for_hash; - uchar *minimum_select_bitmap; - spider_oracle_handler( - ha_spider *spider, - spider_oracle_share *share - ); - ~spider_oracle_handler(); - int init(); - int spider_oracle_handler::append_index_hint( - spider_string *str, - int link_idx, - ulong sql_type - ); - int append_table_name_with_adjusting( - spider_string *str, - int link_idx, - ulong sql_type - ); - int append_key_column_types( - const key_range *start_key, - spider_string *str - ); - int append_key_join_columns_for_bka( - const key_range *start_key, - spider_string *str, - const char **table_aliases, - uint *table_alias_lengths - ); - int append_tmp_table_and_sql_for_bka( - const key_range *start_key - ); - int reuse_tmp_table_and_sql_for_bka(); - void create_tmp_bka_table_name( - char *tmp_table_name, - int *tmp_table_name_length, - int link_idx - ); - int append_create_tmp_bka_table( - const key_range *start_key, - spider_string *str, - char *tmp_table_name, - int tmp_table_name_length, - int *db_name_pos, - CHARSET_INFO *table_charset - ); - int append_drop_tmp_bka_table( - spider_string *str, - char *tmp_table_name, - int tmp_table_name_length, - int *db_name_pos, - int *drop_table_end_pos, - bool with_semicolon - ); - int append_insert_tmp_bka_table( - const key_range *start_key, - spider_string *str, - char *tmp_table_name, - int tmp_table_name_length, - int *db_name_pos - ); - int append_union_table_and_sql_for_bka( - const key_range *start_key - ); - int reuse_union_table_and_sql_for_bka(); - int append_insert_for_recovery( - ulong sql_type, - int link_idx - ); - int append_update( - const TABLE *table, - my_ptrdiff_t ptr_diff - ); - int append_update( - const TABLE *table, - my_ptrdiff_t ptr_diff, - int link_idx - ); - int append_delete( - const TABLE *table, - my_ptrdiff_t ptr_diff - ); - int append_delete( - const TABLE *table, - my_ptrdiff_t ptr_diff, - int link_idx - ); - int append_insert_part(); - int append_insert( - spider_string *str, - int link_idx - ); - int append_update_part(); - int append_update( - spider_string *str, - int link_idx - ); - int append_delete_part(); - int append_delete( - spider_string *str - ); - int append_update_set_part(); - int append_update_set( - spider_string *str - ); - #ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS - int append_direct_update_set_part(); - int append_direct_update_set( - spider_string *str - ); - int append_dup_update_pushdown_part( - const char *alias, - uint alias_length - ); - int append_update_columns_part( - const char *alias, - uint alias_length - ); - int check_update_columns_part(); - int append_update_columns( - spider_string *str, - const char *alias, - uint alias_length - ); - #endif - int append_select_part( - ulong sql_type - ); - int append_select( - spider_string *str, - ulong sql_type - ); - int append_table_select_part( - ulong sql_type - ); - int append_table_select( - spider_string *str - ); - int append_key_select_part( - ulong sql_type, - uint idx - ); - int append_key_select( - spider_string *str, - uint idx - ); - int append_minimum_select_part( - ulong sql_type - ); - int append_minimum_select( - spider_string *str, - ulong sql_type - ); - int append_table_select_with_alias( - spider_string *str, - const char *alias, - uint alias_length - ); - int append_key_select_with_alias( - spider_string *str, - const KEY *key_info, - const char *alias, - uint alias_length - ); - int append_minimum_select_with_alias( - spider_string *str, - const char *alias, - uint alias_length - ); - int append_select_columns_with_alias( - spider_string *str, - const char *alias, - uint alias_length - ); - int append_hint_after_table_part( - ulong sql_type - ); - int append_hint_after_table( - spider_string *str - ); - void set_where_pos( - ulong sql_type - ); - void set_where_to_pos( - ulong sql_type - ); - int check_item_type( - Item *item - ); - int append_values_connector_part( - ulong sql_type - ); - int append_values_connector( - spider_string *str - ); - int append_values_terminator_part( - ulong sql_type - ); - int append_values_terminator( - spider_string *str - ); - int append_union_table_connector_part( - ulong sql_type - ); - int append_union_table_connector( - spider_string *str - ); - int append_union_table_terminator_part( - ulong sql_type - ); - int append_union_table_terminator( - spider_string *str - ); - int append_key_column_values_part( - const key_range *start_key, - ulong sql_type - ); - int append_key_column_values( - spider_string *str, - const key_range *start_key - ); - int append_key_column_values_with_name_part( - const key_range *start_key, - ulong sql_type - ); - int append_key_column_values_with_name( - spider_string *str, - const key_range *start_key - ); - int append_key_where_part( - const key_range *start_key, - const key_range *end_key, - ulong sql_type - ); - int append_key_where( - spider_string *str, - spider_string *str_part, - spider_string *str_part2, - const key_range *start_key, - const key_range *end_key, - ulong sql_type, - bool set_order - ); - int append_is_null_part( - ulong sql_type, - KEY_PART_INFO *key_part, - const key_range *key, - const uchar **ptr, - bool key_eq, - bool tgt_final - ); - int append_is_null( - ulong sql_type, - spider_string *str, - spider_string *str_part, - spider_string *str_part2, - KEY_PART_INFO *key_part, - const key_range *key, - const uchar **ptr, - bool key_eq, - bool tgt_final - ); - int append_where_terminator_part( - ulong sql_type, - bool set_order, - int key_count - ); - int append_where_terminator( - ulong sql_type, - spider_string *str, - spider_string *str_part, - spider_string *str_part2, - bool set_order, - int key_count - ); - int append_match_where_part( - ulong sql_type - ); - int append_match_where( - spider_string *str - ); - int append_update_where( - spider_string *str, - const TABLE *table, - my_ptrdiff_t ptr_diff - ); - int append_condition_part( - const char *alias, - uint alias_length, - ulong sql_type, - bool test_flg - ); - int append_condition( - spider_string *str, - const char *alias, - uint alias_length, - bool start_where, - ulong sql_type - ); - int append_match_against_part( - ulong sql_type, - st_spider_ft_info *ft_info, - const char *alias, - uint alias_length - ); - int append_match_against( - spider_string *str, - st_spider_ft_info *ft_info, - const char *alias, - uint alias_length - ); - int append_match_select_part( - ulong sql_type, - const char *alias, - uint alias_length - ); - int append_match_select( - spider_string *str, - const char *alias, - uint alias_length - ); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE - int append_sum_select_part( - ulong sql_type, - const char *alias, - uint alias_length - ); - int append_sum_select( - spider_string *str, - const char *alias, - uint alias_length - ); -#endif - void set_order_pos( - ulong sql_type - ); - void set_order_to_pos( - ulong sql_type - ); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE - int append_group_by_part( - const char *alias, - uint alias_length, - ulong sql_type - ); - int append_group_by( - spider_string *str, - const char *alias, - uint alias_length - ); -#endif - int append_key_order_for_merge_with_alias_part( - const char *alias, - uint alias_length, - ulong sql_type - ); - int append_key_order_for_merge_with_alias( - spider_string *str, - const char *alias, - uint alias_length - ); - int append_key_order_for_direct_order_limit_with_alias_part( - const char *alias, - uint alias_length, - ulong sql_type - ); - int append_key_order_for_direct_order_limit_with_alias( - spider_string *str, - const char *alias, - uint alias_length - ); - int append_key_order_with_alias_part( - const char *alias, - uint alias_length, - ulong sql_type - ); - int append_key_order_for_handler( - spider_string *str, - const char *alias, - uint alias_length - ); - int append_key_order_with_alias( - spider_string *str, - const char *alias, - uint alias_length - ); - int append_limit_part( - longlong offset, - longlong limit, - ulong sql_type - ); - int reappend_limit_part( - longlong offset, - longlong limit, - ulong sql_type - ); - int append_limit( - spider_string *str, - longlong offset, - longlong limit - ); - int append_select_lock_part( - ulong sql_type - ); - int append_select_lock( - spider_string *str - ); - int append_union_all_start_part( - ulong sql_type - ); - int append_union_all_start( - spider_string *str - ); - int append_union_all_part( - ulong sql_type - ); - int append_union_all( - spider_string *str - ); - int append_union_all_end_part( - ulong sql_type - ); - int append_union_all_end( - spider_string *str - ); - int append_multi_range_cnt_part( - ulong sql_type, - uint multi_range_cnt, - bool with_comma - ); - int append_multi_range_cnt( - spider_string *str, - uint multi_range_cnt, - bool with_comma - ); - int append_multi_range_cnt_with_name_part( - ulong sql_type, - uint multi_range_cnt - ); - int append_multi_range_cnt_with_name( - spider_string *str, - uint multi_range_cnt - ); - int append_open_handler_part( - ulong sql_type, - uint handler_id, - SPIDER_CONN *conn, - int link_idx - ); - int append_open_handler( - spider_string *str, - uint handler_id, - SPIDER_CONN *conn, - int link_idx - ); - int append_close_handler_part( - ulong sql_type, - int link_idx - ); - int append_close_handler( - spider_string *str, - int link_idx - ); - int append_insert_terminator_part( - ulong sql_type - ); - int append_insert_terminator( - spider_string *str - ); - int append_insert_values_part( - ulong sql_type - ); - int append_insert_values( - spider_string *str - ); - int append_into_part( - ulong sql_type - ); - int append_into( - spider_string *str - ); - void set_insert_to_pos( - ulong sql_type - ); - int append_from_part( - ulong sql_type, - int link_idx - ); - int append_from( - spider_string *str, - ulong sql_type, - int link_idx - ); - int append_flush_tables_part( - ulong sql_type, - int link_idx, - bool lock - ); - int append_flush_tables( - spider_string *str, - int link_idx, - bool lock - ); - int append_optimize_table_part( - ulong sql_type, - int link_idx - ); - int append_optimize_table( - spider_string *str, - int link_idx - ); - int append_analyze_table_part( - ulong sql_type, - int link_idx - ); - int append_analyze_table( - spider_string *str, - int link_idx - ); - int append_repair_table_part( - ulong sql_type, - int link_idx, - HA_CHECK_OPT* check_opt - ); - int append_repair_table( - spider_string *str, - int link_idx, - HA_CHECK_OPT* check_opt - ); - int append_check_table_part( - ulong sql_type, - int link_idx, - HA_CHECK_OPT* check_opt - ); - int append_check_table( - spider_string *str, - int link_idx, - HA_CHECK_OPT* check_opt - ); - int append_enable_keys_part( - ulong sql_type, - int link_idx - ); - int append_enable_keys( - spider_string *str, - int link_idx - ); - int append_disable_keys_part( - ulong sql_type, - int link_idx - ); - int append_disable_keys( - spider_string *str, - int link_idx - ); - int append_delete_all_rows_part( - ulong sql_type - ); - int append_delete_all_rows( - spider_string *str, - ulong sql_type - ); - int append_truncate( - spider_string *str, - ulong sql_type, - int link_idx - ); - int append_explain_select_part( - const key_range *start_key, - const key_range *end_key, - ulong sql_type, - int link_idx - ); - int append_explain_select( - spider_string *str, - const key_range *start_key, - const key_range *end_key, - ulong sql_type, - int link_idx - ); - bool is_sole_projection_field( - uint16 field_index - ); - bool is_bulk_insert_exec_period( - bool bulk_end - ); - bool sql_is_filled_up( - ulong sql_type - ); - bool sql_is_empty( - ulong sql_type - ); - bool support_multi_split_read(); - bool support_bulk_update(); - int bulk_tmp_table_insert(); - int bulk_tmp_table_insert( - int link_idx - ); - int bulk_tmp_table_end_bulk_insert(); - int bulk_tmp_table_rnd_init(); - int bulk_tmp_table_rnd_next(); - int bulk_tmp_table_rnd_end(); - bool need_copy_for_update( - int link_idx - ); - bool bulk_tmp_table_created(); - int mk_bulk_tmp_table_and_bulk_start(); - void rm_bulk_tmp_table(); - int store_sql_to_bulk_tmp_table( - spider_string *str, - TABLE *tmp_table - ); - int restore_sql_from_bulk_tmp_table( - spider_string *str, - TABLE *tmp_table - ); - int insert_lock_tables_list( - SPIDER_CONN *conn, - int link_idx - ); - int append_lock_tables_list( - SPIDER_CONN *conn, - int link_idx, - int *appended - ); - int realloc_sql( - ulong *realloced - ); - int reset_sql( - ulong sql_type - ); - bool need_lock_before_set_sql_for_exec( - ulong sql_type - ); -#ifdef SPIDER_HAS_GROUP_BY_HANDLER - int set_sql_for_exec( - ulong sql_type, - int link_idx, - SPIDER_LINK_IDX_CHAIN *link_idx_chain - ); -#endif - int set_sql_for_exec( - ulong sql_type, - int link_idx - ); - int set_sql_for_exec( - spider_db_copy_table *tgt_ct, - ulong sql_type - ); - int execute_sql( - ulong sql_type, - SPIDER_CONN *conn, - int quick_mode, - int *need_mon - ); - int reset(); - int sts_mode_exchange( - int sts_mode - ); - int show_table_status( - int link_idx, - int sts_mode, - uint flag - ); - int crd_mode_exchange( - int crd_mode - ); - int show_index( - int link_idx, - int crd_mode - ); - int show_records( - int link_idx - ); - int show_autoinc( - int link_idx - ); - int show_last_insert_id( - int link_idx, - ulonglong &last_insert_id - ); - ha_rows explain_select( - const key_range *start_key, - const key_range *end_key, - int link_idx - ); - int lock_tables( - int link_idx - ); - int unlock_tables( - int link_idx - ); - int disable_keys( - SPIDER_CONN *conn, - int link_idx - ); - int enable_keys( - SPIDER_CONN *conn, - int link_idx - ); - int check_table( - SPIDER_CONN *conn, - int link_idx, - HA_CHECK_OPT* check_opt - ); - int repair_table( - SPIDER_CONN *conn, - int link_idx, - HA_CHECK_OPT* check_opt - ); - int analyze_table( - SPIDER_CONN *conn, - int link_idx - ); - int optimize_table( - SPIDER_CONN *conn, - int link_idx - ); - int flush_tables( - SPIDER_CONN *conn, - int link_idx, - bool lock - ); - int flush_logs( - SPIDER_CONN *conn, - int link_idx - ); - int insert_opened_handler( - SPIDER_CONN *conn, - int link_idx - ); - int delete_opened_handler( - SPIDER_CONN *conn, - int link_idx - ); - int sync_from_clone_source( - spider_db_handler *dbton_hdl - ); - bool support_use_handler( - int use_handler - ); - void minimum_select_bitmap_create(); - bool minimum_select_bit_is_set( - uint field_index - ); - void copy_minimum_select_bitmap( - uchar *bitmap - ); - int init_union_table_name_pos(); - int set_union_table_name_pos(); - int reset_union_table_name( - spider_string *str, - int link_idx, - ulong sql_type - ); -#ifdef SPIDER_HAS_GROUP_BY_HANDLER - int append_from_and_tables_part( - spider_fields *fields, - ulong sql_type - ); - int reappend_tables_part( - spider_fields *fields, - ulong sql_type - ); - int append_where_part( - ulong sql_type - ); - int append_having_part( - ulong sql_type - ); - int append_item_type_part( - Item *item, - const char *alias, - uint alias_length, - bool use_fields, - spider_fields *fields, - ulong sql_type - ); - int append_list_item_select_part( - List<Item> *select, - const char *alias, - uint alias_length, - bool use_fields, - spider_fields *fields, - ulong sql_type - ); - int append_list_item_select( - List<Item> *select, - spider_string *str, - const char *alias, - uint alias_length, - bool use_fields, - spider_fields *fields - ); - int append_group_by_part( - ORDER *order, - const char *alias, - uint alias_length, - bool use_fields, - spider_fields *fields, - ulong sql_type - ); - int append_group_by( - ORDER *order, - spider_string *str, - const char *alias, - uint alias_length, - bool use_fields, - spider_fields *fields - ); - int append_order_by_part( - ORDER *order, - const char *alias, - uint alias_length, - bool use_fields, - spider_fields *fields, - ulong sql_type - ); - int append_order_by( - ORDER *order, - spider_string *str, - const char *alias, - uint alias_length, - bool use_fields, - spider_fields *fields - ); -#endif -}; - -class spider_oracle_copy_table: public spider_db_copy_table -{ -public: - spider_oracle_share *oracle_share; - spider_string sql; - spider_string sql_part; - uint pos; - uint table_name_pos; - uint pos_diff; - int table_lock_mode; - int store_link_idx; - bool select_rownum_appended; - spider_string *first_str; - spider_string *current_str; - spider_oracle_copy_table( - spider_oracle_share *db_share - ); - ~spider_oracle_copy_table(); - int init(); - void set_sql_charset( - CHARSET_INFO *cs - ); - int append_select_str(); - int append_insert_str( - int insert_flg - ); - int append_table_columns( - TABLE_SHARE *table_share - ); - int append_from_str(); - int append_table_name( - int link_idx - ); - void set_sql_pos(); - void set_sql_to_pos(); - int append_copy_where( - spider_db_copy_table *source_ct, - KEY *key_info, - ulong *last_row_pos, - ulong *last_lengths - ); - int append_key_order_str( - KEY *key_info, - int start_pos, - bool desc_flg - ); - int append_limit( - longlong offset, - longlong limit - ); - int append_into_str(); - int append_open_paren_str(); - int append_values_str(); - int append_select_lock_str( - int lock_mode - ); - int exec_query( - SPIDER_CONN *conn, - int quick_mode, - int *need_mon - ); - int copy_key_row( - spider_db_copy_table *source_ct, - Field *field, - ulong *row_pos, - ulong *length, - const char *joint_str, - const int joint_length - ); - int copy_row( - Field *field, - SPIDER_DB_ROW *row - ); - int copy_rows( - TABLE *table, - SPIDER_DB_ROW *row, - ulong **last_row_pos, - ulong **last_lengths - ); - int copy_rows( - TABLE *table, - SPIDER_DB_ROW *row - ); - int append_insert_terminator(); - int copy_insert_values( - spider_db_copy_table *source_ct - ); -}; diff --git a/storage/spider/spd_direct_sql.cc b/storage/spider/spd_direct_sql.cc index 85d16c1f347..be26009e6f5 100644 --- a/storage/spider/spd_direct_sql.cc +++ b/storage/spider/spd_direct_sql.cc @@ -18,10 +18,6 @@ #include <my_global.h> #include "mysql_version.h" #include "spd_environ.h" -#if MYSQL_VERSION_ID < 50500 -#include "mysql_priv.h" -#include <mysql/plugin.h> -#else #include "sql_priv.h" #include "probes_mysql.h" #include "sql_class.h" @@ -29,7 +25,6 @@ #include "sql_base.h" #include "sql_servers.h" #include "tztime.h" -#endif #include "spd_err.h" #include "spd_param.h" #include "spd_db_include.h" @@ -44,9 +39,7 @@ #include "spd_udf.h" #include "spd_malloc.h" -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100004 #define SPIDER_NEED_INIT_ONE_TABLE_FOR_FIND_TEMPORARY_TABLE -#endif extern const char **spd_defaults_extra_file; extern const char **spd_defaults_file; @@ -115,21 +108,6 @@ int spider_udf_direct_sql_create_table_list( } else break; } -#if MYSQL_VERSION_ID < 50500 - if (!(direct_sql->db_names = (char**) - spider_bulk_malloc(spider_current_trx, 31, MYF(MY_WME | MY_ZEROFILL), - &direct_sql->db_names, (uint) (sizeof(char*) * table_count), - &direct_sql->table_names, (uint) (sizeof(char*) * table_count), - &direct_sql->tables, (uint) (sizeof(TABLE*) * table_count), - &tmp_name_ptr, (uint) (sizeof(char) * ( - table_name_list_length + - thd->db_length * table_count + - 2 * table_count - )), - &direct_sql->iop, (uint) (sizeof(int) * table_count), - NullS)) - ) -#else if (!(direct_sql->db_names = (char**) spider_bulk_malloc(spider_current_trx, 31, MYF(MY_WME | MY_ZEROFILL), &direct_sql->db_names, (uint) (sizeof(char*) * table_count), @@ -146,7 +124,6 @@ int spider_udf_direct_sql_create_table_list( (uint) (sizeof(uchar) * ((table_count + 7) / 8)), NullS)) ) -#endif DBUG_RETURN(HA_ERR_OUT_OF_MEM); tmp_ptr = table_name_list; @@ -382,10 +359,8 @@ int spider_udf_direct_sql_create_conn_key( tmp_name = strmov(tmp_name + 1, direct_sql->tgt_driver); } else tmp_name++; -#ifdef SPIDER_HAS_HASH_VALUE_TYPE direct_sql->conn_key_hash_value = my_calc_hash(&spider_open_connections, (uchar*) direct_sql->conn_key, direct_sql->conn_key_length); -#endif DBUG_RETURN(0); } @@ -578,12 +553,8 @@ SPIDER_CONN *spider_udf_direct_sql_create_conn( conn->semi_trx_chk = FALSE; conn->conn_kind = SPIDER_CONN_KIND_MYSQL; -#if MYSQL_VERSION_ID < 50500 - if (pthread_mutex_init(&conn->mta_conn_mutex, MY_MUTEX_INIT_FAST)) -#else if (mysql_mutex_init(spd_key_mutex_mta_conn, &conn->mta_conn_mutex, MY_MUTEX_INIT_FAST)) -#endif { *error_num = HA_ERR_OUT_OF_MEM; goto error_mta_conn_mutex_init; @@ -604,14 +575,9 @@ SPIDER_CONN *spider_udf_direct_sql_create_conn( pthread_mutex_unlock(&spider_conn_id_mutex); pthread_mutex_lock(&spider_ipport_conn_mutex); -#ifdef SPIDER_HAS_HASH_VALUE_TYPE if ((ip_port_conn = (SPIDER_IP_PORT_CONN*) my_hash_search_using_hash_value( &spider_ipport_conns, conn->conn_key_hash_value, (uchar*)conn->conn_key, conn->conn_key_length))) -#else - if ((ip_port_conn = (SPIDER_IP_PORT_CONN*) my_hash_search( - &spider_ipport_conns, (uchar*)conn->conn_key, conn->conn_key_length))) -#endif { /* exists, +1 */ pthread_mutex_unlock(&spider_ipport_conn_mutex); pthread_mutex_lock(&ip_port_conn->mutex); @@ -668,18 +634,11 @@ SPIDER_CONN *spider_udf_direct_sql_get_conn( SPIDER_CONN *conn = NULL; DBUG_ENTER("spider_udf_direct_sql_get_conn"); -#ifdef SPIDER_HAS_HASH_VALUE_TYPE if ( !(conn = (SPIDER_CONN*) my_hash_search_using_hash_value( &trx->trx_conn_hash, direct_sql->conn_key_hash_value, (uchar*) direct_sql->conn_key, direct_sql->conn_key_length)) ) -#else - if ( - !(conn = (SPIDER_CONN*) my_hash_search(&trx->trx_conn_hash, - (uchar*) direct_sql->conn_key, direct_sql->conn_key_length)) - ) -#endif { if ( ( @@ -688,14 +647,9 @@ SPIDER_CONN *spider_udf_direct_sql_get_conn( ) ) { pthread_mutex_lock(&spider_conn_mutex); -#ifdef SPIDER_HAS_HASH_VALUE_TYPE if (!(conn = (SPIDER_CONN*) my_hash_search_using_hash_value( &spider_open_connections, direct_sql->conn_key_hash_value, (uchar*) direct_sql->conn_key, direct_sql->conn_key_length))) -#else - if (!(conn = (SPIDER_CONN*) my_hash_search(&spider_open_connections, - (uchar*) direct_sql->conn_key, direct_sql->conn_key_length))) -#endif { pthread_mutex_unlock(&spider_conn_mutex); DBUG_PRINT("info",("spider create new conn")); @@ -703,12 +657,7 @@ SPIDER_CONN *spider_udf_direct_sql_get_conn( error_num))) goto error; } else { -#ifdef HASH_UPDATE_WITH_HASH_VALUE - my_hash_delete_with_hash_value(&spider_open_connections, - conn->conn_key_hash_value, (uchar*) conn); -#else my_hash_delete(&spider_open_connections, (uchar*) conn); -#endif pthread_mutex_unlock(&spider_conn_mutex); DBUG_PRINT("info",("spider get global conn")); } @@ -722,12 +671,7 @@ SPIDER_CONN *spider_udf_direct_sql_get_conn( conn->priority = direct_sql->priority; uint old_elements = trx->trx_conn_hash.array.max_element; -#ifdef HASH_UPDATE_WITH_HASH_VALUE - if (my_hash_insert_with_hash_value(&trx->trx_conn_hash, - direct_sql->conn_key_hash_value, (uchar*) conn)) -#else if (my_hash_insert(&trx->trx_conn_hash, (uchar*) conn)) -#endif { spider_free_conn(conn); *error_num = HA_ERR_OUT_OF_MEM; @@ -1025,10 +969,7 @@ int spider_udf_parse_direct_sql_param( direct_sql->net_write_timeout = -1; direct_sql->bulk_insert_rows = -1; direct_sql->connection_channel = -1; -#if MYSQL_VERSION_ID < 50500 -#else direct_sql->use_real_table = -1; -#endif direct_sql->error_rw_mode = -1; for (roop_count = 0; roop_count < direct_sql->table_count; roop_count++) direct_sql->iop[roop_count] = -1; @@ -1102,10 +1043,7 @@ int spider_udf_parse_direct_sql_param( SPIDER_PARAM_STR("srv", server_name); SPIDER_PARAM_INT_WITH_MAX("svc", tgt_ssl_vsc, 0, 1); SPIDER_PARAM_INT_WITH_MAX("tlm", table_loop_mode, 0, 2); -#if MYSQL_VERSION_ID < 50500 -#else SPIDER_PARAM_INT_WITH_MAX("urt", use_real_table, 0, 1); -#endif SPIDER_PARAM_INT("wto", net_write_timeout, 0); error_num = param_string_parse.print_param_error(); goto error; @@ -1155,10 +1093,7 @@ int spider_udf_parse_direct_sql_param( error_num = param_string_parse.print_param_error(); goto error; case 14: -#if MYSQL_VERSION_ID < 50500 -#else SPIDER_PARAM_INT_WITH_MAX("use_real_table", use_real_table, 0, 1); -#endif error_num = param_string_parse.print_param_error(); goto error; case 15: @@ -1445,11 +1380,8 @@ int spider_udf_set_direct_sql_param_default( direct_sql->bulk_insert_rows = 3000; if (direct_sql->connection_channel == -1) direct_sql->connection_channel = 0; -#if MYSQL_VERSION_ID < 50500 -#else if (direct_sql->use_real_table == -1) direct_sql->use_real_table = 0; -#endif if (direct_sql->error_rw_mode == -1) direct_sql->error_rw_mode = 0; for (roop_count = 0; roop_count < direct_sql->table_count; roop_count++) @@ -1466,7 +1398,6 @@ void spider_udf_free_direct_sql_alloc( ) { SPIDER_BG_DIRECT_SQL *bg_direct_sql; DBUG_ENTER("spider_udf_free_direct_sql_alloc"); -#ifndef WITHOUT_SPIDER_BG_SEARCH if (bg) { pthread_mutex_lock(direct_sql->bg_mutex); @@ -1480,15 +1411,11 @@ void spider_udf_free_direct_sql_alloc( pthread_cond_signal(direct_sql->bg_cond); pthread_mutex_unlock(direct_sql->bg_mutex); } -#endif -#if MYSQL_VERSION_ID < 50500 -#else if (direct_sql->real_table_used && direct_sql->open_tables_thd) { spider_sys_close_table(direct_sql->open_tables_thd, &direct_sql->open_tables_backup); } -#endif if (direct_sql->server_name) { spider_free(spider_current_trx, direct_sql->server_name, MYF(0)); @@ -1584,11 +1511,8 @@ long long spider_direct_sql_body( char *sql; TABLE_LIST table_list; SPIDER_BG_DIRECT_SQL *bg_direct_sql; -#if MYSQL_VERSION_ID < 50500 -#else TABLE_LIST *real_table_list_last = NULL; uint use_real_table = 0; -#endif DBUG_ENTER("spider_direct_sql_body"); SPIDER_BACKUP_DASTATUS; if (!(direct_sql = (SPIDER_DIRECT_SQL *) @@ -1601,7 +1525,6 @@ long long spider_direct_sql_body( my_error(ER_OUT_OF_RESOURCES, MYF(0), HA_ERR_OUT_OF_MEM); goto error; } -#ifndef WITHOUT_SPIDER_BG_SEARCH if (bg) { bg_direct_sql = (SPIDER_BG_DIRECT_SQL *) initid->ptr; @@ -1619,7 +1542,6 @@ long long spider_direct_sql_body( direct_sql->parent = bg_direct_sql; bg_direct_sql->called_cnt++; } -#endif if (!(trx = spider_get_trx(thd, TRUE, &error_num))) { if (error_num == HA_ERR_OUT_OF_MEM) @@ -1672,11 +1594,8 @@ long long spider_direct_sql_body( } trx->updated_in_this_trx = TRUE; DBUG_PRINT("info",("spider trx->updated_in_this_trx=TRUE")); -#if MYSQL_VERSION_ID < 50500 -#else use_real_table = spider_param_udf_ds_use_real_table(thd, direct_sql->use_real_table); -#endif for (roop_count = 0; roop_count < direct_sql->table_count; roop_count++) { #ifdef SPIDER_NEED_INIT_ONE_TABLE_FOR_FIND_TEMPORARY_TABLE @@ -1707,19 +1626,14 @@ long long spider_direct_sql_body( if (!(direct_sql->tables[roop_count] = spider_find_temporary_table(thd, &table_list))) { -#if MYSQL_VERSION_ID < 50500 -#else if (!use_real_table) { -#endif error_num = ER_SPIDER_UDF_TMP_TABLE_NOT_FOUND_NUM; my_printf_error(ER_SPIDER_UDF_TMP_TABLE_NOT_FOUND_NUM, ER_SPIDER_UDF_TMP_TABLE_NOT_FOUND_STR, MYF(0), SPIDER_TABLE_LIST_db_str(&table_list), SPIDER_TABLE_LIST_table_name_str(&table_list)); goto error; -#if MYSQL_VERSION_ID < 50500 -#else } TABLE_LIST *tables = &direct_sql->table_list[roop_count]; MDL_REQUEST_INIT(&tables->mdl_request, MDL_key::TABLE, @@ -1735,7 +1649,6 @@ long long spider_direct_sql_body( real_table_list_last = tables; spider_set_bit(direct_sql->real_table_bitmap, roop_count); direct_sql->real_table_used = TRUE; -#endif } } if ((error_num = spider_udf_direct_sql_create_conn_key(direct_sql))) @@ -1766,7 +1679,6 @@ long long spider_direct_sql_body( direct_sql->sql_length = 0; direct_sql->sql = sql; -#ifndef WITHOUT_SPIDER_BG_SEARCH if (bg) { if ((error_num = spider_udf_bg_direct_sql(direct_sql))) @@ -1776,7 +1688,6 @@ long long spider_direct_sql_body( goto error; } } else { -#endif if (conn->bg_init) pthread_mutex_lock(&conn->bg_conn_mutex); if ((error_num = spider_db_udf_direct_sql(direct_sql))) @@ -1793,15 +1704,11 @@ long long spider_direct_sql_body( pthread_mutex_unlock(&conn->bg_conn_mutex); if (direct_sql->modified_non_trans_table) thd->transaction->stmt.modified_non_trans_table = TRUE; -#ifndef WITHOUT_SPIDER_BG_SEARCH } if (!bg) { -#endif spider_udf_free_direct_sql_alloc(direct_sql, FALSE); -#ifndef WITHOUT_SPIDER_BG_SEARCH } -#endif DBUG_RETURN(1); error: @@ -1842,7 +1749,6 @@ my_bool spider_direct_sql_init_body( strcpy(message, "spider_(bg)_direct_sql() requires string arguments"); goto error; } -#ifndef WITHOUT_SPIDER_BG_SEARCH if (bg) { if (!(bg_direct_sql = (SPIDER_BG_DIRECT_SQL *) @@ -1852,37 +1758,26 @@ my_bool spider_direct_sql_init_body( strcpy(message, "spider_bg_direct_sql() out of memory"); goto error; } -#if MYSQL_VERSION_ID < 50500 - if (pthread_mutex_init(&bg_direct_sql->bg_mutex, MY_MUTEX_INIT_FAST)) -#else if (mysql_mutex_init(spd_key_mutex_bg_direct_sql, &bg_direct_sql->bg_mutex, MY_MUTEX_INIT_FAST)) -#endif { strcpy(message, "spider_bg_direct_sql() out of memory"); goto error_mutex_init; } -#if MYSQL_VERSION_ID < 50500 - if (pthread_cond_init(&bg_direct_sql->bg_cond, NULL)) -#else if (mysql_cond_init(spd_key_cond_bg_direct_sql, &bg_direct_sql->bg_cond, NULL)) -#endif { strcpy(message, "spider_bg_direct_sql() out of memory"); goto error_cond_init; } initid->ptr = (char *) bg_direct_sql; } -#endif DBUG_RETURN(FALSE); -#ifndef WITHOUT_SPIDER_BG_SEARCH error_cond_init: pthread_mutex_destroy(&bg_direct_sql->bg_mutex); error_mutex_init: spider_free(spider_current_trx, bg_direct_sql, MYF(0)); -#endif error: DBUG_RETURN(TRUE); } @@ -1910,7 +1805,6 @@ void spider_direct_sql_deinit_body( DBUG_VOID_RETURN; } -#ifndef WITHOUT_SPIDER_BG_SEARCH void spider_direct_sql_bg_start( UDF_INIT *initid ) { @@ -1999,4 +1893,3 @@ int spider_udf_bg_direct_sql( } DBUG_RETURN(0); } -#endif diff --git a/storage/spider/spd_direct_sql.h b/storage/spider/spd_direct_sql.h index bf3e24caa13..fa5f00f2431 100644 --- a/storage/spider/spd_direct_sql.h +++ b/storage/spider/spd_direct_sql.h @@ -60,8 +60,6 @@ void spider_udf_free_direct_sql_alloc( my_bool bg ); -#ifndef WITHOUT_SPIDER_BG_SEARCH int spider_udf_bg_direct_sql( SPIDER_DIRECT_SQL *direct_sql ); -#endif diff --git a/storage/spider/spd_environ.h b/storage/spider/spd_environ.h index 320b0edeb30..0caf23af64c 100644 --- a/storage/spider/spd_environ.h +++ b/storage/spider/spd_environ.h @@ -12,7 +12,7 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA */ /* Define functionality offered by MySQL or MariaDB @@ -20,42 +20,13 @@ #ifndef SPD_ENVIRON_INCLUDED -#if (defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000) -#define SPIDER_HANDLER_START_BULK_INSERT_HAS_FLAGS -#endif - -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100100 -#define SPIDER_SUPPORT_CREATE_OR_REPLACE_TABLE #define SPIDER_NET_HAS_THD -#endif - -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100211 #define HANDLER_HAS_TOP_TABLE_FIELDS -#define HANDLER_HAS_DIRECT_UPDATE_ROWS -#define HANDLER_HAS_DIRECT_AGGREGATE -#define PARTITION_HAS_GET_CHILD_HANDLERS #define PARTITION_HAS_GET_PART_SPEC #define HA_EXTRA_HAS_STARTING_ORDERED_INDEX_SCAN -#define HANDLER_HAS_NEED_INFO_FOR_AUTO_INC #define HANDLER_HAS_CAN_USE_FOR_AUTO_INC_INIT -#endif - -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100300 #define SPIDER_UPDATE_ROW_HAS_CONST_NEW_DATA -#endif - -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100309 #define SPIDER_MDEV_16246 -#endif - -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100400 -#define SPIDER_USE_CONST_ITEM_FOR_STRING_INT_REAL_DECIMAL_DATE_ITEM -#define SPIDER_SQL_CACHE_IS_IN_LEX #define SPIDER_LIKE_FUNC_HAS_GET_NEGATED -#define HA_HAS_CHECKSUM_EXTENDED -#endif - -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100500 #define SPIDER_I_S_USE_SHOW_FOR_COLUMN -#endif #endif /* SPD_ENVIRON_INCLUDED */ diff --git a/storage/spider/spd_group_by_handler.cc b/storage/spider/spd_group_by_handler.cc index f2722c85ccc..ca174d42e39 100644 --- a/storage/spider/spd_group_by_handler.cc +++ b/storage/spider/spd_group_by_handler.cc @@ -12,22 +12,17 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA */ #define MYSQL_SERVER 1 #include <my_global.h> #include "mysql_version.h" #include "spd_environ.h" -#if MYSQL_VERSION_ID < 50500 -#include "mysql_priv.h" -#include <mysql/plugin.h> -#else #include "sql_priv.h" #include "probes_mysql.h" #include "sql_class.h" #include "sql_partition.h" #include "ha_partition.h" -#endif #include "sql_common.h" #include <errmsg.h> #include "spd_err.h" @@ -1169,7 +1164,6 @@ int spider_fields::ping_table_mon_from_table( DBUG_RETURN(error_num); } -#ifdef SPIDER_HAS_GROUP_BY_HANDLER spider_group_by_handler::spider_group_by_handler( THD *thd_arg, Query *query_arg, @@ -1247,10 +1241,8 @@ int spider_group_by_handler::init_scan() for (link_idx = 0; link_idx < (int) share->link_count; ++link_idx) spider->sql_kind[link_idx] = SPIDER_SQL_KIND_SQL; -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS spider->do_direct_update = FALSE; spider->direct_update_kinds = 0; -#endif spider_get_select_limit(spider, &select_lex, &select_limit, &offset_limit); direct_order_limit = spider_param_direct_order_limit(thd, share->direct_order_limit); @@ -1262,9 +1254,7 @@ int spider_group_by_handler::init_scan() ) { result_list->internal_limit = select_limit /* + offset_limit */; result_list->split_read = select_limit /* + offset_limit */; -#ifndef WITHOUT_SPIDER_BG_SEARCH result_list->bgs_split_read = select_limit /* + offset_limit */; -#endif result_list->split_read_base = 9223372036854775807LL; result_list->semi_split_read = 0; @@ -1275,10 +1265,8 @@ int spider_group_by_handler::init_scan() } result_list->semi_split_read_base = 0; result_list->set_split_read = TRUE; -#ifndef WITHOUT_SPIDER_BG_SEARCH if ((error_num = spider_set_conn_bg_param(spider))) DBUG_RETURN(error_num); -#endif DBUG_PRINT("info",("spider result_list.finish_flg = FALSE")); result_list->finish_flg = FALSE; result_list->record_num = 0; @@ -1386,7 +1374,6 @@ int spider_group_by_handler::init_scan() link_idx = link_idx_holder->link_idx; dbton_hdl = spider->dbton_handler[conn->dbton_id]; spider->link_idx_chain = link_idx_chain; -#ifndef WITHOUT_SPIDER_BG_SEARCH if (result_list->bgs_phase > 0) { if ((error_num = spider_check_and_init_casual_read(trx->thd, spider, @@ -1410,7 +1397,6 @@ int spider_group_by_handler::init_scan() DBUG_RETURN(error_num); } } else { -#endif pthread_mutex_assert_not_owner(&conn->mta_conn_mutex); if (dbton_hdl->need_lock_before_set_sql_for_exec( SPIDER_SQL_TYPE_SELECT_SQL)) @@ -1516,9 +1502,7 @@ int spider_group_by_handler::init_scan() SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos); pthread_mutex_unlock(&conn->mta_conn_mutex); } -#ifndef WITHOUT_SPIDER_BG_SEARCH } -#endif } first = TRUE; @@ -1557,7 +1541,6 @@ int spider_group_by_handler::next_row() table->status = STATUS_NOT_FOUND; DBUG_RETURN(spider->store_error_num); } -#ifndef WITHOUT_SPIDER_BG_SEARCH if (spider->result_list.bgs_phase > 0) { fields->set_pos_to_first_link_idx_chain(); @@ -1586,7 +1569,6 @@ int spider_group_by_handler::next_row() } } } -#endif spider->use_pre_call = FALSE; } } else if (offset_limit) @@ -1646,7 +1628,6 @@ group_by_handler *spider_create_group_by_handler( break; } -#ifdef WITH_PARTITION_STORAGE_ENGINE from = query->from; do { DBUG_PRINT("info",("spider from=%p", from)); @@ -1655,23 +1636,16 @@ group_by_handler *spider_create_group_by_handler( if (from->table->part_info) { DBUG_PRINT("info",("spider partition handler")); -#if defined(PARTITION_HAS_GET_CHILD_HANDLERS) partition_info *part_info = from->table->part_info; uint bits = bitmap_bits_set(&part_info->read_partitions); DBUG_PRINT("info",("spider bits=%u", bits)); if (bits != 1) { DBUG_PRINT("info",("spider using multiple partitions is not supported by this feature yet")); -#else - DBUG_PRINT("info",("spider partition is not supported by this feature yet")); -#endif DBUG_RETURN(NULL); -#if defined(PARTITION_HAS_GET_CHILD_HANDLERS) } -#endif } } while ((from = from->next_local)); -#endif table_idx = 0; from = query->from; @@ -1684,7 +1658,6 @@ group_by_handler *spider_create_group_by_handler( /* all tables are const_table */ DBUG_RETURN(NULL); } -#if defined(PARTITION_HAS_GET_CHILD_HANDLERS) if (from->table->part_info) { partition_info *part_info = from->table->part_info; @@ -1693,11 +1666,8 @@ group_by_handler *spider_create_group_by_handler( handler **handlers = partition->get_child_handlers(); spider = (ha_spider *) handlers[part]; } else { -#endif spider = (ha_spider *) from->table->file; -#if defined(PARTITION_HAS_GET_CHILD_HANDLERS) } -#endif share = spider->share; spider->idx_for_direct_join = table_idx; ++table_idx; @@ -1716,7 +1686,6 @@ group_by_handler *spider_create_group_by_handler( { if (from->table->const_table) continue; -#if defined(PARTITION_HAS_GET_CHILD_HANDLERS) if (from->table->part_info) { partition_info *part_info = from->table->part_info; @@ -1725,11 +1694,8 @@ group_by_handler *spider_create_group_by_handler( handler **handlers = partition->get_child_handlers(); spider = (ha_spider *) handlers[part]; } else { -#endif spider = (ha_spider *) from->table->file; -#if defined(PARTITION_HAS_GET_CHILD_HANDLERS) } -#endif share = spider->share; spider->idx_for_direct_join = table_idx; ++table_idx; @@ -1755,7 +1721,6 @@ group_by_handler *spider_create_group_by_handler( do { if (from->table->const_table) continue; -#if defined(PARTITION_HAS_GET_CHILD_HANDLERS) if (from->table->part_info) { partition_info *part_info = from->table->part_info; @@ -1764,11 +1729,8 @@ group_by_handler *spider_create_group_by_handler( handler **handlers = partition->get_child_handlers(); spider = (ha_spider *) handlers[part]; } else { -#endif spider = (ha_spider *) from->table->file; -#if defined(PARTITION_HAS_GET_CHILD_HANDLERS) } -#endif share = spider->share; if (spider_param_skip_default_condition(thd, share->skip_default_condition)) @@ -1911,7 +1873,6 @@ group_by_handler *spider_create_group_by_handler( { from = from->next_local; } -#if defined(PARTITION_HAS_GET_CHILD_HANDLERS) if (from->table->part_info) { partition_info *part_info = from->table->part_info; @@ -1920,11 +1881,8 @@ group_by_handler *spider_create_group_by_handler( handler **handlers = partition->get_child_handlers(); spider = (ha_spider *) handlers[part]; } else { -#endif spider = (ha_spider *) from->table->file; -#if defined(PARTITION_HAS_GET_CHILD_HANDLERS) } -#endif share = spider->share; lock_mode = spider_conn_lock_mode(spider); if (lock_mode) @@ -2006,7 +1964,6 @@ group_by_handler *spider_create_group_by_handler( continue; fields->clear_conn_holder_from_conn(); -#if defined(PARTITION_HAS_GET_CHILD_HANDLERS) if (from->table->part_info) { partition_info *part_info = from->table->part_info; @@ -2015,11 +1972,8 @@ group_by_handler *spider_create_group_by_handler( handler **handlers = partition->get_child_handlers(); spider = (ha_spider *) handlers[part]; } else { -#endif spider = (ha_spider *) from->table->file; -#if defined(PARTITION_HAS_GET_CHILD_HANDLERS) } -#endif share = spider->share; if (!fields->add_table(spider)) { @@ -2143,4 +2097,3 @@ group_by_handler *spider_create_group_by_handler( query->order_by = NULL; DBUG_RETURN(group_by_handler); } -#endif diff --git a/storage/spider/spd_group_by_handler.h b/storage/spider/spd_group_by_handler.h index 09f82168708..b8e85a3d417 100644 --- a/storage/spider/spd_group_by_handler.h +++ b/storage/spider/spd_group_by_handler.h @@ -11,9 +11,8 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA */ -#ifdef SPIDER_HAS_GROUP_BY_HANDLER class spider_group_by_handler: public group_by_handler { Query query; @@ -41,4 +40,3 @@ group_by_handler *spider_create_group_by_handler( THD *thd, Query *query ); -#endif diff --git a/storage/spider/spd_i_s.cc b/storage/spider/spd_i_s.cc index 24000f3e6c1..22cd8eb0f15 100644 --- a/storage/spider/spd_i_s.cc +++ b/storage/spider/spd_i_s.cc @@ -18,16 +18,11 @@ #include <my_global.h> #include "mysql_version.h" #include "spd_environ.h" -#if MYSQL_VERSION_ID < 50500 -#include "mysql_priv.h" -#include <mysql/plugin.h> -#else #include "sql_priv.h" #include "probes_mysql.h" #include "sql_class.h" #include "sql_partition.h" #include "sql_show.h" -#endif #include "spd_db_include.h" #include "spd_include.h" #include "spd_table.h" @@ -162,12 +157,9 @@ struct st_mysql_plugin spider_i_s_alloc_mem = NULL, NULL, NULL, -#if MYSQL_VERSION_ID >= 50600 0, -#endif }; -#ifdef MARIADB_BASE_VERSION struct st_maria_plugin spider_i_s_alloc_mem_maria = { MYSQL_INFORMATION_SCHEMA_PLUGIN, @@ -184,7 +176,6 @@ struct st_maria_plugin spider_i_s_alloc_mem_maria = "1.0", MariaDB_PLUGIN_MATURITY_STABLE, }; -#endif extern SPIDER_DBTON spider_dbton[SPIDER_DBTON_SIZE]; @@ -286,12 +277,9 @@ struct st_mysql_plugin spider_i_s_wrapper_protocols = NULL, NULL, NULL, -#if MYSQL_VERSION_ID >= 50600 0, -#endif }; -#ifdef MARIADB_BASE_VERSION struct st_maria_plugin spider_i_s_wrapper_protocols_maria = { MYSQL_INFORMATION_SCHEMA_PLUGIN, @@ -308,4 +296,3 @@ struct st_maria_plugin spider_i_s_wrapper_protocols_maria = "1.0", MariaDB_PLUGIN_MATURITY_STABLE, }; -#endif diff --git a/storage/spider/spd_include.h b/storage/spider/spd_include.h index dde20098a4a..917b3bfe6ec 100644 --- a/storage/spider/spd_include.h +++ b/storage/spider/spd_include.h @@ -14,14 +14,9 @@ along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */ -#define SPIDER_DETAIL_VERSION "3.3.15" -#define SPIDER_HEX_VERSION 0x0303 - -#if MYSQL_VERSION_ID < 50500 -#define spider_my_free(A,B) my_free(A,B) -#define pthread_mutex_assert_owner(A) -#define pthread_mutex_assert_not_owner(A) -#else +#define SPIDER_DETAIL_VERSION PACKAGE_VERSION +#define SPIDER_HEX_VERSION (MYSQL_VERSION_MAJOR << 8 | MYSQL_VERSION_MINOR) + #define spider_my_free(A,B) my_free(A) #ifdef pthread_mutex_t #undef pthread_mutex_t @@ -70,129 +65,49 @@ #endif #define pthread_cond_destroy mysql_cond_destroy #define my_sprintf(A,B) sprintf B -#endif - -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100004 #define spider_stmt_da_message(A) thd_get_error_message(A) #define spider_stmt_da_sql_errno(A) thd_get_error_number(A) #define spider_user_defined_key_parts(A) (A)->user_defined_key_parts #define spider_join_table_count(A) (A)->table_count #define SPIDER_CAN_BG_UPDATE (1LL << 39) -#if MYSQL_VERSION_ID >= 100304 #define SPIDER_ALTER_PARTITION_ADD ALTER_PARTITION_ADD #define SPIDER_ALTER_PARTITION_DROP ALTER_PARTITION_DROP #define SPIDER_ALTER_PARTITION_COALESCE ALTER_PARTITION_COALESCE #define SPIDER_ALTER_PARTITION_REORGANIZE ALTER_PARTITION_REORGANIZE #define SPIDER_ALTER_PARTITION_TABLE_REORG ALTER_PARTITION_TABLE_REORG #define SPIDER_ALTER_PARTITION_REBUILD ALTER_PARTITION_REBUILD -#else -#define SPIDER_ALTER_PARTITION_ADD Alter_info::ALTER_ADD_PARTITION -#define SPIDER_ALTER_PARTITION_DROP Alter_info::ALTER_DROP_PARTITION -#define SPIDER_ALTER_PARTITION_COALESCE Alter_info::ALTER_COALESCE_PARTITION -#define SPIDER_ALTER_PARTITION_REORGANIZE Alter_info::ALTER_REORGANIZE_PARTITION -#define SPIDER_ALTER_PARTITION_TABLE_REORG Alter_info::ALTER_TABLE_REORG -#define SPIDER_ALTER_PARTITION_REBUILD Alter_info::ALTER_REBUILD_PARTITION -#endif #define SPIDER_WARN_LEVEL_WARN Sql_condition::WARN_LEVEL_WARN #define SPIDER_WARN_LEVEL_NOTE Sql_condition::WARN_LEVEL_NOTE #define SPIDER_THD_KILL_CONNECTION KILL_CONNECTION -#else -#if MYSQL_VERSION_ID < 50500 -#define spider_stmt_da_message(A) (A)->main_da.message() -#define spider_stmt_da_sql_errno(A) (A)->main_da.sql_errno() -#else -#if MYSQL_VERSION_ID < 50600 -#define spider_stmt_da_message(A) (A)->stmt_da->message() -#define spider_stmt_da_sql_errno(A) (A)->stmt_da->sql_errno() -#else -#define spider_stmt_da_message(A) (A)->get_stmt_da()->message() -#define spider_stmt_da_sql_errno(A) (A)->get_stmt_da()->sql_errno() -#endif -#endif -#define spider_user_defined_key_parts(A) (A)->key_parts -#define spider_join_table_count(A) (A)->tables -#define SPIDER_ALTER_PARTITION_ADD ALTER_ADD_PARTITION -#define SPIDER_ALTER_PARTITION_DROP ALTER_DROP_PARTITION -#define SPIDER_ALTER_PARTITION_COALESCE ALTER_COALESCE_PARTITION -#define SPIDER_ALTER_PARTITION_REORGANIZE ALTER_REORGANIZE_PARTITION -#define SPIDER_ALTER_PARTITION_TABLE_REORG ALTER_TABLE_REORG -#define SPIDER_ALTER_PARTITION_REBUILD ALTER_REBUILD_PARTITION -#define SPIDER_WARN_LEVEL_WARN MYSQL_ERROR::WARN_LEVEL_WARN -#define SPIDER_WARN_LEVEL_NOTE MYSQL_ERROR::WARN_LEVEL_NOTE -#define SPIDER_THD_KILL_CONNECTION THD::KILL_CONNECTION -#endif -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100005 #define SPIDER_HAS_EXPLAIN_QUERY -#endif -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100009 #define SPIDER_TEST(A) MY_TEST(A) -#else -#define SPIDER_TEST(A) test(A) -#endif -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100100 #define SPIDER_FIELD_FIELDPTR_REQUIRES_THDPTR #define SPIDER_ENGINE_CONDITION_PUSHDOWN_IS_ALWAYS_ON #define SPIDER_XID_USES_xid_cache_iterate -#else -#define SPIDER_XID_STATE_HAS_in_thd -#endif -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100108 #define SPIDER_Item_args_arg_count_IS_PROTECTED -#endif -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100112 #define SPIDER_Item_func_conv_charset_conv_charset collation.collation -#else -#define SPIDER_Item_func_conv_charset_conv_charset conv_charset -#endif -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100200 #define SPIDER_WITHOUT_HA_STATISTIC_INCREMENT #define SPIDER_init_read_record(A,B,C,D,E,F,G,H) init_read_record(A,B,C,D,E,F,G,H) #define SPIDER_HAS_NEXT_THREAD_ID #define SPIDER_new_THD(A) (new THD(A)) #define SPIDER_order_direction_is_asc(A) (A->direction == ORDER::ORDER_ASC) -#else -#define SPIDER_init_read_record(A,B,C,D,E,F,G,H) init_read_record(A,B,C,D,F,G,H) -#define SPIDER_new_THD(A) (new THD()) -#define SPIDER_order_direction_is_asc(A) (A->asc) -#endif -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100201 #define SPIDER_HAS_MY_CHARLEN #define SPIDER_open_temporary_table -#endif -#if defined(MARIADB_BASE_VERSION) -#if MYSQL_VERSION_ID >= 100209 #define SPIDER_generate_partition_syntax(A,B,C,D,E,F,G,H) generate_partition_syntax(A,B,C,E,F,G) -#elif MYSQL_VERSION_ID >= 100200 -#define SPIDER_generate_partition_syntax(A,B,C,D,E,F,G,H) generate_partition_syntax(A,B,C,D,E,F,G,H) -#elif MYSQL_VERSION_ID >= 100007 -#define SPIDER_generate_partition_syntax(A,B,C,D,E,F,G,H) generate_partition_syntax(B,C,D,E,F,G,H) -#else -#define SPIDER_generate_partition_syntax(A,B,C,D,E,F,G,H) generate_partition_syntax(B,C,D,E,F,G) -#endif -#else -#define SPIDER_generate_partition_syntax(A,B,C,D,E,F,G,H) -#endif -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100209 #define SPIDER_create_partition_name(A,B,C,D,E,F) create_partition_name(A,B,C,D,E,F) #define SPIDER_create_subpartition_name(A,B,C,D,E,F) create_subpartition_name(A,B,C,D,E,F) #define SPIDER_free_part_syntax(A,B) -#else -#define SPIDER_create_partition_name(A,B,C,D,E,F) create_partition_name(A,C,D,E,F) -#define SPIDER_create_subpartition_name(A,B,C,D,E,F) create_subpartition_name(A,C,D,E,F) -#define SPIDER_free_part_syntax(A,B) spider_my_free(A,B) -#endif -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100306 #define SPIDER_read_record_read_record(A) read_record() #define SPIDER_has_Item_with_subquery #define SPIDER_use_LEX_CSTRING_for_KEY_Field_name @@ -211,46 +126,13 @@ #define SPIDER_item_name_str(A) (A)->name.str #define SPIDER_item_name_length(A) (A)->name.length const LEX_CSTRING SPIDER_empty_string = {"", 0}; -#else -#define SPIDER_read_record_read_record(A) read_record(A) -#define SPIDER_THD_db_str(A) (A)->db -#define SPIDER_THD_db_length(A) (A)->db_length -#define SPIDER_TABLE_LIST_db_str(A) (A)->db -#define SPIDER_TABLE_LIST_db_length(A) (A)->db_length -#define SPIDER_TABLE_LIST_table_name_str(A) (A)->table_name -#define SPIDER_TABLE_LIST_table_name_length(A) (A)->table_name_length -#define SPIDER_TABLE_LIST_alias_str(A) (A)->alias -#define SPIDER_TABLE_LIST_alias_length(A) strlen((A)->alias) -#define SPIDER_field_name_str(A) (A)->field_name -#define SPIDER_field_name_length(A) strlen((A)->field_name) -#define SPIDER_item_name_str(A) (A)->name -#define SPIDER_item_name_length(A) strlen((A)->name) -const char SPIDER_empty_string = ""; -#endif -#if MYSQL_VERSION_ID >= 50500 -#define SPIDER_HAS_HASH_VALUE_TYPE -#endif - -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100400 #define SPIDER_date_mode_t(A) date_mode_t(A) #define SPIDER_str_to_datetime(A,B,C,D,E) str_to_datetime_or_date(A,B,C,D,E) #define SPIDER_get_linkage(A) A->get_linkage() -#else -#define SPIDER_date_mode_t(A) A -#define SPIDER_str_to_datetime(A,B,C,D,E) str_to_datetime(A,B,C,D,E) -#define SPIDER_get_linkage(A) A->linkage -#endif -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100500 typedef start_new_trans *SPIDER_Open_tables_backup; -#elif MYSQL_VERSION_ID < 50500 -typedef Open_tables_state SPIDER_Open_tables_backup; -#else -typedef Open_tables_backup SPIDER_Open_tables_backup; -#endif -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100500 #define SPIDER_reset_n_backup_open_tables_state(A,B,C) do { \ if (!(*(B) = new start_new_trans(A))) \ { \ @@ -262,12 +144,6 @@ typedef Open_tables_backup SPIDER_Open_tables_backup; delete *(B); \ } while (0) #define SPIDER_sys_close_thread_tables(A) (A)->commit_whole_transaction_and_close_tables() -#else -#define SPIDER_REQUIRE_DEFINE_FOR_SECONDARY_OPEN_TABLES_BACKUP -#define SPIDER_reset_n_backup_open_tables_state(A,B,C) (A)->reset_n_backup_open_tables_state(B) -#define SPIDER_restore_backup_open_tables_state(A,B) (A)->restore_backup_open_tables_state(B) -#define SPIDER_sys_close_thread_tables(A) close_thread_tables(A) -#endif #define spider_bitmap_size(A) ((A + 7) / 8) #define spider_set_bit(BITMAP, BIT) \ @@ -316,7 +192,6 @@ typedef struct st_spider_share SPIDER_SHARE; typedef struct st_spider_table_mon_list SPIDER_TABLE_MON_LIST; typedef struct st_spider_ip_port_conn SPIDER_IP_PORT_CONN; -#ifndef WITHOUT_SPIDER_BG_SEARCH typedef struct st_spider_thread { uint thread_idx; @@ -333,7 +208,6 @@ typedef struct st_spider_thread volatile SPIDER_SHARE *queue_first; volatile SPIDER_SHARE *queue_last; } SPIDER_THREAD; -#endif typedef struct st_spider_file_pos { @@ -348,9 +222,7 @@ typedef struct st_spider_link_for_hash ha_spider *spider; int link_idx; spider_string *db_table_str; -#ifdef SPIDER_HAS_HASH_VALUE_TYPE my_hash_value_type db_table_str_hash_value; -#endif } SPIDER_LINK_FOR_HASH; /* alter table */ @@ -360,9 +232,7 @@ typedef struct st_spider_alter_table char *table_name; uint table_name_length; char *tmp_char; -#ifdef SPIDER_HAS_HASH_VALUE_TYPE my_hash_value_type table_name_hash_value; -#endif longlong tmp_priority; uint link_count; uint all_link_count; @@ -464,9 +334,7 @@ typedef struct st_spider_conn uint conn_kind; char *conn_key; uint conn_key_length; -#ifdef SPIDER_HAS_HASH_VALUE_TYPE my_hash_value_type conn_key_hash_value; -#endif int link_idx; spider_db_conn *db_conn; uint opened_handlers; @@ -552,11 +420,8 @@ typedef struct st_spider_conn uint tgt_driver_length; uint dbton_id; -#ifndef WITHOUT_SPIDER_BG_SEARCH volatile -#endif void *quick_target; -#ifndef WITHOUT_SPIDER_BG_SEARCH volatile bool bg_init; volatile bool bg_break; volatile bool bg_kill; @@ -587,10 +452,7 @@ typedef struct st_spider_conn const char *bg_job_stack_file_name; ulong bg_job_stack_line_no; uint bg_job_stack_cur_pos; -#endif -#ifndef WITHOUT_SPIDER_BG_SEARCH volatile -#endif int *need_mon; int *conn_need_mon; @@ -622,12 +484,6 @@ typedef struct st_spider_conn Time_zone *queued_time_zone_val; XID *queued_xa_start_xid; -#ifdef HA_CAN_BULK_ACCESS - uint bulk_access_requests; - uint bulk_access_sended; - int bulk_access_error_num; - st_spider_conn *bulk_access_next; -#endif bool disable_connect_retry; /* TRUE if it is unnecessary to retry to connect after a @@ -639,10 +495,8 @@ typedef struct st_spider_conn query_id_t connect_error_query_id; time_t connect_error_time; -#ifdef SPIDER_HAS_GROUP_BY_HANDLER SPIDER_CONN_HOLDER *conn_holder_for_direct_join; SPIDER_LINK_IDX_CHAIN *link_idx_chain; -#endif SPIDER_IP_PORT_CONN *ip_port_conn; pthread_mutex_t loop_check_mutex; @@ -666,16 +520,13 @@ typedef struct st_spider_lgtm_tblhnd_share { char *table_name; uint table_name_length; -#ifdef SPIDER_HAS_HASH_VALUE_TYPE my_hash_value_type table_path_hash_value; -#endif pthread_mutex_t auto_increment_mutex; volatile bool auto_increment_init; volatile ulonglong auto_increment_lclval; ulonglong auto_increment_value; } SPIDER_LGTM_TBLHND_SHARE; -#ifdef WITH_PARTITION_STORAGE_ENGINE typedef struct st_spider_patition_handler { bool clone_bitmap_init; @@ -685,15 +536,12 @@ typedef struct st_spider_patition_handler ha_spider *owner; ha_spider **handlers; } SPIDER_PARTITION_HANDLER; -#endif typedef struct st_spider_wide_share { char *table_name; uint table_name_length; -#ifdef SPIDER_HAS_HASH_VALUE_TYPE my_hash_value_type table_path_hash_value; -#endif uint use_count; THR_LOCK lock; pthread_mutex_t sts_mutex; @@ -736,13 +584,9 @@ typedef struct st_spider_wide_handler uchar *rnd_write_bitmap; SPIDER_CONDITION *condition; void *owner; -#ifdef WITH_PARTITION_STORAGE_ENGINE SPIDER_PARTITION_HANDLER *partition_handler; -#endif -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS List<Item> *direct_update_fields; List<Item> *direct_update_values; -#endif TABLE_SHARE *top_share; enum thr_lock_type lock_type; uchar lock_table_type; @@ -751,14 +595,9 @@ typedef struct st_spider_wide_handler int cond_check_error; uint sql_command; uint top_table_fields; -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS #ifdef INFO_KIND_FORCE_LIMIT_BEGIN longlong info_limit; #endif -#endif -#ifdef HA_CAN_BULK_ACCESS - ulonglong external_lock_cnt; -#endif bool between_flg; bool idx_bitmap_is_set; bool rnd_bitmap_is_set; @@ -796,9 +635,6 @@ typedef struct st_spider_transaction bool updated_in_this_trx; THD *thd; -#ifdef SPIDER_HAS_HASH_VALUE_TYPE - my_hash_value_type thd_hash_value; -#endif XID xid; HASH trx_conn_hash; uint trx_conn_hash_id; @@ -833,10 +669,6 @@ typedef struct st_spider_transaction ulonglong direct_aggregate_count; ulonglong parallel_search_count; -#ifdef HA_CAN_BULK_ACCESS - SPIDER_CONN *bulk_access_conn_first; - SPIDER_CONN *bulk_access_conn_last; -#endif pthread_mutex_t *udf_table_mutexes; CHARSET_INFO *udf_access_charset; @@ -884,12 +716,8 @@ typedef struct st_spider_share */ TABLE_SHARE *table_share; SPIDER_LGTM_TBLHND_SHARE *lgtm_tblhnd_share; -#ifdef SPIDER_HAS_HASH_VALUE_TYPE my_hash_value_type table_name_hash_value; -#ifdef WITH_PARTITION_STORAGE_ENGINE my_hash_value_type table_path_hash_value; -#endif -#endif volatile bool init; volatile bool init_error; @@ -898,13 +726,10 @@ typedef struct st_spider_share uchar *table_mon_mutex_bitmap; volatile bool sts_init; volatile time_t sts_get_time; -#ifndef WITHOUT_SPIDER_BG_SEARCH volatile time_t bg_sts_try_time; volatile double bg_sts_interval; volatile int bg_sts_mode; -#ifdef WITH_PARTITION_STORAGE_ENGINE volatile int bg_sts_sync; -#endif volatile bool bg_sts_init; volatile bool bg_sts_kill; volatile bool bg_sts_thd_wait; @@ -913,15 +738,11 @@ typedef struct st_spider_share pthread_cond_t bg_sts_cond; pthread_cond_t bg_sts_sync_cond; volatile bool crd_init; -#endif volatile time_t crd_get_time; -#ifndef WITHOUT_SPIDER_BG_SEARCH volatile time_t bg_crd_try_time; volatile double bg_crd_interval; volatile int bg_crd_mode; -#ifdef WITH_PARTITION_STORAGE_ENGINE volatile int bg_crd_sync; -#endif volatile bool bg_crd_init; volatile bool bg_crd_kill; volatile bool bg_crd_thd_wait; @@ -929,8 +750,6 @@ typedef struct st_spider_share pthread_t bg_crd_thread; pthread_cond_t bg_crd_cond; pthread_cond_t bg_crd_sync_cond; -#endif -#ifndef WITHOUT_SPIDER_BG_SEARCH volatile bool bg_mon_init; volatile bool bg_mon_kill; THD **bg_mon_thds; @@ -938,8 +757,6 @@ typedef struct st_spider_share pthread_mutex_t *bg_mon_mutexes; pthread_cond_t *bg_mon_conds; pthread_cond_t *bg_mon_sleep_conds; -#endif -#ifndef WITHOUT_SPIDER_BG_SEARCH /* static bg thread for sts and crd */ TABLE table; ha_spider *sts_spider; @@ -956,7 +773,6 @@ typedef struct st_spider_share volatile SPIDER_SHARE *sts_next; volatile SPIDER_SHARE *crd_prev; volatile SPIDER_SHARE *crd_next; -#endif MEM_ROOT mem_root; @@ -978,24 +794,16 @@ typedef struct st_spider_share longlong additional_table_flags; bool have_recovery_link; -#ifndef WITHOUT_SPIDER_BG_SEARCH int sts_bg_mode; -#endif double sts_interval; int sts_mode; -#ifdef WITH_PARTITION_STORAGE_ENGINE int sts_sync; -#endif int store_last_sts; int load_sts_at_startup; -#ifndef WITHOUT_SPIDER_BG_SEARCH int crd_bg_mode; -#endif double crd_interval; int crd_mode; -#ifdef WITH_PARTITION_STORAGE_ENGINE int crd_sync; -#endif int store_last_crd; int load_crd_at_startup; int crd_type; @@ -1029,11 +837,9 @@ typedef struct st_spider_share int low_mem_read; int table_count_mode; int select_column_mode; -#ifndef WITHOUT_SPIDER_BG_SEARCH int bgs_mode; longlong bgs_first_read; longlong bgs_second_read; -#endif longlong first_read; longlong second_read; int auto_increment_mode; @@ -1047,9 +853,6 @@ typedef struct st_spider_share int error_read_mode; int error_write_mode; int active_link_count; -#ifdef HA_CAN_BULK_ACCESS - int bulk_access_free; -#endif #ifdef HA_CAN_FORCE_BULK_UPDATE int force_bulk_update; #endif @@ -1063,9 +866,7 @@ typedef struct st_spider_share char *bka_engine; int bka_engine_length; -#ifdef SPIDER_HAS_HASH_VALUE_TYPE my_hash_value_type *conn_keys_hash_value; -#endif char **server_names; char **tgt_table_names; char **tgt_dbs; @@ -1091,16 +892,12 @@ typedef struct st_spider_share long *tgt_ports; long *tgt_ssl_vscs; long *link_statuses; -#ifndef WITHOUT_SPIDER_BG_SEARCH long *monitoring_bg_flag; long *monitoring_bg_kind; -#endif long *monitoring_binlog_pos_at_failing; long *monitoring_flag; long *monitoring_kind; -#ifndef WITHOUT_SPIDER_BG_SEARCH longlong *monitoring_bg_interval; -#endif longlong *monitoring_limit; longlong *monitoring_sid; long *use_handlers; @@ -1183,16 +980,12 @@ typedef struct st_spider_share uint tgt_ports_length; uint tgt_ssl_vscs_length; uint link_statuses_length; -#ifndef WITHOUT_SPIDER_BG_SEARCH uint monitoring_bg_flag_length; uint monitoring_bg_kind_length; -#endif uint monitoring_binlog_pos_at_failing_length; uint monitoring_flag_length; uint monitoring_kind_length; -#ifndef WITHOUT_SPIDER_BG_SEARCH uint monitoring_bg_interval_length; -#endif uint monitoring_limit_length; uint monitoring_sid_length; uint use_handlers_length; @@ -1227,9 +1020,7 @@ typedef struct st_spider_init_error_table { char *table_name; uint table_name_length; -#ifdef SPIDER_HAS_HASH_VALUE_TYPE my_hash_value_type table_name_hash_value; -#endif bool init_error_with_message; char init_error_msg[MYSQL_ERRMSG_SIZE]; volatile int init_error; @@ -1244,8 +1035,6 @@ typedef struct st_spider_direct_sql TABLE **tables; int *iop; -#if MYSQL_VERSION_ID < 50500 -#else /* for using real table */ bool real_table_used; TABLE_LIST *table_list_first; @@ -1253,7 +1042,6 @@ typedef struct st_spider_direct_sql uchar *real_table_bitmap; SPIDER_Open_tables_backup open_tables_backup; THD *open_tables_thd; -#endif char *sql; ulong sql_length; @@ -1270,10 +1058,7 @@ typedef struct st_spider_direct_sql int net_write_timeout; longlong bulk_insert_rows; int connection_channel; -#if MYSQL_VERSION_ID < 50500 -#else int use_real_table; -#endif int error_rw_mode; char *server_name; @@ -1316,9 +1101,7 @@ typedef struct st_spider_direct_sql uint tgt_driver_length; uint conn_key_length; uint dbton_id; -#ifdef SPIDER_HAS_HASH_VALUE_TYPE my_hash_value_type conn_key_hash_value; -#endif pthread_mutex_t *bg_mutex; pthread_cond_t *bg_cond; @@ -1356,9 +1139,7 @@ typedef struct st_spider_table_mon_list { char *key; uint key_length; -#ifdef SPIDER_HAS_HASH_VALUE_TYPE my_hash_value_type key_hash_value; -#endif uint use_count; uint mutex_hash; @@ -1392,9 +1173,7 @@ typedef struct st_spider_copy_table_conn spider_db_copy_table *copy_table; ha_spider *spider; int need_mon; -#ifndef WITHOUT_SPIDER_BG_SEARCH int bg_error_num; -#endif st_spider_copy_table_conn *next; } SPIDER_COPY_TABLE_CONN; @@ -1419,9 +1198,7 @@ typedef struct st_spider_copy_tables longlong bulk_insert_rows; int use_table_charset; int use_transaction; -#ifndef WITHOUT_SPIDER_BG_SEARCH int bg_mode; -#endif char *database; @@ -1447,17 +1224,6 @@ typedef struct st_spider_trx_ha bool wait_for_reusing; } SPIDER_TRX_HA; -#ifdef HA_CAN_BULK_ACCESS -typedef struct st_spider_bulk_access_link -{ - ha_spider *spider; - uint sequence_num; - bool used; - bool called; - MEM_ROOT mem_root; - st_spider_bulk_access_link *next; -} SPIDER_BULK_ACCESS_LINK; -#endif #define SPIDER_INT_HLD_TGT_SIZE 100 typedef struct st_spider_int_hld @@ -1487,9 +1253,7 @@ char *spider_create_string( typedef struct st_spider_ip_port_conn { char *key; size_t key_len; -#ifdef SPIDER_HAS_HASH_VALUE_TYPE my_hash_value_type key_hash_value; -#endif char *remote_ip_str; long remote_port; ulong ip_port_count; diff --git a/storage/spider/spd_init_query.h b/storage/spider/spd_init_query.h index 1cf987134f6..e66e94d8373 100644 --- a/storage/spider/spd_init_query.h +++ b/storage/spider/spd_init_query.h @@ -12,7 +12,7 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA */ /* This SQL script creates system tables for SPIDER diff --git a/storage/spider/spd_malloc.cc b/storage/spider/spd_malloc.cc index 8a99e648afc..56f8218853b 100644 --- a/storage/spider/spd_malloc.cc +++ b/storage/spider/spd_malloc.cc @@ -18,15 +18,10 @@ #include <my_global.h> #include "mysql_version.h" #include "spd_environ.h" -#if MYSQL_VERSION_ID < 50500 -#include "mysql_priv.h" -#include <mysql/plugin.h> -#else #include "sql_priv.h" #include "probes_mysql.h" #include "sql_class.h" #include "sql_analyse.h" -#endif #include "spd_db_include.h" #include "spd_include.h" #include "spd_malloc.h" diff --git a/storage/spider/spd_param.cc b/storage/spider/spd_param.cc index b14c19fc2c2..c1b84ed4452 100644 --- a/storage/spider/spd_param.cc +++ b/storage/spider/spd_param.cc @@ -17,15 +17,10 @@ #include <my_global.h> #include "mysql_version.h" #include "spd_environ.h" -#if MYSQL_VERSION_ID < 50500 -#include "mysql_priv.h" -#include <mysql/plugin.h> -#else #include "sql_priv.h" #include "probes_mysql.h" #include "sql_class.h" #include "sql_partition.h" -#endif #include <my_getopt.h> #include "spd_err.h" #include "spd_db_include.h" @@ -36,15 +31,12 @@ extern struct st_mysql_plugin spider_i_s_alloc_mem; extern struct st_mysql_plugin spider_i_s_wrapper_protocols; -#ifdef MARIADB_BASE_VERSION extern struct st_maria_plugin spider_i_s_alloc_mem_maria; extern struct st_maria_plugin spider_i_s_wrapper_protocols_maria; -#endif extern volatile ulonglong spider_mon_table_cache_version; extern volatile ulonglong spider_mon_table_cache_version_req; -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS static int spider_direct_update(THD *thd, SHOW_VAR *var, char *buff) { int error_num = 0; @@ -66,7 +58,6 @@ static int spider_direct_delete(THD *thd, SHOW_VAR *var, char *buff) var->value = (char *) &trx->direct_delete_count; DBUG_RETURN(error_num); } -#endif static int spider_direct_order_limit(THD *thd, SHOW_VAR *var, char *buff) { @@ -107,7 +98,6 @@ struct st_mysql_show_var spider_status_variables[] = (char *) &spider_mon_table_cache_version, SHOW_LONGLONG}, {"Spider_mon_table_cache_version_req", (char *) &spider_mon_table_cache_version_req, SHOW_LONGLONG}, -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS #ifdef SPIDER_HAS_SHOW_SIMPLE_FUNC {"Spider_direct_update", (char *) &spider_direct_update, SHOW_SIMPLE_FUNC}, {"Spider_direct_delete", (char *) &spider_direct_delete, SHOW_SIMPLE_FUNC}, @@ -115,7 +105,6 @@ struct st_mysql_show_var spider_status_variables[] = {"Spider_direct_update", (char *) &spider_direct_update, SHOW_FUNC}, {"Spider_direct_delete", (char *) &spider_direct_delete, SHOW_FUNC}, #endif -#endif #ifdef SPIDER_HAS_SHOW_SIMPLE_FUNC {"Spider_direct_order_limit", (char *) &spider_direct_order_limit, SHOW_SIMPLE_FUNC}, @@ -135,13 +124,8 @@ struct st_mysql_show_var spider_status_variables[] = }; typedef DECLARE_MYSQL_THDVAR_SIMPLE(thdvar_int_t, int); -#if MYSQL_VERSION_ID < 50500 -extern bool throw_bounds_warning(THD *thd, bool fixed, bool unsignd, - const char *name, long long val); -#else extern bool throw_bounds_warning(THD *thd, const char *name, bool fixed, bool is_unsignd, longlong v); -#endif static my_bool spider_support_xa; static MYSQL_SYSVAR_BOOL( @@ -742,14 +726,9 @@ static int spider_param_semi_table_lock_check( (long) ((MYSQL_SYSVAR_NAME(thdvar_int_t) *) var)->blk_sz; options.arg_type = REQUIRED_ARG; *((int *) save) = (int) getopt_ll_limit_value(tmp, &options, &fixed); -#if MYSQL_VERSION_ID < 50500 - DBUG_RETURN(throw_bounds_warning(thd, fixed, FALSE, - ((MYSQL_SYSVAR_NAME(thdvar_int_t) *) var)->name, (long long) tmp)); -#else DBUG_RETURN(throw_bounds_warning(thd, ((MYSQL_SYSVAR_NAME(thdvar_int_t) *) var)->name, fixed, FALSE, (longlong) tmp)); -#endif } /* @@ -806,14 +785,9 @@ static int spider_param_semi_table_lock_connection_check( (long) ((MYSQL_SYSVAR_NAME(thdvar_int_t) *) var)->blk_sz; options.arg_type = REQUIRED_ARG; *((int *) save) = (int) getopt_ll_limit_value(tmp, &options, &fixed); -#if MYSQL_VERSION_ID < 50500 - DBUG_RETURN(throw_bounds_warning(thd, fixed, FALSE, - ((MYSQL_SYSVAR_NAME(thdvar_int_t) *) var)->name, (long long) tmp)); -#else DBUG_RETURN(throw_bounds_warning(thd, ((MYSQL_SYSVAR_NAME(thdvar_int_t) *) var)->name, fixed, FALSE, (longlong) tmp)); -#endif } /* @@ -1448,7 +1422,6 @@ int spider_param_select_column_mode( select_column_mode : THDVAR(thd, select_column_mode)); } -#ifndef WITHOUT_SPIDER_BG_SEARCH /* -1 :use table parameter 0 :background search is disabled @@ -1528,7 +1501,6 @@ longlong spider_param_bgs_second_read( DBUG_RETURN(THDVAR(thd, bgs_second_read) < 0 ? bgs_second_read : THDVAR(thd, bgs_second_read)); } -#endif /* -1 :use table parameter @@ -1636,7 +1608,6 @@ int spider_param_crd_mode( crd_mode : THDVAR(thd, crd_mode)); } -#ifdef WITH_PARTITION_STORAGE_ENGINE /* -1 :use table parameter 0 :No synchronization. @@ -1664,7 +1635,6 @@ int spider_param_crd_sync( DBUG_RETURN(THDVAR(thd, crd_sync) == -1 ? crd_sync : THDVAR(thd, crd_sync)); } -#endif /* -1 :use table parameter @@ -1718,7 +1688,6 @@ double spider_param_crd_weight( crd_weight : THDVAR(thd, crd_weight)); } -#ifndef WITHOUT_SPIDER_BG_SEARCH /* -1 :use table parameter 0 :Background confirmation is disabled @@ -1745,7 +1714,6 @@ int spider_param_crd_bg_mode( DBUG_RETURN(THDVAR(thd, crd_bg_mode) == -1 ? crd_bg_mode : THDVAR(thd, crd_bg_mode)); } -#endif /* -1 :use table parameter @@ -1800,7 +1768,6 @@ int spider_param_sts_mode( sts_mode : THDVAR(thd, sts_mode)); } -#ifdef WITH_PARTITION_STORAGE_ENGINE /* -1 :use table parameter 0 :No synchronization. @@ -1828,9 +1795,7 @@ int spider_param_sts_sync( DBUG_RETURN(THDVAR(thd, sts_sync) == -1 ? sts_sync : THDVAR(thd, sts_sync)); } -#endif -#ifndef WITHOUT_SPIDER_BG_SEARCH /* -1 :use table parameter 0 :Background confirmation is disabled @@ -1857,7 +1822,6 @@ int spider_param_sts_bg_mode( DBUG_RETURN(THDVAR(thd, sts_bg_mode) == -1 ? sts_bg_mode : THDVAR(thd, sts_bg_mode)); } -#endif /* 0 :always ping @@ -2102,19 +2066,6 @@ int spider_param_udf_ds_table_loop_mode( static char *spider_remote_access_charset; /* */ -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000 -static MYSQL_SYSVAR_STR( - remote_access_charset, - spider_remote_access_charset, - PLUGIN_VAR_MEMALLOC | - PLUGIN_VAR_RQCMDARG, - "Set remote access charset at connecting for improvement performance of connection if you know", - NULL, - NULL, - NULL -); -#else -#ifdef PLUGIN_VAR_CAN_MEMALLOC static MYSQL_SYSVAR_STR( remote_access_charset, spider_remote_access_charset, @@ -2125,18 +2076,6 @@ static MYSQL_SYSVAR_STR( NULL, NULL ); -#else -static MYSQL_SYSVAR_STR( - remote_access_charset, - spider_remote_access_charset, - PLUGIN_VAR_RQCMDARG, - "Set remote access charset at connecting for improvement performance of connection if you know", - NULL, - NULL, - NULL -); -#endif -#endif char *spider_param_remote_access_charset() { @@ -2172,19 +2111,6 @@ int spider_param_remote_autocommit() static char *spider_remote_time_zone; /* */ -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000 -static MYSQL_SYSVAR_STR( - remote_time_zone, - spider_remote_time_zone, - PLUGIN_VAR_MEMALLOC | - PLUGIN_VAR_RQCMDARG, - "Set remote time_zone at connecting for improvement performance of connection if you know", - NULL, - NULL, - NULL -); -#else -#ifdef PLUGIN_VAR_CAN_MEMALLOC static MYSQL_SYSVAR_STR( remote_time_zone, spider_remote_time_zone, @@ -2195,18 +2121,6 @@ static MYSQL_SYSVAR_STR( NULL, NULL ); -#else -static MYSQL_SYSVAR_STR( - remote_time_zone, - spider_remote_time_zone, - PLUGIN_VAR_RQCMDARG, - "Set remote time_zone at connecting for improvement performance of connection if you know", - NULL, - NULL, - NULL -); -#endif -#endif char *spider_param_remote_time_zone() { @@ -2269,7 +2183,6 @@ int spider_param_remote_trx_isolation() static char *spider_remote_default_database; /* */ -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000 static MYSQL_SYSVAR_STR( remote_default_database, spider_remote_default_database, @@ -2280,30 +2193,6 @@ static MYSQL_SYSVAR_STR( NULL, NULL ); -#else -#ifdef PLUGIN_VAR_CAN_MEMALLOC -static MYSQL_SYSVAR_STR( - remote_default_database, - spider_remote_default_database, - PLUGIN_VAR_MEMALLOC | - PLUGIN_VAR_RQCMDARG, - "Set remote database at connecting for improvement performance of connection if you know", - NULL, - NULL, - NULL -); -#else -static MYSQL_SYSVAR_STR( - remote_default_database, - spider_remote_default_database, - PLUGIN_VAR_RQCMDARG, - "Set remote database at connecting for improvement performance of connection if you know", - NULL, - NULL, - NULL -); -#endif -#endif char *spider_param_remote_default_database() { @@ -2361,7 +2250,6 @@ int spider_param_connect_retry_count( /* */ -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000 static MYSQL_THDVAR_STR( bka_engine, /* name */ PLUGIN_VAR_MEMALLOC | @@ -2371,28 +2259,6 @@ static MYSQL_THDVAR_STR( NULL, /* update */ NULL /* def */ ); -#else -#ifdef PLUGIN_VAR_CAN_MEMALLOC -static MYSQL_THDVAR_STR( - bka_engine, /* name */ - PLUGIN_VAR_MEMALLOC | - PLUGIN_VAR_RQCMDARG, - "Temporary table's engine for BKA", /* comment */ - NULL, /* check */ - NULL, /* update */ - NULL /* def */ -); -#else -static MYSQL_THDVAR_STR( - bka_engine, /* name */ - PLUGIN_VAR_RQCMDARG, - "Temporary table's engine for BKA", /* comment */ - NULL, /* check */ - NULL, /* update */ - NULL /* def */ -); -#endif -#endif char *spider_param_bka_engine( THD *thd, @@ -2665,37 +2531,7 @@ int spider_param_read_only_mode( read_only_mode : THDVAR(thd, read_only_mode)); } -#ifdef HA_CAN_BULK_ACCESS -static int spider_bulk_access_free; -/* - -1 :use table parameter - 0 :in reset - 1 :in close - */ -static MYSQL_SYSVAR_INT( - bulk_access_free, - spider_bulk_access_free, - PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY, - "Free mode of bulk access resources", - NULL, - NULL, - -1, - -1, - 1, - 0 -); -int spider_param_bulk_access_free( - int bulk_access_free -) { - DBUG_ENTER("spider_param_bulk_access_free"); - DBUG_RETURN(spider_bulk_access_free == -1 ? - bulk_access_free : spider_bulk_access_free); -} -#endif - -#if MYSQL_VERSION_ID < 50500 -#else /* -1 :use UDF parameter 0 :can not use @@ -2721,7 +2557,6 @@ int spider_param_udf_ds_use_real_table( DBUG_RETURN(THDVAR(thd, udf_ds_use_real_table) == -1 ? udf_ds_use_real_table : THDVAR(thd, udf_ds_use_real_table)); } -#endif static my_bool spider_general_log; static MYSQL_SYSVAR_BOOL( @@ -2853,17 +2688,6 @@ uint spider_param_log_result_error_with_sql() DBUG_RETURN(spider_log_result_error_with_sql); } -static char *spider_version = (char *) SPIDER_DETAIL_VERSION; -static MYSQL_SYSVAR_STR( - version, - spider_version, - PLUGIN_VAR_NOCMDOPT | PLUGIN_VAR_READONLY, - "The version of Spider", - NULL, - NULL, - SPIDER_DETAIL_VERSION -); - /* 0: server_id + thread_id 1: server_id + thread_id + query_id @@ -3115,7 +2939,6 @@ int spider_param_load_crd_at_startup( load_crd_at_startup : spider_load_crd_at_startup); } -#ifndef WITHOUT_SPIDER_BG_SEARCH static uint spider_table_sts_thread_count; /* 1-: thread count @@ -3161,7 +2984,6 @@ uint spider_param_table_crd_thread_count() DBUG_ENTER("spider_param_table_crd_thread_count"); DBUG_RETURN(spider_table_crd_thread_count); } -#endif static int spider_slave_trx_isolation; /* @@ -3338,35 +3160,25 @@ static struct st_mysql_sys_var* spider_system_variables[] = { MYSQL_SYSVAR(quick_page_byte), MYSQL_SYSVAR(low_mem_read), MYSQL_SYSVAR(select_column_mode), -#ifndef WITHOUT_SPIDER_BG_SEARCH MYSQL_SYSVAR(bgs_mode), MYSQL_SYSVAR(bgs_first_read), MYSQL_SYSVAR(bgs_second_read), -#endif MYSQL_SYSVAR(first_read), MYSQL_SYSVAR(second_read), MYSQL_SYSVAR(crd_interval), MYSQL_SYSVAR(crd_mode), -#ifdef WITH_PARTITION_STORAGE_ENGINE MYSQL_SYSVAR(crd_sync), -#endif MYSQL_SYSVAR(store_last_crd), MYSQL_SYSVAR(load_crd_at_startup), MYSQL_SYSVAR(crd_type), MYSQL_SYSVAR(crd_weight), -#ifndef WITHOUT_SPIDER_BG_SEARCH MYSQL_SYSVAR(crd_bg_mode), -#endif MYSQL_SYSVAR(sts_interval), MYSQL_SYSVAR(sts_mode), -#ifdef WITH_PARTITION_STORAGE_ENGINE MYSQL_SYSVAR(sts_sync), -#endif MYSQL_SYSVAR(store_last_sts), MYSQL_SYSVAR(load_sts_at_startup), -#ifndef WITHOUT_SPIDER_BG_SEARCH MYSQL_SYSVAR(sts_bg_mode), -#endif MYSQL_SYSVAR(ping_interval_at_trx_start), MYSQL_SYSVAR(auto_increment_mode), MYSQL_SYSVAR(same_server_link), @@ -3397,20 +3209,13 @@ static struct st_mysql_sys_var* spider_system_variables[] = { MYSQL_SYSVAR(skip_parallel_search), MYSQL_SYSVAR(direct_order_limit), MYSQL_SYSVAR(read_only_mode), -#ifdef HA_CAN_BULK_ACCESS - MYSQL_SYSVAR(bulk_access_free), -#endif -#if MYSQL_VERSION_ID < 50500 -#else MYSQL_SYSVAR(udf_ds_use_real_table), -#endif MYSQL_SYSVAR(general_log), MYSQL_SYSVAR(index_hint_pushdown), MYSQL_SYSVAR(max_connections), MYSQL_SYSVAR(conn_wait_timeout), MYSQL_SYSVAR(log_result_errors), MYSQL_SYSVAR(log_result_error_with_sql), - MYSQL_SYSVAR(version), MYSQL_SYSVAR(internal_xa_id_type), MYSQL_SYSVAR(casual_read), MYSQL_SYSVAR(dry_access), @@ -3418,10 +3223,8 @@ static struct st_mysql_sys_var* spider_system_variables[] = { MYSQL_SYSVAR(bka_table_name_type), MYSQL_SYSVAR(use_cond_other_than_pk_for_update), MYSQL_SYSVAR(connect_error_interval), -#ifndef WITHOUT_SPIDER_BG_SEARCH MYSQL_SYSVAR(table_sts_thread_count), MYSQL_SYSVAR(table_crd_thread_count), -#endif MYSQL_SYSVAR(slave_trx_isolation), MYSQL_SYSVAR(remote_wait_timeout), MYSQL_SYSVAR(wait_timeout), @@ -3444,15 +3247,12 @@ mysql_declare_plugin(spider) spider_status_variables, spider_system_variables, NULL, -#if MYSQL_VERSION_ID >= 50600 0, -#endif }, spider_i_s_alloc_mem, spider_i_s_wrapper_protocols mysql_declare_plugin_end; -#ifdef MARIADB_BASE_VERSION maria_declare_plugin(spider) { MYSQL_STORAGE_ENGINE_PLUGIN, @@ -3472,4 +3272,3 @@ maria_declare_plugin(spider) spider_i_s_alloc_mem_maria, spider_i_s_wrapper_protocols_maria maria_declare_plugin_end; -#endif diff --git a/storage/spider/spd_param.h b/storage/spider/spd_param.h index a6a9dd80026..0c5392e302a 100644 --- a/storage/spider/spd_param.h +++ b/storage/spider/spd_param.h @@ -182,7 +182,6 @@ int spider_param_select_column_mode( THD *thd, int select_column_mode ); -#ifndef WITHOUT_SPIDER_BG_SEARCH int spider_param_bgs_mode( THD *thd, int bgs_mode @@ -195,7 +194,6 @@ longlong spider_param_bgs_second_read( THD *thd, longlong bgs_second_read ); -#endif longlong spider_param_first_read( THD *thd, longlong first_read @@ -212,12 +210,10 @@ int spider_param_crd_mode( THD *thd, int crd_mode ); -#ifdef WITH_PARTITION_STORAGE_ENGINE int spider_param_crd_sync( THD *thd, int crd_sync ); -#endif int spider_param_crd_type( THD *thd, int crd_type @@ -226,12 +222,10 @@ double spider_param_crd_weight( THD *thd, double crd_weight ); -#ifndef WITHOUT_SPIDER_BG_SEARCH int spider_param_crd_bg_mode( THD *thd, int crd_bg_mode ); -#endif double spider_param_sts_interval( THD *thd, double sts_interval @@ -240,18 +234,14 @@ int spider_param_sts_mode( THD *thd, int sts_mode ); -#ifdef WITH_PARTITION_STORAGE_ENGINE int spider_param_sts_sync( THD *thd, int sts_sync ); -#endif -#ifndef WITHOUT_SPIDER_BG_SEARCH int spider_param_sts_bg_mode( THD *thd, int sts_bg_mode ); -#endif double spider_param_ping_interval_at_trx_start( THD *thd ); @@ -337,18 +327,10 @@ int spider_param_read_only_mode( THD *thd, int read_only_mode ); -#ifdef HA_CAN_BULK_ACCESS -int spider_param_bulk_access_free( - int bulk_access_free -); -#endif -#if MYSQL_VERSION_ID < 50500 -#else int spider_param_udf_ds_use_real_table( THD *thd, int udf_ds_use_real_table ); -#endif my_bool spider_param_general_log(); my_bool spider_param_index_hint_pushdown( THD *thd @@ -389,10 +371,8 @@ int spider_param_load_sts_at_startup( int spider_param_load_crd_at_startup( int load_crd_at_startup ); -#ifndef WITHOUT_SPIDER_BG_SEARCH uint spider_param_table_sts_thread_count(); uint spider_param_table_crd_thread_count(); -#endif int spider_param_slave_trx_isolation(); int spider_param_remote_wait_timeout( THD *thd diff --git a/storage/spider/spd_ping_table.cc b/storage/spider/spd_ping_table.cc index 8c2c8d2ce9e..fc550f05392 100644 --- a/storage/spider/spd_ping_table.cc +++ b/storage/spider/spd_ping_table.cc @@ -18,16 +18,11 @@ #include <my_global.h> #include "mysql_version.h" #include "spd_environ.h" -#if MYSQL_VERSION_ID < 50500 -#include "mysql_priv.h" -#include <mysql/plugin.h> -#else #include "sql_priv.h" #include "probes_mysql.h" #include "sql_class.h" #include "sql_partition.h" #include "sql_acl.h" -#endif #include "spd_err.h" #include "spd_param.h" #include "spd_db_include.h" @@ -88,9 +83,7 @@ SPIDER_TABLE_MON_LIST *spider_get_ping_table_mon_list( SPIDER_TABLE_MON_LIST *table_mon_list; MEM_ROOT mem_root; ulonglong mon_table_cache_version; -#ifdef SPIDER_HAS_HASH_VALUE_TYPE my_hash_value_type hash_value; -#endif DBUG_ENTER("spider_get_ping_table_mon_list"); if (spider_mon_table_cache_version != spider_mon_table_cache_version_req) { @@ -108,27 +101,17 @@ SPIDER_TABLE_MON_LIST *spider_get_ping_table_mon_list( spider_param_udf_table_mon_mutex_count()); DBUG_PRINT("info",("spider hash key=%s", str->c_ptr())); DBUG_PRINT("info",("spider hash key length=%u", str->length())); -#ifdef SPIDER_HAS_HASH_VALUE_TYPE hash_value = my_calc_hash( &spider_udf_table_mon_list_hash[mutex_hash], (uchar*) str->c_ptr(), str->length()); -#endif pthread_mutex_lock(&spider_udf_table_mon_mutexes[mutex_hash]); mon_table_cache_version = (ulonglong) spider_mon_table_cache_version; -#ifdef SPIDER_HAS_HASH_VALUE_TYPE if (!(table_mon_list = (SPIDER_TABLE_MON_LIST *) my_hash_search_using_hash_value( &spider_udf_table_mon_list_hash[mutex_hash], hash_value, (uchar*) str->c_ptr(), str->length())) || table_mon_list->mon_table_cache_version != mon_table_cache_version ) -#else - if (!(table_mon_list = (SPIDER_TABLE_MON_LIST *) my_hash_search( - &spider_udf_table_mon_list_hash[mutex_hash], - (uchar*) str->c_ptr(), str->length())) || - table_mon_list->mon_table_cache_version != mon_table_cache_version - ) -#endif { if ( table_mon_list && @@ -147,17 +130,9 @@ SPIDER_TABLE_MON_LIST *spider_get_ping_table_mon_list( table_mon_list->mon_table_cache_version = mon_table_cache_version; uint old_elements = spider_udf_table_mon_list_hash[mutex_hash].array.max_element; -#ifdef SPIDER_HAS_HASH_VALUE_TYPE table_mon_list->key_hash_value = hash_value; -#endif -#ifdef HASH_UPDATE_WITH_HASH_VALUE - if (my_hash_insert_with_hash_value( - &spider_udf_table_mon_list_hash[mutex_hash], - hash_value, (uchar*) table_mon_list)) -#else if (my_hash_insert(&spider_udf_table_mon_list_hash[mutex_hash], (uchar*) table_mon_list)) -#endif { spider_ping_table_free_mon_list(table_mon_list); *error_num = HA_ERR_OUT_OF_MEM; @@ -206,13 +181,8 @@ void spider_release_ping_table_mon_list_loop( SPIDER_TABLE_MON_LIST *table_mon_list ) { DBUG_ENTER("spider_release_ping_table_mon_list_loop"); -#ifdef HASH_UPDATE_WITH_HASH_VALUE - my_hash_delete_with_hash_value(&spider_udf_table_mon_list_hash[mutex_hash], - table_mon_list->key_hash_value, (uchar*) table_mon_list); -#else my_hash_delete(&spider_udf_table_mon_list_hash[mutex_hash], (uchar*) table_mon_list); -#endif while (TRUE) { if (table_mon_list->use_count) @@ -256,22 +226,14 @@ int spider_release_ping_table_mon_list( mutex_hash = spider_udf_calc_hash(conv_name_str.c_ptr_safe(), spider_param_udf_table_mon_mutex_count()); -#ifdef SPIDER_HAS_HASH_VALUE_TYPE my_hash_value_type hash_value = my_calc_hash( &spider_udf_table_mon_list_hash[mutex_hash], (uchar*) conv_name_str.c_ptr(), conv_name_str.length()); -#endif pthread_mutex_lock(&spider_udf_table_mon_mutexes[mutex_hash]); -#ifdef SPIDER_HAS_HASH_VALUE_TYPE if ((table_mon_list = (SPIDER_TABLE_MON_LIST *) my_hash_search_using_hash_value( &spider_udf_table_mon_list_hash[mutex_hash], hash_value, (uchar*) conv_name_str.c_ptr(), conv_name_str.length()))) -#else - if ((table_mon_list = (SPIDER_TABLE_MON_LIST *) my_hash_search( - &spider_udf_table_mon_list_hash[mutex_hash], - (uchar*) conv_name_str.c_ptr(), conv_name_str.length()))) -#endif spider_release_ping_table_mon_list_loop(mutex_hash, table_mon_list); pthread_mutex_unlock(&spider_udf_table_mon_mutexes[mutex_hash]); my_afree(buf); @@ -403,10 +365,8 @@ create_table_mon: if ( (error_num = spider_set_connect_info_default( tmp_share, -#ifdef WITH_PARTITION_STORAGE_ENGINE NULL, NULL, -#endif NULL )) || (error_num = spider_set_connect_info_default_dbtable( @@ -559,10 +519,8 @@ SPIDER_TABLE_MON_LIST *spider_get_ping_table_tgt( if ( (*error_num = spider_set_connect_info_default( tmp_share, -#ifdef WITH_PARTITION_STORAGE_ENGINE NULL, NULL, -#endif NULL )) || (*error_num = spider_set_connect_info_default_dbtable( @@ -581,43 +539,26 @@ SPIDER_TABLE_MON_LIST *spider_get_ping_table_tgt( if (tmp_share->link_statuses[0] == SPIDER_LINK_STATUS_NG) table_mon_list->mon_status = SPIDER_LINK_MON_NG; -#if MYSQL_VERSION_ID < 50500 - if (pthread_mutex_init(&table_mon_list->caller_mutex, MY_MUTEX_INIT_FAST)) -#else if (mysql_mutex_init(spd_key_mutex_mon_list_caller, &table_mon_list->caller_mutex, MY_MUTEX_INIT_FAST)) -#endif { *error_num = HA_ERR_OUT_OF_MEM; goto error_caller_mutex_init; } -#if MYSQL_VERSION_ID < 50500 - if (pthread_mutex_init(&table_mon_list->receptor_mutex, MY_MUTEX_INIT_FAST)) -#else if (mysql_mutex_init(spd_key_mutex_mon_list_receptor, &table_mon_list->receptor_mutex, MY_MUTEX_INIT_FAST)) -#endif { *error_num = HA_ERR_OUT_OF_MEM; goto error_receptor_mutex_init; } -#if MYSQL_VERSION_ID < 50500 - if (pthread_mutex_init(&table_mon_list->monitor_mutex, MY_MUTEX_INIT_FAST)) -#else if (mysql_mutex_init(spd_key_mutex_mon_list_monitor, &table_mon_list->monitor_mutex, MY_MUTEX_INIT_FAST)) -#endif { *error_num = HA_ERR_OUT_OF_MEM; goto error_monitor_mutex_init; } -#if MYSQL_VERSION_ID < 50500 - if (pthread_mutex_init(&table_mon_list->update_status_mutex, - MY_MUTEX_INIT_FAST)) -#else if (mysql_mutex_init(spd_key_mutex_mon_list_update_status, &table_mon_list->update_status_mutex, MY_MUTEX_INIT_FAST)) -#endif { *error_num = HA_ERR_OUT_OF_MEM; goto error_update_status_mutex_init; @@ -1086,23 +1027,14 @@ long long spider_ping_table_body( conv_name.init_calc_mem(135); tmp_str.init_calc_mem(247); conv_name.length(0); -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100002 server_id = global_system_variables.server_id; -#else - server_id = thd->server_id; -#endif if ( thd->open_tables != 0 || thd->handler_tables_hash.records != 0 || thd->derived_tables != 0 || thd->lock != 0 || -#if MYSQL_VERSION_ID < 50500 - thd->locked_tables != 0 || - thd->prelocked_mode != NON_PRELOCKED -#else thd->locked_tables_list.locked_tables() || thd->locked_tables_mode != LTM_NONE -#endif ) { if (thd->open_tables != 0) { @@ -1125,18 +1057,6 @@ long long spider_ping_table_body( my_printf_error(ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_NUM, ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_STR_WITH_PTR, MYF(0), "thd->lock", thd->lock); -#if MYSQL_VERSION_ID < 50500 - } else if (thd->locked_tables != 0) - { - my_printf_error(ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_NUM, - ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_STR_WITH_PTR, MYF(0), - "thd->locked_tables", thd->locked_tables); - } else if (thd->prelocked_mode != NON_PRELOCKED) - { - my_printf_error(ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_NUM, - ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_STR_WITH_NUM, MYF(0), - "thd->prelocked_mode", (longlong) thd->prelocked_mode); -#else } else if (thd->locked_tables_list.locked_tables()) { my_printf_error(ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_NUM, @@ -1148,7 +1068,6 @@ long long spider_ping_table_body( my_printf_error(ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_NUM, ER_SPIDER_UDF_CANT_USE_IF_OPEN_TABLE_STR_WITH_NUM, MYF(0), "thd->locked_tables_mode", (longlong) thd->locked_tables_mode); -#endif } goto error; } diff --git a/storage/spider/spd_sys_table.cc b/storage/spider/spd_sys_table.cc index 4bd30573b1c..a0cf104d46e 100644 --- a/storage/spider/spd_sys_table.cc +++ b/storage/spider/spd_sys_table.cc @@ -17,17 +17,12 @@ #include <my_global.h> #include "mysql_version.h" #include "spd_environ.h" -#if MYSQL_VERSION_ID < 50500 -#include "mysql_priv.h" -#include <mysql/plugin.h> -#else #include "sql_priv.h" #include "probes_mysql.h" #include "sql_class.h" #include "key.h" #include "sql_base.h" #include "tztime.h" -#endif #include "sql_select.h" #include "spd_err.h" #include "spd_param.h" @@ -245,22 +240,9 @@ TABLE *spider_open_sys_table( ) { TABLE *table; TABLE_LIST tables; -#if MYSQL_VERSION_ID < 50500 - TABLE_SHARE *table_share; - char table_key[MAX_DBKEY_LENGTH]; - uint table_key_length; -#endif DBUG_ENTER("spider_open_sys_table"); -#if MYSQL_VERSION_ID < 50500 - memset(&tables, 0, sizeof(TABLE_LIST)); - SPIDER_TABLE_LIST_db_str(&tables) = (char*)"mysql"; - SPIDER_TABLE_LIST_db_length(&tables) = sizeof("mysql") - 1; - SPIDER_TABLE_LIST_alias_str(&tables) = - SPIDER_TABLE_LIST_table_name_str(&tables) = (char *) table_name; - SPIDER_TABLE_LIST_table_name_length(&tables) = table_name_length; - tables.lock_type = (write ? TL_WRITE : TL_READ); -#else + #ifdef SPIDER_use_LEX_CSTRING_for_database_tablename_alias LEX_CSTRING db_name = { @@ -278,18 +260,7 @@ TABLE *spider_open_sys_table( "mysql", sizeof("mysql") - 1, table_name, table_name_length, table_name, (write ? TL_WRITE : TL_READ)); #endif -#endif - -#if MYSQL_VERSION_ID < 50500 - if (need_lock) - { -#endif -#if MYSQL_VERSION_ID < 50500 - if (!(table = open_performance_schema_table(thd, &tables, - open_tables_backup))) -#else if (!(table = spider_sys_open_table(thd, &tables, open_tables_backup))) -#endif { my_printf_error(ER_SPIDER_CANT_OPEN_SYS_TABLE_NUM, ER_SPIDER_CANT_OPEN_SYS_TABLE_STR, MYF(0), @@ -297,38 +268,6 @@ TABLE *spider_open_sys_table( *error_num = ER_SPIDER_CANT_OPEN_SYS_TABLE_NUM; DBUG_RETURN(NULL); } -#if MYSQL_VERSION_ID < 50500 - } else { - SPIDER_reset_n_backup_open_tables_state(thd, open_tables_backup, NULL); - - if (!(table = (TABLE*) spider_malloc(spider_current_trx, 12, - sizeof(*table), MYF(MY_WME)))) - { - *error_num = HA_ERR_OUT_OF_MEM; - goto error_malloc; - } - - table_key_length = - create_table_def_key(thd, table_key, &tables, FALSE); - - if (!(table_share = get_table_share(thd, - &tables, table_key, table_key_length, 0, error_num))) - goto error; - if (open_table_from_share(thd, table_share, tables.alias, - (uint) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE | HA_GET_INDEX), - READ_KEYINFO | COMPUTE_TYPES | EXTRA_RECORD, - (uint) HA_OPEN_IGNORE_IF_LOCKED | HA_OPEN_FROM_SQL_LAYER, - table, FALSE) - ) { - release_table_share(table_share, RELEASE_NORMAL); - 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; - goto error; - } - } -#endif switch (table_name_length) { case 9: @@ -589,13 +528,6 @@ TABLE *spider_open_sys_table( break; } DBUG_RETURN(table); - -#if MYSQL_VERSION_ID < 50500 -error: - spider_free(spider_current_trx, table, MYF(0)); -error_malloc: - SPIDER_restore_backup_open_tables_state(thd, open_tables_backup); -#endif error_col_num_chk: DBUG_RETURN(NULL); } @@ -607,24 +539,10 @@ void spider_close_sys_table( bool need_lock ) { DBUG_ENTER("spider_close_sys_table"); -#if MYSQL_VERSION_ID < 50500 - if (need_lock) - { - close_performance_schema_table(thd, open_tables_backup); - } else { - table->file->ha_reset(); - closefrm(table, TRUE); - spider_free(spider_current_trx, table, MYF(0)); - SPIDER_restore_backup_open_tables_state(thd, open_tables_backup); - } -#else spider_sys_close_table(thd, open_tables_backup); -#endif DBUG_VOID_RETURN; } -#if MYSQL_VERSION_ID < 50500 -#else bool spider_sys_open_and_lock_tables( THD *thd, TABLE_LIST **tables, @@ -692,7 +610,6 @@ void spider_sys_close_table( } DBUG_VOID_RETURN; } -#endif int spider_sys_index_init( TABLE *table, @@ -737,15 +654,9 @@ int spider_check_sys_table( table->key_info, table->key_info->key_length); -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 50200 DBUG_RETURN(table->file->ha_index_read_idx_map( table->record[0], 0, (uchar *) table_key, HA_WHOLE_KEY, HA_READ_KEY_EXACT)); -#else - DBUG_RETURN(table->file->index_read_idx_map( - table->record[0], 0, (uchar *) table_key, - HA_WHOLE_KEY, HA_READ_KEY_EXACT)); -#endif } int spider_check_sys_table_with_find_flag( @@ -761,15 +672,9 @@ int spider_check_sys_table_with_find_flag( table->key_info, table->key_info->key_length); -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 50200 DBUG_RETURN(table->file->ha_index_read_idx_map( table->record[0], 0, (uchar *) table_key, HA_WHOLE_KEY, find_flag)); -#else - DBUG_RETURN(table->file->index_read_idx_map( - table->record[0], 0, (uchar *) table_key, - HA_WHOLE_KEY, find_flag)); -#endif } int spider_check_sys_table_for_update_all_columns( @@ -784,15 +689,9 @@ int spider_check_sys_table_for_update_all_columns( table->key_info, table->key_info->key_length); -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 50200 DBUG_RETURN(table->file->ha_index_read_idx_map( table->record[1], 0, (uchar *) table_key, HA_WHOLE_KEY, HA_READ_KEY_EXACT)); -#else - DBUG_RETURN(table->file->index_read_idx_map( - table->record[1], 0, (uchar *) table_key, - HA_WHOLE_KEY, HA_READ_KEY_EXACT)); -#endif } int spider_get_sys_table_by_idx( @@ -827,26 +726,9 @@ int spider_get_sys_table_by_idx( key_length); if ( -/* -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 50200 - (error_num = table->file->ha_index_read_idx_map( - table->record[0], idx, (uchar *) table_key, - make_prev_keypart_map(col_count), HA_READ_KEY_EXACT)) -#else - (error_num = table->file->index_read_idx_map( - table->record[0], idx, (uchar *) table_key, - make_prev_keypart_map(col_count), HA_READ_KEY_EXACT)) -#endif -*/ -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 50200 (error_num = table->file->ha_index_read_map( table->record[0], (uchar *) table_key, make_prev_keypart_map(col_count), HA_READ_KEY_EXACT)) -#else - (error_num = table->file->index_read_map( - table->record[0], (uchar *) table_key, - make_prev_keypart_map(col_count), HA_READ_KEY_EXACT)) -#endif ) { spider_sys_index_end(table); DBUG_RETURN(error_num); @@ -859,17 +741,10 @@ int spider_sys_index_next_same( char *table_key ) { DBUG_ENTER("spider_sys_index_next_same"); -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 50200 DBUG_RETURN(table->file->ha_index_next_same( table->record[0], (const uchar*) table_key, table->key_info->key_length)); -#else - DBUG_RETURN(table->file->index_next_same( - table->record[0], - (const uchar*) table_key, - table->key_info->key_length)); -#endif } int spider_sys_index_first( @@ -882,11 +757,7 @@ int spider_sys_index_first( DBUG_RETURN(error_num); if ( -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 50200 (error_num = table->file->ha_index_first(table->record[0])) -#else - (error_num = table->file->index_first(table->record[0])) -#endif ) { spider_sys_index_end(table); DBUG_RETURN(error_num); @@ -904,11 +775,7 @@ int spider_sys_index_last( DBUG_RETURN(error_num); if ( -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 50200 (error_num = table->file->ha_index_last(table->record[0])) -#else - (error_num = table->file->index_last(table->record[0])) -#endif ) { spider_sys_index_end(table); DBUG_RETURN(error_num); @@ -920,11 +787,7 @@ int spider_sys_index_next( TABLE *table ) { DBUG_ENTER("spider_sys_index_next"); -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 50200 DBUG_RETURN(table->file->ha_index_next(table->record[0])); -#else - DBUG_RETURN(table->file->index_next(table->record[0])); -#endif } void spider_store_xa_pk( @@ -1832,12 +1695,6 @@ int 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 defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000 -#else - if (table->field[SPIDER_LINK_FAILED_LOG_FAILED_TIME_POS] == - table->timestamp_field) - table->timestamp_field->set_time(); -#endif if ((error_num = spider_write_sys_table_row(table))) { DBUG_RETURN(error_num); @@ -1871,12 +1728,6 @@ int spider_log_xa_failed( (uint) strlen(status), system_charset_info); -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000 -#else - if (table->field[SPIDER_XA_FAILED_LOG_FAILED_TIME_POS] == - table->timestamp_field) - table->timestamp_field->set_time(); -#endif if ((error_num = spider_write_sys_table_row(table))) { DBUG_RETURN(error_num); @@ -2882,11 +2733,7 @@ void spider_get_sys_table_sts_info( ha_statistics *stat ) { MYSQL_TIME mysql_time; -#ifdef MARIADB_BASE_VERSION uint not_used_uint; -#else - my_bool not_used_my_bool; -#endif long not_used_long; DBUG_ENTER("spider_get_sys_table_sts_info"); stat->data_file_length = (ulonglong) table-> @@ -2901,31 +2748,16 @@ void spider_get_sys_table_sts_info( 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)); -#ifdef MARIADB_BASE_VERSION stat->check_time = (time_t) my_system_gmt_sec(&mysql_time, ¬_used_long, ¬_used_uint); -#else - stat->check_time = (time_t) my_system_gmt_sec(&mysql_time, - ¬_used_long, ¬_used_my_bool); -#endif table->field[SPIDER_TABLE_STS_CREATE_TIME_POS]->get_date(&mysql_time, SPIDER_date_mode_t(0)); -#ifdef MARIADB_BASE_VERSION stat->create_time = (time_t) my_system_gmt_sec(&mysql_time, ¬_used_long, ¬_used_uint); -#else - stat->create_time = (time_t) my_system_gmt_sec(&mysql_time, - ¬_used_long, ¬_used_my_bool); -#endif table->field[SPIDER_TABLE_STS_UPDATE_TIME_POS]->get_date(&mysql_time, SPIDER_date_mode_t(0)); -#ifdef MARIADB_BASE_VERSION stat->update_time = (time_t) my_system_gmt_sec(&mysql_time, ¬_used_long, ¬_used_uint); -#else - stat->update_time = (time_t) my_system_gmt_sec(&mysql_time, - ¬_used_long, ¬_used_my_bool); -#endif if (table->field[SPIDER_TABLE_STS_CHECKSUM_POS]->is_null()) { stat->checksum_null = TRUE; @@ -3667,12 +3499,8 @@ int spider_sys_replace( if (table->file->ha_table_flags() & HA_DUPLICATE_POS) { -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 50200 error_num = table->file->ha_rnd_pos(table->record[1], table->file->dup_ref); -#else - error_num = table->file->rnd_pos(table->record[1], table->file->dup_ref); -#endif if (error_num) { if (error_num == HA_ERR_RECORD_DELETED) @@ -3685,13 +3513,8 @@ int spider_sys_replace( key_copy((uchar*)table_key, table->record[0], table->key_info + key_num, 0); -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 50200 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); -#else - error_num = table->file->index_read_idx_map(table->record[1], key_num, - (const uchar*)table_key, HA_WHOLE_KEY, HA_READ_KEY_EXACT); -#endif if (error_num) { if (error_num == HA_ERR_RECORD_DELETED) diff --git a/storage/spider/spd_sys_table.h b/storage/spider/spd_sys_table.h index 22f48b05dfb..36f72375f5a 100644 --- a/storage/spider/spd_sys_table.h +++ b/storage/spider/spd_sys_table.h @@ -103,8 +103,6 @@ void spider_close_sys_table( bool need_lock ); -#if MYSQL_VERSION_ID < 50500 -#else bool spider_sys_open_and_lock_tables( THD *thd, TABLE_LIST **tables, @@ -121,7 +119,6 @@ void spider_sys_close_table( THD *thd, SPIDER_Open_tables_backup *open_tables_backup ); -#endif int spider_sys_index_init( TABLE *table, diff --git a/storage/spider/spd_table.cc b/storage/spider/spd_table.cc index 88d1b07986e..ea7b471b245 100644 --- a/storage/spider/spd_table.cc +++ b/storage/spider/spd_table.cc @@ -18,10 +18,6 @@ #include <my_global.h> #include "mysql_version.h" #include "spd_environ.h" -#if MYSQL_VERSION_ID < 50500 -#include "mysql_priv.h" -#include <mysql/plugin.h> -#else #include "sql_priv.h" #include "probes_mysql.h" #include "my_getopt.h" @@ -32,7 +28,6 @@ #include "tztime.h" #include "sql_parse.h" #include "create_options.h" -#endif #include "spd_err.h" #include "spd_param.h" #include "spd_db_include.h" @@ -138,20 +133,13 @@ handlerton *spider_hton_ptr; SPIDER_DBTON spider_dbton[SPIDER_DBTON_SIZE]; extern SPIDER_DBTON spider_dbton_mysql; extern SPIDER_DBTON spider_dbton_mariadb; -#ifdef HAVE_ORACLE_OCI -extern SPIDER_DBTON spider_dbton_oracle; -#endif -#ifndef WITHOUT_SPIDER_BG_SEARCH SPIDER_THREAD *spider_table_sts_threads; SPIDER_THREAD *spider_table_crd_threads; -#endif #ifdef HAVE_PSI_INTERFACE PSI_mutex_key spd_key_mutex_tbl; PSI_mutex_key spd_key_mutex_init_error_tbl; -#ifdef WITH_PARTITION_STORAGE_ENGINE PSI_mutex_key spd_key_mutex_wide_share; -#endif PSI_mutex_key spd_key_mutex_lgtm_tblhnd_share; PSI_mutex_key spd_key_mutex_conn; PSI_mutex_key spd_key_mutex_open_conn; @@ -159,14 +147,12 @@ PSI_mutex_key spd_key_mutex_allocated_thds; PSI_mutex_key spd_key_mutex_mon_table_cache; PSI_mutex_key spd_key_mutex_udf_table_mon; PSI_mutex_key spd_key_mutex_mta_conn; -#ifndef WITHOUT_SPIDER_BG_SEARCH PSI_mutex_key spd_key_mutex_bg_conn_chain; PSI_mutex_key spd_key_mutex_bg_conn_sync; PSI_mutex_key spd_key_mutex_bg_conn; PSI_mutex_key spd_key_mutex_bg_job_stack; PSI_mutex_key spd_key_mutex_bg_mon; PSI_mutex_key spd_key_mutex_bg_direct_sql; -#endif PSI_mutex_key spd_key_mutex_mon_list_caller; PSI_mutex_key spd_key_mutex_mon_list_receptor; PSI_mutex_key spd_key_mutex_mon_list_monitor; @@ -175,29 +161,23 @@ PSI_mutex_key spd_key_mutex_share; PSI_mutex_key spd_key_mutex_share_sts; PSI_mutex_key spd_key_mutex_share_crd; PSI_mutex_key spd_key_mutex_share_auto_increment; -#ifdef WITH_PARTITION_STORAGE_ENGINE PSI_mutex_key spd_key_mutex_wide_share_sts; PSI_mutex_key spd_key_mutex_wide_share_crd; -#endif PSI_mutex_key spd_key_mutex_udf_table; PSI_mutex_key spd_key_mutex_mem_calc; PSI_mutex_key spd_key_thread_id; PSI_mutex_key spd_key_conn_id; PSI_mutex_key spd_key_mutex_ipport_count; PSI_mutex_key spd_key_mutex_conn_i; -#ifndef WITHOUT_SPIDER_BG_SEARCH PSI_mutex_key spd_key_mutex_bg_stss; PSI_mutex_key spd_key_mutex_bg_crds; -#endif PSI_mutex_key spd_key_mutex_conn_loop_check; static PSI_mutex_info all_spider_mutexes[]= { { &spd_key_mutex_tbl, "tbl", PSI_FLAG_GLOBAL}, { &spd_key_mutex_init_error_tbl, "init_error_tbl", PSI_FLAG_GLOBAL}, -#ifdef WITH_PARTITION_STORAGE_ENGINE { &spd_key_mutex_wide_share, "wide_share", PSI_FLAG_GLOBAL}, -#endif { &spd_key_mutex_lgtm_tblhnd_share, "lgtm_tblhnd_share", PSI_FLAG_GLOBAL}, { &spd_key_mutex_conn, "conn", PSI_FLAG_GLOBAL}, { &spd_key_mutex_open_conn, "open_conn", PSI_FLAG_GLOBAL}, @@ -208,20 +188,16 @@ static PSI_mutex_info all_spider_mutexes[]= { &spd_key_thread_id, "thread_id", PSI_FLAG_GLOBAL}, { &spd_key_conn_id, "conn_id", PSI_FLAG_GLOBAL}, { &spd_key_mutex_ipport_count, "ipport_count", PSI_FLAG_GLOBAL}, -#ifndef WITHOUT_SPIDER_BG_SEARCH { &spd_key_mutex_bg_stss, "bg_stss", PSI_FLAG_GLOBAL}, { &spd_key_mutex_bg_crds, "bg_crds", PSI_FLAG_GLOBAL}, -#endif { &spd_key_mutex_conn_i, "conn_i", 0}, { &spd_key_mutex_mta_conn, "mta_conn", 0}, -#ifndef WITHOUT_SPIDER_BG_SEARCH { &spd_key_mutex_bg_conn_chain, "bg_conn_chain", 0}, { &spd_key_mutex_bg_conn_sync, "bg_conn_sync", 0}, { &spd_key_mutex_bg_conn, "bg_conn", 0}, { &spd_key_mutex_bg_job_stack, "bg_job_stack", 0}, { &spd_key_mutex_bg_mon, "bg_mon", 0}, { &spd_key_mutex_bg_direct_sql, "bg_direct_sql", 0}, -#endif { &spd_key_mutex_mon_list_caller, "mon_list_caller", 0}, { &spd_key_mutex_mon_list_receptor, "mon_list_receptor", 0}, { &spd_key_mutex_mon_list_monitor, "mon_list_monitor", 0}, @@ -230,15 +206,12 @@ static PSI_mutex_info all_spider_mutexes[]= { &spd_key_mutex_share_sts, "share_sts", 0}, { &spd_key_mutex_share_crd, "share_crd", 0}, { &spd_key_mutex_share_auto_increment, "share_auto_increment", 0}, -#ifdef WITH_PARTITION_STORAGE_ENGINE { &spd_key_mutex_wide_share_sts, "wide_share_sts", 0}, { &spd_key_mutex_wide_share_crd, "wide_share_crd", 0}, -#endif { &spd_key_mutex_udf_table, "udf_table", 0}, { &spd_key_mutex_conn_loop_check, "conn_loop_check", 0}, }; -#ifndef WITHOUT_SPIDER_BG_SEARCH PSI_cond_key spd_key_cond_bg_conn_sync; PSI_cond_key spd_key_cond_bg_conn; PSI_cond_key spd_key_cond_bg_sts; @@ -248,18 +221,14 @@ PSI_cond_key spd_key_cond_bg_crd_sync; PSI_cond_key spd_key_cond_bg_mon; PSI_cond_key spd_key_cond_bg_mon_sleep; PSI_cond_key spd_key_cond_bg_direct_sql; -#endif PSI_cond_key spd_key_cond_udf_table_mon; PSI_cond_key spd_key_cond_conn_i; -#ifndef WITHOUT_SPIDER_BG_SEARCH PSI_cond_key spd_key_cond_bg_stss; PSI_cond_key spd_key_cond_bg_sts_syncs; PSI_cond_key spd_key_cond_bg_crds; PSI_cond_key spd_key_cond_bg_crd_syncs; -#endif static PSI_cond_info all_spider_conds[] = { -#ifndef WITHOUT_SPIDER_BG_SEARCH {&spd_key_cond_bg_conn_sync, "bg_conn_sync", 0}, {&spd_key_cond_bg_conn, "bg_conn", 0}, {&spd_key_cond_bg_sts, "bg_sts", 0}, @@ -269,35 +238,28 @@ static PSI_cond_info all_spider_conds[] = { {&spd_key_cond_bg_mon, "bg_mon", 0}, {&spd_key_cond_bg_mon_sleep, "bg_mon_sleep", 0}, {&spd_key_cond_bg_direct_sql, "bg_direct_sql", 0}, -#endif {&spd_key_cond_udf_table_mon, "udf_table_mon", 0}, {&spd_key_cond_conn_i, "conn_i", 0}, -#ifndef WITHOUT_SPIDER_BG_SEARCH {&spd_key_cond_bg_stss, "bg_stss", 0}, {&spd_key_cond_bg_sts_syncs, "bg_sts_syncs", 0}, {&spd_key_cond_bg_crds, "bg_crds", 0}, {&spd_key_cond_bg_crd_syncs, "bg_crd_syncs", 0}, -#endif }; -#ifndef WITHOUT_SPIDER_BG_SEARCH PSI_thread_key spd_key_thd_bg; PSI_thread_key spd_key_thd_bg_sts; PSI_thread_key spd_key_thd_bg_crd; PSI_thread_key spd_key_thd_bg_mon; PSI_thread_key spd_key_thd_bg_stss; PSI_thread_key spd_key_thd_bg_crds; -#endif static PSI_thread_info all_spider_threads[] = { -#ifndef WITHOUT_SPIDER_BG_SEARCH {&spd_key_thd_bg, "bg", 0}, {&spd_key_thd_bg_sts, "bg_sts", 0}, {&spd_key_thd_bg_crd, "bg_crd", 0}, {&spd_key_thd_bg_mon, "bg_mon", 0}, {&spd_key_thd_bg_stss, "bg_stss", 0}, {&spd_key_thd_bg_crds, "bg_crds", 0}, -#endif }; #endif @@ -352,14 +314,12 @@ extern pthread_mutex_t spider_thread_id_mutex; extern pthread_mutex_t spider_conn_id_mutex; extern pthread_mutex_t spider_ipport_conn_mutex; -#ifdef WITH_PARTITION_STORAGE_ENGINE HASH spider_open_wide_share; uint spider_open_wide_share_id; const char *spider_open_wide_share_func_name; const char *spider_open_wide_share_file_name; ulong spider_open_wide_share_line_no; pthread_mutex_t spider_wide_share_mutex; -#endif HASH spider_lgtm_tblhnd_share_hash; uint spider_lgtm_tblhnd_share_hash_id; @@ -375,9 +335,7 @@ const char *spider_allocated_thds_file_name; ulong spider_allocated_thds_line_no; pthread_mutex_t spider_allocated_thds_mutex; -#ifndef WITHOUT_SPIDER_BG_SEARCH pthread_attr_t spider_pt_attr; -#endif extern pthread_mutex_t spider_mem_calc_mutex; @@ -849,12 +807,10 @@ int spider_free_share_alloc( spider_free(spider_current_trx, share->tgt_ssl_vscs, MYF(0)); if (share->link_statuses) spider_free(spider_current_trx, share->link_statuses, MYF(0)); -#ifndef WITHOUT_SPIDER_BG_SEARCH if (share->monitoring_bg_flag) spider_free(spider_current_trx, share->monitoring_bg_flag, MYF(0)); if (share->monitoring_bg_kind) spider_free(spider_current_trx, share->monitoring_bg_kind, MYF(0)); -#endif if (share->monitoring_binlog_pos_at_failing) spider_free(spider_current_trx, share->monitoring_binlog_pos_at_failing, MYF(0)); if (share->monitoring_flag) @@ -875,10 +831,8 @@ int spider_free_share_alloc( spider_free(spider_current_trx, share->bka_table_name_types, MYF(0)); if (share->strict_group_bys) spider_free(spider_current_trx, share->strict_group_bys, MYF(0)); -#ifndef WITHOUT_SPIDER_BG_SEARCH if (share->monitoring_bg_interval) spider_free(spider_current_trx, share->monitoring_bg_interval, MYF(0)); -#endif if (share->monitoring_limit) spider_free(spider_current_trx, share->monitoring_limit, MYF(0)); if (share->monitoring_sid) @@ -2059,9 +2013,7 @@ int st_spider_param_string_parse::print_param_error() int spider_parse_connect_info( SPIDER_SHARE *share, TABLE_SHARE *table_share, -#ifdef WITH_PARTITION_STORAGE_ENGINE partition_info *part_info, -#endif uint create_table ) { int error_num = 0; @@ -2073,26 +2025,17 @@ int spider_parse_connect_info( SPIDER_PARAM_STRING_PARSE connect_string_parse; SPIDER_ALTER_TABLE *share_alter; ha_table_option_struct *option_struct; -#ifdef WITH_PARTITION_STORAGE_ENGINE partition_element *part_elem; partition_element *sub_elem; -#endif DBUG_ENTER("spider_parse_connect_info"); -#ifdef WITH_PARTITION_STORAGE_ENGINE -#if MYSQL_VERSION_ID < 50500 - DBUG_PRINT("info",("spider partition_info=%s", table_share->partition_info)); -#else DBUG_PRINT("info",("spider partition_info=%s", table_share->partition_info_str)); -#endif DBUG_PRINT("info",("spider part_info=%p", part_info)); -#endif DBUG_PRINT("info",("spider s->db=%s", table_share->db.str)); DBUG_PRINT("info",("spider s->table_name=%s", table_share->table_name.str)); DBUG_PRINT("info",("spider s->path=%s", table_share->path.str)); DBUG_PRINT("info", ("spider s->normalized_path=%s", table_share->normalized_path.str)); -#ifdef WITH_PARTITION_STORAGE_ENGINE spider_get_partition_info(share->table_name, share->table_name_length, table_share, part_info, &part_elem, &sub_elem); if (part_info) @@ -2101,26 +2044,17 @@ int spider_parse_connect_info( else option_struct= part_elem->option_struct; else -#endif option_struct= table_share->option_struct; -#ifndef WITHOUT_SPIDER_BG_SEARCH share->sts_bg_mode = -1; -#endif share->sts_interval = -1; share->sts_mode = -1; -#ifdef WITH_PARTITION_STORAGE_ENGINE share->sts_sync = -1; -#endif share->store_last_sts = -1; share->load_sts_at_startup = -1; -#ifndef WITHOUT_SPIDER_BG_SEARCH share->crd_bg_mode = -1; -#endif share->crd_interval = -1; share->crd_mode = -1; -#ifdef WITH_PARTITION_STORAGE_ENGINE share->crd_sync = -1; -#endif share->store_last_crd = -1; share->load_crd_at_startup = -1; share->crd_type = -1; @@ -2154,11 +2088,9 @@ int spider_parse_connect_info( share->low_mem_read = -1; share->table_count_mode = -1; share->select_column_mode = -1; -#ifndef WITHOUT_SPIDER_BG_SEARCH share->bgs_mode = -1; share->bgs_first_read = -1; share->bgs_second_read = -1; -#endif share->first_read = -1; share->second_read = -1; share->auto_increment_mode = -1; @@ -2173,9 +2105,6 @@ int spider_parse_connect_info( share->error_read_mode = -1; share->error_write_mode = -1; share->active_link_count = -1; -#ifdef HA_CAN_BULK_ACCESS - share->bulk_access_free = -1; -#endif #ifdef HA_CAN_FORCE_BULK_UPDATE share->force_bulk_update = -1; #endif @@ -2191,11 +2120,7 @@ int spider_parse_connect_info( share->static_key_cardinality[roop_count] = -1; } -#ifdef WITH_PARTITION_STORAGE_ENGINE for (roop_count = 4; roop_count > 0; roop_count--) -#else - for (roop_count = 2; roop_count > 0; roop_count--) -#endif { if (connect_string) { @@ -2204,7 +2129,6 @@ int spider_parse_connect_info( } switch (roop_count) { -#ifdef WITH_PARTITION_STORAGE_ENGINE case 4: if (!sub_elem || !sub_elem->part_comment) continue; @@ -2233,7 +2157,6 @@ int spider_parse_connect_info( } DBUG_PRINT("info",("spider part comment string=%s", connect_string)); break; -#endif case 2: if (table_share->comment.length == 0) continue; @@ -2305,16 +2228,11 @@ int spider_parse_connect_info( 2147483647); SPIDER_PARAM_INT_WITH_MAX("aim", auto_increment_mode, 0, 3); SPIDER_PARAM_INT("alc", active_link_count, 1); -#ifdef HA_CAN_BULK_ACCESS - SPIDER_PARAM_INT_WITH_MAX("baf", bulk_access_free, 0, 1); -#endif SPIDER_PARAM_DEPRECATED_WARNING("bfz"); SPIDER_PARAM_INT("bfz", buffer_size, 0); -#ifndef WITHOUT_SPIDER_BG_SEARCH SPIDER_PARAM_LONGLONG("bfr", bgs_first_read, 0); SPIDER_PARAM_INT("bmd", bgs_mode, 0); SPIDER_PARAM_LONGLONG("bsr", bgs_second_read, 0); -#endif SPIDER_PARAM_STR("bke", bka_engine); SPIDER_PARAM_INT_WITH_MAX("bkm", bka_mode, 0, 2); SPIDER_PARAM_INT("bsz", bulk_size, 0); @@ -2323,16 +2241,12 @@ int spider_parse_connect_info( 0, 1); SPIDER_PARAM_INT_WITH_MAX("bum", bulk_update_mode, 0, 2); SPIDER_PARAM_INT("bus", bulk_update_size, 0); -#ifndef WITHOUT_SPIDER_BG_SEARCH SPIDER_PARAM_INT_WITH_MAX("cbm", crd_bg_mode, 0, 2); -#endif SPIDER_PARAM_DOUBLE("civ", crd_interval, 0); SPIDER_PARAM_DEPRECATED_WARNING("cmd"); SPIDER_PARAM_INT_WITH_MAX("cmd", crd_mode, 0, 3); SPIDER_PARAM_INT_WITH_MAX("csr", casual_read, 0, 63); -#ifdef WITH_PARTITION_STORAGE_ENGINE SPIDER_PARAM_INT_WITH_MAX("csy", crd_sync, 0, 2); -#endif SPIDER_PARAM_LONG_LIST_WITH_MAX("cto", connect_timeouts, 0, 2147483647); SPIDER_PARAM_DEPRECATED_WARNING("ctp"); @@ -2368,12 +2282,10 @@ int spider_parse_connect_info( SPIDER_PARAM_INT_WITH_MAX("lcs", load_crd_at_startup, 0, 1); SPIDER_PARAM_INT_WITH_MAX("lss", load_sts_at_startup, 0, 1); SPIDER_PARAM_LONG_LIST_WITH_MAX("lst", link_statuses, 0, 3); -#ifndef WITHOUT_SPIDER_BG_SEARCH SPIDER_PARAM_LONG_LIST_WITH_MAX("mbf", monitoring_bg_flag, 0, 1); SPIDER_PARAM_LONGLONG_LIST_WITH_MAX( "mbi", monitoring_bg_interval, 0, 4294967295LL); SPIDER_PARAM_LONG_LIST_WITH_MAX("mbk", monitoring_bg_kind, 0, 3); -#endif SPIDER_PARAM_LONG_LIST_WITH_MAX("mbp", monitoring_binlog_pos_at_failing, 0, 2); SPIDER_PARAM_LONG_LIST_WITH_MAX("mfg", monitoring_flag, 0, 1); SPIDER_PARAM_LONG_LIST_WITH_MAX("mkd", monitoring_kind, 0, 3); @@ -2397,9 +2309,7 @@ int spider_parse_connect_info( SPIDER_PARAM_INT_WITH_MAX("rom", read_only_mode, 0, 1); SPIDER_PARAM_DOUBLE("rrt", read_rate, 0); SPIDER_PARAM_INT_WITH_MAX("rsa", reset_sql_alloc, 0, 1); -#ifndef WITHOUT_SPIDER_BG_SEARCH SPIDER_PARAM_INT_WITH_MAX("sbm", sts_bg_mode, 0, 2); -#endif SPIDER_PARAM_STR_LIST("sca", tgt_ssl_cas); SPIDER_PARAM_STR_LIST("sch", tgt_ssl_ciphers); SPIDER_PARAM_INT_WITH_MAX("scm", select_column_mode, 0, 1); @@ -2426,9 +2336,7 @@ int spider_parse_connect_info( option_struct->remote_server); SPIDER_PARAM_DOUBLE("ssr", semi_split_read, 0); SPIDER_PARAM_LONGLONG("ssl", semi_split_read_limit, 0); -#ifdef WITH_PARTITION_STORAGE_ENGINE SPIDER_PARAM_INT_WITH_MAX("ssy", sts_sync, 0, 2); -#endif SPIDER_PARAM_DEPRECATED_WARNING("stc"); SPIDER_PARAM_INT_WITH_MAX("stc", semi_table_lock_conn, 0, 1); SPIDER_PARAM_DEPRECATED_WARNING("stl"); @@ -2484,20 +2392,14 @@ int spider_parse_connect_info( SPIDER_PARAM_STR_LIST("password", tgt_passwords); SPIDER_PARAM_DEPRECATED_WARNING("sts_mode"); SPIDER_PARAM_INT_WITH_MAX("sts_mode", sts_mode, 1, 2); -#ifdef WITH_PARTITION_STORAGE_ENGINE SPIDER_PARAM_INT_WITH_MAX("sts_sync", sts_sync, 0, 2); -#endif SPIDER_PARAM_DEPRECATED_WARNING("crd_mode"); SPIDER_PARAM_INT_WITH_MAX("crd_mode", crd_mode, 0, 3); -#ifdef WITH_PARTITION_STORAGE_ENGINE SPIDER_PARAM_INT_WITH_MAX("crd_sync", crd_sync, 0, 2); -#endif SPIDER_PARAM_DEPRECATED_WARNING("crd_type"); SPIDER_PARAM_INT_WITH_MAX("crd_type", crd_type, 0, 2); SPIDER_PARAM_LONGLONG("priority", priority, 0); -#ifndef WITHOUT_SPIDER_BG_SEARCH SPIDER_PARAM_INT("bgs_mode", bgs_mode, 0); -#endif SPIDER_PARAM_STR_LIST("ssl_cert", tgt_ssl_certs); SPIDER_PARAM_INT_WITH_MAX("bka_mode", bka_mode, 0, 2); error_num = connect_string_parse.print_param_error(); @@ -2522,10 +2424,8 @@ int spider_parse_connect_info( goto error; case 11: SPIDER_PARAM_INT_WITH_MAX("query_cache", query_cache, 0, 2); -#ifndef WITHOUT_SPIDER_BG_SEARCH SPIDER_PARAM_INT_WITH_MAX("crd_bg_mode", crd_bg_mode, 0, 2); SPIDER_PARAM_INT_WITH_MAX("sts_bg_mode", sts_bg_mode, 0, 2); -#endif SPIDER_PARAM_LONG_LIST_WITH_MAX("link_status", link_statuses, 0, 3); SPIDER_PARAM_DEPRECATED_WARNING("use_handler"); SPIDER_PARAM_LONG_LIST_WITH_MAX("use_handler", use_handlers, 0, 3); @@ -2549,9 +2449,7 @@ int spider_parse_connect_info( case 14: SPIDER_PARAM_DEPRECATED_WARNING("internal_limit"); SPIDER_PARAM_LONGLONG("internal_limit", internal_limit, 0); -#ifndef WITHOUT_SPIDER_BG_SEARCH SPIDER_PARAM_LONGLONG("bgs_first_read", bgs_first_read, 0); -#endif SPIDER_PARAM_INT_WITH_MAX("read_only_mode", read_only_mode, 0, 1); SPIDER_PARAM_LONG_LIST_WITH_MAX("access_balance", access_balances, 0, 2147483647); @@ -2568,9 +2466,7 @@ int spider_parse_connect_info( SPIDER_PARAM_INT_WITH_MAX("semi_table_lock", semi_table_lock, 0, 1); SPIDER_PARAM_LONGLONG("quick_page_byte", quick_page_byte, 0); SPIDER_PARAM_LONGLONG("quick_page_size", quick_page_size, 0); -#ifndef WITHOUT_SPIDER_BG_SEARCH SPIDER_PARAM_LONGLONG("bgs_second_read", bgs_second_read, 0); -#endif SPIDER_PARAM_LONG_LIST_WITH_MAX("monitoring_flag", monitoring_flag, 0, 1); SPIDER_PARAM_LONG_LIST_WITH_MAX("monitoring_kind", monitoring_kind, 0, 3); SPIDER_PARAM_DOUBLE("semi_split_read", semi_split_read, 0); @@ -2599,10 +2495,6 @@ int spider_parse_connect_info( net_read_timeouts, 0, 2147483647); SPIDER_PARAM_INT_WITH_MAX( "error_write_mode", error_write_mode, 0, 1); -#ifdef HA_CAN_BULK_ACCESS - SPIDER_PARAM_INT_WITH_MAX( - "bulk_access_free", bulk_access_free, 0, 1); -#endif SPIDER_PARAM_INT_WITH_MAX( "query_cache_sync", query_cache_sync, 0, 3); error_num = connect_string_parse.print_param_error(); @@ -2630,12 +2522,10 @@ int spider_parse_connect_info( case 18: SPIDER_PARAM_INT_WITH_MAX( "select_column_mode", select_column_mode, 0, 1); -#ifndef WITHOUT_SPIDER_BG_SEARCH SPIDER_PARAM_LONG_LIST_WITH_MAX( "monitoring_bg_flag", monitoring_bg_flag, 0, 1); SPIDER_PARAM_LONG_LIST_WITH_MAX( "monitoring_bg_kind", monitoring_bg_kind, 0, 3); -#endif SPIDER_PARAM_LONGLONG( "direct_order_limit", direct_order_limit, 0); error_num = connect_string_parse.print_param_error(); @@ -2671,10 +2561,8 @@ int spider_parse_connect_info( case 22: SPIDER_PARAM_LONG_LIST_WITH_MAX( "ssl_verify_server_cert", tgt_ssl_vscs, 0, 1); -#ifndef WITHOUT_SPIDER_BG_SEARCH SPIDER_PARAM_LONGLONG_LIST_WITH_MAX( "monitoring_bg_interval", monitoring_bg_interval, 0, 4294967295LL); -#endif SPIDER_PARAM_INT_WITH_MAX( "skip_default_condition", skip_default_condition, 0, 1); SPIDER_PARAM_LONGLONG( @@ -2779,14 +2667,12 @@ int spider_parse_connect_info( share->all_link_count = share->monitoring_limit_length; if (share->all_link_count < share->monitoring_sid_length) share->all_link_count = share->monitoring_sid_length; -#ifndef WITHOUT_SPIDER_BG_SEARCH if (share->all_link_count < share->monitoring_bg_flag_length) share->all_link_count = share->monitoring_bg_flag_length; if (share->all_link_count < share->monitoring_bg_kind_length) share->all_link_count = share->monitoring_bg_kind_length; if (share->all_link_count < share->monitoring_bg_interval_length) share->all_link_count = share->monitoring_bg_interval_length; -#endif if (share->all_link_count < share->use_handlers_length) share->all_link_count = share->use_handlers_length; if (share->all_link_count < share->connect_timeouts_length) @@ -2963,7 +2849,6 @@ int spider_parse_connect_info( &share->link_statuses_length, share->all_link_count))) goto error; -#ifndef WITHOUT_SPIDER_BG_SEARCH if ((error_num = spider_increase_long_list( &share->monitoring_bg_flag, &share->monitoring_bg_flag_length, @@ -2974,7 +2859,6 @@ int spider_parse_connect_info( &share->monitoring_bg_kind_length, share->all_link_count))) goto error; -#endif if ((error_num = spider_increase_long_list( &share->monitoring_binlog_pos_at_failing, &share->monitoring_binlog_pos_at_failing_length, @@ -2990,13 +2874,11 @@ int spider_parse_connect_info( &share->monitoring_kind_length, share->all_link_count))) goto error; -#ifndef WITHOUT_SPIDER_BG_SEARCH if ((error_num = spider_increase_longlong_list( &share->monitoring_bg_interval, &share->monitoring_bg_interval_length, share->all_link_count))) goto error; -#endif if ((error_num = spider_increase_longlong_list( &share->monitoring_limit, &share->monitoring_limit_length, @@ -3302,10 +3184,8 @@ int spider_parse_connect_info( if ((error_num = spider_set_connect_info_default( share, -#ifdef WITH_PARTITION_STORAGE_ENGINE part_elem, sub_elem, -#endif table_share ))) goto error; @@ -3639,10 +3519,8 @@ error_alloc_conn_string: int spider_set_connect_info_default( SPIDER_SHARE *share, -#ifdef WITH_PARTITION_STORAGE_ENGINE partition_element *part_elem, partition_element *sub_elem, -#endif TABLE_SHARE *table_share ) { bool check_socket; @@ -3813,13 +3691,8 @@ int spider_set_connect_info_default( if ( !(share->tgt_table_names[roop_count] = spider_create_table_name_string( table_share->table_name.str, -#ifdef WITH_PARTITION_STORAGE_ENGINE (part_elem ? part_elem->partition_name : NULL), (sub_elem ? sub_elem->partition_name : NULL) -#else - NULL, - NULL -#endif )) ) { DBUG_RETURN(HA_ERR_OUT_OF_MEM); @@ -3929,30 +3802,22 @@ int spider_set_connect_info_default( if (share->link_statuses[roop_count] == -1) share->link_statuses[roop_count] = SPIDER_LINK_STATUS_NO_CHANGE; -#ifndef WITHOUT_SPIDER_BG_SEARCH if (share->monitoring_bg_flag[roop_count] == -1) share->monitoring_bg_flag[roop_count] = 0; if (share->monitoring_bg_kind[roop_count] == -1) share->monitoring_bg_kind[roop_count] = 0; -#endif if (share->monitoring_binlog_pos_at_failing[roop_count] == -1) share->monitoring_binlog_pos_at_failing[roop_count] = 0; if (share->monitoring_flag[roop_count] == -1) share->monitoring_flag[roop_count] = 0; if (share->monitoring_kind[roop_count] == -1) share->monitoring_kind[roop_count] = 0; -#ifndef WITHOUT_SPIDER_BG_SEARCH if (share->monitoring_bg_interval[roop_count] == -1) share->monitoring_bg_interval[roop_count] = 10000000; -#endif if (share->monitoring_limit[roop_count] == -1) share->monitoring_limit[roop_count] = 1; if (share->monitoring_sid[roop_count] == -1) -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100002 share->monitoring_sid[roop_count] = global_system_variables.server_id; -#else - share->monitoring_sid[roop_count] = current_thd->server_id; -#endif if (share->use_handlers[roop_count] == -1) share->use_handlers[roop_count] = 0; @@ -3970,34 +3835,26 @@ int spider_set_connect_info_default( share->strict_group_bys[roop_count] = 1; } -#ifndef WITHOUT_SPIDER_BG_SEARCH if (share->sts_bg_mode == -1) share->sts_bg_mode = 2; -#endif if (share->sts_interval == -1) share->sts_interval = 10; if (share->sts_mode == -1) share->sts_mode = 1; -#ifdef WITH_PARTITION_STORAGE_ENGINE if (share->sts_sync == -1) share->sts_sync = 0; -#endif if (share->store_last_sts == -1) share->store_last_sts = 1; if (share->load_sts_at_startup == -1) share->load_sts_at_startup = 1; -#ifndef WITHOUT_SPIDER_BG_SEARCH if (share->crd_bg_mode == -1) share->crd_bg_mode = 2; -#endif if (share->crd_interval == -1) share->crd_interval = 51; if (share->crd_mode == -1) share->crd_mode = 1; -#ifdef WITH_PARTITION_STORAGE_ENGINE if (share->crd_sync == -1) share->crd_sync = 0; -#endif if (share->store_last_crd == -1) share->store_last_crd = 1; if (share->load_crd_at_startup == -1) @@ -4064,14 +3921,12 @@ int spider_set_connect_info_default( share->table_count_mode = 0; if (share->select_column_mode == -1) share->select_column_mode = 1; -#ifndef WITHOUT_SPIDER_BG_SEARCH if (share->bgs_mode == -1) share->bgs_mode = 0; if (share->bgs_first_read == -1) share->bgs_first_read = 2; if (share->bgs_second_read == -1) share->bgs_second_read = 100; -#endif if (share->first_read == -1) share->first_read = 0; if (share->second_read == -1) @@ -4098,10 +3953,6 @@ int spider_set_connect_info_default( share->error_write_mode = 0; if (share->active_link_count == -1) share->active_link_count = share->all_link_count; -#ifdef HA_CAN_BULK_ACCESS - if (share->bulk_access_free == -1) - share->bulk_access_free = 0; -#endif #ifdef HA_CAN_FORCE_BULK_UPDATE if (share->force_bulk_update == -1) share->force_bulk_update = 0; @@ -4114,11 +3965,7 @@ int spider_set_connect_info_default( share->casual_read = 0; if (share->delete_all_rows_type == -1) { -#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS share->delete_all_rows_type = 1; -#else - share->delete_all_rows_type = 0; -#endif } if (share->bka_mode == -1) share->bka_mode = 1; @@ -4354,10 +4201,8 @@ int spider_create_conn_keys( __func__, __FILE__, __LINE__, MYF(MY_WME | MY_ZEROFILL), &share->conn_keys, sizeof(char *) * share->all_link_count, &share->conn_keys_lengths, length_base, -#ifdef SPIDER_HAS_HASH_VALUE_TYPE &share->conn_keys_hash_value, sizeof(my_hash_value_type) * share->all_link_count, -#endif &tmp_name, sizeof(char) * share->conn_keys_charlen, &share->sql_dbton_ids, length_base, NullS)) @@ -4505,11 +4350,9 @@ int spider_create_conn_keys( tmp_name++; tmp_name++; tmp_name++; -#ifdef SPIDER_HAS_HASH_VALUE_TYPE share->conn_keys_hash_value[roop_count] = my_calc_hash( &spider_open_connections, (uchar*) share->conn_keys[roop_count], share->conn_keys_lengths[roop_count]); -#endif } for (roop_count2 = 0; roop_count2 < SPIDER_DBTON_SIZE; roop_count2++) { @@ -4529,12 +4372,8 @@ int spider_create_conn_keys( SPIDER_SHARE *spider_create_share( const char *table_name, TABLE_SHARE *table_share, -#ifdef WITH_PARTITION_STORAGE_ENGINE partition_info *part_info, -#endif -#ifdef SPIDER_HAS_HASH_VALUE_TYPE my_hash_value_type hash_value, -#endif int *error_num ) { int bitmap_size, roop_count; @@ -4546,9 +4385,7 @@ SPIDER_SHARE *spider_create_share( uchar *tmp_cardinality_upd, *tmp_table_mon_mutex_bitmap; char buf[MAX_FIELD_WIDTH], *buf_pos; char link_idx_str[SPIDER_SQL_INT_LEN]; -#ifdef HA_HAS_CHECKSUM_EXTENDED bool checksum_support = TRUE; -#endif DBUG_ENTER("spider_create_share"); length = (uint) strlen(table_name); bitmap_size = spider_bitmap_size(table_share->fields); @@ -4583,19 +4420,13 @@ SPIDER_SHARE *spider_create_share( share->table_mon_mutex_bitmap = tmp_table_mon_mutex_bitmap; share->bitmap_size = bitmap_size; share->table_share = table_share; -#ifdef SPIDER_HAS_HASH_VALUE_TYPE share->table_name_hash_value = hash_value; -#ifdef WITH_PARTITION_STORAGE_ENGINE share->table_path_hash_value = my_calc_hash(&spider_open_tables, (uchar*) table_share->path.str, table_share->path.length); -#endif -#endif -#ifndef WITHOUT_SPIDER_BG_SEARCH share->table.s = table_share; share->table.field = table_share->field; share->table.key_info = table_share->key_info; share->table.read_set = &table_share->all_set; -#endif if (table_share->keys > 0 && !(share->key_hint = new spider_string[table_share->keys]) @@ -4608,9 +4439,7 @@ SPIDER_SHARE *spider_create_share( DBUG_PRINT("info",("spider share->key_hint=%p", share->key_hint)); if ((*error_num = spider_parse_connect_info(share, table_share, -#ifdef WITH_PARTITION_STORAGE_ENGINE part_info, -#endif 0))) goto error_parse_connect_string; @@ -4641,47 +4470,30 @@ SPIDER_SHARE *spider_create_share( if (share->table_count_mode & 2) share->additional_table_flags |= HA_HAS_RECORDS; -#if MYSQL_VERSION_ID < 50500 - if (pthread_mutex_init(&share->mutex, MY_MUTEX_INIT_FAST)) -#else if (mysql_mutex_init(spd_key_mutex_share, &share->mutex, MY_MUTEX_INIT_FAST)) -#endif { *error_num = HA_ERR_OUT_OF_MEM; goto error_init_mutex; } -#if MYSQL_VERSION_ID < 50500 - if (pthread_mutex_init(&share->sts_mutex, MY_MUTEX_INIT_FAST)) -#else if (mysql_mutex_init(spd_key_mutex_share_sts, &share->sts_mutex, MY_MUTEX_INIT_FAST)) -#endif { *error_num = HA_ERR_OUT_OF_MEM; goto error_init_sts_mutex; } -#if MYSQL_VERSION_ID < 50500 - if (pthread_mutex_init(&share->crd_mutex, MY_MUTEX_INIT_FAST)) -#else if (mysql_mutex_init(spd_key_mutex_share_crd, &share->crd_mutex, MY_MUTEX_INIT_FAST)) -#endif { *error_num = HA_ERR_OUT_OF_MEM; goto error_init_crd_mutex; } -#ifdef SPIDER_HAS_HASH_VALUE_TYPE if (!(share->lgtm_tblhnd_share = spider_get_lgtm_tblhnd_share(tmp_name, length, hash_value, FALSE, TRUE, error_num))) -#else - if (!(share->lgtm_tblhnd_share = - spider_get_lgtm_tblhnd_share(tmp_name, length, FALSE, TRUE, error_num))) -#endif { goto error_get_lgtm_tblhnd_share; } @@ -4704,24 +4516,20 @@ SPIDER_SHARE *spider_create_share( { goto error_init_dbton; } -#ifdef HA_HAS_CHECKSUM_EXTENDED if ( spider_dbton[roop_count].db_access_type == SPIDER_DB_ACCESS_TYPE_SQL && !share->dbton_share[roop_count]->checksum_support() ) { checksum_support = FALSE; } -#endif } } -#ifdef HA_HAS_CHECKSUM_EXTENDED if (checksum_support) { share->additional_table_flags |= HA_HAS_OLD_CHECKSUM | HA_HAS_NEW_CHECKSUM; } -#endif DBUG_RETURN(share); /* @@ -4769,15 +4577,11 @@ SPIDER_SHARE *spider_get_share( int roop_count; double sts_interval; int sts_mode; -#ifdef WITH_PARTITION_STORAGE_ENGINE int sts_sync; int auto_increment_mode; -#endif double crd_interval; int crd_mode; -#ifdef WITH_PARTITION_STORAGE_ENGINE int crd_sync; -#endif char first_byte; int semi_table_lock_conn; int search_link_idx; @@ -4796,10 +4600,8 @@ SPIDER_SHARE *spider_get_share( DBUG_ENTER("spider_get_share"); top_share = spider->wide_handler->top_share; length = (uint) strlen(table_name); -#ifdef SPIDER_HAS_HASH_VALUE_TYPE my_hash_value_type hash_value = my_calc_hash(&spider_open_tables, (uchar*) table_name, length); -#endif if (top_share) { lex_str.length = top_share->path.length + SPIDER_SQL_LOP_CHK_PRM_PRF_LEN; @@ -4844,34 +4646,20 @@ SPIDER_SHARE *spider_get_share( my_afree(loop_check_buf); } pthread_mutex_lock(&spider_tbl_mutex); -#ifdef SPIDER_HAS_HASH_VALUE_TYPE if (!(share = (SPIDER_SHARE*) my_hash_search_using_hash_value( &spider_open_tables, hash_value, (uchar*) table_name, length))) -#else - if (!(share = (SPIDER_SHARE*) my_hash_search(&spider_open_tables, - (uchar*) table_name, length))) -#endif { if (!(share = spider_create_share( table_name, table_share, -#ifdef WITH_PARTITION_STORAGE_ENGINE table->part_info, -#endif -#ifdef SPIDER_HAS_HASH_VALUE_TYPE hash_value, -#endif error_num ))) { goto error_alloc_share; } uint old_elements = spider_open_tables.array.max_element; -#ifdef HASH_UPDATE_WITH_HASH_VALUE - if (my_hash_insert_with_hash_value(&spider_open_tables, hash_value, - (uchar*) share)) -#else if (my_hash_insert(&spider_open_tables, (uchar*) share)) -#endif { *error_num = HA_ERR_OUT_OF_MEM; goto error_hash_insert; @@ -5008,7 +4796,6 @@ SPIDER_SHARE *spider_get_share( } spider->set_error_mode(); -#ifndef WITHOUT_SPIDER_BG_SEARCH if (!share->sts_spider_init) { pthread_mutex_lock(&share->mutex); @@ -5024,14 +4811,9 @@ SPIDER_SHARE *spider_get_share( spider_free_share(share); goto error_sts_spider_init; } -#ifdef HASH_UPDATE_WITH_HASH_VALUE - share->sts_thread = &spider_table_sts_threads[ - hash_value % spider_param_table_sts_thread_count()]; -#else share->sts_thread = &spider_table_sts_threads[ my_calc_hash(&spider_open_tables, (uchar*) table_name, length) % spider_param_table_sts_thread_count()]; -#endif share->sts_spider_init = TRUE; } pthread_mutex_unlock(&share->mutex); @@ -5052,21 +4834,14 @@ SPIDER_SHARE *spider_get_share( spider_free_share(share); goto error_crd_spider_init; } -#ifdef HASH_UPDATE_WITH_HASH_VALUE - share->crd_thread = &spider_table_crd_threads[ - hash_value % spider_param_table_crd_thread_count()]; -#else share->crd_thread = &spider_table_crd_threads[ my_calc_hash(&spider_open_tables, (uchar*) table_name, length) % spider_param_table_crd_thread_count()]; -#endif share->crd_spider_init = TRUE; } pthread_mutex_unlock(&share->mutex); } -#endif -#ifndef WITHOUT_SPIDER_BG_SEARCH if ( sql_command != SQLCOM_DROP_TABLE && sql_command != SQLCOM_ALTER_TABLE && @@ -5080,7 +4855,6 @@ SPIDER_SHARE *spider_get_share( spider_free_share(share); goto error_but_no_delete; } -#endif if (!(spider->conn_keys = (char **) spider_bulk_alloc_mem(spider_current_trx, 47, @@ -5278,20 +5052,16 @@ SPIDER_SHARE *spider_get_share( SPIDER_INIT_ERROR_TABLE *spider_init_error_table; sts_interval = spider_param_sts_interval(thd, share->sts_interval); sts_mode = spider_param_sts_mode(thd, share->sts_mode); -#ifdef WITH_PARTITION_STORAGE_ENGINE sts_sync = spider_param_sts_sync(thd, share->sts_sync); auto_increment_mode = spider_param_auto_increment_mode(thd, share->auto_increment_mode); if (auto_increment_mode == 1) sts_sync = 0; -#endif crd_interval = spider_param_crd_interval(thd, share->crd_interval); crd_mode = spider_param_crd_mode(thd, share->crd_mode); if (crd_mode == 3) crd_mode = 1; -#ifdef WITH_PARTITION_STORAGE_ENGINE crd_sync = spider_param_crd_sync(thd, share->crd_sync); -#endif time_t tmp_time = (time_t) time((time_t*) 0); pthread_mutex_lock(&share->sts_mutex); pthread_mutex_lock(&share->crd_mutex); @@ -5323,9 +5093,7 @@ SPIDER_SHARE *spider_get_share( ) && (*error_num = spider_get_sts(share, spider->search_link_idx, tmp_time, spider, sts_interval, sts_mode, -#ifdef WITH_PARTITION_STORAGE_ENGINE sts_sync, -#endif 1, HA_STATUS_VARIABLE | HA_STATUS_CONST | HA_STATUS_AUTO)) ) { if (*error_num != ER_SPIDER_SYS_TABLE_VERSION_NUM) @@ -5347,9 +5115,7 @@ SPIDER_SHARE *spider_get_share( ) && (*error_num = spider_get_crd(share, spider->search_link_idx, tmp_time, spider, table, crd_interval, crd_mode, -#ifdef WITH_PARTITION_STORAGE_ENGINE crd_sync, -#endif 1)) ) { if (*error_num != ER_SPIDER_SYS_TABLE_VERSION_NUM) @@ -5503,7 +5269,6 @@ SPIDER_SHARE *spider_get_share( } spider->set_error_mode(); -#ifndef WITHOUT_SPIDER_BG_SEARCH if (!share->sts_spider_init) { pthread_mutex_lock(&share->mutex); @@ -5516,14 +5281,9 @@ SPIDER_SHARE *spider_get_share( spider_free_share(share); goto error_sts_spider_init; } -#ifdef HASH_UPDATE_WITH_HASH_VALUE - share->sts_thread = &spider_table_sts_threads[ - hash_value % spider_param_table_sts_thread_count()]; -#else share->sts_thread = &spider_table_sts_threads[ my_calc_hash(&spider_open_tables, (uchar*) table_name, length) % spider_param_table_sts_thread_count()]; -#endif share->sts_spider_init = TRUE; } pthread_mutex_unlock(&share->mutex); @@ -5541,21 +5301,14 @@ SPIDER_SHARE *spider_get_share( spider_free_share(share); goto error_crd_spider_init; } -#ifdef HASH_UPDATE_WITH_HASH_VALUE - share->crd_thread = &spider_table_crd_threads[ - hash_value % spider_param_table_crd_thread_count()]; -#else share->crd_thread = &spider_table_crd_threads[ my_calc_hash(&spider_open_tables, (uchar*) table_name, length) % spider_param_table_crd_thread_count()]; -#endif share->crd_spider_init = TRUE; } pthread_mutex_unlock(&share->mutex); } -#endif -#ifndef WITHOUT_SPIDER_BG_SEARCH if ( sql_command != SQLCOM_DROP_TABLE && sql_command != SQLCOM_ALTER_TABLE && @@ -5566,7 +5319,6 @@ SPIDER_SHARE *spider_get_share( spider_free_share(share); goto error_but_no_delete; } -#endif if (!(spider->conn_keys = (char **) spider_bulk_alloc_mem(spider_current_trx, 49, @@ -5752,20 +5504,16 @@ SPIDER_SHARE *spider_get_share( SPIDER_INIT_ERROR_TABLE *spider_init_error_table; sts_interval = spider_param_sts_interval(thd, share->sts_interval); sts_mode = spider_param_sts_mode(thd, share->sts_mode); -#ifdef WITH_PARTITION_STORAGE_ENGINE sts_sync = spider_param_sts_sync(thd, share->sts_sync); auto_increment_mode = spider_param_auto_increment_mode(thd, share->auto_increment_mode); if (auto_increment_mode == 1) sts_sync = 0; -#endif crd_interval = spider_param_crd_interval(thd, share->crd_interval); crd_mode = spider_param_crd_mode(thd, share->crd_mode); if (crd_mode == 3) crd_mode = 1; -#ifdef WITH_PARTITION_STORAGE_ENGINE crd_sync = spider_param_crd_sync(thd, share->crd_sync); -#endif time_t tmp_time = (time_t) time((time_t*) 0); if ((spider_init_error_table = spider_get_init_error_table(spider->wide_handler->trx, share, @@ -5794,9 +5542,7 @@ SPIDER_SHARE *spider_get_share( ) && (*error_num = spider_get_sts(share, spider->search_link_idx, tmp_time, spider, sts_interval, sts_mode, -#ifdef WITH_PARTITION_STORAGE_ENGINE sts_sync, -#endif 1, HA_STATUS_VARIABLE | HA_STATUS_CONST | HA_STATUS_AUTO)) ) { if (*error_num != ER_SPIDER_SYS_TABLE_VERSION_NUM) @@ -5815,9 +5561,7 @@ SPIDER_SHARE *spider_get_share( ) && (*error_num = spider_get_crd(share, spider->search_link_idx, tmp_time, spider, table, crd_interval, crd_mode, -#ifdef WITH_PARTITION_STORAGE_ENGINE crd_sync, -#endif 1)) ) { if (*error_num != ER_SPIDER_SYS_TABLE_VERSION_NUM) @@ -5861,10 +5605,8 @@ error_hash_insert: error_alloc_share: pthread_mutex_unlock(&spider_tbl_mutex); error_open_sys_table: -#ifndef WITHOUT_SPIDER_BG_SEARCH error_crd_spider_init: error_sts_spider_init: -#endif if (init_mem_root) { free_root(&mem_root, MYF(0)); @@ -5895,7 +5637,6 @@ int spider_free_share( THD *thd = current_thd; if (!--share->use_count) { -#ifndef WITHOUT_SPIDER_BG_SEARCH spider_free_sts_thread(share); spider_free_crd_thread(share); spider_free_mon_threads(share); @@ -5909,7 +5650,6 @@ int spider_free_share( spider_table_remove_share_from_crd_thread(share); spider_free_spider_object_for_share(&share->crd_spider); } -#endif if ( share->sts_init && share->table_share->tmp_table == NO_TMP_TABLE && @@ -5954,12 +5694,7 @@ int spider_free_share( ); } spider_free_share_alloc(share); -#ifdef HASH_UPDATE_WITH_HASH_VALUE - my_hash_delete_with_hash_value(&spider_open_tables, - share->table_name_hash_value, (uchar*) share); -#else my_hash_delete(&spider_open_tables, (uchar*) share); -#endif pthread_mutex_destroy(&share->crd_mutex); pthread_mutex_destroy(&share->sts_mutex); pthread_mutex_destroy(&share->mutex); @@ -5981,19 +5716,12 @@ void spider_update_link_status_for_share( SPIDER_SHARE *share; DBUG_ENTER("spider_update_link_status_for_share"); -#ifdef SPIDER_HAS_HASH_VALUE_TYPE my_hash_value_type hash_value = my_calc_hash(&spider_open_tables, (uchar*) table_name, table_name_length); -#endif pthread_mutex_lock(&spider_tbl_mutex); -#ifdef SPIDER_HAS_HASH_VALUE_TYPE if ((share = (SPIDER_SHARE*) my_hash_search_using_hash_value( &spider_open_tables, hash_value, (uchar*) table_name, table_name_length))) -#else - if ((share = (SPIDER_SHARE*) my_hash_search(&spider_open_tables, - (uchar*) table_name, table_name_length))) -#endif { DBUG_PRINT("info", ("spider share->link_status_init=%s", share->link_status_init ? "TRUE" : "FALSE")); @@ -6008,7 +5736,6 @@ void spider_update_link_status_for_share( DBUG_VOID_RETURN; } -#ifdef SPIDER_HAS_HASH_VALUE_TYPE SPIDER_LGTM_TBLHND_SHARE *spider_get_lgtm_tblhnd_share( const char *table_name, uint table_name_length, @@ -6017,15 +5744,6 @@ SPIDER_LGTM_TBLHND_SHARE *spider_get_lgtm_tblhnd_share( bool need_to_create, int *error_num ) -#else -SPIDER_LGTM_TBLHND_SHARE *spider_get_lgtm_tblhnd_share( - const char *table_name, - uint table_name_length, - bool locked, - bool need_to_create, - int *error_num -) -#endif { SPIDER_LGTM_TBLHND_SHARE *lgtm_tblhnd_share; char *tmp_name; @@ -6033,16 +5751,10 @@ SPIDER_LGTM_TBLHND_SHARE *spider_get_lgtm_tblhnd_share( if (!locked) pthread_mutex_lock(&spider_lgtm_tblhnd_share_mutex); -#ifdef SPIDER_HAS_HASH_VALUE_TYPE if (!(lgtm_tblhnd_share = (SPIDER_LGTM_TBLHND_SHARE*) my_hash_search_using_hash_value( &spider_lgtm_tblhnd_share_hash, hash_value, (uchar*) table_name, table_name_length))) -#else - if (!(lgtm_tblhnd_share = (SPIDER_LGTM_TBLHND_SHARE*) my_hash_search( - &spider_lgtm_tblhnd_share_hash, - (uchar*) table_name, table_name_length))) -#endif { DBUG_PRINT("info",("spider create new lgtm tblhnd share")); if (!(lgtm_tblhnd_share = (SPIDER_LGTM_TBLHND_SHARE *) @@ -6059,30 +5771,18 @@ SPIDER_LGTM_TBLHND_SHARE *spider_get_lgtm_tblhnd_share( lgtm_tblhnd_share->table_name = tmp_name; memcpy(lgtm_tblhnd_share->table_name, table_name, lgtm_tblhnd_share->table_name_length); -#ifdef SPIDER_HAS_HASH_VALUE_TYPE lgtm_tblhnd_share->table_path_hash_value = hash_value; -#endif -#if MYSQL_VERSION_ID < 50500 - if (pthread_mutex_init(&lgtm_tblhnd_share->auto_increment_mutex, - MY_MUTEX_INIT_FAST)) -#else if (mysql_mutex_init(spd_key_mutex_share_auto_increment, &lgtm_tblhnd_share->auto_increment_mutex, MY_MUTEX_INIT_FAST)) -#endif { *error_num = HA_ERR_OUT_OF_MEM; goto error_init_auto_increment_mutex; } uint old_elements = spider_lgtm_tblhnd_share_hash.array.max_element; -#ifdef HASH_UPDATE_WITH_HASH_VALUE - if (my_hash_insert_with_hash_value(&spider_lgtm_tblhnd_share_hash, - hash_value, (uchar*) lgtm_tblhnd_share)) -#else if (my_hash_insert(&spider_lgtm_tblhnd_share_hash, (uchar*) lgtm_tblhnd_share)) -#endif { *error_num = HA_ERR_OUT_OF_MEM; goto error_hash_insert; @@ -6118,12 +5818,7 @@ void spider_free_lgtm_tblhnd_share_alloc( DBUG_ENTER("spider_free_lgtm_tblhnd_share"); if (!locked) pthread_mutex_lock(&spider_lgtm_tblhnd_share_mutex); -#ifdef HASH_UPDATE_WITH_HASH_VALUE - my_hash_delete_with_hash_value(&spider_lgtm_tblhnd_share_hash, - lgtm_tblhnd_share->table_path_hash_value, (uchar*) lgtm_tblhnd_share); -#else my_hash_delete(&spider_lgtm_tblhnd_share_hash, (uchar*) lgtm_tblhnd_share); -#endif pthread_mutex_destroy(&lgtm_tblhnd_share->auto_increment_mutex); spider_free(spider_current_trx, lgtm_tblhnd_share, MYF(0)); if (!locked) @@ -6142,16 +5837,10 @@ SPIDER_WIDE_SHARE *spider_get_wide_share( DBUG_ENTER("spider_get_wide_share"); pthread_mutex_lock(&spider_wide_share_mutex); -#ifdef SPIDER_HAS_HASH_VALUE_TYPE if (!(wide_share = (SPIDER_WIDE_SHARE*) my_hash_search_using_hash_value( &spider_open_wide_share, share->table_path_hash_value, (uchar*) table_share->path.str, table_share->path.length))) -#else - if (!(wide_share = (SPIDER_WIDE_SHARE*) my_hash_search( - &spider_open_wide_share, - (uchar*) table_share->path.str, table_share->path.length))) -#endif { DBUG_PRINT("info",("spider create new wide share")); if (!(wide_share = (SPIDER_WIDE_SHARE *) @@ -6171,31 +5860,21 @@ SPIDER_WIDE_SHARE *spider_get_wide_share( wide_share->table_name = tmp_name; memcpy(wide_share->table_name, table_share->path.str, wide_share->table_name_length); -#ifdef SPIDER_HAS_HASH_VALUE_TYPE wide_share->table_path_hash_value = share->table_path_hash_value; -#endif wide_share->cardinality = tmp_cardinality; wide_share->crd_get_time = wide_share->sts_get_time = share->crd_get_time; -#if MYSQL_VERSION_ID < 50500 - if (pthread_mutex_init(&wide_share->sts_mutex, MY_MUTEX_INIT_FAST)) -#else if (mysql_mutex_init(spd_key_mutex_wide_share_sts, &wide_share->sts_mutex, MY_MUTEX_INIT_FAST)) -#endif { *error_num = HA_ERR_OUT_OF_MEM; goto error_init_sts_mutex; } -#if MYSQL_VERSION_ID < 50500 - if (pthread_mutex_init(&wide_share->crd_mutex, MY_MUTEX_INIT_FAST)) -#else if (mysql_mutex_init(spd_key_mutex_wide_share_crd, &wide_share->crd_mutex, MY_MUTEX_INIT_FAST)) -#endif { *error_num = HA_ERR_OUT_OF_MEM; goto error_init_crd_mutex; @@ -6204,13 +5883,7 @@ SPIDER_WIDE_SHARE *spider_get_wide_share( thr_lock_init(&wide_share->lock); uint old_elements = spider_open_wide_share.array.max_element; -#ifdef HASH_UPDATE_WITH_HASH_VALUE - if (my_hash_insert_with_hash_value(&spider_open_wide_share, - share->table_path_hash_value, - (uchar*) wide_share)) -#else if (my_hash_insert(&spider_open_wide_share, (uchar*) wide_share)) -#endif { *error_num = HA_ERR_OUT_OF_MEM; goto error_hash_insert; @@ -6248,12 +5921,7 @@ int spider_free_wide_share( if (!--wide_share->use_count) { thr_lock_delete(&wide_share->lock); -#ifdef HASH_UPDATE_WITH_HASH_VALUE - my_hash_delete_with_hash_value(&spider_open_wide_share, - wide_share->table_path_hash_value, (uchar*) wide_share); -#else my_hash_delete(&spider_open_wide_share, (uchar*) wide_share); -#endif pthread_mutex_destroy(&wide_share->crd_mutex); pthread_mutex_destroy(&wide_share->sts_mutex); spider_free(spider_current_trx, wide_share, MYF(0)); @@ -6369,10 +6037,8 @@ int spider_open_all_tables( table_tables, &tmp_share, 0, &mem_root)) || (error_num = spider_set_connect_info_default( &tmp_share, -#ifdef WITH_PARTITION_STORAGE_ENGINE NULL, NULL, -#endif NULL )) ) { @@ -6620,7 +6286,6 @@ handler* spider_create_handler( MEM_ROOT *mem_root ) { DBUG_ENTER("spider_create_handler"); -#ifndef WITHOUT_SPIDER_BG_SEARCH SPIDER_THREAD *thread = &spider_table_sts_threads[0]; if (unlikely(thread->init_command)) { @@ -6643,7 +6308,6 @@ handler* spider_create_handler( DBUG_RETURN(NULL); } } -#endif DBUG_RETURN(new (mem_root) ha_spider(hton, table)); } @@ -6738,7 +6402,6 @@ int spider_db_done( } } -#ifndef WITHOUT_SPIDER_BG_SEARCH for (roop_count = spider_param_table_crd_thread_count() - 1; roop_count >= 0; roop_count--) { @@ -6750,7 +6413,6 @@ int spider_db_done( spider_free_sts_threads(&spider_table_sts_threads[roop_count]); } spider_free(NULL, spider_table_sts_threads, MYF(0)); -#endif for (roop_count = spider_param_udf_table_mon_mutex_count() - 1; roop_count >= 0; roop_count--) @@ -6758,14 +6420,8 @@ int spider_db_done( while ((table_mon_list = (SPIDER_TABLE_MON_LIST *) my_hash_element( &spider_udf_table_mon_list_hash[roop_count], 0))) { -#ifdef HASH_UPDATE_WITH_HASH_VALUE - my_hash_delete_with_hash_value( - &spider_udf_table_mon_list_hash[roop_count], - table_mon_list->key_hash_value, (uchar*) table_mon_list); -#else my_hash_delete(&spider_udf_table_mon_list_hash[roop_count], (uchar*) table_mon_list); -#endif spider_ping_table_free_mon_list(table_mon_list); } spider_free_mem_calc(spider_current_trx, @@ -6801,12 +6457,7 @@ int spider_db_done( pthread_mutex_lock(&spider_conn_mutex); while ((conn = (SPIDER_CONN*) my_hash_element(&spider_open_connections, 0))) { -#ifdef HASH_UPDATE_WITH_HASH_VALUE - my_hash_delete_with_hash_value(&spider_open_connections, - conn->conn_key_hash_value, (uchar*) conn); -#else my_hash_delete(&spider_open_connections, (uchar*) conn); -#endif spider_free_conn(conn); } pthread_mutex_unlock(&spider_conn_mutex); @@ -6838,25 +6489,17 @@ int spider_db_done( spider_lgtm_tblhnd_share_hash.array.max_element * spider_lgtm_tblhnd_share_hash.array.size_of_element); my_hash_free(&spider_lgtm_tblhnd_share_hash); -#ifdef WITH_PARTITION_STORAGE_ENGINE spider_free_mem_calc(spider_current_trx, spider_open_wide_share_id, spider_open_wide_share.array.max_element * spider_open_wide_share.array.size_of_element); my_hash_free(&spider_open_wide_share); -#endif pthread_mutex_lock(&spider_init_error_tbl_mutex); while ((spider_init_error_table = (SPIDER_INIT_ERROR_TABLE*) my_hash_element(&spider_init_error_tables, 0))) { -#ifdef HASH_UPDATE_WITH_HASH_VALUE - my_hash_delete_with_hash_value(&spider_init_error_tables, - spider_init_error_table->table_name_hash_value, - (uchar*) spider_init_error_table); -#else my_hash_delete(&spider_init_error_tables, (uchar*) spider_init_error_table); -#endif spider_free(NULL, spider_init_error_table, MYF(0)); } pthread_mutex_unlock(&spider_init_error_tbl_mutex); @@ -6876,17 +6519,13 @@ int spider_db_done( pthread_mutex_destroy(&spider_open_conn_mutex); pthread_mutex_destroy(&spider_conn_mutex); pthread_mutex_destroy(&spider_lgtm_tblhnd_share_mutex); -#ifdef WITH_PARTITION_STORAGE_ENGINE pthread_mutex_destroy(&spider_wide_share_mutex); -#endif pthread_mutex_destroy(&spider_init_error_tbl_mutex); pthread_mutex_destroy(&spider_conn_id_mutex); pthread_mutex_destroy(&spider_ipport_conn_mutex); pthread_mutex_destroy(&spider_thread_id_mutex); pthread_mutex_destroy(&spider_tbl_mutex); -#ifndef WITHOUT_SPIDER_BG_SEARCH pthread_attr_destroy(&spider_pt_attr); -#endif for (roop_count = 0; roop_count < SPIDER_MEM_CALC_LIST_NUM; roop_count++) { @@ -6952,9 +6591,7 @@ int spider_db_init( spider_hton->flush_logs = spider_flush_logs; spider_hton->commit = spider_commit; spider_hton->rollback = spider_rollback; -#ifdef SPIDER_HAS_DISCOVER_TABLE_STRUCTURE spider_hton->discover_table_structure = spider_discover_table_structure; -#endif if (spider_param_support_xa()) { spider_hton->prepare = spider_xa_prepare; @@ -6965,9 +6602,7 @@ int spider_db_init( spider_hton->create = spider_create_handler; spider_hton->drop_database = spider_drop_database; spider_hton->show_status = spider_show_status; -#ifdef SPIDER_HAS_GROUP_BY_HANDLER spider_hton->create_group_by = spider_create_group_by_handler; -#endif spider_hton->table_options= spider_table_option_list; if (my_gethwaddr((uchar *) addr)) @@ -7018,108 +6653,59 @@ int spider_db_init( init_spider_psi_keys(); #endif -#ifndef WITHOUT_SPIDER_BG_SEARCH if (pthread_attr_init(&spider_pt_attr)) goto error_pt_attr_init; /* if (pthread_attr_setdetachstate(&spider_pt_attr, PTHREAD_CREATE_DETACHED)) goto error_pt_attr_setstate; */ -#endif -#if MYSQL_VERSION_ID < 50500 - if (pthread_mutex_init(&spider_tbl_mutex, MY_MUTEX_INIT_FAST)) -#else if (mysql_mutex_init(spd_key_mutex_tbl, &spider_tbl_mutex, MY_MUTEX_INIT_FAST)) -#endif goto error_tbl_mutex_init; -#if MYSQL_VERSION_ID < 50500 - if (pthread_mutex_init(&spider_thread_id_mutex, MY_MUTEX_INIT_FAST)) -#else + if (mysql_mutex_init(spd_key_thread_id, &spider_thread_id_mutex, MY_MUTEX_INIT_FAST)) -#endif goto error_thread_id_mutex_init; -#if MYSQL_VERSION_ID < 50500 - if (pthread_mutex_init(&spider_conn_id_mutex, MY_MUTEX_INIT_FAST)) -#else + if (mysql_mutex_init(spd_key_conn_id, &spider_conn_id_mutex, MY_MUTEX_INIT_FAST)) -#endif goto error_conn_id_mutex_init; -#if MYSQL_VERSION_ID < 50500 - if (pthread_mutex_init(&spider_ipport_conn_mutex, MY_MUTEX_INIT_FAST)) -#else + if (mysql_mutex_init(spd_key_mutex_ipport_count, &spider_ipport_conn_mutex, MY_MUTEX_INIT_FAST)) -#endif goto error_ipport_count_mutex_init; -#if MYSQL_VERSION_ID < 50500 - if (pthread_mutex_init(&spider_init_error_tbl_mutex, MY_MUTEX_INIT_FAST)) -#else if (mysql_mutex_init(spd_key_mutex_init_error_tbl, &spider_init_error_tbl_mutex, MY_MUTEX_INIT_FAST)) -#endif goto error_init_error_tbl_mutex_init; -#ifdef WITH_PARTITION_STORAGE_ENGINE -#if MYSQL_VERSION_ID < 50500 - if (pthread_mutex_init(&spider_wide_share_mutex, MY_MUTEX_INIT_FAST)) -#else if (mysql_mutex_init(spd_key_mutex_wide_share, &spider_wide_share_mutex, MY_MUTEX_INIT_FAST)) -#endif goto error_wide_share_mutex_init; -#endif -#if MYSQL_VERSION_ID < 50500 - if (pthread_mutex_init(&spider_lgtm_tblhnd_share_mutex, MY_MUTEX_INIT_FAST)) -#else if (mysql_mutex_init(spd_key_mutex_lgtm_tblhnd_share, &spider_lgtm_tblhnd_share_mutex, MY_MUTEX_INIT_FAST)) -#endif goto error_lgtm_tblhnd_share_mutex_init; -#if MYSQL_VERSION_ID < 50500 - if (pthread_mutex_init(&spider_conn_mutex, MY_MUTEX_INIT_FAST)) -#else if (mysql_mutex_init(spd_key_mutex_conn, &spider_conn_mutex, MY_MUTEX_INIT_FAST)) -#endif goto error_conn_mutex_init; -#if MYSQL_VERSION_ID < 50500 - if (pthread_mutex_init(&spider_open_conn_mutex, MY_MUTEX_INIT_FAST)) -#else if (mysql_mutex_init(spd_key_mutex_open_conn, &spider_open_conn_mutex, MY_MUTEX_INIT_FAST)) -#endif goto error_open_conn_mutex_init; -#if MYSQL_VERSION_ID < 50500 - if (pthread_mutex_init(&spider_allocated_thds_mutex, MY_MUTEX_INIT_FAST)) -#else if (mysql_mutex_init(spd_key_mutex_allocated_thds, &spider_allocated_thds_mutex, MY_MUTEX_INIT_FAST)) -#endif goto error_allocated_thds_mutex_init; -#if MYSQL_VERSION_ID < 50500 - if (pthread_mutex_init(&spider_mon_table_cache_mutex, MY_MUTEX_INIT_FAST)) -#else if (mysql_mutex_init(spd_key_mutex_mon_table_cache, &spider_mon_table_cache_mutex, MY_MUTEX_INIT_FAST)) -#endif goto error_mon_table_cache_mutex_init; -#if MYSQL_VERSION_ID < 50500 - if (pthread_mutex_init(&spider_mem_calc_mutex, MY_MUTEX_INIT_FAST)) -#else if (mysql_mutex_init(spd_key_mutex_mem_calc, &spider_mem_calc_mutex, MY_MUTEX_INIT_FAST)) -#endif goto error_mem_calc_mutex_init; if (my_hash_init(PSI_INSTRUMENT_ME, &spider_open_tables, spd_charset_utf8mb3_bin, 32, 0, 0, @@ -7140,7 +6726,6 @@ int spider_db_init( spider_init_error_tables, spider_init_error_tables.array.max_element * spider_init_error_tables.array.size_of_element); -#ifdef WITH_PARTITION_STORAGE_ENGINE if( my_hash_init(PSI_INSTRUMENT_ME, &spider_open_wide_share, spd_charset_utf8mb3_bin, 32, 0, 0, (my_hash_get_key) spider_wide_share_get_key, 0, 0) @@ -7152,7 +6737,6 @@ int spider_db_init( spider_open_wide_share, spider_open_wide_share.array.max_element * spider_open_wide_share.array.size_of_element); -#endif if (my_hash_init(PSI_INSTRUMENT_ME, &spider_lgtm_tblhnd_share_hash, spd_charset_utf8mb3_bin, 32, 0, 0, (my_hash_get_key) spider_lgtm_tblhnd_share_hash_get_key, 0, 0)) @@ -7213,25 +6797,16 @@ int spider_db_init( roop_count < (int) spider_param_udf_table_mon_mutex_count(); roop_count++) { -#if MYSQL_VERSION_ID < 50500 - if (pthread_mutex_init(&spider_udf_table_mon_mutexes[roop_count], - MY_MUTEX_INIT_FAST)) -#else if (mysql_mutex_init(spd_key_mutex_udf_table_mon, &spider_udf_table_mon_mutexes[roop_count], MY_MUTEX_INIT_FAST)) -#endif goto error_init_udf_table_mon_mutex; } for (roop_count = 0; roop_count < (int) spider_param_udf_table_mon_mutex_count(); roop_count++) { -#if MYSQL_VERSION_ID < 50500 - if (pthread_cond_init(&spider_udf_table_mon_conds[roop_count], NULL)) -#else if (mysql_cond_init(spd_key_cond_udf_table_mon, &spider_udf_table_mon_conds[roop_count], NULL)) -#endif goto error_init_udf_table_mon_cond; } for (roop_count = 0; @@ -7250,7 +6825,6 @@ int spider_db_init( spider_udf_table_mon_list_hash[roop_count].array.size_of_element); } -#ifndef WITHOUT_SPIDER_BG_SEARCH if (!(spider_table_sts_threads = (SPIDER_THREAD *) spider_bulk_malloc(NULL, 256, MYF(MY_WME | MY_ZEROFILL), &spider_table_sts_threads, (uint) (sizeof(SPIDER_THREAD) * @@ -7280,7 +6854,6 @@ int spider_db_init( goto error_init_table_crd_threads; } } -#endif spider_dbton_mysql.dbton_id = dbton_id; spider_dbton_mysql.db_util->dbton_id = dbton_id; @@ -7290,12 +6863,6 @@ int spider_db_init( spider_dbton_mariadb.db_util->dbton_id = dbton_id; spider_dbton[dbton_id] = spider_dbton_mariadb; ++dbton_id; -#ifdef HAVE_ORACLE_OCI - spider_dbton_oracle.dbton_id = dbton_id; - spider_dbton_oracle.db_util->dbton_id = dbton_id; - spider_dbton[dbton_id] = spider_dbton_oracle; - ++dbton_id; -#endif for (roop_count = 0; roop_count < SPIDER_DBTON_SIZE; roop_count++) { if (spider_dbton[roop_count].init) @@ -7308,7 +6875,6 @@ int spider_db_init( } DBUG_RETURN(0); -#ifndef WITHOUT_SPIDER_BG_SEARCH error_init_dbton: for (roop_count--; roop_count >= 0; roop_count--) { @@ -7331,7 +6897,6 @@ error_init_table_sts_threads: } spider_free(NULL, spider_table_sts_threads, MYF(0)); roop_count = spider_param_udf_table_mon_mutex_count() - 1; -#endif error_init_udf_table_mon_list_hash: for (; roop_count >= 0; roop_count--) { @@ -7377,14 +6942,12 @@ error_open_connections_hash_init: spider_lgtm_tblhnd_share_hash.array.size_of_element); my_hash_free(&spider_lgtm_tblhnd_share_hash); error_lgtm_tblhnd_share_hash_init: -#ifdef WITH_PARTITION_STORAGE_ENGINE spider_free_mem_calc(NULL, spider_open_wide_share_id, spider_open_wide_share.array.max_element * spider_open_wide_share.array.size_of_element); my_hash_free(&spider_open_wide_share); error_open_wide_share_hash_init: -#endif spider_free_mem_calc(NULL, spider_init_error_tables_id, spider_init_error_tables.array.max_element * @@ -7409,10 +6972,8 @@ error_open_conn_mutex_init: error_conn_mutex_init: pthread_mutex_destroy(&spider_lgtm_tblhnd_share_mutex); error_lgtm_tblhnd_share_mutex_init: -#ifdef WITH_PARTITION_STORAGE_ENGINE pthread_mutex_destroy(&spider_wide_share_mutex); error_wide_share_mutex_init: -#endif pthread_mutex_destroy(&spider_init_error_tbl_mutex); error_init_error_tbl_mutex_init: pthread_mutex_destroy(&spider_ipport_conn_mutex); @@ -7423,13 +6984,11 @@ error_conn_id_mutex_init: error_thread_id_mutex_init: pthread_mutex_destroy(&spider_tbl_mutex); error_tbl_mutex_init: -#ifndef WITHOUT_SPIDER_BG_SEARCH /* error_pt_attr_setstate: */ pthread_attr_destroy(&spider_pt_attr); error_pt_attr_init: -#endif DBUG_RETURN(error_num); } @@ -7478,7 +7037,6 @@ char *spider_create_table_name_string( DBUG_RETURN(res); } -#ifdef WITH_PARTITION_STORAGE_ENGINE /* Get the target partition_elements. @@ -7568,7 +7126,6 @@ void spider_get_partition_info( DBUG_PRINT("info",("spider no hit")); DBUG_VOID_RETURN; } -#endif int spider_get_sts( SPIDER_SHARE *share, @@ -7577,20 +7134,15 @@ int spider_get_sts( ha_spider *spider, double sts_interval, int sts_mode, -#ifdef WITH_PARTITION_STORAGE_ENGINE int sts_sync, -#endif int sts_sync_level, uint flag ) { -#ifdef WITH_PARTITION_STORAGE_ENGINE int get_type; -#endif int error_num = 0; bool need_to_get = TRUE; DBUG_ENTER("spider_get_sts"); -#ifdef WITH_PARTITION_STORAGE_ENGINE if ( sts_sync == 0 ) { @@ -7624,7 +7176,6 @@ int spider_get_sts( /* copy */ get_type = 0; } -#endif if ( !share->sts_init && share->table_share->tmp_table == NO_TMP_TABLE && @@ -7647,23 +7198,16 @@ int spider_get_sts( if (need_to_get) { -#ifdef WITH_PARTITION_STORAGE_ENGINE if (get_type == 0) spider_copy_sts_to_share(share, share->wide_share); else { -#endif error_num = spider_db_show_table_status(spider, link_idx, sts_mode, flag); -#ifdef WITH_PARTITION_STORAGE_ENGINE } -#endif } -#ifdef WITH_PARTITION_STORAGE_ENGINE if (get_type >= 2) pthread_mutex_unlock(&share->wide_share->sts_mutex); -#endif if (error_num) { -#ifdef WITH_PARTITION_STORAGE_ENGINE SPIDER_PARTITION_HANDLER *partition_handler = spider->partition_handler; if ( @@ -7705,17 +7249,14 @@ int spider_get_sts( } } if (error_num) -#endif DBUG_RETURN(error_num); } -#ifdef WITH_PARTITION_STORAGE_ENGINE if (sts_sync >= sts_sync_level && get_type > 0) { spider_copy_sts_to_wide_share(share->wide_share, share); share->wide_share->sts_get_time = tmp_time; share->wide_share->sts_init = TRUE; } -#endif share->sts_get_time = tmp_time; share->sts_init = TRUE; DBUG_RETURN(0); @@ -7729,19 +7270,14 @@ int spider_get_crd( TABLE *table, double crd_interval, int crd_mode, -#ifdef WITH_PARTITION_STORAGE_ENGINE int crd_sync, -#endif int crd_sync_level ) { -#ifdef WITH_PARTITION_STORAGE_ENGINE int get_type; -#endif int error_num = 0; bool need_to_get = TRUE; DBUG_ENTER("spider_get_crd"); -#ifdef WITH_PARTITION_STORAGE_ENGINE if ( crd_sync == 0 ) { @@ -7775,7 +7311,6 @@ int spider_get_crd( /* copy */ get_type = 0; } -#endif if ( !share->crd_init && share->table_share->tmp_table == NO_TMP_TABLE && @@ -7798,24 +7333,17 @@ int spider_get_crd( if (need_to_get) { -#ifdef WITH_PARTITION_STORAGE_ENGINE if (get_type == 0) spider_copy_crd_to_share(share, share->wide_share, table->s->fields); else { -#endif error_num = spider_db_show_index(spider, link_idx, table, crd_mode); -#ifdef WITH_PARTITION_STORAGE_ENGINE } -#endif } -#ifdef WITH_PARTITION_STORAGE_ENGINE if (get_type >= 2) pthread_mutex_unlock(&share->wide_share->crd_mutex); -#endif if (error_num) { -#ifdef WITH_PARTITION_STORAGE_ENGINE SPIDER_PARTITION_HANDLER *partition_handler = spider->partition_handler; if ( @@ -7858,10 +7386,8 @@ int spider_get_crd( } } if (error_num) -#endif DBUG_RETURN(error_num); } -#ifdef WITH_PARTITION_STORAGE_ENGINE if (crd_sync >= crd_sync_level && get_type > 0) { spider_copy_crd_to_wide_share(share->wide_share, share, @@ -7869,7 +7395,6 @@ int spider_get_crd( share->wide_share->crd_get_time = tmp_time; share->wide_share->crd_init = TRUE; } -#endif share->crd_get_time = tmp_time; share->crd_init = TRUE; DBUG_RETURN(0); @@ -7920,16 +7445,10 @@ SPIDER_INIT_ERROR_TABLE *spider_get_init_error_table( char *tmp_name; DBUG_ENTER("spider_get_init_error_table"); pthread_mutex_lock(&spider_init_error_tbl_mutex); -#ifdef SPIDER_HAS_HASH_VALUE_TYPE if (!(spider_init_error_table = (SPIDER_INIT_ERROR_TABLE *) my_hash_search_using_hash_value( &spider_init_error_tables, share->table_name_hash_value, (uchar*) share->table_name, share->table_name_length))) -#else - if (!(spider_init_error_table = (SPIDER_INIT_ERROR_TABLE *) my_hash_search( - &spider_init_error_tables, - (uchar*) share->table_name, share->table_name_length))) -#endif { if (!create) { @@ -7948,18 +7467,11 @@ SPIDER_INIT_ERROR_TABLE *spider_get_init_error_table( memcpy(tmp_name, share->table_name, share->table_name_length); spider_init_error_table->table_name = tmp_name; spider_init_error_table->table_name_length = share->table_name_length; -#ifdef SPIDER_HAS_HASH_VALUE_TYPE spider_init_error_table->table_name_hash_value = share->table_name_hash_value; -#endif uint old_elements = spider_init_error_tables.array.max_element; -#ifdef HASH_UPDATE_WITH_HASH_VALUE - if (my_hash_insert_with_hash_value(&spider_init_error_tables, - share->table_name_hash_value, (uchar*) spider_init_error_table)) -#else if (my_hash_insert(&spider_init_error_tables, (uchar*) spider_init_error_table)) -#endif { spider_free(trx, spider_init_error_table, MYF(0)); pthread_mutex_unlock(&spider_init_error_tbl_mutex); @@ -7982,29 +7494,16 @@ void spider_delete_init_error_table( ) { SPIDER_INIT_ERROR_TABLE *spider_init_error_table; uint length = strlen(name); -#ifdef SPIDER_HAS_HASH_VALUE_TYPE my_hash_value_type hash_value = my_calc_hash(&spider_open_tables, (uchar*) name, length); -#endif DBUG_ENTER("spider_delete_init_error_table"); pthread_mutex_lock(&spider_init_error_tbl_mutex); -#ifdef SPIDER_HAS_HASH_VALUE_TYPE if ((spider_init_error_table = (SPIDER_INIT_ERROR_TABLE *) my_hash_search_using_hash_value(&spider_init_error_tables, hash_value, (uchar*) name, length))) -#else - if ((spider_init_error_table = (SPIDER_INIT_ERROR_TABLE *) my_hash_search( - &spider_init_error_tables, (uchar*) name, length))) -#endif { -#ifdef HASH_UPDATE_WITH_HASH_VALUE - my_hash_delete_with_hash_value(&spider_init_error_tables, - spider_init_error_table->table_name_hash_value, - (uchar*) spider_init_error_table); -#else my_hash_delete(&spider_init_error_tables, (uchar*) spider_init_error_table); -#endif spider_free(spider_current_trx, spider_init_error_table, MYF(0)); } pthread_mutex_unlock(&spider_init_error_tbl_mutex); @@ -8071,10 +7570,8 @@ void spider_set_tmp_share_pointer( tmp_share->monitoring_binlog_pos_at_failing = &tmp_long[3]; tmp_share->monitoring_flag = &tmp_long[4]; tmp_share->monitoring_kind = &tmp_long[5]; -#ifndef WITHOUT_SPIDER_BG_SEARCH tmp_share->monitoring_bg_flag = &tmp_long[6]; tmp_share->monitoring_bg_kind = &tmp_long[7]; -#endif tmp_share->use_handlers = &tmp_long[13]; tmp_share->connect_timeouts = &tmp_long[14]; tmp_long[13] = -1; @@ -8087,9 +7584,7 @@ void spider_set_tmp_share_pointer( tmp_share->strict_group_bys = &tmp_long[19]; tmp_share->monitoring_limit = &tmp_longlong[0]; tmp_share->monitoring_sid = &tmp_longlong[1]; -#ifndef WITHOUT_SPIDER_BG_SEARCH tmp_share->monitoring_bg_interval = &tmp_longlong[2]; -#endif tmp_share->server_names_lengths = &tmp_connect_info_length[0]; tmp_share->tgt_table_names_lengths = &tmp_connect_info_length[1]; tmp_share->tgt_dbs_lengths = &tmp_connect_info_length[2]; @@ -8138,15 +7633,11 @@ void spider_set_tmp_share_pointer( tmp_share->monitoring_binlog_pos_at_failing_length = 1; tmp_share->monitoring_flag_length = 1; tmp_share->monitoring_kind_length = 1; -#ifndef WITHOUT_SPIDER_BG_SEARCH tmp_share->monitoring_bg_flag_length = 1; tmp_share->monitoring_bg_kind_length = 1; -#endif tmp_share->monitoring_limit_length = 1; tmp_share->monitoring_sid_length = 1; -#ifndef WITHOUT_SPIDER_BG_SEARCH tmp_share->monitoring_bg_interval_length = 1; -#endif tmp_share->use_handlers_length = 1; tmp_share->connect_timeouts_length = 1; tmp_share->net_read_timeouts_length = 1; @@ -8155,16 +7646,12 @@ void spider_set_tmp_share_pointer( tmp_share->bka_table_name_types_length = 1; tmp_share->strict_group_bys_length = 1; -#ifndef WITHOUT_SPIDER_BG_SEARCH tmp_share->monitoring_bg_flag[0] = -1; tmp_share->monitoring_bg_kind[0] = -1; -#endif tmp_share->monitoring_binlog_pos_at_failing[0] = -1; tmp_share->monitoring_flag[0] = -1; tmp_share->monitoring_kind[0] = -1; -#ifndef WITHOUT_SPIDER_BG_SEARCH tmp_share->monitoring_bg_interval[0] = -1; -#endif tmp_share->monitoring_limit[0] = -1; tmp_share->monitoring_sid[0] = -1; tmp_share->bka_engine = NULL; @@ -8348,13 +7835,11 @@ longlong spider_split_read_param( DBUG_PRINT("info",("spider bulk_update_mode=%d", bulk_update_mode)); DBUG_PRINT("info",("spider support_bulk_update_sql=%s", spider->support_bulk_update_sql() ? "TRUE" : "FALSE")); -#ifdef SPIDER_HAS_GROUP_BY_HANDLER bool inserting = ( spider->wide_handler->sql_command == SQLCOM_INSERT || spider->wide_handler->sql_command == SQLCOM_INSERT_SELECT ); -#endif bool updating = ( spider->wide_handler->sql_command == SQLCOM_UPDATE || @@ -8375,12 +7860,10 @@ longlong spider_split_read_param( DBUG_PRINT("info",("spider replacing=%s", replacing ? "TRUE" : "FALSE")); TABLE *table = spider->get_table(); if ( -#ifdef SPIDER_HAS_GROUP_BY_HANDLER ( inserting && spider->use_fields ) || -#endif replacing || ( ( @@ -8574,75 +8057,52 @@ bool spider_check_direct_order_limit( spider->use_index_merge ? "TRUE" : "FALSE")); DBUG_PRINT("info",("spider is_clone=%s", spider->is_clone ? "TRUE" : "FALSE")); -#ifdef HA_CAN_BULK_ACCESS - DBUG_PRINT("info",("spider is_bulk_access_clone=%s", - spider->is_bulk_access_clone ? "TRUE" : "FALSE")); -#endif if ( spider->wide_handler->sql_command != SQLCOM_HA_READ && !spider->use_index_merge && -#ifdef HA_CAN_BULK_ACCESS - (!spider->is_clone || spider->is_bulk_access_clone) -#else !spider->is_clone -#endif ) { spider_get_select_limit(spider, &select_lex, &select_limit, &offset_limit); bool first_check = TRUE; DBUG_PRINT("info",("spider select_lex=%p", select_lex)); -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000 DBUG_PRINT("info",("spider leaf_tables.elements=%u", select_lex ? select_lex->leaf_tables.elements : 0)); -#endif if (select_lex && (select_lex->options & SELECT_DISTINCT)) { DBUG_PRINT("info",("spider with distinct")); spider->result_list.direct_distinct = TRUE; } -#ifdef HANDLER_HAS_DIRECT_AGGREGATE spider->result_list.direct_aggregate = TRUE; -#endif DBUG_PRINT("info",("spider select_limit=%lld", select_limit)); DBUG_PRINT("info",("spider offset_limit=%lld", offset_limit)); if ( -#if MYSQL_VERSION_ID < 50500 - !thd->variables.engine_condition_pushdown || -#else #ifdef SPIDER_ENGINE_CONDITION_PUSHDOWN_IS_ALWAYS_ON #else !(thd->variables.optimizer_switch & OPTIMIZER_SWITCH_ENGINE_CONDITION_PUSHDOWN) || #endif -#endif #ifdef SPIDER_NEED_CHECK_CONDITION_AT_CHECKING_DIRECT_ORDER_LIMIT !spider->condition || #endif !select_lex || -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000 select_lex->leaf_tables.elements != 1 || -#endif select_lex->table_list.elements != 1 ) { DBUG_PRINT("info",("spider first_check is FALSE")); first_check = FALSE; spider->result_list.direct_distinct = FALSE; -#ifdef HANDLER_HAS_DIRECT_AGGREGATE spider->result_list.direct_aggregate = FALSE; -#endif } else if (spider_db_append_condition(spider, NULL, 0, TRUE)) { DBUG_PRINT("info",("spider FALSE by condition")); first_check = FALSE; spider->result_list.direct_distinct = FALSE; -#ifdef HANDLER_HAS_DIRECT_AGGREGATE spider->result_list.direct_aggregate = FALSE; -#endif } else if (spider->sql_kinds & SPIDER_SQL_KIND_HANDLER) { DBUG_PRINT("info",("spider sql_kinds with SPIDER_SQL_KIND_HANDLER")); spider->result_list.direct_distinct = FALSE; -#ifdef HANDLER_HAS_DIRECT_AGGREGATE spider->result_list.direct_aggregate = FALSE; } else if ( !select_lex->group_list.elements && @@ -8680,7 +8140,6 @@ bool spider_check_direct_order_limit( first_check = FALSE; spider->result_list.direct_distinct = FALSE; } -#endif } longlong direct_order_limit = spider_param_direct_order_limit(thd, @@ -8692,10 +8151,8 @@ bool spider_check_direct_order_limit( first_check ? "TRUE" : "FALSE")); DBUG_PRINT("info",("spider (select_lex->options & OPTION_FOUND_ROWS)=%s", select_lex && (select_lex->options & OPTION_FOUND_ROWS) ? "TRUE" : "FALSE")); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE DBUG_PRINT("info",("spider direct_aggregate=%s", spider->result_list.direct_aggregate ? "TRUE" : "FALSE")); -#endif DBUG_PRINT("info",("spider select_lex->group_list.elements=%u", select_lex ? select_lex->group_list.elements : 0)); DBUG_PRINT("info",("spider select_lex->with_sum_func=%s", @@ -8709,9 +8166,7 @@ bool spider_check_direct_order_limit( !select_lex->limit_params.explicit_limit || (select_lex->options & OPTION_FOUND_ROWS) || ( -#ifdef HANDLER_HAS_DIRECT_AGGREGATE !spider->result_list.direct_aggregate && -#endif ( select_lex->group_list.elements || select_lex->with_sum_func @@ -8745,7 +8200,6 @@ bool spider_check_direct_order_limit( DBUG_RETURN(FALSE); } -#ifdef HANDLER_HAS_DIRECT_AGGREGATE bool spider_all_part_in_order( ORDER *order, TABLE *table @@ -8808,12 +8262,6 @@ Field *spider_field_exchange( Field *field ) { DBUG_ENTER("spider_field_exchange"); -#ifdef HA_CAN_BULK_ACCESS - if (handler->is_bulk_access_clone) - { - handler = handler->pt_clone_source_handler; - } -#endif DBUG_PRINT("info",("spider in field=%p", field)); DBUG_PRINT("info",("spider in field->table=%p", field->table)); DBUG_PRINT("info",("spider table=%p", handler->get_table())); @@ -8822,7 +8270,6 @@ Field *spider_field_exchange( DBUG_PRINT("info",("spider out field=%p", field)); DBUG_RETURN(field); } -#endif int spider_set_direct_limit_offset( ha_spider *spider @@ -8855,9 +8302,7 @@ int spider_set_direct_limit_offset( if ( spider->wide_handler->sql_command != SQLCOM_SELECT || -#ifdef HANDLER_HAS_DIRECT_AGGREGATE spider->result_list.direct_aggregate || -#endif spider->result_list.direct_order_limit || spider->prev_index_rnd_init != SPD_RND // must be RND_INIT and not be INDEX_INIT ) @@ -8888,15 +8333,11 @@ int spider_set_direct_limit_offset( // contain where if ( -#if MYSQL_VERSION_ID < 50500 - !thd->variables.engine_condition_pushdown || -#else #ifdef SPIDER_ENGINE_CONDITION_PUSHDOWN_IS_ALWAYS_ON #else !(thd->variables.optimizer_switch & OPTIMIZER_SWITCH_ENGINE_CONDITION_PUSHDOWN) || #endif -#endif // conditions is null may be no where condition in rand_init spider->wide_handler->condition ) @@ -9042,24 +8483,14 @@ ulong spider_calc_for_sort( double spider_rand( uint32 rand_source ) { -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000 struct my_rnd_struct rand; -#else - struct rand_struct rand; -#endif DBUG_ENTER("spider_rand"); /* generate same as rand function for applications */ -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000 my_rnd_init(&rand, (uint32) (rand_source * 65537L + 55555555L), (uint32) (rand_source * 268435457L)); -#else - randominit(&rand, (uint32) (rand_source * 65537L + 55555555L), - (uint32) (rand_source * 268435457L)); -#endif DBUG_RETURN(my_rnd(&rand)); } -#ifdef SPIDER_HAS_DISCOVER_TABLE_STRUCTURE int spider_discover_table_structure_internal( SPIDER_TRX *trx, SPIDER_SHARE *spider_share, @@ -9093,14 +8524,10 @@ int spider_discover_table_structure( const char *table_name = share->path.str; uint table_name_length = (uint) strlen(table_name); SPIDER_TRX *trx; -#ifdef WITH_PARTITION_STORAGE_ENGINE partition_info *part_info = thd->work_part_info; -#endif SPIDER_Open_tables_backup open_tables_backup; TABLE *table_tables; -#ifdef WITH_PARTITION_STORAGE_ENGINE uint str_len; -#endif char buf[MAX_FIELD_WIDTH]; spider_string str(buf, sizeof(buf), system_charset_info); DBUG_ENTER("spider_discover_table_structure"); @@ -9122,13 +8549,9 @@ int spider_discover_table_structure( str.q_append(share->table_name.str, share->table_name.length); str.q_append(SPIDER_SQL_LCL_NAME_QUOTE_STR, SPIDER_SQL_LCL_NAME_QUOTE_LEN); str.q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN); -#ifdef WITH_PARTITION_STORAGE_ENGINE str_len = str.length(); -#endif -#ifdef SPIDER_HAS_HASH_VALUE_TYPE my_hash_value_type hash_value = my_calc_hash(&spider_open_tables, (uchar*) table_name, table_name_length); -#endif if (!(trx = spider_get_trx(thd, TRUE, &error_num))) { DBUG_PRINT("info",("spider spider_get_trx error")); @@ -9137,17 +8560,11 @@ int spider_discover_table_structure( } share->table_charset = info->default_table_charset; share->comment = info->comment; -#ifdef WITH_PARTITION_STORAGE_ENGINE if (!part_info) { -#endif if (!(spider_share = spider_create_share(table_name, share, -#ifdef WITH_PARTITION_STORAGE_ENGINE NULL, -#endif -#ifdef SPIDER_HAS_HASH_VALUE_TYPE hash_value, -#endif &error_num ))) { DBUG_RETURN(error_num); @@ -9163,7 +8580,6 @@ int spider_discover_table_structure( SPIDER_SYS_TABLES_TABLE_NAME_LEN, TRUE, &open_tables_backup, FALSE, &error_num)) ) { -#ifdef SPIDER_SUPPORT_CREATE_OR_REPLACE_TABLE if (thd->lex->create_info.or_replace()) { error_num = spider_delete_tables(table_tables, @@ -9171,18 +8587,14 @@ int spider_discover_table_structure( } if (!error_num) { -#endif error_num = spider_insert_tables(table_tables, spider_share); -#ifdef SPIDER_SUPPORT_CREATE_OR_REPLACE_TABLE } -#endif spider_close_sys_table(thd, table_tables, &open_tables_backup, FALSE); } } spider_free_share_resource_only(spider_share); -#ifdef WITH_PARTITION_STORAGE_ENGINE } else { char tmp_name[FN_REFLEN + 1]; List_iterator<partition_element> part_it(part_info->partitions); @@ -9206,9 +8618,7 @@ int spider_discover_table_structure( DBUG_PRINT("info",("spider tmp_name=%s", tmp_name)); if (!(spider_share = spider_create_share(tmp_name, share, part_info, -#ifdef SPIDER_HAS_HASH_VALUE_TYPE hash_value, -#endif &error_num ))) { DBUG_RETURN(error_num); @@ -9234,9 +8644,7 @@ int spider_discover_table_structure( DBUG_PRINT("info",("spider tmp_name=%s", tmp_name)); if (!(spider_share = spider_create_share(tmp_name, share, part_info, -#ifdef SPIDER_HAS_HASH_VALUE_TYPE hash_value, -#endif &error_num ))) { DBUG_RETURN(error_num); @@ -9277,15 +8685,12 @@ int spider_discover_table_structure( DBUG_PRINT("info",("spider tmp_name=%s", tmp_name)); if (!(spider_share = spider_create_share(tmp_name, share, part_info, -#ifdef SPIDER_HAS_HASH_VALUE_TYPE hash_value, -#endif &error_num ))) { DBUG_RETURN(error_num); } -#ifdef SPIDER_SUPPORT_CREATE_OR_REPLACE_TABLE if (thd->lex->create_info.or_replace()) { error_num = spider_delete_tables(table_tables, @@ -9293,11 +8698,8 @@ int spider_discover_table_structure( } if (!error_num) { -#endif error_num = spider_insert_tables(table_tables, spider_share); -#ifdef SPIDER_SUPPORT_CREATE_OR_REPLACE_TABLE } -#endif spider_free_share_resource_only(spider_share); if (error_num) @@ -9315,15 +8717,12 @@ int spider_discover_table_structure( DBUG_PRINT("info",("spider tmp_name=%s", tmp_name)); if (!(spider_share = spider_create_share(tmp_name, share, part_info, -#ifdef SPIDER_HAS_HASH_VALUE_TYPE hash_value, -#endif &error_num ))) { DBUG_RETURN(error_num); } -#ifdef SPIDER_SUPPORT_CREATE_OR_REPLACE_TABLE if (thd->lex->create_info.or_replace()) { error_num = spider_delete_tables(table_tables, @@ -9331,11 +8730,8 @@ int spider_discover_table_structure( } if (!error_num) { -#endif error_num = spider_insert_tables(table_tables, spider_share); -#ifdef SPIDER_SUPPORT_CREATE_OR_REPLACE_TABLE } -#endif spider_free_share_resource_only(spider_share); if (error_num) @@ -9346,7 +8742,6 @@ int spider_discover_table_structure( &open_tables_backup, FALSE); } } -#endif if (!error_num) thd->clear_error(); @@ -9394,7 +8789,6 @@ int spider_discover_table_structure( DBUG_RETURN(HA_ERR_OUT_OF_MEM); } str.q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN); -#ifdef WITH_PARTITION_STORAGE_ENGINE DBUG_PRINT("info",("spider part_info=%p", part_info)); if (part_info) { @@ -9430,16 +8824,13 @@ int spider_discover_table_structure( str.q_append(part_syntax, part_syntax_len); SPIDER_free_part_syntax(part_syntax, MYF(0)); } -#endif DBUG_PRINT("info",("spider str=%s", str.c_ptr_safe())); error_num = share->init_from_sql_statement_string(thd, TRUE, str.ptr(), str.length()); DBUG_RETURN(error_num); } -#endif -#ifndef WITHOUT_SPIDER_BG_SEARCH int spider_create_spider_object_for_share( SPIDER_TRX *trx, SPIDER_SHARE *share, @@ -9568,46 +8959,27 @@ int spider_create_sts_threads( ) { int error_num; DBUG_ENTER("spider_create_sts_threads"); -#if MYSQL_VERSION_ID < 50500 - if (pthread_mutex_init(&spider_thread->mutex, - MY_MUTEX_INIT_FAST)) -#else if (mysql_mutex_init(spd_key_mutex_bg_stss, &spider_thread->mutex, MY_MUTEX_INIT_FAST)) -#endif { error_num = HA_ERR_OUT_OF_MEM; goto error_mutex_init; } -#if MYSQL_VERSION_ID < 50500 - if (pthread_cond_init(&spider_thread->cond, NULL)) -#else if (mysql_cond_init(spd_key_cond_bg_stss, &spider_thread->cond, NULL)) -#endif { error_num = HA_ERR_OUT_OF_MEM; goto error_cond_init; } -#if MYSQL_VERSION_ID < 50500 - if (pthread_cond_init(&spider_thread->sync_cond, NULL)) -#else if (mysql_cond_init(spd_key_cond_bg_sts_syncs, &spider_thread->sync_cond, NULL)) -#endif { error_num = HA_ERR_OUT_OF_MEM; goto error_sync_cond_init; } -#if MYSQL_VERSION_ID < 50500 - if (pthread_create(&spider_thread->thread, &spider_pt_attr, - spider_table_bg_sts_action, (void *) spider_thread) - ) -#else if (mysql_thread_create(spd_key_thd_bg_stss, &spider_thread->thread, &spider_pt_attr, spider_table_bg_sts_action, (void *) spider_thread) ) -#endif { error_num = HA_ERR_OUT_OF_MEM; goto error_thread_create; @@ -9656,46 +9028,27 @@ int spider_create_crd_threads( ) { int error_num; DBUG_ENTER("spider_create_crd_threads"); -#if MYSQL_VERSION_ID < 50500 - if (pthread_mutex_init(&spider_thread->mutex, - MY_MUTEX_INIT_FAST)) -#else if (mysql_mutex_init(spd_key_mutex_bg_crds, &spider_thread->mutex, MY_MUTEX_INIT_FAST)) -#endif { error_num = HA_ERR_OUT_OF_MEM; goto error_mutex_init; } -#if MYSQL_VERSION_ID < 50500 - if (pthread_cond_init(&spider_thread->cond, NULL)) -#else if (mysql_cond_init(spd_key_cond_bg_crds, &spider_thread->cond, NULL)) -#endif { error_num = HA_ERR_OUT_OF_MEM; goto error_cond_init; } -#if MYSQL_VERSION_ID < 50500 - if (pthread_cond_init(&spider_thread->sync_cond, NULL)) -#else if (mysql_cond_init(spd_key_cond_bg_crd_syncs, &spider_thread->sync_cond, NULL)) -#endif { error_num = HA_ERR_OUT_OF_MEM; goto error_sync_cond_init; } -#if MYSQL_VERSION_ID < 50500 - if (pthread_create(&spider_thread->thread, &spider_pt_attr, - spider_table_bg_crd_action, (void *) spider_thread) - ) -#else if (mysql_thread_create(spd_key_thd_bg_crds, &spider_thread->thread, &spider_pt_attr, spider_table_bg_crd_action, (void *) spider_thread) ) -#endif { error_num = HA_ERR_OUT_OF_MEM; goto error_thread_create; @@ -9907,18 +9260,11 @@ void *spider_table_bg_sts_action( ("spider search_link_idx=%d", spider->search_link_idx)); if (spider->search_link_idx >= 0 && conns[spider->search_link_idx]) { -#ifdef WITH_PARTITION_STORAGE_ENGINE if (spider_get_sts(share, spider->search_link_idx, share->bg_sts_try_time, spider, share->bg_sts_interval, share->bg_sts_mode, share->bg_sts_sync, 2, HA_STATUS_CONST | HA_STATUS_VARIABLE)) -#else - if (spider_get_sts(share, spider->search_link_idx, - share->bg_sts_try_time, spider, - share->bg_sts_interval, share->bg_sts_mode, - 2, HA_STATUS_CONST | HA_STATUS_VARIABLE)) -#endif { spider->search_link_idx = -1; } @@ -10060,18 +9406,11 @@ void *spider_table_bg_crd_action( ("spider search_link_idx=%d", spider->search_link_idx)); if (spider->search_link_idx >= 0 && conns[spider->search_link_idx]) { -#ifdef WITH_PARTITION_STORAGE_ENGINE if (spider_get_crd(share, spider->search_link_idx, share->bg_crd_try_time, spider, table, share->bg_crd_interval, share->bg_crd_mode, share->bg_crd_sync, 2)) -#else - if (spider_get_crd(share, spider->search_link_idx, - share->bg_crd_try_time, spider, table, - share->bg_crd_interval, share->bg_crd_mode, - 2)) -#endif { spider->search_link_idx = -1; } @@ -10258,7 +9597,6 @@ void spider_table_remove_share_from_crd_thread( } DBUG_VOID_RETURN; } -#endif uchar *spider_duplicate_char( uchar *dst, diff --git a/storage/spider/spd_table.h b/storage/spider/spd_table.h index c55e016c988..9b6eecb9d56 100644 --- a/storage/spider/spd_table.h +++ b/storage/spider/spd_table.h @@ -402,18 +402,14 @@ int spider_increase_longlong_list( int spider_parse_connect_info( SPIDER_SHARE *share, TABLE_SHARE *table_share, -#ifdef WITH_PARTITION_STORAGE_ENGINE partition_info *part_info, -#endif uint create_table ); int spider_set_connect_info_default( SPIDER_SHARE *share, -#ifdef WITH_PARTITION_STORAGE_ENGINE partition_element *part_elem, partition_element *sub_elem, -#endif TABLE_SHARE *table_share ); @@ -442,7 +438,6 @@ int spider_create_conn_keys( SPIDER_SHARE *share ); -#ifdef SPIDER_HAS_HASH_VALUE_TYPE SPIDER_LGTM_TBLHND_SHARE *spider_get_lgtm_tblhnd_share( const char *table_name, uint table_name_length, @@ -451,15 +446,6 @@ SPIDER_LGTM_TBLHND_SHARE *spider_get_lgtm_tblhnd_share( bool need_to_create, int *error_num ); -#else -SPIDER_LGTM_TBLHND_SHARE *spider_get_lgtm_tblhnd_share( - const char *table_name, - uint table_name_length, - bool locked, - bool need_to_create, - int *error_num -); -#endif void spider_free_lgtm_tblhnd_share_alloc( SPIDER_LGTM_TBLHND_SHARE *lgtm_tblhnd_share, @@ -469,12 +455,8 @@ void spider_free_lgtm_tblhnd_share_alloc( SPIDER_SHARE *spider_create_share( const char *table_name, TABLE_SHARE *table_share, -#ifdef WITH_PARTITION_STORAGE_ENGINE partition_info *part_info, -#endif -#ifdef SPIDER_HAS_HASH_VALUE_TYPE my_hash_value_type hash_value, -#endif int *error_num ); @@ -584,7 +566,6 @@ char *spider_create_table_name_string( const char *sub_name ); -#ifdef WITH_PARTITION_STORAGE_ENGINE void spider_get_partition_info( const char *table_name, uint table_name_length, @@ -593,7 +574,6 @@ void spider_get_partition_info( partition_element **part_elem, partition_element **sub_elem ); -#endif int spider_get_sts( SPIDER_SHARE *share, @@ -602,9 +582,7 @@ int spider_get_sts( ha_spider *spider, double sts_interval, int sts_mode, -#ifdef WITH_PARTITION_STORAGE_ENGINE int sts_sync, -#endif int sts_sync_level, uint flag ); @@ -617,9 +595,7 @@ int spider_get_crd( TABLE *table, double crd_interval, int crd_mode, -#ifdef WITH_PARTITION_STORAGE_ENGINE int crd_sync, -#endif int crd_sync_level ); @@ -709,7 +685,6 @@ bool spider_check_direct_order_limit( ha_spider *spider ); -#ifdef HANDLER_HAS_DIRECT_AGGREGATE bool spider_all_part_in_order( ORDER *order, TABLE *table @@ -719,7 +694,6 @@ Field *spider_field_exchange( handler *handler, Field *field ); -#endif int spider_set_direct_limit_offset( ha_spider *spider @@ -744,7 +718,6 @@ double spider_rand( uint32 rand_source ); -#ifdef SPIDER_HAS_DISCOVER_TABLE_STRUCTURE int spider_discover_table_structure_internal( SPIDER_TRX *trx, SPIDER_SHARE *spider_share, @@ -757,9 +730,7 @@ int spider_discover_table_structure( TABLE_SHARE *share, HA_CREATE_INFO *info ); -#endif -#ifndef WITHOUT_SPIDER_BG_SEARCH int spider_create_spider_object_for_share( SPIDER_TRX *trx, SPIDER_SHARE *share, @@ -809,7 +780,6 @@ void spider_table_remove_share_from_sts_thread( void spider_table_remove_share_from_crd_thread( SPIDER_SHARE *share ); -#endif uchar *spider_duplicate_char( uchar *dst, uchar esc, diff --git a/storage/spider/spd_trx.cc b/storage/spider/spd_trx.cc index dac9b728e97..29dddee5b98 100644 --- a/storage/spider/spd_trx.cc +++ b/storage/spider/spd_trx.cc @@ -18,16 +18,11 @@ #include <my_global.h> #include "mysql_version.h" #include "spd_environ.h" -#if MYSQL_VERSION_ID < 50500 -#include "mysql_priv.h" -#include <mysql/plugin.h> -#else #include "sql_priv.h" #include "probes_mysql.h" #include "sql_class.h" #include "sql_partition.h" #include "records.h" -#endif #include "spd_err.h" #include "spd_param.h" #include "spd_db_include.h" @@ -384,12 +379,7 @@ void spider_free_trx_alter_table_alloc( SPIDER_ALTER_TABLE *alter_table ) { DBUG_ENTER("spider_free_trx_alter_table_alloc"); -#ifdef HASH_UPDATE_WITH_HASH_VALUE - my_hash_delete_with_hash_value(&trx->trx_alter_table_hash, - alter_table->table_name_hash_value, (uchar*) alter_table); -#else my_hash_delete(&trx->trx_alter_table_hash, (uchar*) alter_table); -#endif if (alter_table->tmp_char) spider_free(trx, alter_table->tmp_char, MYF(0)); spider_free(trx, alter_table, MYF(0)); @@ -590,11 +580,9 @@ int spider_create_trx_alter_table( alter_table->table_name = tmp_name; memcpy(alter_table->table_name, share->table_name, share->table_name_length); alter_table->table_name_length = share->table_name_length; -#ifdef SPIDER_HAS_HASH_VALUE_TYPE DBUG_PRINT("info",("spider table_name_hash_value=%u", share->table_name_hash_value)); alter_table->table_name_hash_value = share->table_name_hash_value; -#endif alter_table->tmp_priority = share->priority; alter_table->link_count = share->link_count; alter_table->all_link_count = share->all_link_count; @@ -904,12 +892,7 @@ int spider_create_trx_alter_table( share_alter->tmp_link_statuses_length; old_elements = trx->trx_alter_table_hash.array.max_element; -#ifdef HASH_UPDATE_WITH_HASH_VALUE - if (my_hash_insert_with_hash_value(&trx->trx_alter_table_hash, - alter_table->table_name_hash_value, (uchar*) alter_table)) -#else if (my_hash_insert(&trx->trx_alter_table_hash, (uchar*) alter_table)) -#endif { error_num = HA_ERR_OUT_OF_MEM; goto error; @@ -1250,13 +1233,8 @@ SPIDER_TRX *spider_get_trx( roop_count < (int) spider_param_udf_table_lock_mutex_count(); roop_count++) { -#if MYSQL_VERSION_ID < 50500 - if (pthread_mutex_init(&trx->udf_table_mutexes[roop_count], - MY_MUTEX_INIT_FAST)) -#else if (mysql_mutex_init(spd_key_mutex_udf_table, &trx->udf_table_mutexes[roop_count], MY_MUTEX_INIT_FAST)) -#endif goto error_init_udf_table_mutex; } @@ -1313,13 +1291,6 @@ SPIDER_TRX *spider_get_trx( trx->trx_ha_hash.array.size_of_element); trx->thd = (THD*) thd; -#ifdef SPIDER_HAS_HASH_VALUE_TYPE - if (thd) - trx->thd_hash_value = my_calc_hash(&spider_allocated_thds, - (uchar*) thd, sizeof(THD *)); - else - trx->thd_hash_value = 0; -#endif pthread_mutex_lock(&spider_thread_id_mutex); trx->spider_thread_id = spider_thread_id; ++spider_thread_id; @@ -1333,10 +1304,8 @@ SPIDER_TRX *spider_get_trx( if ( spider_set_connect_info_default( trx->tmp_share, -#ifdef WITH_PARTITION_STORAGE_ENGINE NULL, NULL, -#endif NULL ) || spider_set_connect_info_default_db_table( @@ -1406,12 +1375,7 @@ SPIDER_TRX *spider_get_trx( { pthread_mutex_lock(&spider_allocated_thds_mutex); uint old_elements = spider_allocated_thds.array.max_element; -#ifdef HASH_UPDATE_WITH_HASH_VALUE - if (my_hash_insert_with_hash_value(&spider_allocated_thds, - trx->thd_hash_value, (uchar*) thd)) -#else if (my_hash_insert(&spider_allocated_thds, (uchar*) thd)) -#endif { pthread_mutex_unlock(&spider_allocated_thds_mutex); goto error_allocated_thds_insert; @@ -1517,12 +1481,7 @@ int spider_free_trx( { if (need_lock) pthread_mutex_lock(&spider_allocated_thds_mutex); -#ifdef HASH_UPDATE_WITH_HASH_VALUE - my_hash_delete_with_hash_value(&spider_allocated_thds, - trx->thd_hash_value, (uchar*) trx->thd); -#else my_hash_delete(&spider_allocated_thds, (uchar*) trx->thd); -#endif if (need_lock) pthread_mutex_unlock(&spider_allocated_thds_mutex); } @@ -1679,14 +1638,12 @@ static int spider_xa_lock( DBUG_ENTER("spider_xa_lock"); #ifdef SPIDER_XID_USES_xid_cache_iterate #else -#ifdef SPIDER_HAS_HASH_VALUE_TYPE my_hash_value_type hash_value = my_calc_hash(spd_db_att_xid_cache, (uchar*) xid_state->xid.key(), xid_state->xid.key_length()); #ifdef XID_CACHE_IS_SPLITTED uint idx = hash_value % *spd_db_att_xid_cache_split_num; #endif #endif -#endif old_proc_info = thd_proc_info(thd, "Locking xid by Spider"); #ifdef SPIDER_XID_USES_xid_cache_iterate if (xid_cache_insert(thd, xid_state, xid)) @@ -1701,7 +1658,6 @@ static int spider_xa_lock( #else pthread_mutex_lock(spd_db_att_LOCK_xid_cache); #endif -#ifdef SPIDER_HAS_HASH_VALUE_TYPE #ifdef XID_CACHE_IS_SPLITTED if (my_hash_search_using_hash_value(&spd_db_att_xid_cache[idx], hash_value, xid_state->xid.key(), xid_state->xid.key_length())) @@ -1709,25 +1665,11 @@ static int spider_xa_lock( if (my_hash_search_using_hash_value(spd_db_att_xid_cache, hash_value, xid_state->xid.key(), xid_state->xid.key_length())) #endif -#else - if (my_hash_search(spd_db_att_xid_cache, - xid_state->xid.key(), xid_state->xid.key_length())) -#endif { error_num = ER_SPIDER_XA_LOCKED_NUM; goto error; } -#ifdef HASH_UPDATE_WITH_HASH_VALUE -#ifdef XID_CACHE_IS_SPLITTED - if (my_hash_insert_with_hash_value(&spd_db_att_xid_cache[idx], hash_value, - (uchar*)xid_state)) -#else - if (my_hash_insert_with_hash_value(spd_db_att_xid_cache, hash_value, - (uchar*)xid_state)) -#endif -#else if (my_hash_insert(spd_db_att_xid_cache, (uchar*)xid_state)) -#endif { error_num = HA_ERR_OUT_OF_MEM; goto error; @@ -1762,13 +1704,6 @@ static int spider_xa_unlock( DBUG_ENTER("spider_xa_unlock"); #ifdef SPIDER_XID_USES_xid_cache_iterate #else -#if defined(SPIDER_HAS_HASH_VALUE_TYPE) && defined(HASH_UPDATE_WITH_HASH_VALUE) - my_hash_value_type hash_value = my_calc_hash(spd_db_att_xid_cache, - (uchar*) xid_state->xid.key(), xid_state->xid.key_length()); -#ifdef XID_CACHE_IS_SPLITTED - uint idx = hash_value % *spd_db_att_xid_cache_split_num; -#endif -#endif #endif old_proc_info = thd_proc_info(thd, "Unlocking xid by Spider"); #ifdef SPIDER_XID_USES_xid_cache_iterate @@ -1779,17 +1714,7 @@ static int spider_xa_unlock( #else pthread_mutex_lock(spd_db_att_LOCK_xid_cache); #endif -#if defined(SPIDER_HAS_HASH_VALUE_TYPE) && defined(HASH_UPDATE_WITH_HASH_VALUE) -#ifdef XID_CACHE_IS_SPLITTED - my_hash_delete_with_hash_value(&spd_db_att_xid_cache[idx], - hash_value, (uchar *)xid_state); -#else - my_hash_delete_with_hash_value(spd_db_att_xid_cache, - hash_value, (uchar *)xid_state); -#endif -#else my_hash_delete(spd_db_att_xid_cache, (uchar *)xid_state); -#endif #ifdef XID_CACHE_IS_SPLITTED pthread_mutex_unlock(&spd_db_att_LOCK_xid_cache[idx]); #else @@ -1875,17 +1800,10 @@ int spider_internal_start_trx( (trx->xid.data, "%lx%016llx", thd_get_thread_id(thd), thd->query_id)); } -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100002 trx->xid.bqual_length = my_sprintf(trx->xid.data + trx->xid.gtrid_length, (trx->xid.data + trx->xid.gtrid_length, "%lx", thd->variables.server_id)); -#else - trx->xid.bqual_length - = my_sprintf(trx->xid.data + trx->xid.gtrid_length, - (trx->xid.data + trx->xid.gtrid_length, "%x", - thd->server_id)); -#endif #ifdef SPIDER_XID_STATE_HAS_in_thd trx->internal_xid_state.in_thd = 1; @@ -3316,11 +3234,6 @@ int spider_commit( if (!(trx = (SPIDER_TRX*) thd_get_ha_data(thd, spider_hton_ptr))) DBUG_RETURN(0); /* transaction is not started */ -#ifdef HA_CAN_BULK_ACCESS - DBUG_PRINT("info",("spider trx->bulk_access_conn_first=%p", - trx->bulk_access_conn_first)); - trx->bulk_access_conn_first = NULL; -#endif /* We do (almost) nothing if the following two conditions are both met: @@ -3414,11 +3327,6 @@ int spider_rollback( if (!(trx = (SPIDER_TRX*) thd_get_ha_data(thd, spider_hton_ptr))) DBUG_RETURN(0); /* transaction is not started */ -#ifdef HA_CAN_BULK_ACCESS - DBUG_PRINT("info",("spider trx->bulk_access_conn_first=%p", - trx->bulk_access_conn_first)); - trx->bulk_access_conn_first = NULL; -#endif if (all || (!thd_test_options(thd, OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN))) { @@ -3902,19 +3810,8 @@ THD *spider_create_tmp_thd() DBUG_ENTER("spider_create_tmp_thd"); if (!(thd = SPIDER_new_THD((my_thread_id) 0))) DBUG_RETURN(NULL); -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000 thd->killed = NOT_KILLED; -#else - thd->killed = THD::NOT_KILLED; -#endif -#if MYSQL_VERSION_ID < 50500 - thd->locked_tables = FALSE; -#endif thd->proc_info = ""; -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100200 -#else - thd->thread_id = thd->variables.pseudo_thread_id = 0; -#endif thd->thread_stack = (char*) &thd; thd->store_globals(); lex_start(thd); @@ -3926,11 +3823,7 @@ void spider_free_tmp_thd( ) { DBUG_ENTER("spider_free_tmp_thd"); thd->cleanup(); -#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000 thd->reset_globals(); -#else - thd->restore_globals(); -#endif delete thd; DBUG_VOID_RETURN; } @@ -3957,12 +3850,7 @@ int spider_create_trx_ha( ) { DBUG_PRINT("info",("spider need recreate")); need_create = TRUE; -#ifdef HASH_UPDATE_WITH_HASH_VALUE - my_hash_delete_with_hash_value(&trx->trx_ha_hash, - share->table_name_hash_value, (uchar*) trx_ha); -#else my_hash_delete(&trx->trx_ha_hash, (uchar*) trx_ha); -#endif spider_free(trx, trx_ha, MYF(0)); } else { DBUG_PRINT("info",("spider use this")); @@ -3993,12 +3881,7 @@ int spider_create_trx_ha( trx_ha->conn_can_fo = conn_can_fo; trx_ha->wait_for_reusing = FALSE; uint old_elements = trx->trx_ha_hash.array.max_element; -#ifdef HASH_UPDATE_WITH_HASH_VALUE - if (my_hash_insert_with_hash_value(&trx->trx_ha_hash, - share->table_name_hash_value, (uchar*) trx_ha)) -#else if (my_hash_insert(&trx->trx_ha_hash, (uchar*) trx_ha)) -#endif { spider_free(trx, trx_ha, MYF(0)); DBUG_RETURN(HA_ERR_OUT_OF_MEM); @@ -4025,14 +3908,9 @@ SPIDER_TRX_HA *spider_check_trx_ha( SPIDER_TRX_HA *trx_ha; SPIDER_SHARE *share = spider->share; DBUG_ENTER("spider_check_trx_ha"); -#ifdef SPIDER_HAS_HASH_VALUE_TYPE if ((trx_ha = (SPIDER_TRX_HA *) my_hash_search_using_hash_value( &trx->trx_ha_hash, share->table_name_hash_value, (uchar*) share->table_name, share->table_name_length))) -#else - if ((trx_ha = (SPIDER_TRX_HA *) my_hash_search(&trx->trx_ha_hash, - (uchar*) share->table_name, share->table_name_length))) -#endif { memcpy(spider->conn_link_idx, trx_ha->conn_link_idx, sizeof(uint) * share->link_count); @@ -4148,34 +4026,3 @@ int spider_trx_check_link_idx_failed( DBUG_RETURN(0); } -#ifdef HA_CAN_BULK_ACCESS -void spider_trx_add_bulk_access_conn( - SPIDER_TRX *trx, - SPIDER_CONN *conn -) { - DBUG_ENTER("spider_trx_add_bulk_access_conn"); - DBUG_PRINT("info",("spider trx=%p", trx)); - DBUG_PRINT("info",("spider conn=%p", conn)); - DBUG_PRINT("info",("spider conn->bulk_access_requests=%u", - conn->bulk_access_requests)); - DBUG_PRINT("info",("spider conn->bulk_access_sended=%u", - conn->bulk_access_sended)); - DBUG_PRINT("info",("spider trx->bulk_access_conn_first=%p", - trx->bulk_access_conn_first)); - if (!conn->bulk_access_requests && !conn->bulk_access_sended) - { - if (!trx->bulk_access_conn_first) - { - trx->bulk_access_conn_first = conn; - } else { - trx->bulk_access_conn_last->bulk_access_next = conn; - } - trx->bulk_access_conn_last = conn; - conn->bulk_access_next = NULL; - } - conn->bulk_access_requests++; - DBUG_PRINT("info",("spider conn->bulk_access_requests=%u", - conn->bulk_access_requests)); - DBUG_VOID_RETURN; -} -#endif diff --git a/storage/spider/spd_trx.h b/storage/spider/spd_trx.h index 3bf93aada1a..2055a49717e 100644 --- a/storage/spider/spd_trx.h +++ b/storage/spider/spd_trx.h @@ -266,9 +266,3 @@ int spider_trx_check_link_idx_failed( ha_spider *spider ); -#ifdef HA_CAN_BULK_ACCESS -void spider_trx_add_bulk_access_conn( - SPIDER_TRX *trx, - SPIDER_CONN *conn -); -#endif diff --git a/storage/spider/spd_udf.cc b/storage/spider/spd_udf.cc index 3f7cc65477f..13a9b41f7e2 100644 --- a/storage/spider/spd_udf.cc +++ b/storage/spider/spd_udf.cc @@ -43,7 +43,6 @@ void spider_direct_sql_deinit( spider_direct_sql_deinit_body(initid); } -#ifndef WITHOUT_SPIDER_BG_SEARCH long long spider_bg_direct_sql( UDF_INIT *initid, UDF_ARGS *args, @@ -83,7 +82,6 @@ void spider_bg_direct_sql_add( ) { spider_direct_sql_body(initid, args, is_null, error, TRUE); } -#endif long long spider_ping_table( UDF_INIT *initid, diff --git a/storage/spider/spd_udf.h b/storage/spider/spd_udf.h index d00a6151894..bb9f1ce252b 100644 --- a/storage/spider/spd_udf.h +++ b/storage/spider/spd_udf.h @@ -32,7 +32,6 @@ void spider_direct_sql_deinit_body( UDF_INIT *initid ); -#ifndef WITHOUT_SPIDER_BG_SEARCH void spider_direct_sql_bg_start( UDF_INIT *initid ); @@ -40,7 +39,6 @@ void spider_direct_sql_bg_start( long long spider_direct_sql_bg_end( UDF_INIT *initid ); -#endif long long spider_ping_table_body( UDF_INIT *initid, |