1 /* Copyright (C) 2008-2018 Kentoku Shiba
2
3 This program is free software; you can redistribute it and/or modify
4 it under the terms of the GNU General Public License as published by
5 the Free Software Foundation; version 2 of the License.
6
7 This program is distributed in the hope that it will be useful,
8 but WITHOUT ANY WARRANTY; without even the implied warranty of
9 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 GNU General Public License for more details.
11
12 You should have received a copy of the GNU General Public License
13 along with this program; if not, write to the Free Software
14 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
15
16 #define MYSQL_SERVER 1
17 #include <my_global.h>
18 #include "mysql_version.h"
19 #include "spd_environ.h"
20 #if MYSQL_VERSION_ID < 50500
21 #include "mysql_priv.h"
22 #include <mysql/plugin.h>
23 #else
24 #include "sql_priv.h"
25 #include "probes_mysql.h"
26 #include "sql_class.h"
27 #include "sql_partition.h"
28 #include "sql_analyse.h"
29 #include "sql_base.h"
30 #include "tztime.h"
31 #include "errmsg.h"
32 #ifdef HANDLER_HAS_DIRECT_AGGREGATE
33 #include "sql_select.h"
34 #endif
35 #endif
36 #include "sql_common.h"
37 #include <errmsg.h>
38 #include "spd_err.h"
39 #include "spd_param.h"
40 #include "spd_db_include.h"
41 #include "spd_include.h"
42 #include "spd_sys_table.h"
43 #include "ha_spider.h"
44 #include "spd_db_conn.h"
45 #include "spd_table.h"
46 #include "spd_trx.h"
47 #include "spd_conn.h"
48 #include "spd_direct_sql.h"
49 #include "spd_ping_table.h"
50 #include "spd_copy_tables.h"
51 #include "spd_malloc.h"
52
53 extern handlerton *spider_hton_ptr;
54 extern SPIDER_DBTON spider_dbton[SPIDER_DBTON_SIZE];
55
56 #define SPIDER_SQL_COALESCE_STR "coalesce("
57 #define SPIDER_SQL_COALESCE_LEN (sizeof(SPIDER_SQL_COALESCE_STR) - 1)
58 #define SPIDER_SQL_HEX_STR "0x"
59 #define SPIDER_SQL_HEX_LEN (sizeof(SPIDER_SQL_HEX_STR) - 1)
60 #define SPIDER_SQL_SQL_FORCE_IDX_STR " force index("
61 #define SPIDER_SQL_SQL_FORCE_IDX_LEN (sizeof(SPIDER_SQL_SQL_FORCE_IDX_STR) - 1)
62 #define SPIDER_SQL_SQL_USE_IDX_STR " use index("
63 #define SPIDER_SQL_SQL_USE_IDX_LEN (sizeof(SPIDER_SQL_SQL_USE_IDX_STR) - 1)
64 #define SPIDER_SQL_SQL_IGNORE_IDX_STR " ignore index("
65 #define SPIDER_SQL_SQL_IGNORE_IDX_LEN (sizeof(SPIDER_SQL_SQL_IGNORE_IDX_STR) - 1)
66
67 #define SPIDER_SQL_SET_NAMES_STR "set names "
68 #define SPIDER_SQL_SET_NAMES_LEN sizeof(SPIDER_SQL_SET_NAMES_STR) - 1
69
70 #define SPIDER_SQL_PING_TABLE_STR "spider_ping_table("
71 #define SPIDER_SQL_PING_TABLE_LEN (sizeof(SPIDER_SQL_PING_TABLE_STR) - 1)
72
73 #ifdef SPIDER_HAS_HASH_VALUE_TYPE
74 extern HASH spider_open_connections;
75 #endif
76 pthread_mutex_t spider_open_conn_mutex;
77 const char spider_dig_upper[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
78
79 /* UTC time zone for timestamp columns */
80 Time_zone *UTC = 0;
81
spider_db_connect(const SPIDER_SHARE * share,SPIDER_CONN * conn,int link_idx)82 int spider_db_connect(
83 const SPIDER_SHARE *share,
84 SPIDER_CONN *conn,
85 int link_idx
86 ) {
87 int error_num, connect_retry_count;
88 THD* thd = current_thd;
89 longlong connect_retry_interval;
90 DBUG_ENTER("spider_db_connect");
91 DBUG_ASSERT(conn->conn_kind != SPIDER_CONN_KIND_MYSQL || conn->need_mon);
92 DBUG_PRINT("info",("spider link_idx=%d", link_idx));
93 DBUG_PRINT("info",("spider conn=%p", conn));
94
95 if (conn->connect_error)
96 {
97 time_t tmp_time = (time_t) time((time_t*) 0);
98 DBUG_PRINT("info",("spider diff=%f",
99 difftime(tmp_time, conn->connect_error_time)));
100 if (
101 (
102 conn->thd &&
103 conn->thd == conn->connect_error_thd &&
104 conn->thd->query_id == conn->connect_error_query_id
105 ) ||
106 (
107 difftime(tmp_time, conn->connect_error_time) <
108 spider_param_connect_error_interval()
109 )
110 ) {
111 DBUG_PRINT("info",("spider set same error"));
112 if (conn->connect_error_with_message)
113 my_message(conn->connect_error, conn->connect_error_msg, MYF(0));
114 DBUG_RETURN(conn->connect_error);
115 }
116 }
117
118 if (thd)
119 {
120 conn->connect_timeout = spider_param_connect_timeout(thd,
121 share->connect_timeouts[link_idx]);
122 conn->net_read_timeout = spider_param_net_read_timeout(thd,
123 share->net_read_timeouts[link_idx]);
124 conn->net_write_timeout = spider_param_net_write_timeout(thd,
125 share->net_write_timeouts[link_idx]);
126 connect_retry_interval = spider_param_connect_retry_interval(thd);
127 if (conn->disable_connect_retry)
128 connect_retry_count = 0;
129 else
130 connect_retry_count = spider_param_connect_retry_count(thd);
131 } else {
132 conn->connect_timeout = spider_param_connect_timeout(NULL,
133 share->connect_timeouts[link_idx]);
134 conn->net_read_timeout = spider_param_net_read_timeout(NULL,
135 share->net_read_timeouts[link_idx]);
136 conn->net_write_timeout = spider_param_net_write_timeout(NULL,
137 share->net_write_timeouts[link_idx]);
138 connect_retry_interval = spider_param_connect_retry_interval(NULL);
139 connect_retry_count = spider_param_connect_retry_count(NULL);
140 }
141 DBUG_PRINT("info",("spider connect_timeout=%u", conn->connect_timeout));
142 DBUG_PRINT("info",("spider net_read_timeout=%u", conn->net_read_timeout));
143 DBUG_PRINT("info",("spider net_write_timeout=%u", conn->net_write_timeout));
144
145 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
146 if (conn->conn_kind == SPIDER_CONN_KIND_MYSQL)
147 {
148 #endif
149 if ((error_num = spider_reset_conn_setted_parameter(conn, thd)))
150 DBUG_RETURN(error_num);
151 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
152 }
153 #endif
154
155 if (conn->dbton_id == SPIDER_DBTON_SIZE)
156 {
157 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
158 if (conn->conn_kind == SPIDER_CONN_KIND_MYSQL)
159 {
160 #endif
161 my_printf_error(
162 ER_SPIDER_SQL_WRAPPER_IS_INVALID_NUM,
163 ER_SPIDER_SQL_WRAPPER_IS_INVALID_STR,
164 MYF(0), conn->tgt_wrapper);
165 DBUG_RETURN(ER_SPIDER_SQL_WRAPPER_IS_INVALID_NUM);
166 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
167 } else {
168 my_printf_error(
169 ER_SPIDER_NOSQL_WRAPPER_IS_INVALID_NUM,
170 ER_SPIDER_NOSQL_WRAPPER_IS_INVALID_STR,
171 MYF(0), conn->tgt_wrapper);
172 DBUG_RETURN(ER_SPIDER_NOSQL_WRAPPER_IS_INVALID_NUM);
173 }
174 #endif
175 }
176
177 if ((error_num = conn->db_conn->connect(
178 share->tgt_hosts[link_idx],
179 share->tgt_usernames[link_idx],
180 share->tgt_passwords[link_idx],
181 share->tgt_ports[link_idx],
182 share->tgt_sockets[link_idx],
183 share->server_names[link_idx],
184 connect_retry_count, connect_retry_interval)))
185 {
186 if (conn->thd)
187 {
188 conn->connect_error_thd = conn->thd;
189 conn->connect_error_query_id = conn->thd->query_id;
190 conn->connect_error_time = (time_t) time((time_t*) 0);
191 conn->connect_error = error_num;
192 if ((conn->connect_error_with_message = thd->is_error()))
193 strmov(conn->connect_error_msg, spider_stmt_da_message(thd));
194 }
195 DBUG_RETURN(error_num);
196 }
197
198 conn->connect_error = 0;
199 conn->opened_handlers = 0;
200 conn->db_conn->reset_opened_handler();
201 ++conn->connection_id;
202
203 /* Set the connection's time zone to UTC */
204 spider_conn_queue_UTC_time_zone(conn);
205 DBUG_RETURN(0);
206 }
207
spider_db_ping_internal(SPIDER_SHARE * share,SPIDER_CONN * conn,int all_link_idx,int * need_mon)208 int spider_db_ping_internal(
209 SPIDER_SHARE *share,
210 SPIDER_CONN *conn,
211 int all_link_idx,
212 int *need_mon
213 ) {
214 int error_num;
215 DBUG_ENTER("spider_db_ping_internal");
216 pthread_mutex_assert_owner(&conn->mta_conn_mutex);
217 DBUG_ASSERT(conn->mta_conn_mutex_file_pos.file_name);
218 if (conn->server_lost || conn->queued_connect)
219 {
220 if ((error_num = spider_db_connect(share, conn, all_link_idx)))
221 {
222 pthread_mutex_assert_owner(&conn->mta_conn_mutex);
223 DBUG_RETURN(error_num);
224 }
225 conn->server_lost = FALSE;
226 conn->queued_connect = FALSE;
227 }
228 if ((error_num = conn->db_conn->ping()))
229 {
230 spider_db_disconnect(conn);
231 if ((error_num = spider_db_connect(share, conn, all_link_idx)))
232 {
233 DBUG_PRINT("info", ("spider conn=%p SERVER_LOST", conn));
234 conn->server_lost = TRUE;
235 pthread_mutex_assert_owner(&conn->mta_conn_mutex);
236 DBUG_RETURN(error_num);
237 }
238 if((error_num = conn->db_conn->ping()))
239 {
240 spider_db_disconnect(conn);
241 DBUG_PRINT("info", ("spider conn=%p SERVER_LOST", conn));
242 conn->server_lost = TRUE;
243 pthread_mutex_assert_owner(&conn->mta_conn_mutex);
244 DBUG_RETURN(error_num);
245 }
246 }
247 conn->ping_time = (time_t) time((time_t*) 0);
248 pthread_mutex_assert_owner(&conn->mta_conn_mutex);
249 DBUG_RETURN(0);
250 }
251
spider_db_ping(ha_spider * spider,SPIDER_CONN * conn,int link_idx)252 int spider_db_ping(
253 ha_spider *spider,
254 SPIDER_CONN *conn,
255 int link_idx
256 ) {
257 DBUG_ENTER("spider_db_ping");
258 #ifndef DBUG_OFF
259 if (spider->trx->thd)
260 DBUG_PRINT("info", ("spider thd->query_id is %lld",
261 spider->trx->thd->query_id));
262 #endif
263 DBUG_RETURN(spider_db_ping_internal(spider->share, conn,
264 spider->conn_link_idx[link_idx], &spider->need_mons[link_idx]));
265 }
266
spider_db_disconnect(SPIDER_CONN * conn)267 void spider_db_disconnect(
268 SPIDER_CONN *conn
269 ) {
270 DBUG_ENTER("spider_db_disconnect");
271 DBUG_PRINT("info",("spider conn=%p", conn));
272 DBUG_PRINT("info",("spider conn->conn_kind=%u", conn->conn_kind));
273 if (conn->db_conn->is_connected())
274 {
275 conn->db_conn->disconnect();
276 }
277 DBUG_VOID_RETURN;
278 }
279
spider_db_conn_queue_action(SPIDER_CONN * conn)280 int spider_db_conn_queue_action(
281 SPIDER_CONN *conn
282 ) {
283 int error_num;
284 char sql_buf[MAX_FIELD_WIDTH * 2];
285 spider_string sql_str(sql_buf, sizeof(sql_buf), system_charset_info);
286 DBUG_ENTER("spider_db_conn_queue_action");
287 DBUG_PRINT("info", ("spider conn=%p", conn));
288 sql_str.init_calc_mem(106);
289 sql_str.length(0);
290 if (conn->queued_connect)
291 {
292 if ((error_num = spider_db_connect(conn->queued_connect_share, conn,
293 conn->queued_connect_link_idx)))
294 {
295 DBUG_PRINT("info", ("spider conn=%p SERVER_LOST", conn));
296 conn->server_lost = TRUE;
297 DBUG_RETURN(error_num);
298 }
299 conn->server_lost = FALSE;
300 conn->queued_connect = FALSE;
301 }
302
303 pthread_mutex_assert_owner(&conn->mta_conn_mutex);
304 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
305 if (conn->conn_kind == SPIDER_CONN_KIND_MYSQL)
306 {
307 #endif
308 if (conn->queued_ping)
309 {
310 if ((error_num = spider_db_ping(conn->queued_ping_spider, conn,
311 conn->queued_ping_link_idx)))
312 DBUG_RETURN(error_num);
313 conn->queued_ping = FALSE;
314 }
315
316 if (conn->server_lost)
317 {
318 DBUG_PRINT("info", ("spider no reconnect queue"));
319 DBUG_RETURN(CR_SERVER_GONE_ERROR);
320 }
321
322 if (conn->queued_net_timeout)
323 {
324 conn->db_conn->set_net_timeout();
325 conn->queued_net_timeout = FALSE;
326 }
327 if (
328 (
329 conn->queued_trx_isolation &&
330 !conn->queued_semi_trx_isolation &&
331 conn->queued_trx_isolation_val != conn->trx_isolation &&
332 conn->db_conn->set_trx_isolation_in_bulk_sql() &&
333 (error_num = spider_dbton[conn->dbton_id].db_util->
334 append_trx_isolation(&sql_str, conn->queued_trx_isolation_val))
335 ) ||
336 (
337 conn->queued_semi_trx_isolation &&
338 conn->queued_semi_trx_isolation_val != conn->trx_isolation &&
339 conn->db_conn->set_trx_isolation_in_bulk_sql() &&
340 (error_num = spider_dbton[conn->dbton_id].db_util->
341 append_trx_isolation(&sql_str, conn->queued_semi_trx_isolation_val))
342 ) ||
343 (
344 conn->queued_autocommit &&
345 (
346 (conn->queued_autocommit_val && conn->autocommit != 1) ||
347 (!conn->queued_autocommit_val && conn->autocommit != 0)
348 ) &&
349 conn->db_conn->set_autocommit_in_bulk_sql() &&
350 (error_num = spider_dbton[conn->dbton_id].db_util->
351 append_autocommit(&sql_str, conn->queued_autocommit_val))
352 ) ||
353 (
354 conn->queued_sql_log_off &&
355 (
356 (conn->queued_sql_log_off_val && conn->sql_log_off != 1) ||
357 (!conn->queued_sql_log_off_val && conn->sql_log_off != 0)
358 ) &&
359 conn->db_conn->set_sql_log_off_in_bulk_sql() &&
360 (error_num = spider_dbton[conn->dbton_id].db_util->
361 append_sql_log_off(&sql_str, conn->queued_sql_log_off_val))
362 ) ||
363 (
364 conn->queued_time_zone &&
365 conn->queued_time_zone_val != conn->time_zone &&
366 conn->db_conn->set_time_zone_in_bulk_sql() &&
367 (error_num = spider_dbton[conn->dbton_id].db_util->
368 append_time_zone(&sql_str, conn->queued_time_zone_val))
369 ) ||
370 (
371 conn->queued_trx_start &&
372 conn->db_conn->trx_start_in_bulk_sql() &&
373 (error_num = spider_dbton[conn->dbton_id].db_util->
374 append_start_transaction(&sql_str))
375 ) ||
376 (
377 conn->queued_xa_start &&
378 conn->db_conn->xa_start_in_bulk_sql() &&
379 (error_num = spider_dbton[conn->dbton_id].db_util->
380 append_xa_start(&sql_str, conn->queued_xa_start_xid))
381 )
382 )
383 DBUG_RETURN(error_num);
384 if (sql_str.length())
385 {
386 if ((error_num = conn->db_conn->exec_query(sql_str.ptr(),
387 sql_str.length(), -1)))
388 DBUG_RETURN(error_num);
389 spider_db_result *result;
390 do {
391 st_spider_db_request_key request_key;
392 request_key.spider_thread_id = 1;
393 request_key.query_id = 1;
394 request_key.handler = NULL;
395 request_key.request_id = 1;
396 request_key.next = NULL;
397 if ((result = conn->db_conn->store_result(NULL, &request_key,
398 &error_num)))
399 {
400 result->free_result();
401 delete result;
402 } else if ((error_num = conn->db_conn->get_errno()))
403 {
404 break;
405 }
406 } while (!(error_num = conn->db_conn->next_result()));
407 if (error_num > 0)
408 DBUG_RETURN(error_num);
409 }
410
411 if (
412 conn->queued_autocommit &&
413 (
414 (conn->queued_autocommit_val && conn->autocommit != 1) ||
415 (!conn->queued_autocommit_val && conn->autocommit != 0)
416 ) &&
417 !conn->db_conn->set_autocommit_in_bulk_sql() &&
418 (error_num = spider_dbton[conn->dbton_id].db_util->
419 append_autocommit(&sql_str, conn->queued_autocommit_val))
420 ) {
421 DBUG_RETURN(error_num);
422 }
423 if (
424 conn->queued_sql_log_off &&
425 (
426 (conn->queued_sql_log_off_val && conn->sql_log_off != 1) ||
427 (!conn->queued_sql_log_off_val && conn->sql_log_off != 0)
428 ) &&
429 !conn->db_conn->set_sql_log_off_in_bulk_sql() &&
430 (error_num = spider_dbton[conn->dbton_id].db_util->
431 append_sql_log_off(&sql_str, conn->queued_sql_log_off_val))
432 ) {
433 DBUG_RETURN(error_num);
434 }
435 if (
436 conn->queued_time_zone &&
437 conn->queued_time_zone_val != conn->time_zone &&
438 !conn->db_conn->set_time_zone_in_bulk_sql() &&
439 (error_num = spider_dbton[conn->dbton_id].db_util->
440 append_time_zone(&sql_str, conn->queued_time_zone_val))
441 ) {
442 DBUG_RETURN(error_num);
443 }
444 if (
445 conn->queued_trx_isolation &&
446 !conn->queued_semi_trx_isolation &&
447 conn->queued_trx_isolation_val != conn->trx_isolation &&
448 !conn->db_conn->set_trx_isolation_in_bulk_sql() &&
449 (error_num = conn->db_conn->set_trx_isolation(
450 conn->queued_trx_isolation_val, (int *) conn->need_mon))
451 ) {
452 DBUG_RETURN(error_num);
453 }
454 if (
455 conn->queued_semi_trx_isolation &&
456 conn->queued_semi_trx_isolation_val != conn->trx_isolation &&
457 !conn->db_conn->set_trx_isolation_in_bulk_sql() &&
458 (error_num = conn->db_conn->set_trx_isolation(
459 conn->queued_semi_trx_isolation_val, (int *) conn->need_mon))
460 ) {
461 DBUG_RETURN(error_num);
462 }
463 if (
464 conn->queued_trx_start &&
465 !conn->db_conn->trx_start_in_bulk_sql() &&
466 (error_num = conn->db_conn->
467 start_transaction((int *) conn->need_mon))
468 ) {
469 DBUG_RETURN(error_num);
470 }
471 if (
472 conn->queued_xa_start &&
473 !conn->db_conn->xa_start_in_bulk_sql() &&
474 (error_num = conn->db_conn->
475 xa_start(conn->queued_xa_start_xid, (int *) conn->need_mon))
476 ) {
477 DBUG_RETURN(error_num);
478 }
479
480 if (
481 conn->queued_trx_isolation &&
482 !conn->queued_semi_trx_isolation &&
483 conn->queued_trx_isolation_val != conn->trx_isolation
484 ) {
485 conn->trx_isolation = conn->queued_trx_isolation_val;
486 DBUG_PRINT("info", ("spider conn->trx_isolation=%d",
487 conn->trx_isolation));
488 }
489
490 if (
491 conn->queued_semi_trx_isolation &&
492 conn->queued_semi_trx_isolation_val != conn->trx_isolation
493 ) {
494 conn->semi_trx_isolation = conn->queued_semi_trx_isolation_val;
495 DBUG_PRINT("info", ("spider conn->semi_trx_isolation=%d",
496 conn->semi_trx_isolation));
497 conn->trx_isolation = thd_tx_isolation(conn->thd);
498 DBUG_PRINT("info", ("spider conn->trx_isolation=%d",
499 conn->trx_isolation));
500 }
501
502 if (conn->queued_autocommit)
503 {
504 if (conn->queued_autocommit_val && conn->autocommit != 1)
505 {
506 conn->autocommit = 1;
507 } else if (!conn->queued_autocommit_val && conn->autocommit != 0)
508 {
509 conn->autocommit = 0;
510 }
511 DBUG_PRINT("info", ("spider conn->autocommit=%d",
512 conn->autocommit));
513 }
514
515 if (conn->queued_sql_log_off)
516 {
517 if (conn->queued_sql_log_off_val && conn->sql_log_off != 1)
518 {
519 conn->sql_log_off = 1;
520 } else if (!conn->queued_sql_log_off_val && conn->sql_log_off != 0)
521 {
522 conn->sql_log_off = 0;
523 }
524 DBUG_PRINT("info", ("spider conn->sql_log_off=%d",
525 conn->sql_log_off));
526 }
527
528 if (
529 conn->queued_time_zone &&
530 conn->queued_time_zone_val != conn->time_zone
531 ) {
532 conn->time_zone = conn->queued_time_zone_val;
533 DBUG_PRINT("info", ("spider conn->time_zone=%p",
534 conn->time_zone));
535 }
536 spider_conn_clear_queue(conn);
537 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
538 } else if (conn->server_lost)
539 {
540 DBUG_PRINT("info", ("spider no connect queue"));
541 DBUG_RETURN(CR_SERVER_GONE_ERROR);
542 }
543 #endif
544 DBUG_RETURN(0);
545 }
546
spider_db_before_query(SPIDER_CONN * conn,int * need_mon)547 int spider_db_before_query(
548 SPIDER_CONN *conn,
549 int *need_mon
550 ) {
551 int error_num;
552 DBUG_ENTER("spider_db_before_query");
553 DBUG_ASSERT(need_mon);
554 #ifndef WITHOUT_SPIDER_BG_SEARCH
555 if (conn->bg_search)
556 spider_bg_conn_break(conn, NULL);
557 #endif
558 conn->in_before_query = TRUE;
559 pthread_mutex_assert_owner(&conn->mta_conn_mutex);
560 DBUG_ASSERT(conn->mta_conn_mutex_file_pos.file_name);
561 if ((error_num = spider_db_conn_queue_action(conn)))
562 {
563 conn->in_before_query = FALSE;
564 pthread_mutex_assert_owner(&conn->mta_conn_mutex);
565 DBUG_RETURN(error_num);
566 }
567 if (conn->server_lost)
568 {
569 conn->in_before_query = FALSE;
570 pthread_mutex_assert_owner(&conn->mta_conn_mutex);
571 DBUG_RETURN(CR_SERVER_GONE_ERROR);
572 }
573 DBUG_PRINT("info", ("spider conn[%p]->quick_target=%p",
574 conn, conn->quick_target));
575 if (conn->quick_target)
576 {
577 bool tmp_mta_conn_mutex_unlock_later;
578 ha_spider *spider = (ha_spider*) conn->quick_target;
579 SPIDER_RESULT_LIST *result_list = &spider->result_list;
580 DBUG_PRINT("info", ("spider result_list->quick_mode=%d",
581 result_list->quick_mode));
582 if (result_list->quick_mode == 2)
583 {
584 result_list->quick_phase = 1;
585 spider->connection_ids[conn->link_idx] = conn->connection_id;
586 tmp_mta_conn_mutex_unlock_later = conn->mta_conn_mutex_unlock_later;
587 conn->mta_conn_mutex_unlock_later = TRUE;
588 while (conn->quick_target)
589 {
590 if (
591 (error_num = spider_db_store_result(spider, conn->link_idx,
592 result_list->table)) &&
593 error_num != HA_ERR_END_OF_FILE
594 ) {
595 conn->mta_conn_mutex_unlock_later = tmp_mta_conn_mutex_unlock_later;
596 conn->in_before_query = FALSE;
597 pthread_mutex_assert_owner(&conn->mta_conn_mutex);
598 DBUG_RETURN(error_num);
599 }
600 }
601 conn->mta_conn_mutex_unlock_later = tmp_mta_conn_mutex_unlock_later;
602 result_list->quick_phase = 2;
603 } else {
604 result_list->bgs_current->result->free_result();
605 delete result_list->bgs_current->result;
606 result_list->bgs_current->result = NULL;
607 DBUG_PRINT("info", ("spider conn[%p]->quick_target=NULL", conn));
608 conn->quick_target = NULL;
609 spider->quick_targets[conn->link_idx] = NULL;
610 }
611 }
612 conn->in_before_query = FALSE;
613 pthread_mutex_assert_owner(&conn->mta_conn_mutex);
614 DBUG_RETURN(0);
615 }
616
spider_db_query(SPIDER_CONN * conn,const char * query,uint length,int quick_mode,int * need_mon)617 int spider_db_query(
618 SPIDER_CONN *conn,
619 const char *query,
620 uint length,
621 int quick_mode,
622 int *need_mon
623 ) {
624 int error_num;
625 DBUG_ENTER("spider_db_query");
626 pthread_mutex_assert_owner(&conn->mta_conn_mutex);
627 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
628 if (conn->conn_kind == SPIDER_CONN_KIND_MYSQL)
629 {
630 #endif
631 DBUG_PRINT("info", ("spider conn->db_conn %p", conn->db_conn));
632 if (
633 !conn->in_before_query &&
634 (error_num = spider_db_before_query(conn, need_mon))
635 )
636 DBUG_RETURN(error_num);
637 #ifndef DBUG_OFF
638 spider_string tmp_query_str(sizeof(char) * (length + 1));
639 tmp_query_str.init_calc_mem(107);
640 char *tmp_query = (char *) tmp_query_str.c_ptr_safe();
641 memcpy(tmp_query, query, length);
642 tmp_query[length] = '\0';
643 query = (const char *) tmp_query;
644 DBUG_PRINT("info", ("spider query=%s", query));
645 DBUG_PRINT("info", ("spider length=%u", length));
646 #endif
647 if ((error_num = conn->db_conn->exec_query(query, length, quick_mode)))
648 DBUG_RETURN(error_num);
649 DBUG_RETURN(0);
650 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
651 } else {
652 if (conn->queued_net_timeout)
653 {
654 if (conn->db_conn->set_net_timeout())
655 DBUG_RETURN(ER_SPIDER_HS_NUM);
656 conn->queued_net_timeout = FALSE;
657 }
658 DBUG_RETURN(conn->db_conn->exec_query(NULL, 0, quick_mode));
659 }
660 #endif
661 }
662
spider_db_errorno(SPIDER_CONN * conn)663 int spider_db_errorno(
664 SPIDER_CONN *conn
665 ) {
666 int error_num;
667 DBUG_ENTER("spider_db_errorno");
668 DBUG_ASSERT(conn->need_mon);
669 pthread_mutex_assert_owner(&conn->mta_conn_mutex);
670 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
671 if (conn->conn_kind == SPIDER_CONN_KIND_MYSQL)
672 {
673 #endif
674 if (conn->server_lost)
675 {
676 *conn->need_mon = ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM;
677 if (!current_thd->is_error())
678 {
679 my_message(ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM,
680 ER_SPIDER_REMOTE_SERVER_GONE_AWAY_STR, MYF(0));
681 }
682 if (!conn->mta_conn_mutex_unlock_later)
683 {
684 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
685 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
686 pthread_mutex_unlock(&conn->mta_conn_mutex);
687 }
688 DBUG_RETURN(ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM);
689 }
690 if ((error_num = conn->db_conn->get_errno()))
691 {
692 DBUG_PRINT("info",("spider error_num = %d", error_num));
693 if (conn->db_conn->is_server_gone_error(error_num))
694 {
695 spider_db_disconnect(conn);
696 DBUG_PRINT("info", ("spider conn=%p SERVER_LOST", conn));
697 conn->server_lost = TRUE;
698 if (conn->disable_reconnect)
699 {
700 *conn->need_mon = ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM;
701 my_message(ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM,
702 ER_SPIDER_REMOTE_SERVER_GONE_AWAY_STR, MYF(0));
703 }
704 if (!conn->mta_conn_mutex_unlock_later)
705 {
706 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
707 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
708 pthread_mutex_unlock(&conn->mta_conn_mutex);
709 }
710 DBUG_RETURN(ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM);
711 } else if (
712 conn->ignore_dup_key &&
713 conn->db_conn->is_dup_entry_error(error_num)
714 ) {
715 conn->error_str = (char*) conn->db_conn->get_error();
716 conn->error_length = strlen(conn->error_str);
717 if (!conn->mta_conn_mutex_unlock_later)
718 {
719 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
720 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
721 pthread_mutex_unlock(&conn->mta_conn_mutex);
722 }
723 DBUG_RETURN(HA_ERR_FOUND_DUPP_KEY);
724 } else if (
725 conn->db_conn->is_xa_nota_error(error_num) &&
726 current_thd &&
727 spider_param_force_commit(current_thd) == 1
728 ) {
729 push_warning(current_thd, SPIDER_WARN_LEVEL_WARN,
730 error_num, conn->db_conn->get_error());
731 if (spider_param_log_result_errors() >= 3)
732 {
733 time_t cur_time = (time_t) time((time_t*) 0);
734 struct tm lt;
735 struct tm *l_time = localtime_r(&cur_time, <);
736 fprintf(stderr, "%04d%02d%02d %02d:%02d:%02d [WARN SPIDER RESULT] "
737 "to %lld: %d %s\n",
738 l_time->tm_year + 1900, l_time->tm_mon + 1, l_time->tm_mday,
739 l_time->tm_hour, l_time->tm_min, l_time->tm_sec,
740 (long long int) current_thd->thread_id, error_num,
741 conn->db_conn->get_error());
742 }
743 if (!conn->mta_conn_mutex_unlock_later)
744 {
745 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
746 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
747 pthread_mutex_unlock(&conn->mta_conn_mutex);
748 }
749 DBUG_RETURN(error_num);
750 }
751 *conn->need_mon = error_num;
752 my_message(error_num, conn->db_conn->get_error(), MYF(0));
753 if (spider_param_log_result_errors() >= 1)
754 {
755 time_t cur_time = (time_t) time((time_t*) 0);
756 struct tm lt;
757 struct tm *l_time = localtime_r(&cur_time, <);
758 fprintf(stderr, "%04d%02d%02d %02d:%02d:%02d [ERROR SPIDER RESULT] "
759 "to %lld: %d %s\n",
760 l_time->tm_year + 1900, l_time->tm_mon + 1, l_time->tm_mday,
761 l_time->tm_hour, l_time->tm_min, l_time->tm_sec,
762 (long long int) current_thd->thread_id, error_num,
763 conn->db_conn->get_error());
764 }
765 if (!conn->mta_conn_mutex_unlock_later)
766 {
767 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
768 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
769 pthread_mutex_unlock(&conn->mta_conn_mutex);
770 }
771 DBUG_RETURN(error_num);
772 }
773 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
774 } else {
775 if (conn->db_conn->is_server_gone_error(0))
776 {
777 my_printf_error(ER_SPIDER_HS_NUM, ER_SPIDER_HS_STR, MYF(0),
778 conn->db_conn->get_errno(), conn->db_conn->get_error());
779 *conn->need_mon = ER_SPIDER_HS_NUM;
780 DBUG_PRINT("info", ("spider conn=%p SERVER_LOST", conn));
781 conn->server_lost = TRUE;
782 if (!conn->mta_conn_mutex_unlock_later)
783 {
784 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
785 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
786 pthread_mutex_unlock(&conn->mta_conn_mutex);
787 }
788 DBUG_RETURN(ER_SPIDER_HS_NUM);
789 } else if (conn->db_conn->is_dup_entry_error(0))
790 {
791 *conn->need_mon = 0;
792 if (!conn->mta_conn_mutex_unlock_later)
793 {
794 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
795 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
796 pthread_mutex_unlock(&conn->mta_conn_mutex);
797 }
798 DBUG_RETURN(HA_ERR_FOUND_DUPP_KEY);
799 }
800 my_printf_error(ER_SPIDER_HS_NUM, ER_SPIDER_HS_STR, MYF(0),
801 conn->db_conn->get_errno(), conn->db_conn->get_error());
802 if (spider_param_log_result_errors() >= 1)
803 {
804 time_t cur_time = (time_t) time((time_t*) 0);
805 struct tm lt;
806 struct tm *l_time = localtime_r(&cur_time, <);
807 fprintf(stderr, "%04d%02d%02d %02d:%02d:%02d [ERROR SPIDER RESULT] "
808 "to %ld: %d %s\n",
809 l_time->tm_year + 1900, l_time->tm_mon + 1, l_time->tm_mday,
810 l_time->tm_hour, l_time->tm_min, l_time->tm_sec,
811 (ulong) current_thd->thread_id, conn->db_conn->get_errno(),
812 conn->db_conn->get_error());
813 }
814 *conn->need_mon = ER_SPIDER_HS_NUM;
815 if (!conn->mta_conn_mutex_unlock_later)
816 {
817 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
818 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
819 pthread_mutex_unlock(&conn->mta_conn_mutex);
820 }
821 DBUG_RETURN(ER_SPIDER_HS_NUM);
822 }
823 #endif
824 if (!conn->mta_conn_mutex_unlock_later)
825 {
826 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
827 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
828 pthread_mutex_unlock(&conn->mta_conn_mutex);
829 }
830 DBUG_RETURN(0);
831 }
832
spider_db_set_trx_isolation(SPIDER_CONN * conn,int trx_isolation,int * need_mon)833 int spider_db_set_trx_isolation(
834 SPIDER_CONN *conn,
835 int trx_isolation,
836 int *need_mon
837 ) {
838 DBUG_ENTER("spider_db_set_trx_isolation");
839 DBUG_RETURN(conn->db_conn->set_trx_isolation(trx_isolation, need_mon));
840 }
841
spider_db_set_names_internal(SPIDER_TRX * trx,SPIDER_SHARE * share,SPIDER_CONN * conn,int all_link_idx,int * need_mon)842 int spider_db_set_names_internal(
843 SPIDER_TRX *trx,
844 SPIDER_SHARE *share,
845 SPIDER_CONN *conn,
846 int all_link_idx,
847 int *need_mon
848 ) {
849 DBUG_ENTER("spider_db_set_names_internal");
850 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
851 if (conn->conn_kind == SPIDER_CONN_KIND_MYSQL)
852 {
853 #endif
854 pthread_mutex_assert_owner(&conn->mta_conn_mutex);
855 DBUG_ASSERT(conn->mta_conn_mutex_file_pos.file_name);
856 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
857 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
858 if (
859 !conn->access_charset ||
860 share->access_charset->cset != conn->access_charset->cset
861 ) {
862 if (
863 spider_db_before_query(conn, need_mon) ||
864 conn->db_conn->set_character_set(share->access_charset->csname)
865 ) {
866 DBUG_RETURN(spider_db_errorno(conn));
867 }
868 conn->access_charset = share->access_charset;
869 }
870 if (
871 spider_param_use_default_database(trx->thd) &&
872 (
873 !conn->default_database.length() ||
874 conn->default_database.length() !=
875 share->tgt_dbs_lengths[all_link_idx] ||
876 memcmp(share->tgt_dbs[all_link_idx], conn->default_database.ptr(),
877 share->tgt_dbs_lengths[all_link_idx])
878 )
879 ) {
880 DBUG_PRINT("info",("spider all_link_idx=%d db=%s", all_link_idx,
881 share->tgt_dbs[all_link_idx]));
882 if (
883 spider_db_before_query(conn, need_mon) ||
884 conn->db_conn->select_db(share->tgt_dbs[all_link_idx])
885 ) {
886 DBUG_RETURN(spider_db_errorno(conn));
887 }
888 conn->default_database.length(0);
889 if (conn->default_database.reserve(
890 share->tgt_dbs_lengths[all_link_idx] + 1))
891 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
892 conn->default_database.q_append(share->tgt_dbs[all_link_idx],
893 share->tgt_dbs_lengths[all_link_idx] + 1);
894 conn->default_database.length(share->tgt_dbs_lengths[all_link_idx]);
895 }
896 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
897 }
898 #endif
899 DBUG_RETURN(0);
900 }
901
spider_db_set_names(ha_spider * spider,SPIDER_CONN * conn,int link_idx)902 int spider_db_set_names(
903 ha_spider *spider,
904 SPIDER_CONN *conn,
905 int link_idx
906 ) {
907 DBUG_ENTER("spider_db_set_names");
908 DBUG_RETURN(spider_db_set_names_internal(spider->trx, spider->share, conn,
909 spider->conn_link_idx[link_idx], &spider->need_mons[link_idx]));
910 }
911
spider_db_query_with_set_names(ulong sql_type,ha_spider * spider,SPIDER_CONN * conn,int link_idx)912 int spider_db_query_with_set_names(
913 ulong sql_type,
914 ha_spider *spider,
915 SPIDER_CONN *conn,
916 int link_idx
917 ) {
918 int error_num;
919 SPIDER_SHARE *share = spider->share;
920 spider_db_handler *dbton_hdl = spider->dbton_handler[conn->dbton_id];
921 DBUG_ENTER("spider_db_query_with_set_names");
922
923 pthread_mutex_assert_owner(&conn->mta_conn_mutex);
924 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
925 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
926 if ((error_num = spider_db_set_names(spider, conn, link_idx)))
927 {
928 if (
929 share->monitoring_kind[link_idx] &&
930 spider->need_mons[link_idx]
931 ) {
932 error_num = spider_ping_table_mon_from_table(
933 spider->trx,
934 spider->trx->thd,
935 share,
936 link_idx,
937 (uint32) share->monitoring_sid[link_idx],
938 share->table_name,
939 share->table_name_length,
940 spider->conn_link_idx[link_idx],
941 NULL,
942 0,
943 share->monitoring_kind[link_idx],
944 share->monitoring_limit[link_idx],
945 share->monitoring_flag[link_idx],
946 TRUE
947 );
948 }
949 DBUG_RETURN(error_num);
950 }
951 spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
952 share);
953 if (dbton_hdl->execute_sql(
954 sql_type,
955 conn,
956 -1,
957 &spider->need_mons[link_idx])
958 ) {
959 error_num = spider_db_errorno(conn);
960 if (
961 share->monitoring_kind[link_idx] &&
962 spider->need_mons[link_idx]
963 ) {
964 error_num = spider_ping_table_mon_from_table(
965 spider->trx,
966 spider->trx->thd,
967 share,
968 link_idx,
969 (uint32) share->monitoring_sid[link_idx],
970 share->table_name,
971 share->table_name_length,
972 spider->conn_link_idx[link_idx],
973 NULL,
974 0,
975 share->monitoring_kind[link_idx],
976 share->monitoring_limit[link_idx],
977 share->monitoring_flag[link_idx],
978 TRUE
979 );
980 }
981 DBUG_RETURN(error_num);
982 }
983 DBUG_RETURN(0);
984 }
985
spider_db_query_for_bulk_update(ha_spider * spider,SPIDER_CONN * conn,int link_idx,ha_rows * dup_key_found)986 int spider_db_query_for_bulk_update(
987 ha_spider *spider,
988 SPIDER_CONN *conn,
989 int link_idx,
990 ha_rows *dup_key_found
991 ) {
992 int error_num;
993 SPIDER_SHARE *share = spider->share;
994 DBUG_ENTER("spider_db_query_for_bulk_update");
995
996 pthread_mutex_assert_owner(&conn->mta_conn_mutex);
997 conn->need_mon = &spider->need_mons[link_idx];
998 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
999 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
1000 conn->mta_conn_mutex_lock_already = TRUE;
1001 conn->mta_conn_mutex_unlock_later = TRUE;
1002 if ((error_num = spider_db_set_names(spider, conn, link_idx)))
1003 {
1004 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
1005 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
1006 conn->mta_conn_mutex_lock_already = FALSE;
1007 conn->mta_conn_mutex_unlock_later = FALSE;
1008 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
1009 pthread_mutex_unlock(&conn->mta_conn_mutex);
1010 if (
1011 share->monitoring_kind[link_idx] &&
1012 spider->need_mons[link_idx]
1013 ) {
1014 error_num = spider_ping_table_mon_from_table(
1015 spider->trx,
1016 spider->trx->thd,
1017 share,
1018 link_idx,
1019 (uint32) share->monitoring_sid[link_idx],
1020 share->table_name,
1021 share->table_name_length,
1022 spider->conn_link_idx[link_idx],
1023 NULL,
1024 0,
1025 share->monitoring_kind[link_idx],
1026 share->monitoring_limit[link_idx],
1027 share->monitoring_flag[link_idx],
1028 TRUE
1029 );
1030 }
1031 DBUG_RETURN(error_num);
1032 }
1033 spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
1034 share);
1035 spider_db_handler *dbton_hdl = spider->dbton_handler[conn->dbton_id];
1036 if (dbton_hdl->execute_sql(
1037 SPIDER_SQL_TYPE_BULK_UPDATE_SQL,
1038 conn,
1039 -1,
1040 &spider->need_mons[link_idx])
1041 ) {
1042 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
1043 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
1044 conn->mta_conn_mutex_lock_already = FALSE;
1045 conn->mta_conn_mutex_unlock_later = FALSE;
1046 error_num = spider_db_errorno(conn);
1047 if (
1048 error_num != ER_DUP_ENTRY &&
1049 error_num != ER_DUP_KEY &&
1050 error_num != HA_ERR_FOUND_DUPP_KEY &&
1051 share->monitoring_kind[link_idx] &&
1052 spider->need_mons[link_idx]
1053 ) {
1054 error_num = spider_ping_table_mon_from_table(
1055 spider->trx,
1056 spider->trx->thd,
1057 share,
1058 link_idx,
1059 (uint32) share->monitoring_sid[link_idx],
1060 share->table_name,
1061 share->table_name_length,
1062 spider->conn_link_idx[link_idx],
1063 NULL,
1064 0,
1065 share->monitoring_kind[link_idx],
1066 share->monitoring_limit[link_idx],
1067 share->monitoring_flag[link_idx],
1068 TRUE
1069 );
1070 }
1071 if (
1072 spider->ignore_dup_key &&
1073 (
1074 error_num == ER_DUP_ENTRY ||
1075 error_num == ER_DUP_KEY ||
1076 error_num == HA_ERR_FOUND_DUPP_KEY
1077 )
1078 ) {
1079 ++(*dup_key_found);
1080 spider->trx->thd->clear_error();
1081 DBUG_RETURN(0);
1082 }
1083 DBUG_RETURN(error_num);
1084 }
1085 while (!(error_num = conn->db_conn->next_result()))
1086 {
1087 ;
1088 }
1089 if (error_num > 0 && !conn->db_conn->is_dup_entry_error(error_num))
1090 {
1091 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
1092 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
1093 conn->mta_conn_mutex_lock_already = FALSE;
1094 conn->mta_conn_mutex_unlock_later = FALSE;
1095 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
1096 pthread_mutex_unlock(&conn->mta_conn_mutex);
1097 if (
1098 share->monitoring_kind[link_idx] &&
1099 spider->need_mons[link_idx]
1100 ) {
1101 error_num = spider_ping_table_mon_from_table(
1102 spider->trx,
1103 spider->trx->thd,
1104 share,
1105 link_idx,
1106 (uint32) share->monitoring_sid[link_idx],
1107 share->table_name,
1108 share->table_name_length,
1109 spider->conn_link_idx[link_idx],
1110 NULL,
1111 0,
1112 share->monitoring_kind[link_idx],
1113 share->monitoring_limit[link_idx],
1114 share->monitoring_flag[link_idx],
1115 TRUE
1116 );
1117 }
1118 DBUG_RETURN(error_num);
1119 }
1120 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
1121 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
1122 conn->mta_conn_mutex_lock_already = FALSE;
1123 conn->mta_conn_mutex_unlock_later = FALSE;
1124 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
1125 pthread_mutex_unlock(&conn->mta_conn_mutex);
1126 DBUG_RETURN(0);
1127 }
1128
spider_db_real_escape_string(SPIDER_CONN * conn,char * to,const char * from,size_t from_length)1129 size_t spider_db_real_escape_string(
1130 SPIDER_CONN *conn,
1131 char *to,
1132 const char *from,
1133 size_t from_length
1134 ) {
1135 DBUG_ENTER("spider_db_real_escape_string");
1136 DBUG_RETURN(conn->db_conn->escape_string(to, from, from_length));
1137 }
1138
spider_db_consistent_snapshot(SPIDER_CONN * conn,int * need_mon)1139 int spider_db_consistent_snapshot(
1140 SPIDER_CONN *conn,
1141 int *need_mon
1142 ) {
1143 int error_num;
1144 DBUG_ENTER("spider_db_consistent_snapshot");
1145 if ((error_num = conn->db_conn->consistent_snapshot(need_mon)))
1146 {
1147 DBUG_RETURN(error_num);
1148 }
1149 conn->trx_start = TRUE;
1150 DBUG_RETURN(0);
1151 }
1152
spider_db_start_transaction(SPIDER_CONN * conn,int * need_mon)1153 int spider_db_start_transaction(
1154 SPIDER_CONN *conn,
1155 int *need_mon
1156 ) {
1157 int error_num;
1158 DBUG_ENTER("spider_db_start_transaction");
1159 if ((error_num = conn->db_conn->start_transaction(need_mon)))
1160 {
1161 DBUG_RETURN(error_num);
1162 }
1163 conn->trx_start = TRUE;
1164 DBUG_RETURN(0);
1165 }
1166
spider_db_commit(SPIDER_CONN * conn)1167 int spider_db_commit(
1168 SPIDER_CONN *conn
1169 ) {
1170 int need_mon = 0, error_num;
1171 DBUG_ENTER("spider_db_commit");
1172 if (!conn->queued_connect && !conn->queued_trx_start)
1173 {
1174 if (conn->use_for_active_standby && conn->server_lost)
1175 {
1176 my_message(ER_SPIDER_LINK_IS_FAILOVER_NUM,
1177 ER_SPIDER_LINK_IS_FAILOVER_STR, MYF(0));
1178 DBUG_RETURN(ER_SPIDER_LINK_IS_FAILOVER_NUM);
1179 }
1180 if ((error_num = conn->db_conn->commit(&need_mon)))
1181 {
1182 DBUG_RETURN(error_num);
1183 }
1184 conn->trx_start = FALSE;
1185 } else
1186 conn->trx_start = FALSE;
1187 DBUG_RETURN(0);
1188 }
1189
spider_db_rollback(SPIDER_CONN * conn)1190 int spider_db_rollback(
1191 SPIDER_CONN *conn
1192 ) {
1193 int error_num, need_mon = 0;
1194 DBUG_ENTER("spider_db_rollback");
1195 if (!conn->queued_connect && !conn->queued_trx_start)
1196 {
1197 if ((error_num = conn->db_conn->rollback(&need_mon)))
1198 {
1199 DBUG_RETURN(error_num);
1200 }
1201 conn->trx_start = FALSE;
1202 } else
1203 conn->trx_start = FALSE;
1204 DBUG_RETURN(0);
1205 }
1206
spider_db_append_hex_string(spider_string * str,uchar * hex_ptr,int hex_ptr_length)1207 int spider_db_append_hex_string(
1208 spider_string *str,
1209 uchar *hex_ptr,
1210 int hex_ptr_length
1211 ) {
1212 uchar *end_ptr;
1213 char *str_ptr;
1214 DBUG_ENTER("spider_db_append_hex_string");
1215 if (hex_ptr_length)
1216 {
1217 if (str->reserve(SPIDER_SQL_HEX_LEN + hex_ptr_length * 2))
1218 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1219 str->q_append(SPIDER_SQL_HEX_STR, SPIDER_SQL_HEX_LEN);
1220 str_ptr = (char *) str->ptr() + str->length();
1221 for (end_ptr = hex_ptr + hex_ptr_length; hex_ptr < end_ptr; hex_ptr++)
1222 {
1223 *str_ptr++ = spider_dig_upper[(*hex_ptr) >> 4];
1224 *str_ptr++ = spider_dig_upper[(*hex_ptr) & 0x0F];
1225 }
1226 str->length(str->length() + hex_ptr_length * 2);
1227 } else {
1228 if (str->reserve((SPIDER_SQL_VALUE_QUOTE_LEN) * 2))
1229 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1230 str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
1231 str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
1232 }
1233 DBUG_RETURN(0);
1234 }
1235
spider_db_append_xid_str(spider_string * tmp_str,XID * xid)1236 void spider_db_append_xid_str(
1237 spider_string *tmp_str,
1238 XID *xid
1239 ) {
1240 char format_id[sizeof(long) + 3];
1241 uint format_id_length;
1242 DBUG_ENTER("spider_db_append_xid_str");
1243
1244 format_id_length =
1245 my_sprintf(format_id, (format_id, "%lu", xid->formatID));
1246 spider_db_append_hex_string(tmp_str, (uchar *) xid->data, xid->gtrid_length);
1247 /*
1248 tmp_str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
1249 tmp_str->q_append(xid->data, xid->gtrid_length);
1250 tmp_str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
1251 */
1252 tmp_str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
1253 spider_db_append_hex_string(tmp_str,
1254 (uchar *) xid->data + xid->gtrid_length, xid->bqual_length);
1255 /*
1256 tmp_str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
1257 tmp_str->q_append(xid->data + xid->gtrid_length, xid->bqual_length);
1258 tmp_str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
1259 */
1260 tmp_str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
1261 tmp_str->q_append(format_id, format_id_length);
1262 #ifndef DBUG_OFF
1263 ((char *) tmp_str->ptr())[tmp_str->length()] = '\0';
1264 #endif
1265
1266 DBUG_VOID_RETURN;
1267 }
1268
spider_db_xa_end(SPIDER_CONN * conn,XID * xid)1269 int spider_db_xa_end(
1270 SPIDER_CONN *conn,
1271 XID *xid
1272 ) {
1273 int need_mon = 0;
1274 DBUG_ENTER("spider_db_xa_end");
1275 if (!conn->queued_connect && !conn->queued_xa_start)
1276 {
1277 DBUG_RETURN(conn->db_conn->xa_end(xid, &need_mon));
1278 }
1279 DBUG_RETURN(0);
1280 }
1281
spider_db_xa_prepare(SPIDER_CONN * conn,XID * xid)1282 int spider_db_xa_prepare(
1283 SPIDER_CONN *conn,
1284 XID *xid
1285 ) {
1286 int need_mon = 0;
1287 DBUG_ENTER("spider_db_xa_prepare");
1288 if (!conn->queued_connect && !conn->queued_xa_start)
1289 {
1290 if (conn->use_for_active_standby && conn->server_lost)
1291 {
1292 my_message(ER_SPIDER_LINK_IS_FAILOVER_NUM,
1293 ER_SPIDER_LINK_IS_FAILOVER_STR, MYF(0));
1294 DBUG_RETURN(ER_SPIDER_LINK_IS_FAILOVER_NUM);
1295 }
1296 DBUG_RETURN(conn->db_conn->xa_prepare(xid, &need_mon));
1297 }
1298 DBUG_RETURN(0);
1299 }
1300
spider_db_xa_commit(SPIDER_CONN * conn,XID * xid)1301 int spider_db_xa_commit(
1302 SPIDER_CONN *conn,
1303 XID *xid
1304 ) {
1305 int need_mon = 0;
1306 DBUG_ENTER("spider_db_xa_commit");
1307 if (!conn->queued_connect && !conn->queued_xa_start)
1308 {
1309 DBUG_RETURN(conn->db_conn->xa_commit(xid, &need_mon));
1310 }
1311 DBUG_RETURN(0);
1312 }
1313
spider_db_xa_rollback(SPIDER_CONN * conn,XID * xid)1314 int spider_db_xa_rollback(
1315 SPIDER_CONN *conn,
1316 XID *xid
1317 ) {
1318 int need_mon = 0;
1319 DBUG_ENTER("spider_db_xa_rollback");
1320 if (!conn->queued_connect && !conn->queued_xa_start)
1321 {
1322 DBUG_RETURN(conn->db_conn->xa_rollback(xid, &need_mon));
1323 }
1324 DBUG_RETURN(0);
1325 }
1326
spider_db_lock_tables(ha_spider * spider,int link_idx)1327 int spider_db_lock_tables(
1328 ha_spider *spider,
1329 int link_idx
1330 ) {
1331 int error_num;
1332 SPIDER_CONN *conn = spider->conns[link_idx];
1333 DBUG_ENTER("spider_db_lock_tables");
1334 error_num = spider->dbton_handler[conn->dbton_id]->lock_tables(link_idx);
1335 DBUG_RETURN(error_num);
1336 }
1337
spider_db_unlock_tables(ha_spider * spider,int link_idx)1338 int spider_db_unlock_tables(
1339 ha_spider *spider,
1340 int link_idx
1341 ) {
1342 int error_num;
1343 SPIDER_CONN *conn = spider->conns[link_idx];
1344 DBUG_ENTER("spider_db_unlock_tables");
1345 error_num = spider->dbton_handler[conn->dbton_id]->unlock_tables(link_idx);
1346 DBUG_RETURN(error_num);
1347 }
1348
spider_db_append_name_with_quote_str(spider_string * str,const char * name,uint dbton_id)1349 int spider_db_append_name_with_quote_str(
1350 spider_string *str,
1351 const char *name,
1352 uint dbton_id
1353 ) {
1354 DBUG_ENTER("spider_db_append_name_with_quote_str");
1355 DBUG_RETURN(spider_db_append_name_with_quote_str_internal(
1356 str, name, strlen(name), dbton_id));
1357 }
1358
spider_db_append_name_with_quote_str(spider_string * str,LEX_CSTRING & name,uint dbton_id)1359 int spider_db_append_name_with_quote_str(
1360 spider_string *str,
1361 LEX_CSTRING &name,
1362 uint dbton_id
1363 ) {
1364 DBUG_ENTER("spider_db_append_name_with_quote_str");
1365 DBUG_RETURN(spider_db_append_name_with_quote_str_internal(
1366 str, name.str, name.length, dbton_id));
1367 }
1368
spider_db_append_name_with_quote_str_internal(spider_string * str,const char * name,int length,uint dbton_id)1369 int spider_db_append_name_with_quote_str_internal(
1370 spider_string *str,
1371 const char *name,
1372 int length,
1373 uint dbton_id
1374 ) {
1375 int error_num;
1376 const char *name_end;
1377 char head_code;
1378 DBUG_ENTER("spider_db_append_name_with_quote_str_internal");
1379 for (name_end = name + length; name < name_end; name += length)
1380 {
1381 head_code = *name;
1382 #ifdef SPIDER_HAS_MY_CHARLEN
1383 if ((length = my_charlen(system_charset_info, name, name_end)) < 1)
1384 #else
1385 if (!(length = my_mbcharlen(system_charset_info, (uchar) head_code)))
1386 #endif
1387 {
1388 my_message(ER_SPIDER_WRONG_CHARACTER_IN_NAME_NUM,
1389 ER_SPIDER_WRONG_CHARACTER_IN_NAME_STR, MYF(0));
1390 DBUG_RETURN(ER_SPIDER_WRONG_CHARACTER_IN_NAME_NUM);
1391 }
1392 if (
1393 length == 1 &&
1394 spider_dbton[dbton_id].db_util->is_name_quote(head_code)
1395 ) {
1396 if ((error_num = spider_dbton[dbton_id].db_util->
1397 append_escaped_name_quote(str)))
1398 {
1399 DBUG_RETURN(error_num);
1400 }
1401 } else {
1402 if (str->append(name, length, system_charset_info))
1403 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1404 }
1405 }
1406 DBUG_RETURN(0);
1407 }
1408
spider_db_append_select(ha_spider * spider)1409 int spider_db_append_select(
1410 ha_spider *spider
1411 ) {
1412 int error_num;
1413 DBUG_ENTER("spider_db_append_select");
1414
1415 if (spider->sql_kinds & SPIDER_SQL_KIND_SQL)
1416 {
1417 if ((error_num = spider->append_select_sql_part(
1418 SPIDER_SQL_TYPE_SELECT_SQL)))
1419 DBUG_RETURN(error_num);
1420 }
1421 if (spider->sql_kinds & SPIDER_SQL_KIND_HANDLER)
1422 {
1423 if ((error_num = spider->append_select_sql_part(
1424 SPIDER_SQL_TYPE_HANDLER)))
1425 DBUG_RETURN(error_num);
1426 }
1427 DBUG_RETURN(0);
1428 }
1429
spider_db_append_select_columns(ha_spider * spider)1430 int spider_db_append_select_columns(
1431 ha_spider *spider
1432 ) {
1433 int error_num;
1434 SPIDER_RESULT_LIST *result_list = &spider->result_list;
1435 DBUG_ENTER("spider_db_append_select_columns");
1436 if (spider->sql_kinds & SPIDER_SQL_KIND_SQL)
1437 {
1438 #ifdef HANDLER_HAS_DIRECT_AGGREGATE
1439 if (
1440 result_list->direct_aggregate &&
1441 (error_num = spider->append_sum_select_sql_part(
1442 SPIDER_SQL_TYPE_SELECT_SQL, NULL, 0))
1443 )
1444 DBUG_RETURN(error_num);
1445 #endif
1446 if ((error_num = spider->append_match_select_sql_part(
1447 SPIDER_SQL_TYPE_SELECT_SQL, NULL, 0)))
1448 DBUG_RETURN(error_num);
1449 if (!spider->select_column_mode)
1450 {
1451 if (result_list->keyread)
1452 {
1453 if ((error_num = spider->append_key_select_sql_part(
1454 SPIDER_SQL_TYPE_SELECT_SQL, spider->active_index)))
1455 DBUG_RETURN(error_num);
1456 } else {
1457 if ((error_num = spider->append_table_select_sql_part(
1458 SPIDER_SQL_TYPE_SELECT_SQL)))
1459 DBUG_RETURN(error_num);
1460 }
1461 } else {
1462 if ((error_num = spider->append_minimum_select_sql_part(
1463 SPIDER_SQL_TYPE_SELECT_SQL)))
1464 DBUG_RETURN(error_num);
1465 }
1466 }
1467 if (spider->sql_kinds & SPIDER_SQL_KIND_HANDLER)
1468 {
1469 if ((error_num = spider->append_from_sql_part(SPIDER_SQL_TYPE_HANDLER)))
1470 DBUG_RETURN(error_num);
1471 }
1472 DBUG_RETURN(0);
1473 }
1474
spider_db_append_null_value(spider_string * str,KEY_PART_INFO * key_part,const uchar ** ptr)1475 int spider_db_append_null_value(
1476 spider_string *str,
1477 KEY_PART_INFO *key_part,
1478 const uchar **ptr
1479 ) {
1480 DBUG_ENTER("spider_db_append_null_value");
1481 if (key_part->null_bit)
1482 {
1483 if (*(*ptr)++)
1484 {
1485 if (str->reserve(SPIDER_SQL_NULL_LEN))
1486 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1487 str->q_append(SPIDER_SQL_NULL_STR, SPIDER_SQL_NULL_LEN);
1488 DBUG_RETURN(-1);
1489 }
1490 }
1491 DBUG_RETURN(0);
1492 }
1493
spider_db_append_key_columns(const key_range * start_key,ha_spider * spider,spider_string * str)1494 int spider_db_append_key_columns(
1495 const key_range *start_key,
1496 ha_spider *spider,
1497 spider_string *str
1498 ) {
1499 SPIDER_RESULT_LIST *result_list = &spider->result_list;
1500 KEY *key_info = result_list->key_info;
1501 uint key_name_length, key_count;
1502 key_part_map full_key_part_map =
1503 make_prev_keypart_map(spider_user_defined_key_parts(key_info));
1504 key_part_map start_key_part_map;
1505 char tmp_buf[MAX_FIELD_WIDTH];
1506 DBUG_ENTER("spider_db_append_key_columns");
1507
1508 start_key_part_map = start_key->keypart_map & full_key_part_map;
1509 DBUG_PRINT("info", ("spider spider_user_defined_key_parts=%u",
1510 spider_user_defined_key_parts(key_info)));
1511 DBUG_PRINT("info", ("spider full_key_part_map=%lu", full_key_part_map));
1512 DBUG_PRINT("info", ("spider start_key_part_map=%lu", start_key_part_map));
1513
1514 if (!start_key_part_map)
1515 DBUG_RETURN(0);
1516
1517 for (
1518 key_count = 0;
1519 start_key_part_map;
1520 start_key_part_map >>= 1,
1521 key_count++
1522 ) {
1523 key_name_length = my_sprintf(tmp_buf, (tmp_buf, "c%u", key_count));
1524 if (str->reserve(key_name_length + SPIDER_SQL_COMMA_LEN))
1525 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1526 str->q_append(tmp_buf, key_name_length);
1527 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
1528 }
1529 str->length(str->length() - SPIDER_SQL_COMMA_LEN);
1530
1531 DBUG_RETURN(0);
1532 }
1533
spider_db_append_key_hint(spider_string * str,char * hint_str)1534 int spider_db_append_key_hint(
1535 spider_string *str,
1536 char *hint_str
1537 ) {
1538 int hint_str_len = strlen(hint_str);
1539 DBUG_ENTER("spider_db_append_key_hint");
1540 if (hint_str_len >= 2 &&
1541 (hint_str[0] == 'f' || hint_str[0] == 'F') && hint_str[1] == ' '
1542 ) {
1543 if (str->reserve(hint_str_len - 2 +
1544 SPIDER_SQL_SQL_FORCE_IDX_LEN + SPIDER_SQL_CLOSE_PAREN_LEN))
1545 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1546 hint_str += 2;
1547 str->q_append(SPIDER_SQL_SQL_FORCE_IDX_STR, SPIDER_SQL_SQL_FORCE_IDX_LEN);
1548 str->q_append(hint_str, hint_str_len - 2);
1549 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN);
1550 } else if (hint_str_len >= 2 &&
1551 (hint_str[0] == 'u' || hint_str[0] == 'U') && hint_str[1] == ' '
1552 ) {
1553 if (str->reserve(hint_str_len - 2 +
1554 SPIDER_SQL_SQL_USE_IDX_LEN + SPIDER_SQL_CLOSE_PAREN_LEN))
1555 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1556 hint_str += 2;
1557 str->q_append(SPIDER_SQL_SQL_USE_IDX_STR, SPIDER_SQL_SQL_USE_IDX_LEN);
1558 str->q_append(hint_str, hint_str_len - 2);
1559 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN);
1560 } else if (hint_str_len >= 3 &&
1561 (hint_str[0] == 'i' || hint_str[0] == 'I') &&
1562 (hint_str[1] == 'g' || hint_str[1] == 'G') && hint_str[2] == ' '
1563 ) {
1564 if (str->reserve(hint_str_len - 3 +
1565 SPIDER_SQL_SQL_IGNORE_IDX_LEN + SPIDER_SQL_CLOSE_PAREN_LEN))
1566 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1567 hint_str += 3;
1568 str->q_append(
1569 SPIDER_SQL_SQL_IGNORE_IDX_STR, SPIDER_SQL_SQL_IGNORE_IDX_LEN);
1570 str->q_append(hint_str, hint_str_len - 3);
1571 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN);
1572 } else if (str->reserve(hint_str_len + SPIDER_SQL_SPACE_LEN))
1573 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1574 else
1575 {
1576 str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);
1577 str->q_append(hint_str, hint_str_len);
1578 }
1579 DBUG_RETURN(0);
1580 }
1581
spider_db_append_hint_after_table(ha_spider * spider,spider_string * str,spider_string * hint)1582 int spider_db_append_hint_after_table(
1583 ha_spider *spider,
1584 spider_string *str,
1585 spider_string *hint
1586 ) {
1587 DBUG_ENTER("spider_db_append_hint_after_table");
1588 if (spider->sql_kinds & SPIDER_SQL_KIND_SQL)
1589 {
1590 if (str->append(*hint))
1591 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1592 }
1593 DBUG_RETURN(0);
1594 }
1595
spider_db_append_key_where_internal(spider_string * str,spider_string * str_part,spider_string * str_part2,const key_range * start_key,const key_range * end_key,ha_spider * spider,bool set_order,ulong sql_type,uint dbton_id)1596 int spider_db_append_key_where_internal(
1597 spider_string *str,
1598 spider_string *str_part,
1599 spider_string *str_part2,
1600 const key_range *start_key,
1601 const key_range *end_key,
1602 ha_spider *spider,
1603 bool set_order,
1604 ulong sql_type,
1605 uint dbton_id
1606 ) {
1607 SPIDER_RESULT_LIST *result_list = &spider->result_list;
1608 SPIDER_SHARE *share = spider->share;
1609 #ifndef DBUG_OFF
1610 TABLE *table = spider->get_table();
1611 #endif
1612 KEY *key_info = result_list->key_info;
1613 int error_num;
1614 uint key_name_length;
1615 key_part_map full_key_part_map;
1616 key_part_map start_key_part_map;
1617 key_part_map end_key_part_map;
1618 key_part_map tgt_key_part_map;
1619 int key_count;
1620 uint length;
1621 uint store_length;
1622 const uchar *ptr, *another_ptr;
1623 const key_range *use_key, *another_key;
1624 KEY_PART_INFO *key_part;
1625 Field *field;
1626 bool use_both = TRUE, key_eq;
1627 uint sql_kind;
1628 spider_db_handler *dbton_hdl = spider->dbton_handler[dbton_id];
1629 spider_db_share *dbton_share = share->dbton_share[dbton_id];
1630 DBUG_ENTER("spider_db_append_key_where_internal");
1631 switch (sql_type)
1632 {
1633 case SPIDER_SQL_TYPE_HANDLER:
1634 sql_kind = SPIDER_SQL_KIND_HANDLER;
1635 break;
1636 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
1637 case SPIDER_SQL_TYPE_SELECT_HS:
1638 case SPIDER_SQL_TYPE_INSERT_HS:
1639 case SPIDER_SQL_TYPE_UPDATE_HS:
1640 case SPIDER_SQL_TYPE_DELETE_HS:
1641 sql_kind = SPIDER_SQL_KIND_HS;
1642 break;
1643 #endif
1644 default:
1645 sql_kind = SPIDER_SQL_KIND_SQL;
1646 break;
1647 }
1648
1649 if (key_info)
1650 full_key_part_map =
1651 make_prev_keypart_map(spider_user_defined_key_parts(key_info));
1652 else
1653 full_key_part_map = 0;
1654
1655 if (start_key)
1656 {
1657 start_key_part_map = start_key->keypart_map & full_key_part_map;
1658 } else {
1659 start_key_part_map = 0;
1660 use_both = FALSE;
1661 }
1662 if (end_key) {
1663 end_key_part_map = end_key->keypart_map & full_key_part_map;
1664 result_list->end_key = end_key;
1665 } else {
1666 end_key_part_map = 0;
1667 use_both = FALSE;
1668 }
1669 DBUG_PRINT("info", ("spider spider_user_defined_key_parts=%u", key_info ?
1670 spider_user_defined_key_parts(key_info) : 0));
1671 DBUG_PRINT("info", ("spider full_key_part_map=%lu", full_key_part_map));
1672 DBUG_PRINT("info", ("spider start_key_part_map=%lu", start_key_part_map));
1673 DBUG_PRINT("info", ("spider end_key_part_map=%lu", end_key_part_map));
1674
1675 #ifndef DBUG_OFF
1676 MY_BITMAP *tmp_map = dbug_tmp_use_all_columns(table, &table->read_set);
1677 #endif
1678
1679 if (sql_kind == SPIDER_SQL_KIND_HANDLER)
1680 {
1681 #ifdef SPIDER_use_LEX_CSTRING_for_KEY_Field_name
1682 const char *key_name = key_info->name.str;
1683 key_name_length = key_info->name.length;
1684 #else
1685 const char *key_name = key_info->name;
1686 key_name_length = strlen(key_name);
1687 #endif
1688 if (str->reserve(SPIDER_SQL_READ_LEN +
1689 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + key_name_length))
1690 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1691 str->q_append(SPIDER_SQL_READ_STR, SPIDER_SQL_READ_LEN);
1692 if ((error_num = spider_dbton[dbton_id].db_util->
1693 append_name(str, key_name, key_name_length)))
1694 {
1695 DBUG_RETURN(error_num);
1696 }
1697 dbton_hdl->set_order_pos(SPIDER_SQL_TYPE_HANDLER);
1698 if (
1699 (start_key_part_map || end_key_part_map) &&
1700 !(use_both && (!start_key_part_map || !end_key_part_map))
1701 ) {
1702 if (str_part->reserve(SPIDER_SQL_OPEN_PAREN_LEN))
1703 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1704 str_part->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
1705 result_list->ha_read_kind = 0;
1706 } else if (!result_list->desc_flg)
1707 {
1708 if (str->reserve(SPIDER_SQL_FIRST_LEN))
1709 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1710 str->q_append(SPIDER_SQL_FIRST_STR, SPIDER_SQL_FIRST_LEN);
1711 result_list->ha_read_kind = 1;
1712 } else {
1713 if (str->reserve(SPIDER_SQL_LAST_LEN))
1714 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1715 str->q_append(SPIDER_SQL_LAST_STR, SPIDER_SQL_LAST_LEN);
1716 result_list->ha_read_kind = 2;
1717 }
1718 }
1719 if (!start_key_part_map && !end_key_part_map)
1720 {
1721 result_list->key_order = 0;
1722 goto end;
1723 } else if (use_both && (!start_key_part_map || !end_key_part_map))
1724 {
1725 result_list->key_order = 0;
1726 goto end;
1727 } else if (start_key_part_map >= end_key_part_map)
1728 {
1729 use_key = start_key;
1730 another_key = end_key;
1731 tgt_key_part_map = start_key_part_map;
1732 } else {
1733 use_key = end_key;
1734 another_key = start_key;
1735 tgt_key_part_map = end_key_part_map;
1736 }
1737 DBUG_PRINT("info", ("spider tgt_key_part_map=%lu", tgt_key_part_map));
1738 if (start_key_part_map == end_key_part_map)
1739 result_list->use_both_key = TRUE;
1740
1741 if (sql_kind == SPIDER_SQL_KIND_SQL)
1742 {
1743 if (str->reserve(SPIDER_SQL_WHERE_LEN))
1744 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1745 str->q_append(SPIDER_SQL_WHERE_STR, SPIDER_SQL_WHERE_LEN);
1746 } else if (sql_kind == SPIDER_SQL_KIND_HANDLER)
1747 {
1748 if (str_part2->reserve(SPIDER_SQL_WHERE_LEN))
1749 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1750 str_part2->q_append(SPIDER_SQL_WHERE_STR, SPIDER_SQL_WHERE_LEN);
1751 }
1752
1753 for (
1754 key_part = key_info->key_part,
1755 length = 0,
1756 key_count = 0;
1757 tgt_key_part_map;
1758 length += store_length,
1759 tgt_key_part_map >>= 1,
1760 start_key_part_map >>= 1,
1761 end_key_part_map >>= 1,
1762 key_part++,
1763 key_count++
1764 ) {
1765 store_length = key_part->store_length;
1766 field = key_part->field;
1767 key_name_length = dbton_share->get_column_name_length(field->field_index);
1768 ptr = use_key->key + length;
1769 if (use_both)
1770 {
1771 another_ptr = another_key->key + length;
1772 if (
1773 start_key_part_map &&
1774 end_key_part_map &&
1775 !memcmp(ptr, another_ptr, store_length)
1776 )
1777 key_eq = TRUE;
1778 else {
1779 key_eq = FALSE;
1780 #ifndef DBUG_OFF
1781 if (
1782 start_key_part_map &&
1783 end_key_part_map
1784 )
1785 DBUG_PRINT("info", ("spider memcmp=%d",
1786 memcmp(ptr, another_ptr, store_length)));
1787 #endif
1788 }
1789 } else {
1790 DBUG_PRINT("info", ("spider tgt_key_part_map=%lu", tgt_key_part_map));
1791 if (tgt_key_part_map > 1)
1792 key_eq = TRUE;
1793 else
1794 key_eq = FALSE;
1795 }
1796 if (
1797 (key_eq && use_key == start_key) ||
1798 (!key_eq && start_key_part_map)
1799 ) {
1800 bool tgt_final = (use_key == start_key && tgt_key_part_map == 1);
1801 ptr = start_key->key + length;
1802 if (
1803 (error_num = dbton_hdl->append_is_null_part(sql_type, key_part,
1804 start_key, &ptr, key_eq, tgt_final))
1805 ) {
1806 if (error_num > 0)
1807 DBUG_RETURN(error_num);
1808 if (
1809 !set_order &&
1810 start_key->flag != HA_READ_KEY_EXACT &&
1811 sql_kind == SPIDER_SQL_KIND_SQL
1812 ) {
1813 result_list->key_order = key_count;
1814 set_order = TRUE;
1815 }
1816 } else if (key_eq)
1817 {
1818 DBUG_PRINT("info", ("spider key_eq"));
1819 if (sql_kind == SPIDER_SQL_KIND_SQL)
1820 {
1821 if (str->reserve(store_length + key_name_length +
1822 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 +
1823 SPIDER_SQL_EQUAL_LEN + SPIDER_SQL_AND_LEN))
1824 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1825 dbton_share->append_column_name(str, field->field_index);
1826 str->q_append(SPIDER_SQL_EQUAL_STR, SPIDER_SQL_EQUAL_LEN);
1827 if (spider_dbton[dbton_id].db_util->
1828 append_column_value(spider, str, field, ptr,
1829 share->access_charset))
1830 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1831 } else if (sql_kind == SPIDER_SQL_KIND_HANDLER)
1832 {
1833 if (str_part2->reserve(store_length + key_name_length +
1834 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 +
1835 SPIDER_SQL_EQUAL_LEN + SPIDER_SQL_AND_LEN))
1836 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1837 dbton_share->append_column_name(str_part2, field->field_index);
1838 str_part2->q_append(SPIDER_SQL_EQUAL_STR, SPIDER_SQL_EQUAL_LEN);
1839 if (spider_dbton[dbton_id].db_util->
1840 append_column_value(spider, str_part2, field, ptr,
1841 share->access_charset))
1842 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1843
1844 if (use_key == start_key)
1845 {
1846 if (spider_dbton[dbton_id].db_util->
1847 append_column_value(spider, str_part, field, ptr,
1848 share->access_charset))
1849 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1850 }
1851 }
1852 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
1853 else {
1854 if (spider_dbton[share->use_hs_dbton_ids[0]].db_util->
1855 append_column_value(spider, NULL, field, ptr,
1856 share->access_charset))
1857 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1858 }
1859 #endif
1860 } else {
1861 DBUG_PRINT("info", ("spider start_key->flag=%d", start_key->flag));
1862 switch (start_key->flag)
1863 {
1864 #if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000
1865 case HA_READ_PREFIX_LAST:
1866 result_list->desc_flg = TRUE;
1867 #endif
1868 /* fall through */
1869 case HA_READ_KEY_EXACT:
1870 if (sql_kind == SPIDER_SQL_KIND_SQL)
1871 {
1872 if (str->reserve(store_length + key_name_length +
1873 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 +
1874 SPIDER_SQL_EQUAL_LEN))
1875 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1876 dbton_share->append_column_name(str, field->field_index);
1877 str->q_append(SPIDER_SQL_EQUAL_STR, SPIDER_SQL_EQUAL_LEN);
1878 if (spider_dbton[dbton_id].db_util->
1879 append_column_value(spider, str, field, ptr,
1880 share->access_charset))
1881 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1882 } else if (sql_kind == SPIDER_SQL_KIND_HANDLER)
1883 {
1884 if (str_part2->reserve(store_length + key_name_length +
1885 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 +
1886 SPIDER_SQL_EQUAL_LEN))
1887 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1888 dbton_share->append_column_name(str_part2, field->field_index);
1889 str_part2->q_append(SPIDER_SQL_EQUAL_STR, SPIDER_SQL_EQUAL_LEN);
1890 if (spider_dbton[dbton_id].db_util->
1891 append_column_value(spider, str_part2, field, ptr,
1892 share->access_charset))
1893 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1894
1895 if (use_key == start_key)
1896 {
1897 if (tgt_key_part_map == 1)
1898 {
1899 if (str->reserve(SPIDER_SQL_EQUAL_LEN))
1900 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1901 str->q_append(SPIDER_SQL_EQUAL_STR, SPIDER_SQL_EQUAL_LEN);
1902 }
1903 if (spider_dbton[dbton_id].db_util->
1904 append_column_value(spider, str_part, field, ptr,
1905 share->access_charset))
1906 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1907 }
1908 }
1909 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
1910 else {
1911 if (spider_dbton[share->use_hs_dbton_ids[0]].db_util->
1912 append_column_value(spider, NULL, field, ptr,
1913 share->access_charset))
1914 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1915 if (str->reserve(SPIDER_SQL_HS_EQUAL_LEN))
1916 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1917 str->q_append(SPIDER_SQL_HS_EQUAL_STR, SPIDER_SQL_HS_EQUAL_LEN);
1918 }
1919 #endif
1920 break;
1921 case HA_READ_AFTER_KEY:
1922 if (sql_kind == SPIDER_SQL_KIND_SQL)
1923 {
1924 const char* op_str;
1925 uint32 op_len;
1926 if (start_key_part_map == 1) {
1927 op_str = SPIDER_SQL_GT_STR;
1928 op_len = SPIDER_SQL_GT_LEN;
1929 } else {
1930 op_str = SPIDER_SQL_GTEQUAL_STR;
1931 op_len = SPIDER_SQL_GTEQUAL_LEN;
1932 }
1933 if (str->reserve(store_length + key_name_length +
1934 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + op_len))
1935 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1936 dbton_share->append_column_name(str, field->field_index);
1937 str->q_append(op_str, op_len);
1938 if (spider_dbton[dbton_id].db_util->
1939 append_column_value(spider, str, field, ptr,
1940 share->access_charset))
1941 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1942 if (use_both)
1943 start_key_part_map = 0;
1944 if (!set_order)
1945 {
1946 result_list->key_order = key_count;
1947 set_order = TRUE;
1948 }
1949 } else if (sql_kind == SPIDER_SQL_KIND_HANDLER)
1950 {
1951 if (str_part2->reserve(store_length + key_name_length +
1952 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 +
1953 SPIDER_SQL_GT_LEN))
1954 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1955 dbton_share->append_column_name(str_part2, field->field_index);
1956 str_part2->q_append(SPIDER_SQL_GT_STR, SPIDER_SQL_GT_LEN);
1957 if (spider_dbton[dbton_id].db_util->
1958 append_column_value(spider, str_part2, field, ptr,
1959 share->access_charset))
1960 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1961
1962 if (use_key == start_key)
1963 {
1964 if (tgt_key_part_map == 1)
1965 {
1966 if (str->reserve(SPIDER_SQL_GT_LEN))
1967 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1968 str->q_append(SPIDER_SQL_GT_STR, SPIDER_SQL_GT_LEN);
1969 }
1970 if (spider_dbton[dbton_id].db_util->
1971 append_column_value(spider, str_part, field, ptr,
1972 share->access_charset))
1973 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1974 }
1975 }
1976 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
1977 else {
1978 if (spider_dbton[share->use_hs_dbton_ids[0]].db_util->
1979 append_column_value(spider, NULL, field, ptr,
1980 share->access_charset))
1981 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1982 if (str->reserve(SPIDER_SQL_HS_GT_LEN))
1983 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1984 str->q_append(SPIDER_SQL_HS_GT_STR, SPIDER_SQL_HS_GT_LEN);
1985 }
1986 #endif
1987 break;
1988 case HA_READ_BEFORE_KEY:
1989 result_list->desc_flg = TRUE;
1990 if (sql_kind == SPIDER_SQL_KIND_SQL)
1991 {
1992 const char* op_str;
1993 uint32 op_len;
1994 if (start_key_part_map == 1) {
1995 op_str = SPIDER_SQL_LT_STR;
1996 op_len = SPIDER_SQL_LT_LEN;
1997 } else {
1998 op_str = SPIDER_SQL_LTEQUAL_STR;
1999 op_len = SPIDER_SQL_LTEQUAL_LEN;
2000 }
2001 if (str->reserve(store_length + key_name_length +
2002 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + op_len))
2003 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2004 dbton_share->append_column_name(str, field->field_index);
2005 str->q_append(op_str, op_len);
2006 if (spider_dbton[dbton_id].db_util->
2007 append_column_value(spider, str, field, ptr,
2008 share->access_charset))
2009 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2010 if (use_both)
2011 start_key_part_map = 0;
2012 if (!set_order)
2013 {
2014 result_list->key_order = key_count;
2015 set_order = TRUE;
2016 }
2017 } else if (sql_kind == SPIDER_SQL_KIND_HANDLER)
2018 {
2019 if (str_part2->reserve(store_length + key_name_length +
2020 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 +
2021 SPIDER_SQL_LT_LEN))
2022 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2023 dbton_share->append_column_name(str_part2, field->field_index);
2024 str_part2->q_append(SPIDER_SQL_LT_STR, SPIDER_SQL_LT_LEN);
2025 if (spider_dbton[dbton_id].db_util->
2026 append_column_value(spider, str_part2, field, ptr,
2027 share->access_charset))
2028 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2029
2030 if (use_key == start_key)
2031 {
2032 if (tgt_key_part_map == 1)
2033 {
2034 if (str->reserve(SPIDER_SQL_LT_LEN))
2035 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2036 str->q_append(SPIDER_SQL_LT_STR, SPIDER_SQL_LT_LEN);
2037 }
2038 if (spider_dbton[dbton_id].db_util->
2039 append_column_value(spider, str_part, field, ptr,
2040 share->access_charset))
2041 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2042 }
2043 }
2044 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
2045 else {
2046 if (spider_dbton[share->use_hs_dbton_ids[0]].db_util->
2047 append_column_value(spider, NULL, field, ptr,
2048 share->access_charset))
2049 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2050 if (str->reserve(SPIDER_SQL_HS_LT_LEN))
2051 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2052 str->q_append(SPIDER_SQL_HS_LT_STR, SPIDER_SQL_HS_LT_LEN);
2053 }
2054 #endif
2055 break;
2056 #if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000
2057 #else
2058 case HA_READ_PREFIX_LAST:
2059 result_list->limit_num = 1;
2060 /* fall through */
2061 #endif
2062 case HA_READ_KEY_OR_PREV:
2063 case HA_READ_PREFIX_LAST_OR_PREV:
2064 result_list->desc_flg = TRUE;
2065 if (sql_kind == SPIDER_SQL_KIND_SQL)
2066 {
2067 if (str->reserve(store_length + key_name_length +
2068 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 +
2069 SPIDER_SQL_LTEQUAL_LEN))
2070 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2071 dbton_share->append_column_name(str, field->field_index);
2072 str->q_append(SPIDER_SQL_LTEQUAL_STR, SPIDER_SQL_LTEQUAL_LEN);
2073 if (spider_dbton[dbton_id].db_util->
2074 append_column_value(spider, str, field, ptr,
2075 share->access_charset))
2076 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2077 if (!set_order)
2078 {
2079 result_list->key_order = key_count;
2080 set_order = TRUE;
2081 }
2082 } else if (sql_kind == SPIDER_SQL_KIND_HANDLER)
2083 {
2084 if (str_part2->reserve(store_length + key_name_length +
2085 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 +
2086 SPIDER_SQL_LTEQUAL_LEN))
2087 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2088 dbton_share->append_column_name(str_part2, field->field_index);
2089 str_part2->q_append(SPIDER_SQL_LTEQUAL_STR,
2090 SPIDER_SQL_LTEQUAL_LEN);
2091 if (spider_dbton[dbton_id].db_util->
2092 append_column_value(spider, str_part2, field, ptr,
2093 share->access_charset))
2094 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2095
2096 if (use_key == start_key)
2097 {
2098 if (tgt_key_part_map == 1)
2099 {
2100 if (str->reserve(SPIDER_SQL_LTEQUAL_LEN))
2101 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2102 str->q_append(SPIDER_SQL_LTEQUAL_STR,
2103 SPIDER_SQL_LTEQUAL_LEN);
2104 }
2105 if (spider_dbton[dbton_id].db_util->
2106 append_column_value(spider, str_part, field, ptr,
2107 share->access_charset))
2108 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2109 }
2110 }
2111 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
2112 else {
2113 if (spider_dbton[share->use_hs_dbton_ids[0]].db_util->
2114 append_column_value(spider, NULL, field, ptr,
2115 share->access_charset))
2116 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2117 if (str->reserve(SPIDER_SQL_HS_LTEQUAL_LEN))
2118 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2119 str->q_append(SPIDER_SQL_HS_LTEQUAL_STR,
2120 SPIDER_SQL_HS_LTEQUAL_LEN);
2121 }
2122 #endif
2123 break;
2124 case HA_READ_MBR_CONTAIN:
2125 if (str->reserve(SPIDER_SQL_MBR_CONTAIN_LEN))
2126 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2127 str->q_append(SPIDER_SQL_MBR_CONTAIN_STR,
2128 SPIDER_SQL_MBR_CONTAIN_LEN);
2129 if (
2130 spider_dbton[dbton_id].db_util->
2131 append_column_value(spider, str, field, ptr,
2132 share->access_charset) ||
2133 str->reserve(SPIDER_SQL_COMMA_LEN + key_name_length +
2134 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_CLOSE_PAREN_LEN)
2135 )
2136 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2137 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
2138 dbton_share->append_column_name(str, field->field_index);
2139 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR,
2140 SPIDER_SQL_CLOSE_PAREN_LEN);
2141 break;
2142 case HA_READ_MBR_INTERSECT:
2143 if (str->reserve(SPIDER_SQL_MBR_INTERSECT_LEN))
2144 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2145 str->q_append(SPIDER_SQL_MBR_INTERSECT_STR,
2146 SPIDER_SQL_MBR_INTERSECT_LEN);
2147 if (
2148 spider_dbton[dbton_id].db_util->
2149 append_column_value(spider, str, field, ptr,
2150 share->access_charset) ||
2151 str->reserve(SPIDER_SQL_COMMA_LEN + key_name_length +
2152 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_CLOSE_PAREN_LEN)
2153 )
2154 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2155 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
2156 dbton_share->append_column_name(str, field->field_index);
2157 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR,
2158 SPIDER_SQL_CLOSE_PAREN_LEN);
2159 break;
2160 case HA_READ_MBR_WITHIN:
2161 if (str->reserve(SPIDER_SQL_MBR_WITHIN_LEN))
2162 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2163 str->q_append(SPIDER_SQL_MBR_WITHIN_STR,
2164 SPIDER_SQL_MBR_WITHIN_LEN);
2165 if (
2166 spider_dbton[dbton_id].db_util->
2167 append_column_value(spider, str, field, ptr,
2168 share->access_charset) ||
2169 str->reserve(SPIDER_SQL_COMMA_LEN + key_name_length +
2170 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_CLOSE_PAREN_LEN)
2171 )
2172 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2173 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
2174 dbton_share->append_column_name(str, field->field_index);
2175 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR,
2176 SPIDER_SQL_CLOSE_PAREN_LEN);
2177 break;
2178 case HA_READ_MBR_DISJOINT:
2179 if (str->reserve(SPIDER_SQL_MBR_DISJOINT_LEN))
2180 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2181 str->q_append(SPIDER_SQL_MBR_DISJOINT_STR,
2182 SPIDER_SQL_MBR_DISJOINT_LEN);
2183 if (
2184 spider_dbton[dbton_id].db_util->
2185 append_column_value(spider, str, field, ptr,
2186 share->access_charset) ||
2187 str->reserve(SPIDER_SQL_COMMA_LEN + key_name_length +
2188 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_CLOSE_PAREN_LEN)
2189 )
2190 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2191 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
2192 dbton_share->append_column_name(str, field->field_index);
2193 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR,
2194 SPIDER_SQL_CLOSE_PAREN_LEN);
2195 break;
2196 case HA_READ_MBR_EQUAL:
2197 if (str->reserve(SPIDER_SQL_MBR_EQUAL_LEN))
2198 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2199 str->q_append(SPIDER_SQL_MBR_EQUAL_STR, SPIDER_SQL_MBR_EQUAL_LEN);
2200 if (
2201 spider_dbton[dbton_id].db_util->
2202 append_column_value(spider, str, field, ptr,
2203 share->access_charset) ||
2204 str->reserve(SPIDER_SQL_COMMA_LEN + key_name_length +
2205 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_CLOSE_PAREN_LEN)
2206 )
2207 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2208 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
2209 dbton_share->append_column_name(str, field->field_index);
2210 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR,
2211 SPIDER_SQL_CLOSE_PAREN_LEN);
2212 break;
2213 default:
2214 if (sql_kind == SPIDER_SQL_KIND_SQL)
2215 {
2216 if (str->reserve(store_length + key_name_length +
2217 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 +
2218 SPIDER_SQL_GTEQUAL_LEN))
2219 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2220 dbton_share->append_column_name(str, field->field_index);
2221 str->q_append(SPIDER_SQL_GTEQUAL_STR, SPIDER_SQL_GTEQUAL_LEN);
2222 if (spider_dbton[dbton_id].db_util->
2223 append_column_value(spider, str, field, ptr,
2224 share->access_charset))
2225 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2226 if (!set_order)
2227 {
2228 result_list->key_order = key_count;
2229 set_order = TRUE;
2230 }
2231 } else if (sql_kind == SPIDER_SQL_KIND_HANDLER)
2232 {
2233 if (str_part2->reserve(store_length + key_name_length +
2234 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 +
2235 SPIDER_SQL_GTEQUAL_LEN))
2236 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2237 dbton_share->append_column_name(str_part2, field->field_index);
2238 str_part2->q_append(SPIDER_SQL_GTEQUAL_STR,
2239 SPIDER_SQL_GTEQUAL_LEN);
2240 if (spider_dbton[dbton_id].db_util->
2241 append_column_value(spider, str_part2, field, ptr,
2242 share->access_charset))
2243 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2244
2245 if (use_key == start_key)
2246 {
2247 if (tgt_key_part_map == 1)
2248 {
2249 if (str->reserve(SPIDER_SQL_GTEQUAL_LEN))
2250 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2251 str->q_append(SPIDER_SQL_GTEQUAL_STR,
2252 SPIDER_SQL_GTEQUAL_LEN);
2253 }
2254 if (spider_dbton[dbton_id].db_util->
2255 append_column_value(spider, str_part, field, ptr,
2256 share->access_charset))
2257 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2258 }
2259 }
2260 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
2261 else {
2262 if (spider_dbton[share->use_hs_dbton_ids[0]].db_util->
2263 append_column_value(spider, NULL, field, ptr,
2264 share->access_charset))
2265 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2266 if (str->reserve(SPIDER_SQL_HS_GTEQUAL_LEN))
2267 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2268 str->q_append(SPIDER_SQL_HS_GTEQUAL_STR,
2269 SPIDER_SQL_HS_GTEQUAL_LEN);
2270 }
2271 #endif
2272 break;
2273 }
2274 }
2275 if (sql_kind == SPIDER_SQL_KIND_SQL)
2276 {
2277 if (str->reserve(SPIDER_SQL_AND_LEN))
2278 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2279 str->q_append(SPIDER_SQL_AND_STR,
2280 SPIDER_SQL_AND_LEN);
2281 } else if (sql_kind == SPIDER_SQL_KIND_HANDLER)
2282 {
2283 if (str_part2->reserve(SPIDER_SQL_AND_LEN))
2284 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2285 str_part2->q_append(SPIDER_SQL_AND_STR,
2286 SPIDER_SQL_AND_LEN);
2287
2288 if (use_key == start_key)
2289 {
2290 if (str_part->reserve(SPIDER_SQL_COMMA_LEN))
2291 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2292 str_part->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
2293 }
2294 }
2295 }
2296
2297 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
2298 if (sql_kind != SPIDER_SQL_KIND_HS)
2299 {
2300 #endif
2301 if (
2302 (key_eq && use_key == end_key) ||
2303 (!key_eq && end_key_part_map)
2304 ) {
2305 bool tgt_final = (use_key == end_key && tgt_key_part_map == 1);
2306 ptr = end_key->key + length;
2307 if ((error_num = dbton_hdl->append_is_null_part(sql_type, key_part,
2308 end_key, &ptr, key_eq, tgt_final)))
2309 {
2310 if (error_num > 0)
2311 DBUG_RETURN(error_num);
2312 if (
2313 !set_order &&
2314 end_key->flag != HA_READ_KEY_EXACT &&
2315 sql_kind == SPIDER_SQL_KIND_SQL
2316 ) {
2317 result_list->key_order = key_count;
2318 set_order = TRUE;
2319 }
2320 } else if (key_eq)
2321 {
2322 DBUG_PRINT("info", ("spider key_eq"));
2323 if (sql_kind == SPIDER_SQL_KIND_SQL)
2324 {
2325 if (str->reserve(store_length + key_name_length +
2326 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 +
2327 SPIDER_SQL_EQUAL_LEN + SPIDER_SQL_AND_LEN))
2328 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2329 dbton_share->append_column_name(str, field->field_index);
2330 str->q_append(SPIDER_SQL_EQUAL_STR, SPIDER_SQL_EQUAL_LEN);
2331 if (spider_dbton[dbton_id].db_util->
2332 append_column_value(spider, str, field, ptr,
2333 share->access_charset))
2334 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2335 } else {
2336 if (str_part2->reserve(store_length + key_name_length +
2337 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 +
2338 SPIDER_SQL_EQUAL_LEN + SPIDER_SQL_AND_LEN))
2339 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2340 dbton_share->append_column_name(str_part2, field->field_index);
2341 str_part2->q_append(SPIDER_SQL_EQUAL_STR, SPIDER_SQL_EQUAL_LEN);
2342 if (spider_dbton[dbton_id].db_util->
2343 append_column_value(spider, str_part2, field, ptr,
2344 share->access_charset))
2345 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2346
2347 if (use_key == end_key)
2348 {
2349 /*
2350 if (tgt_key_part_map == 1)
2351 {
2352 if (str->reserve(SPIDER_SQL_EQUAL_LEN))
2353 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2354 str->q_append(SPIDER_SQL_EQUAL_STR, SPIDER_SQL_EQUAL_LEN);
2355 }
2356 */
2357 if (spider_dbton[dbton_id].db_util->
2358 append_column_value(spider, str_part, field, ptr,
2359 share->access_charset))
2360 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2361 }
2362 }
2363 } else {
2364 DBUG_PRINT("info", ("spider end_key->flag=%d", end_key->flag));
2365 switch (end_key->flag)
2366 {
2367 case HA_READ_BEFORE_KEY:
2368 if (sql_kind == SPIDER_SQL_KIND_SQL)
2369 {
2370 const char* op_str;
2371 uint32 op_len;
2372 if (end_key_part_map == 1) {
2373 op_str = SPIDER_SQL_LT_STR;
2374 op_len = SPIDER_SQL_LT_LEN;
2375 } else {
2376 op_str = SPIDER_SQL_LTEQUAL_STR;
2377 op_len = SPIDER_SQL_LTEQUAL_LEN;
2378 }
2379 if (str->reserve(store_length + key_name_length +
2380 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + op_len))
2381 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2382 dbton_share->append_column_name(str, field->field_index);
2383 str->q_append(op_str, op_len);
2384 if (spider_dbton[dbton_id].db_util->
2385 append_column_value(spider, str, field, ptr,
2386 share->access_charset))
2387 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2388 if (use_both)
2389 end_key_part_map = 0;
2390 if (!set_order)
2391 {
2392 result_list->key_order = key_count;
2393 set_order = TRUE;
2394 }
2395 } else {
2396 if (str_part2->reserve(store_length + key_name_length +
2397 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 +
2398 SPIDER_SQL_LT_LEN))
2399 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2400 dbton_share->append_column_name(str_part2, field->field_index);
2401 str_part2->q_append(SPIDER_SQL_LT_STR, SPIDER_SQL_LT_LEN);
2402 if (spider_dbton[dbton_id].db_util->
2403 append_column_value(spider, str_part2, field, ptr,
2404 share->access_charset))
2405 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2406
2407 if (use_key == end_key)
2408 {
2409 if (tgt_key_part_map == 1)
2410 {
2411 if (str->reserve(SPIDER_SQL_LT_LEN))
2412 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2413 str->q_append(SPIDER_SQL_LT_STR, SPIDER_SQL_LT_LEN);
2414 }
2415 if (spider_dbton[dbton_id].db_util->
2416 append_column_value(spider, str_part, field, ptr,
2417 share->access_charset))
2418 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2419 }
2420 }
2421 break;
2422 default:
2423 if (sql_kind == SPIDER_SQL_KIND_SQL)
2424 {
2425 if (str->reserve(store_length + key_name_length +
2426 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 +
2427 SPIDER_SQL_LTEQUAL_LEN))
2428 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2429 dbton_share->append_column_name(str, field->field_index);
2430 str->q_append(SPIDER_SQL_LTEQUAL_STR, SPIDER_SQL_LTEQUAL_LEN);
2431 if (spider_dbton[dbton_id].db_util->
2432 append_column_value(spider, str, field, ptr,
2433 share->access_charset))
2434 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2435 if (!set_order)
2436 {
2437 result_list->key_order = key_count;
2438 set_order = TRUE;
2439 }
2440 } else {
2441 if (str_part2->reserve(store_length + key_name_length +
2442 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 +
2443 SPIDER_SQL_LTEQUAL_LEN))
2444 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2445 dbton_share->append_column_name(str_part2, field->field_index);
2446 str_part2->q_append(SPIDER_SQL_LTEQUAL_STR,
2447 SPIDER_SQL_LTEQUAL_LEN);
2448 if (spider_dbton[dbton_id].db_util->
2449 append_column_value(spider, str_part2, field, ptr,
2450 share->access_charset))
2451 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2452
2453 if (use_key == end_key)
2454 {
2455 if (tgt_key_part_map == 1)
2456 {
2457 if (str->reserve(SPIDER_SQL_LTEQUAL_LEN))
2458 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2459 str->q_append(SPIDER_SQL_LTEQUAL_STR,
2460 SPIDER_SQL_LTEQUAL_LEN);
2461 }
2462 if (spider_dbton[dbton_id].db_util->
2463 append_column_value(spider, str_part, field, ptr,
2464 share->access_charset))
2465 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2466 }
2467 }
2468 break;
2469 }
2470 }
2471 if (sql_kind == SPIDER_SQL_KIND_SQL)
2472 {
2473 if (str->reserve(SPIDER_SQL_AND_LEN))
2474 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2475 str->q_append(SPIDER_SQL_AND_STR,
2476 SPIDER_SQL_AND_LEN);
2477 } else {
2478 if (str_part2->reserve(SPIDER_SQL_AND_LEN))
2479 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2480 str_part2->q_append(SPIDER_SQL_AND_STR,
2481 SPIDER_SQL_AND_LEN);
2482
2483 if (use_key == end_key)
2484 {
2485 if (str_part->reserve(SPIDER_SQL_COMMA_LEN))
2486 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2487 str_part->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
2488 }
2489 }
2490 }
2491 if (use_both && (!start_key_part_map || !end_key_part_map))
2492 break;
2493 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
2494 }
2495 #endif
2496 }
2497 if ((error_num = dbton_hdl->append_where_terminator_part(sql_type,
2498 set_order, key_count)))
2499 DBUG_RETURN(error_num);
2500
2501 end:
2502 /* use condition */
2503 if (dbton_hdl->append_condition_part(NULL, 0, sql_type, FALSE))
2504 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2505 if (sql_kind == SPIDER_SQL_KIND_SQL)
2506 dbton_hdl->set_order_pos(sql_type);
2507 #ifndef DBUG_OFF
2508 dbug_tmp_restore_column_map(&table->read_set, tmp_map);
2509 #endif
2510 DBUG_RETURN(0);
2511 }
2512
spider_db_append_key_where(const key_range * start_key,const key_range * end_key,ha_spider * spider)2513 int spider_db_append_key_where(
2514 const key_range *start_key,
2515 const key_range *end_key,
2516 ha_spider *spider
2517 ) {
2518 int error_num;
2519 DBUG_ENTER("spider_db_append_key_where");
2520 if ((spider->sql_kinds & SPIDER_SQL_KIND_SQL))
2521 {
2522 DBUG_PRINT("info",("spider call internal by SPIDER_SQL_KIND_SQL"));
2523 if ((error_num = spider->append_key_where_sql_part(start_key, end_key,
2524 SPIDER_SQL_TYPE_SELECT_SQL)))
2525 DBUG_RETURN(error_num);
2526 }
2527 if (spider->sql_kinds & SPIDER_SQL_KIND_HANDLER)
2528 {
2529 DBUG_PRINT("info",("spider call internal by SPIDER_SQL_KIND_HANDLER"));
2530 if ((error_num = spider->append_key_where_sql_part(start_key, end_key,
2531 SPIDER_SQL_TYPE_HANDLER)))
2532 DBUG_RETURN(error_num);
2533 }
2534 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
2535 if ((spider->sql_kinds & SPIDER_SQL_KIND_HS))
2536 {
2537 DBUG_PRINT("info",("spider call internal by SPIDER_SQL_KIND_HS"));
2538 if ((error_num = spider->append_key_where_hs_part(start_key, end_key,
2539 SPIDER_SQL_TYPE_SELECT_HS)))
2540 DBUG_RETURN(error_num);
2541 }
2542 #endif
2543 DBUG_RETURN(0);
2544 }
2545
2546 #ifdef HANDLER_HAS_DIRECT_AGGREGATE
spider_db_refetch_for_item_sum_funcs(ha_spider * spider)2547 int spider_db_refetch_for_item_sum_funcs(
2548 ha_spider *spider
2549 ) {
2550 int error_num;
2551 SPIDER_RESULT_LIST *result_list = &spider->result_list;
2552 DBUG_ENTER("spider_db_refetch_for_item_sum_funcs");
2553 if (result_list->snap_direct_aggregate)
2554 {
2555 SPIDER_DB_ROW *row = result_list->snap_row;
2556 row->first();
2557 if (result_list->snap_mrr_with_cnt)
2558 {
2559 row->next();
2560 }
2561 if ((error_num = spider_db_fetch_for_item_sum_funcs(row, spider)))
2562 DBUG_RETURN(error_num);
2563 }
2564 DBUG_RETURN(0);
2565 }
2566
spider_db_fetch_for_item_sum_funcs(SPIDER_DB_ROW * row,ha_spider * spider)2567 int spider_db_fetch_for_item_sum_funcs(
2568 SPIDER_DB_ROW *row,
2569 ha_spider *spider
2570 ) {
2571 int error_num;
2572 st_select_lex *select_lex;
2573 DBUG_ENTER("spider_db_fetch_for_item_sum_funcs");
2574 select_lex = spider_get_select_lex(spider);
2575 JOIN *join = select_lex->join;
2576 Item_sum **item_sum_ptr;
2577 spider->direct_aggregate_item_current = NULL;
2578 for (item_sum_ptr = join->sum_funcs; *item_sum_ptr; ++item_sum_ptr)
2579 {
2580 if ((error_num = spider_db_fetch_for_item_sum_func(row, *item_sum_ptr,
2581 spider)))
2582 DBUG_RETURN(error_num);
2583 }
2584 DBUG_RETURN(0);
2585 }
2586
spider_db_fetch_for_item_sum_func(SPIDER_DB_ROW * row,Item_sum * item_sum,ha_spider * spider)2587 int spider_db_fetch_for_item_sum_func(
2588 SPIDER_DB_ROW *row,
2589 Item_sum *item_sum,
2590 ha_spider *spider
2591 ) {
2592 int error_num;
2593 SPIDER_SHARE *share = spider->share;
2594 THD *thd = spider->trx->thd;
2595 DBUG_ENTER("spider_db_fetch_for_item_sum_func");
2596 DBUG_PRINT("info",("spider Sumfunctype = %d", item_sum->sum_func()));
2597 switch (item_sum->sum_func())
2598 {
2599 case Item_sum::COUNT_FUNC:
2600 {
2601 Item_sum_count *item_sum_count = (Item_sum_count *) item_sum;
2602 if (!row->is_null())
2603 item_sum_count->direct_add(row->val_int());
2604 else
2605 DBUG_RETURN(ER_SPIDER_UNKNOWN_NUM);
2606 row->next();
2607 }
2608 break;
2609 case Item_sum::SUM_FUNC:
2610 {
2611 Item_sum_sum *item_sum_sum = (Item_sum_sum *) item_sum;
2612 if (item_sum_sum->result_type() == DECIMAL_RESULT)
2613 {
2614 my_decimal decimal_value;
2615 item_sum_sum->direct_add(row->val_decimal(&decimal_value,
2616 share->access_charset));
2617 } else {
2618 item_sum_sum->direct_add(row->val_real(), row->is_null());
2619 }
2620 row->next();
2621 }
2622 break;
2623 case Item_sum::MIN_FUNC:
2624 case Item_sum::MAX_FUNC:
2625 {
2626 if (!spider->direct_aggregate_item_current)
2627 {
2628 if (!spider->direct_aggregate_item_first)
2629 {
2630 if (!spider_bulk_malloc(spider_current_trx, 240, MYF(MY_WME),
2631 &spider->direct_aggregate_item_first, sizeof(SPIDER_ITEM_HLD),
2632 NullS)
2633 ) {
2634 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2635 }
2636 spider->direct_aggregate_item_first->next = NULL;
2637 spider->direct_aggregate_item_first->item = NULL;
2638 spider->direct_aggregate_item_first->tgt_num = 0;
2639 #ifdef SPIDER_ITEM_STRING_WITHOUT_SET_STR_WITH_COPY_AND_THDPTR
2640 spider->direct_aggregate_item_first->init_mem_root = FALSE;
2641 #endif
2642 }
2643 spider->direct_aggregate_item_current =
2644 spider->direct_aggregate_item_first;
2645 } else {
2646 if (!spider->direct_aggregate_item_current->next)
2647 {
2648 if (!spider_bulk_malloc(spider_current_trx, 241, MYF(MY_WME),
2649 &spider->direct_aggregate_item_current->next,
2650 sizeof(SPIDER_ITEM_HLD), NullS)
2651 ) {
2652 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2653 }
2654 spider->direct_aggregate_item_current->next->next = NULL;
2655 spider->direct_aggregate_item_current->next->item = NULL;
2656 spider->direct_aggregate_item_current->next->tgt_num =
2657 spider->direct_aggregate_item_current->tgt_num + 1;
2658 #ifdef SPIDER_ITEM_STRING_WITHOUT_SET_STR_WITH_COPY_AND_THDPTR
2659 spider->direct_aggregate_item_current->next->init_mem_root = FALSE;
2660 #endif
2661 }
2662 spider->direct_aggregate_item_current =
2663 spider->direct_aggregate_item_current->next;
2664 }
2665 if (!spider->direct_aggregate_item_current->item)
2666 {
2667 #ifdef SPIDER_ITEM_STRING_WITHOUT_SET_STR_WITH_COPY_AND_THDPTR
2668 if (!spider->direct_aggregate_item_current->init_mem_root)
2669 {
2670 SPD_INIT_ALLOC_ROOT(
2671 &spider->direct_aggregate_item_current->mem_root,
2672 4096, 0, MYF(MY_WME));
2673 spider->direct_aggregate_item_current->init_mem_root = TRUE;
2674 }
2675 #endif
2676 Item *free_list = thd->free_list;
2677 spider->direct_aggregate_item_current->item =
2678 #ifdef SPIDER_ITEM_STRING_WITHOUT_SET_STR_WITH_COPY
2679 #ifdef SPIDER_ITEM_STRING_WITHOUT_SET_STR_WITH_COPY_AND_THDPTR
2680 new (&spider->direct_aggregate_item_current->mem_root)
2681 Item_string(thd, "", 0, share->access_charset);
2682 #else
2683 new Item_string("", 0, share->access_charset);
2684 #endif
2685 #else
2686 new Item_string(share->access_charset);
2687 #endif
2688 if (!spider->direct_aggregate_item_current->item)
2689 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2690 thd->free_list = free_list;
2691 }
2692
2693 Item_sum_min_max *item_sum_min_max = (Item_sum_min_max *) item_sum;
2694 Item_string *item =
2695 (Item_string *) spider->direct_aggregate_item_current->item;
2696 if (row->is_null())
2697 {
2698 #ifdef SPIDER_ITEM_STRING_WITHOUT_SET_STR_WITH_COPY
2699 item->val_str(NULL)->length(0);
2700 item->append(NULL, 0);
2701 #else
2702 item->set_str_with_copy(NULL, 0);
2703 #endif
2704 item->null_value = TRUE;
2705 } else {
2706 char buf[MAX_FIELD_WIDTH];
2707 spider_string tmp_str(buf, MAX_FIELD_WIDTH, share->access_charset);
2708 tmp_str.init_calc_mem(242);
2709 tmp_str.length(0);
2710 if ((error_num = row->append_to_str(&tmp_str)))
2711 DBUG_RETURN(error_num);
2712 #ifdef SPIDER_ITEM_STRING_WITHOUT_SET_STR_WITH_COPY
2713 item->val_str(NULL)->length(0);
2714 item->append((char *) tmp_str.ptr(), tmp_str.length());
2715 #else
2716 item->set_str_with_copy(tmp_str.ptr(), tmp_str.length());
2717 #endif
2718 item->null_value = FALSE;
2719 }
2720 item_sum_min_max->direct_add(item);
2721 row->next();
2722 }
2723 break;
2724 case Item_sum::COUNT_DISTINCT_FUNC:
2725 case Item_sum::SUM_DISTINCT_FUNC:
2726 case Item_sum::AVG_FUNC:
2727 case Item_sum::AVG_DISTINCT_FUNC:
2728 case Item_sum::STD_FUNC:
2729 case Item_sum::VARIANCE_FUNC:
2730 case Item_sum::SUM_BIT_FUNC:
2731 case Item_sum::UDF_SUM_FUNC:
2732 case Item_sum::GROUP_CONCAT_FUNC:
2733 default:
2734 DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);
2735 }
2736 DBUG_RETURN(0);
2737 }
2738 #endif
2739
spider_db_append_match_fetch(ha_spider * spider,st_spider_ft_info * ft_first,st_spider_ft_info * ft_current,SPIDER_DB_ROW * row)2740 int spider_db_append_match_fetch(
2741 ha_spider *spider,
2742 st_spider_ft_info *ft_first,
2743 st_spider_ft_info *ft_current,
2744 SPIDER_DB_ROW *row
2745 ) {
2746 DBUG_ENTER("spider_db_append_match_fetch");
2747 if (ft_current)
2748 {
2749 st_spider_ft_info *ft_info = ft_first;
2750 while (TRUE)
2751 {
2752 DBUG_PRINT("info",("spider ft_info=%p", ft_info));
2753 if (!row->is_null())
2754 ft_info->score = (float) row->val_real();
2755 else
2756 DBUG_RETURN(ER_SPIDER_UNKNOWN_NUM);
2757 row->next();
2758 if (ft_info == ft_current)
2759 break;
2760 ft_info = ft_info->next;
2761 }
2762 }
2763 DBUG_RETURN(0);
2764 }
2765
spider_db_append_match_where(ha_spider * spider)2766 int spider_db_append_match_where(
2767 ha_spider *spider
2768 ) {
2769 int error_num;
2770 DBUG_ENTER("spider_db_append_match_where");
2771 if ((error_num = spider->append_match_where_sql_part(
2772 SPIDER_SQL_TYPE_SELECT_SQL)))
2773 DBUG_RETURN(error_num);
2774
2775 /* use condition */
2776 if ((error_num = spider->append_condition_sql_part(
2777 NULL, 0, SPIDER_SQL_TYPE_SELECT_SQL, FALSE)))
2778 DBUG_RETURN(error_num);
2779
2780 spider->set_order_pos_sql(SPIDER_SQL_TYPE_SELECT_SQL);
2781 DBUG_RETURN(0);
2782 }
2783
spider_db_append_handler_next(ha_spider * spider)2784 void spider_db_append_handler_next(
2785 ha_spider *spider
2786 ) {
2787 const char *alias;
2788 uint alias_length;
2789 SPIDER_RESULT_LIST *result_list = &spider->result_list;
2790 DBUG_ENTER("spider_db_append_handler_next");
2791 if (result_list->sorted && result_list->desc_flg)
2792 {
2793 alias = SPIDER_SQL_PREV_STR;
2794 alias_length = SPIDER_SQL_PREV_LEN;
2795 } else {
2796 alias = SPIDER_SQL_NEXT_STR;
2797 alias_length = SPIDER_SQL_NEXT_LEN;
2798 }
2799 spider->set_order_to_pos_sql(SPIDER_SQL_TYPE_HANDLER);
2800 spider->append_key_order_with_alias_sql_part(alias, alias_length,
2801 SPIDER_SQL_TYPE_HANDLER);
2802 DBUG_VOID_RETURN;
2803 }
2804
spider_db_get_row_from_tmp_tbl_rec(SPIDER_RESULT * current,SPIDER_DB_ROW ** row)2805 void spider_db_get_row_from_tmp_tbl_rec(
2806 SPIDER_RESULT *current,
2807 SPIDER_DB_ROW **row
2808 ) {
2809 DBUG_ENTER("spider_db_get_row_from_tmp_tbl_rec");
2810 *row = current->result->fetch_row_from_tmp_table(current->result_tmp_tbl);
2811 DBUG_VOID_RETURN;
2812 }
2813
spider_db_get_row_from_tmp_tbl(SPIDER_RESULT * current,SPIDER_DB_ROW ** row)2814 int spider_db_get_row_from_tmp_tbl(
2815 SPIDER_RESULT *current,
2816 SPIDER_DB_ROW **row
2817 ) {
2818 int error_num;
2819 DBUG_ENTER("spider_db_get_row_from_tmp_tbl");
2820 if (current->result_tmp_tbl_inited == 2)
2821 {
2822 current->result_tmp_tbl->file->ha_rnd_end();
2823 current->result_tmp_tbl_inited = 0;
2824 }
2825 if (current->result_tmp_tbl_inited == 0)
2826 {
2827 current->result_tmp_tbl->file->extra(HA_EXTRA_CACHE);
2828 if ((error_num = current->result_tmp_tbl->file->ha_rnd_init(TRUE)))
2829 DBUG_RETURN(error_num);
2830 current->result_tmp_tbl_inited = 1;
2831 }
2832 if (
2833 #if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 50200
2834 (error_num = current->result_tmp_tbl->file->ha_rnd_next(
2835 current->result_tmp_tbl->record[0]))
2836 #else
2837 (error_num = current->result_tmp_tbl->file->rnd_next(
2838 current->result_tmp_tbl->record[0]))
2839 #endif
2840 ) {
2841 DBUG_RETURN(error_num);
2842 }
2843 spider_db_get_row_from_tmp_tbl_rec(current, row);
2844 DBUG_RETURN(0);
2845 }
2846
spider_db_get_row_from_tmp_tbl_pos(SPIDER_POSITION * pos,SPIDER_DB_ROW ** row)2847 int spider_db_get_row_from_tmp_tbl_pos(
2848 SPIDER_POSITION *pos,
2849 SPIDER_DB_ROW **row
2850 ) {
2851 int error_num;
2852 SPIDER_RESULT *result = pos->result;
2853 TABLE *tmp_tbl = result->result_tmp_tbl;
2854 DBUG_ENTER("spider_db_get_row_from_tmp_tbl_pos");
2855 if (result->result_tmp_tbl_inited == 1)
2856 {
2857 tmp_tbl->file->ha_rnd_end();
2858 result->result_tmp_tbl_inited = 0;
2859 }
2860 if (result->result_tmp_tbl_inited == 0)
2861 {
2862 if ((error_num = tmp_tbl->file->ha_rnd_init(FALSE)))
2863 DBUG_RETURN(error_num);
2864 result->result_tmp_tbl_inited = 2;
2865 }
2866 if (
2867 #if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 50200
2868 (error_num = tmp_tbl->file->ha_rnd_pos(tmp_tbl->record[0],
2869 (uchar *) &pos->tmp_tbl_pos))
2870 #else
2871 (error_num = tmp_tbl->file->rnd_pos(tmp_tbl->record[0],
2872 (uchar *) &pos->tmp_tbl_pos))
2873 #endif
2874 ) {
2875 DBUG_RETURN(error_num);
2876 }
2877 spider_db_get_row_from_tmp_tbl_rec(result, row);
2878 DBUG_RETURN(0);
2879 }
2880
spider_db_fetch_row(SPIDER_SHARE * share,Field * field,SPIDER_DB_ROW * row,my_ptrdiff_t ptr_diff)2881 int spider_db_fetch_row(
2882 SPIDER_SHARE *share,
2883 Field *field,
2884 SPIDER_DB_ROW *row,
2885 my_ptrdiff_t ptr_diff
2886 ) {
2887 int error_num;
2888 THD *thd = field->table->in_use;
2889 Time_zone *saved_time_zone = thd->variables.time_zone;
2890 DBUG_ENTER("spider_db_fetch_row");
2891 DBUG_PRINT("info", ("spider field_name %s", SPIDER_field_name_str(field)));
2892 DBUG_PRINT("info", ("spider fieldcharset %s", field->charset()->csname));
2893
2894 thd->variables.time_zone = UTC;
2895
2896 field->move_field_offset(ptr_diff);
2897 error_num = row->store_to_field(field, share->access_charset);
2898 field->move_field_offset(-ptr_diff);
2899
2900 thd->variables.time_zone = saved_time_zone;
2901
2902 DBUG_RETURN(error_num);
2903 }
2904
spider_db_fetch_table(ha_spider * spider,uchar * buf,TABLE * table,SPIDER_RESULT_LIST * result_list)2905 int spider_db_fetch_table(
2906 ha_spider *spider,
2907 uchar *buf,
2908 TABLE *table,
2909 SPIDER_RESULT_LIST *result_list
2910 ) {
2911 int error_num;
2912 SPIDER_SHARE *share = spider->share;
2913 my_ptrdiff_t ptr_diff = PTR_BYTE_DIFF(buf, table->record[0]);
2914 SPIDER_RESULT *current = (SPIDER_RESULT*) result_list->current;
2915 SPIDER_DB_ROW *row;
2916 Field **field;
2917 DBUG_ENTER("spider_db_fetch_table");
2918 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
2919 if (spider->conn_kind[spider->result_link_idx] == SPIDER_CONN_KIND_MYSQL)
2920 {
2921 #endif
2922 if (result_list->quick_mode == 0)
2923 {
2924 SPIDER_DB_RESULT *result = current->result;
2925 if (!(row = result->fetch_row()))
2926 {
2927 table->status = STATUS_NOT_FOUND;
2928 DBUG_RETURN(HA_ERR_END_OF_FILE);
2929 }
2930 } else {
2931 if (result_list->current_row_num < result_list->quick_page_size)
2932 {
2933 if (!current->first_position)
2934 {
2935 table->status = STATUS_NOT_FOUND;
2936 DBUG_RETURN(HA_ERR_END_OF_FILE);
2937 }
2938 row = current->first_position[result_list->current_row_num].row;
2939 } else {
2940 if ((error_num = spider_db_get_row_from_tmp_tbl(
2941 current, &row)))
2942 {
2943 if (error_num == HA_ERR_END_OF_FILE)
2944 table->status = STATUS_NOT_FOUND;
2945 DBUG_RETURN(error_num);
2946 }
2947 }
2948 }
2949
2950 DBUG_PRINT("info", ("spider row=%p", row));
2951 #ifdef HANDLER_HAS_DIRECT_AGGREGATE
2952 DBUG_PRINT("info", ("spider direct_aggregate=%s",
2953 result_list->direct_aggregate ? "TRUE" : "FALSE"));
2954 result_list->snap_mrr_with_cnt = spider->mrr_with_cnt;
2955 result_list->snap_direct_aggregate = result_list->direct_aggregate;
2956 result_list->snap_row = row;
2957 #endif
2958
2959 /* for mrr */
2960 if (spider->mrr_with_cnt)
2961 {
2962 DBUG_PRINT("info", ("spider mrr_with_cnt"));
2963 if (spider->sql_kind[spider->result_link_idx] == SPIDER_SQL_KIND_SQL)
2964 {
2965 if (!row->is_null())
2966 spider->multi_range_hit_point = row->val_int();
2967 #ifdef HANDLER_HAS_DIRECT_AGGREGATE
2968 else if (result_list->direct_aggregate)
2969 {
2970 table->status = STATUS_NOT_FOUND;
2971 DBUG_RETURN(HA_ERR_END_OF_FILE);
2972 }
2973 #endif
2974 else
2975 DBUG_RETURN(ER_SPIDER_UNKNOWN_NUM);
2976 row->next();
2977 } else {
2978 spider->multi_range_hit_point = 0;
2979 #ifdef HANDLER_HAS_DIRECT_AGGREGATE
2980 result_list->snap_mrr_with_cnt = FALSE;
2981 #endif
2982 }
2983 }
2984
2985 #ifdef HANDLER_HAS_DIRECT_AGGREGATE
2986 /* for direct_aggregate */
2987 if (result_list->direct_aggregate)
2988 {
2989 if ((error_num = spider_db_fetch_for_item_sum_funcs(row, spider)))
2990 DBUG_RETURN(error_num);
2991 }
2992 #endif
2993
2994 #ifdef SPIDER_HAS_GROUP_BY_HANDLER
2995 if (!spider->use_fields)
2996 {
2997 #endif
2998 if ((error_num = spider_db_append_match_fetch(spider,
2999 spider->ft_first, spider->ft_current, row)))
3000 DBUG_RETURN(error_num);
3001 #ifdef SPIDER_HAS_GROUP_BY_HANDLER
3002 }
3003 #endif
3004 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
3005 } else {
3006 if (!(row = result_list->hs_result->fetch_row_from_result_buffer(
3007 result_list->hs_result_buf)))
3008 {
3009 table->status = STATUS_NOT_FOUND;
3010 DBUG_RETURN(HA_ERR_END_OF_FILE);
3011 }
3012 }
3013 #endif
3014
3015 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
3016 if (spider->conn_kind[spider->result_link_idx] == SPIDER_CONN_KIND_MYSQL)
3017 {
3018 #endif
3019 for (
3020 field = table->field;
3021 *field;
3022 field++
3023 ) {
3024 if ((
3025 bitmap_is_set(table->read_set, (*field)->field_index) |
3026 bitmap_is_set(table->write_set, (*field)->field_index)
3027 )) {
3028 #ifndef DBUG_OFF
3029 MY_BITMAP *tmp_map =
3030 dbug_tmp_use_all_columns(table, &table->write_set);
3031 #endif
3032 DBUG_PRINT("info", ("spider bitmap is set %s",
3033 SPIDER_field_name_str(*field)));
3034 if ((error_num =
3035 spider_db_fetch_row(share, *field, row, ptr_diff)))
3036 DBUG_RETURN(error_num);
3037 #ifndef DBUG_OFF
3038 dbug_tmp_restore_column_map(&table->write_set, tmp_map);
3039 #endif
3040 } else {
3041 DBUG_PRINT("info", ("spider bitmap is not set %s",
3042 SPIDER_field_name_str(*field)));
3043 }
3044 row->next();
3045 }
3046 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
3047 } else {
3048 #ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
3049 if (spider->hs_pushed_ret_fields_num == MAX_FIELDS)
3050 {
3051 #endif
3052 spider_db_handler *dbton_hdl = spider->dbton_handler[row->dbton_id];
3053 for (
3054 field = table->field;
3055 *field;
3056 field++
3057 ) {
3058 if (dbton_hdl->minimum_select_bit_is_set((*field)->field_index))
3059 {
3060 #ifndef DBUG_OFF
3061 my_bitmap_map *tmp_map =
3062 dbug_tmp_use_all_columns(table, table->write_set);
3063 #endif
3064 if ((error_num = spider_db_fetch_row(share, *field, row, ptr_diff)))
3065 DBUG_RETURN(error_num);
3066 #ifndef DBUG_OFF
3067 dbug_tmp_restore_column_map(table->write_set, tmp_map);
3068 #endif
3069 row->next();
3070 }
3071 }
3072 #ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
3073 } else {
3074 uint32 *field_idxs = spider->hs_pushed_ret_fields;
3075 size_t field_idxs_num = spider->hs_pushed_ret_fields_num;
3076 Field *tf;
3077 int roop_count;
3078 if (spider->hs_pushed_lcl_fields_num !=
3079 result_list->hs_result->num_fields())
3080 {
3081 DBUG_PRINT("info", ("spider different field_num %zu %u",
3082 spider->hs_pushed_lcl_fields_num,
3083 result_list->hs_result->num_fields()));
3084 DBUG_RETURN(ER_SPIDER_UNKNOWN_NUM);
3085 }
3086 for (roop_count = 0; roop_count < (int) field_idxs_num;
3087 roop_count++)
3088 {
3089 tf = spider->get_top_table_field(field_idxs[roop_count]);
3090 if ((tf = spider->field_exchange(tf)))
3091 {
3092 #ifndef DBUG_OFF
3093 my_bitmap_map *tmp_map =
3094 dbug_tmp_use_all_columns(table, table->write_set);
3095 #endif
3096 if ((error_num = spider_db_fetch_row(share, tf, row, ptr_diff)))
3097 DBUG_RETURN(error_num);
3098 #ifndef DBUG_OFF
3099 dbug_tmp_restore_column_map(table->write_set, tmp_map);
3100 #endif
3101 row->next();
3102 }
3103 }
3104 }
3105 #endif
3106 }
3107 #endif
3108 table->status = 0;
3109 DBUG_RETURN(0);
3110 }
3111
spider_db_fetch_key(ha_spider * spider,uchar * buf,TABLE * table,const KEY * key_info,SPIDER_RESULT_LIST * result_list)3112 int spider_db_fetch_key(
3113 ha_spider *spider,
3114 uchar *buf,
3115 TABLE *table,
3116 const KEY *key_info,
3117 SPIDER_RESULT_LIST *result_list
3118 ) {
3119 int error_num;
3120 SPIDER_SHARE *share = spider->share;
3121 my_ptrdiff_t ptr_diff = PTR_BYTE_DIFF(buf, table->record[0]);
3122 SPIDER_RESULT *current = (SPIDER_RESULT*) result_list->current;
3123 KEY_PART_INFO *key_part;
3124 uint part_num;
3125 SPIDER_DB_ROW *row;
3126 Field *field;
3127 DBUG_ENTER("spider_db_fetch_key");
3128 if (result_list->quick_mode == 0)
3129 {
3130 SPIDER_DB_RESULT *result = current->result;
3131 if (!(row = result->fetch_row()))
3132 {
3133 table->status = STATUS_NOT_FOUND;
3134 DBUG_RETURN(HA_ERR_END_OF_FILE);
3135 }
3136 } else {
3137 if (result_list->current_row_num < result_list->quick_page_size)
3138 {
3139 if (!current->first_position)
3140 {
3141 table->status = STATUS_NOT_FOUND;
3142 DBUG_RETURN(HA_ERR_END_OF_FILE);
3143 }
3144 row = current->first_position[result_list->current_row_num].row;
3145 } else {
3146 if ((error_num = spider_db_get_row_from_tmp_tbl(
3147 current, &row)))
3148 {
3149 if (error_num == HA_ERR_END_OF_FILE)
3150 table->status = STATUS_NOT_FOUND;
3151 DBUG_RETURN(error_num);
3152 }
3153 }
3154 }
3155
3156 DBUG_PRINT("info", ("spider row=%p", row));
3157 #ifdef HANDLER_HAS_DIRECT_AGGREGATE
3158 DBUG_PRINT("info", ("spider direct_aggregate=%s",
3159 result_list->direct_aggregate ? "TRUE" : "FALSE"));
3160 result_list->snap_mrr_with_cnt = spider->mrr_with_cnt;
3161 result_list->snap_direct_aggregate = result_list->direct_aggregate;
3162 result_list->snap_row = row;
3163 #endif
3164
3165 /* for mrr */
3166 if (spider->mrr_with_cnt)
3167 {
3168 DBUG_PRINT("info", ("spider mrr_with_cnt"));
3169 if (!row->is_null())
3170 spider->multi_range_hit_point = row->val_int();
3171 #ifdef HANDLER_HAS_DIRECT_AGGREGATE
3172 else if (result_list->direct_aggregate)
3173 {
3174 table->status = STATUS_NOT_FOUND;
3175 DBUG_RETURN(HA_ERR_END_OF_FILE);
3176 }
3177 #endif
3178 else
3179 DBUG_RETURN(ER_SPIDER_UNKNOWN_NUM);
3180 row->next();
3181 }
3182
3183 #ifdef HANDLER_HAS_DIRECT_AGGREGATE
3184 /* for direct_aggregate */
3185 if (result_list->direct_aggregate)
3186 {
3187 if ((error_num = spider_db_fetch_for_item_sum_funcs(row, spider)))
3188 DBUG_RETURN(error_num);
3189 }
3190 #endif
3191
3192 if ((error_num = spider_db_append_match_fetch(spider,
3193 spider->ft_first, spider->ft_current, row)))
3194 DBUG_RETURN(error_num);
3195
3196 for (
3197 key_part = key_info->key_part,
3198 part_num = 0;
3199 part_num < spider_user_defined_key_parts(key_info);
3200 key_part++,
3201 part_num++
3202 ) {
3203 field = key_part->field;
3204 if ((
3205 bitmap_is_set(table->read_set, field->field_index) |
3206 bitmap_is_set(table->write_set, field->field_index)
3207 )) {
3208 #ifndef DBUG_OFF
3209 MY_BITMAP *tmp_map =
3210 dbug_tmp_use_all_columns(table, &table->write_set);
3211 #endif
3212 DBUG_PRINT("info", ("spider bitmap is set %s",
3213 SPIDER_field_name_str(field)));
3214 if ((error_num =
3215 spider_db_fetch_row(share, field, row, ptr_diff)))
3216 DBUG_RETURN(error_num);
3217 #ifndef DBUG_OFF
3218 dbug_tmp_restore_column_map(&table->write_set, tmp_map);
3219 #endif
3220 }
3221 row->next();
3222 }
3223 table->status = 0;
3224 DBUG_RETURN(0);
3225 }
3226
spider_db_fetch_minimum_columns(ha_spider * spider,uchar * buf,TABLE * table,SPIDER_RESULT_LIST * result_list)3227 int spider_db_fetch_minimum_columns(
3228 ha_spider *spider,
3229 uchar *buf,
3230 TABLE *table,
3231 SPIDER_RESULT_LIST *result_list
3232 ) {
3233 int error_num;
3234 my_ptrdiff_t ptr_diff = PTR_BYTE_DIFF(buf, table->record[0]);
3235 SPIDER_SHARE *share = spider->share;
3236 SPIDER_RESULT *current = (SPIDER_RESULT*) result_list->current;
3237 SPIDER_DB_ROW *row;
3238 Field **field;
3239 spider_db_handler *dbton_hdl;
3240 DBUG_ENTER("spider_db_fetch_minimum_columns");
3241 if (result_list->quick_mode == 0)
3242 {
3243 SPIDER_DB_RESULT *result = current->result;
3244 if (!(row = result->fetch_row()))
3245 {
3246 table->status = STATUS_NOT_FOUND;
3247 DBUG_RETURN(HA_ERR_END_OF_FILE);
3248 }
3249 } else {
3250 if (result_list->current_row_num < result_list->quick_page_size)
3251 {
3252 DBUG_PRINT("info", ("spider current=%p", current));
3253 DBUG_PRINT("info", ("spider first_position=%p", current->first_position));
3254 if (!current->first_position)
3255 {
3256 table->status = STATUS_NOT_FOUND;
3257 DBUG_RETURN(HA_ERR_END_OF_FILE);
3258 }
3259 DBUG_PRINT("info", ("spider current_row_num=%lld", result_list->current_row_num));
3260 DBUG_PRINT("info", ("spider first_position[]=%p", ¤t->first_position[result_list->current_row_num]));
3261 row = current->first_position[result_list->current_row_num].row;
3262 } else {
3263 if ((error_num = spider_db_get_row_from_tmp_tbl(
3264 current, &row)))
3265 {
3266 if (error_num == HA_ERR_END_OF_FILE)
3267 table->status = STATUS_NOT_FOUND;
3268 DBUG_RETURN(error_num);
3269 }
3270 }
3271 }
3272
3273 DBUG_PRINT("info", ("spider row=%p", row));
3274 #ifdef HANDLER_HAS_DIRECT_AGGREGATE
3275 DBUG_PRINT("info", ("spider direct_aggregate=%s",
3276 result_list->direct_aggregate ? "TRUE" : "FALSE"));
3277 result_list->snap_mrr_with_cnt = spider->mrr_with_cnt;
3278 result_list->snap_direct_aggregate = result_list->direct_aggregate;
3279 result_list->snap_row = row;
3280 #endif
3281
3282 /* for mrr */
3283 if (spider->mrr_with_cnt)
3284 {
3285 DBUG_PRINT("info", ("spider mrr_with_cnt"));
3286 if (!row->is_null())
3287 spider->multi_range_hit_point = row->val_int();
3288 #ifdef HANDLER_HAS_DIRECT_AGGREGATE
3289 else if (result_list->direct_aggregate)
3290 {
3291 table->status = STATUS_NOT_FOUND;
3292 DBUG_RETURN(HA_ERR_END_OF_FILE);
3293 }
3294 #endif
3295 else
3296 DBUG_RETURN(ER_SPIDER_UNKNOWN_NUM);
3297 row->next();
3298 }
3299
3300 #ifdef HANDLER_HAS_DIRECT_AGGREGATE
3301 /* for direct_aggregate */
3302 if (result_list->direct_aggregate)
3303 {
3304 if ((error_num = spider_db_fetch_for_item_sum_funcs(row, spider)))
3305 DBUG_RETURN(error_num);
3306 }
3307 #endif
3308
3309 if ((error_num = spider_db_append_match_fetch(spider,
3310 spider->ft_first, spider->ft_current, row)))
3311 DBUG_RETURN(error_num);
3312
3313 dbton_hdl = spider->dbton_handler[row->dbton_id];
3314 for (
3315 field = table->field;
3316 *field;
3317 field++
3318 ) {
3319 DBUG_PRINT("info", ("spider field_index %u", (*field)->field_index));
3320 DBUG_PRINT("info", ("spider searched_bitmap %u",
3321 spider_bit_is_set(spider->searched_bitmap, (*field)->field_index)));
3322 DBUG_PRINT("info", ("spider read_set %u",
3323 bitmap_is_set(table->read_set, (*field)->field_index)));
3324 DBUG_PRINT("info", ("spider write_set %u",
3325 bitmap_is_set(table->write_set, (*field)->field_index)));
3326 if (dbton_hdl->minimum_select_bit_is_set((*field)->field_index))
3327 {
3328 if ((
3329 bitmap_is_set(table->read_set, (*field)->field_index) |
3330 bitmap_is_set(table->write_set, (*field)->field_index)
3331 )) {
3332 #ifndef DBUG_OFF
3333 MY_BITMAP *tmp_map =
3334 dbug_tmp_use_all_columns(table, &table->write_set);
3335 #endif
3336 DBUG_PRINT("info", ("spider bitmap is set %s",
3337 SPIDER_field_name_str(*field)));
3338 if ((error_num = spider_db_fetch_row(share, *field, row, ptr_diff)))
3339 DBUG_RETURN(error_num);
3340 #ifndef DBUG_OFF
3341 dbug_tmp_restore_column_map(&table->write_set, tmp_map);
3342 #endif
3343 }
3344 row->next();
3345 }
3346 }
3347 table->status = 0;
3348 DBUG_RETURN(0);
3349 }
3350
spider_db_free_one_result_for_start_next(ha_spider * spider)3351 void spider_db_free_one_result_for_start_next(
3352 ha_spider *spider
3353 ) {
3354 SPIDER_RESULT_LIST *result_list = &spider->result_list;
3355 SPIDER_RESULT *result = (SPIDER_RESULT *) result_list->current;
3356 DBUG_ENTER("spider_db_free_one_result_for_start_next");
3357 spider_bg_all_conn_break(spider);
3358
3359 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
3360 if (spider->conn_kind[spider->result_link_idx] == SPIDER_CONN_KIND_MYSQL)
3361 {
3362 #endif
3363 if (result_list->low_mem_read)
3364 {
3365 if (result)
3366 {
3367 do {
3368 spider_db_free_one_result(result_list, result);
3369 DBUG_PRINT("info",("spider result=%p", result));
3370 DBUG_PRINT("info",("spider result->finish_flg = FALSE"));
3371 result->finish_flg = FALSE;
3372 result = (SPIDER_RESULT *) result->next;
3373 } while (result && (result->result || result->first_position));
3374 result = (SPIDER_RESULT *) result_list->current;
3375 if (
3376 !result->result &&
3377 !result->first_position &&
3378 !result->tmp_tbl_use_position
3379 )
3380 result_list->current = result->prev;
3381 }
3382 } else {
3383 while (
3384 result && result->next &&
3385 (result->next->result || result->next->first_position)
3386 ) {
3387 result_list->current = result->next;
3388 result = (SPIDER_RESULT *) result->next;
3389 }
3390 }
3391 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
3392 } else {
3393 if (result_list->hs_has_result)
3394 {
3395 if (result_list->hs_result)
3396 {
3397 result_list->hs_result->free_result();
3398 delete result_list->hs_result;
3399 result_list->hs_result = NULL;
3400 }
3401 if (result_list->hs_result_buf)
3402 {
3403 result_list->hs_result_buf->clear();
3404 }
3405 result_list->hs_has_result = FALSE;
3406 }
3407 }
3408 #endif
3409 DBUG_VOID_RETURN;
3410 }
3411
spider_db_free_one_result(SPIDER_RESULT_LIST * result_list,SPIDER_RESULT * result)3412 void spider_db_free_one_result(
3413 SPIDER_RESULT_LIST *result_list,
3414 SPIDER_RESULT *result
3415 ) {
3416 DBUG_ENTER("spider_db_free_one_result");
3417 if (result_list->quick_mode == 0)
3418 {
3419 if (
3420 !result->use_position &&
3421 result->result
3422 ) {
3423 result->result->free_result();
3424 delete result->result;
3425 result->result = NULL;
3426 }
3427 } else {
3428 int roop_count;
3429 SPIDER_POSITION *position = result->first_position;
3430 if (position)
3431 {
3432 for (roop_count = 0; roop_count < result->pos_page_size; roop_count++)
3433 {
3434 if (
3435 position[roop_count].row &&
3436 !position[roop_count].use_position
3437 ) {
3438 delete position[roop_count].row;
3439 position[roop_count].row = NULL;
3440 }
3441 }
3442 if (result_list->quick_mode == 3)
3443 {
3444 if (!result->first_pos_use_position)
3445 {
3446 spider_free(spider_current_trx, position, MYF(0));
3447 result->first_position = NULL;
3448 }
3449 if (result->result)
3450 {
3451 result->result->free_result();
3452 if (!result->tmp_tbl_use_position)
3453 {
3454 delete result->result;
3455 result->result = NULL;
3456 }
3457 }
3458 if (!result->tmp_tbl_use_position)
3459 {
3460 if (result->result_tmp_tbl)
3461 {
3462 if (result->result_tmp_tbl_inited)
3463 {
3464 result->result_tmp_tbl->file->ha_rnd_end();
3465 result->result_tmp_tbl_inited = 0;
3466 }
3467 spider_rm_sys_tmp_table_for_result(result->result_tmp_tbl_thd,
3468 result->result_tmp_tbl, &result->result_tmp_tbl_prm);
3469 result->result_tmp_tbl = NULL;
3470 result->result_tmp_tbl_thd = NULL;
3471 }
3472 }
3473 }
3474 }
3475 }
3476 DBUG_VOID_RETURN;
3477 }
3478
spider_db_free_one_quick_result(SPIDER_RESULT * result)3479 void spider_db_free_one_quick_result(
3480 SPIDER_RESULT *result
3481 ) {
3482 DBUG_ENTER("spider_db_free_one_quick_result");
3483 if (result && result->result)
3484 {
3485 result->result->free_result();
3486 if (!result->result_tmp_tbl)
3487 {
3488 delete result->result;
3489 result->result = NULL;
3490 }
3491 }
3492 DBUG_VOID_RETURN;
3493 }
3494
spider_db_free_result(ha_spider * spider,bool final)3495 int spider_db_free_result(
3496 ha_spider *spider,
3497 bool final
3498 ) {
3499 SPIDER_RESULT_LIST *result_list = &spider->result_list;
3500 SPIDER_RESULT *result;
3501 SPIDER_RESULT *prev;
3502 SPIDER_SHARE *share = spider->share;
3503 SPIDER_TRX *trx = spider->trx;
3504 SPIDER_POSITION *position;
3505 int roop_count, error_num;
3506 DBUG_ENTER("spider_db_free_result");
3507 spider_bg_all_conn_break(spider);
3508 result = (SPIDER_RESULT*) result_list->first;
3509
3510 while (result_list->tmp_pos_row_first)
3511 {
3512 SPIDER_DB_ROW *tmp_pos_row = result_list->tmp_pos_row_first;
3513 result_list->tmp_pos_row_first = tmp_pos_row->next_pos;
3514 delete tmp_pos_row;
3515 }
3516
3517 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
3518 if (result_list->hs_has_result)
3519 {
3520 if (result_list->hs_result)
3521 {
3522 result_list->hs_result->free_result();
3523 delete result_list->hs_result;
3524 result_list->hs_result = NULL;
3525 }
3526 if (result_list->hs_result_buf)
3527 {
3528 if (result_list->hs_result_buf->check_size(
3529 spider_param_hs_result_free_size(trx->thd, share->hs_result_free_size))
3530 ) {
3531 trx->hs_result_free_count++;
3532 }
3533 result_list->hs_result_buf->clear();
3534 }
3535 result_list->hs_has_result = FALSE;
3536 }
3537 #endif
3538
3539 if (
3540 final ||
3541 spider_param_reset_sql_alloc(trx->thd, share->reset_sql_alloc) == 1
3542 ) {
3543 int alloc_size = final ? 0 :
3544 (spider_param_init_sql_alloc_size(trx->thd, share->init_sql_alloc_size));
3545 while (result)
3546 {
3547 position = result->first_position;
3548 if (position)
3549 {
3550 for (roop_count = 0; roop_count < result->pos_page_size; roop_count++)
3551 {
3552 if (position[roop_count].row)
3553 {
3554 delete position[roop_count].row;
3555 }
3556 }
3557 spider_free(spider_current_trx, position, MYF(0));
3558 }
3559 if (result->result)
3560 {
3561 result->result->free_result();
3562 delete result->result;
3563 result->result = NULL;
3564 }
3565 if (result->result_tmp_tbl)
3566 {
3567 if (result->result_tmp_tbl_inited)
3568 {
3569 result->result_tmp_tbl->file->ha_rnd_end();
3570 result->result_tmp_tbl_inited = 0;
3571 }
3572 spider_rm_sys_tmp_table_for_result(result->result_tmp_tbl_thd,
3573 result->result_tmp_tbl, &result->result_tmp_tbl_prm);
3574 result->result_tmp_tbl = NULL;
3575 result->result_tmp_tbl_thd = NULL;
3576 }
3577 prev = result;
3578 result = (SPIDER_RESULT*) result->next;
3579 spider_free(spider_current_trx, prev, MYF(0));
3580 }
3581 result_list->first = NULL;
3582 result_list->last = NULL;
3583 if (!final)
3584 {
3585 ulong realloced = 0;
3586 int init_sql_alloc_size =
3587 spider_param_init_sql_alloc_size(trx->thd, share->init_sql_alloc_size);
3588 for (roop_count = 0; roop_count < (int) share->use_dbton_count;
3589 roop_count++)
3590 {
3591 uint dbton_id = share->use_dbton_ids[roop_count];
3592 if ((error_num = spider->dbton_handler[dbton_id]->
3593 realloc_sql(&realloced)))
3594 {
3595 DBUG_RETURN(error_num);
3596 }
3597 }
3598 if (realloced & (SPIDER_SQL_TYPE_SELECT_SQL | SPIDER_SQL_TYPE_HANDLER))
3599 {
3600 for (roop_count = 0; roop_count < (int) share->link_count;
3601 roop_count++)
3602 {
3603 if ((int) result_list->sqls[roop_count].alloced_length() >
3604 alloc_size * 2)
3605 {
3606 result_list->sqls[roop_count].free();
3607 if (result_list->sqls[roop_count].real_alloc(
3608 init_sql_alloc_size))
3609 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3610 }
3611 }
3612 }
3613 if (realloced & SPIDER_SQL_TYPE_INSERT_SQL)
3614 {
3615 for (roop_count = 0; roop_count < (int) share->link_count;
3616 roop_count++)
3617 {
3618 if ((int) result_list->insert_sqls[roop_count].alloced_length() >
3619 alloc_size * 2)
3620 {
3621 result_list->insert_sqls[roop_count].free();
3622 if (result_list->insert_sqls[roop_count].real_alloc(
3623 init_sql_alloc_size))
3624 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3625 }
3626 }
3627 }
3628 if (realloced & SPIDER_SQL_TYPE_UPDATE_SQL)
3629 {
3630 for (roop_count = 0; roop_count < (int) share->link_count;
3631 roop_count++)
3632 {
3633 if ((int) result_list->update_sqls[roop_count].alloced_length() >
3634 alloc_size * 2)
3635 {
3636 result_list->update_sqls[roop_count].free();
3637 if (result_list->update_sqls[roop_count].real_alloc(
3638 init_sql_alloc_size))
3639 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3640 }
3641 }
3642 }
3643 if ((error_num = spider->reset_sql_sql(SPIDER_SQL_TYPE_BULK_UPDATE_SQL)))
3644 DBUG_RETURN(error_num);
3645
3646 if (realloced & SPIDER_SQL_TYPE_TMP_SQL)
3647 {
3648 for (roop_count = 0; roop_count < (int) share->link_count;
3649 roop_count++)
3650 {
3651 if ((int) result_list->tmp_sqls[roop_count].alloced_length() >
3652 alloc_size * 2)
3653 {
3654 result_list->tmp_sqls[roop_count].free();
3655 if (result_list->tmp_sqls[roop_count].real_alloc(
3656 init_sql_alloc_size))
3657 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3658 }
3659 }
3660 }
3661 }
3662 } else {
3663 while (result)
3664 {
3665 position = result->first_position;
3666 if (position)
3667 {
3668 for (roop_count = 0; roop_count < result->pos_page_size; roop_count++)
3669 {
3670 if (position[roop_count].row)
3671 {
3672 delete position[roop_count].row;
3673 }
3674 }
3675 spider_free(spider_current_trx, position, MYF(0));
3676 }
3677 result->first_position = NULL;
3678 if (result->result)
3679 {
3680 result->result->free_result();
3681 delete result->result;
3682 result->result = NULL;
3683 }
3684 if (result->result_tmp_tbl)
3685 {
3686 if (result->result_tmp_tbl_inited)
3687 {
3688 result->result_tmp_tbl->file->ha_rnd_end();
3689 result->result_tmp_tbl_inited = 0;
3690 }
3691 spider_rm_sys_tmp_table_for_result(result->result_tmp_tbl_thd,
3692 result->result_tmp_tbl, &result->result_tmp_tbl_prm);
3693 result->result_tmp_tbl = NULL;
3694 result->result_tmp_tbl_thd = NULL;
3695 }
3696 result->record_num = 0;
3697 DBUG_PRINT("info",("spider result->finish_flg = FALSE"));
3698 result->finish_flg = FALSE;
3699 result->first_pos_use_position = FALSE;
3700 result->tmp_tbl_use_position = FALSE;
3701 result->use_position = FALSE;
3702 result = (SPIDER_RESULT*) result->next;
3703 }
3704 }
3705 result_list->current = NULL;
3706 result_list->record_num = 0;
3707 DBUG_PRINT("info",("spider result_list->finish_flg = FALSE"));
3708 result_list->finish_flg = FALSE;
3709 result_list->quick_phase = 0;
3710 #ifndef WITHOUT_SPIDER_BG_SEARCH
3711 result_list->bgs_phase = 0;
3712 #endif
3713 DBUG_RETURN(0);
3714 }
3715
spider_db_store_result(ha_spider * spider,int link_idx,TABLE * table)3716 int spider_db_store_result(
3717 ha_spider *spider,
3718 int link_idx,
3719 TABLE *table
3720 ) {
3721 int error_num;
3722 SPIDER_CONN *conn;
3723 SPIDER_DB_CONN *db_conn;
3724 SPIDER_RESULT_LIST *result_list = &spider->result_list;
3725 SPIDER_RESULT *current;
3726 DBUG_ENTER("spider_db_store_result");
3727 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
3728 if (spider->conn_kind[link_idx] == SPIDER_CONN_KIND_MYSQL)
3729 {
3730 #endif
3731 conn = spider->conns[link_idx];
3732 DBUG_PRINT("info",("spider conn->connection_id=%llu",
3733 conn->connection_id));
3734 DBUG_PRINT("info",("spider spider->connection_ids[%d]=%llu",
3735 link_idx, spider->connection_ids[link_idx]));
3736 if (conn->connection_id != spider->connection_ids[link_idx])
3737 {
3738 my_message(ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM,
3739 ER_SPIDER_REMOTE_SERVER_GONE_AWAY_STR, MYF(0));
3740 if (!conn->mta_conn_mutex_unlock_later)
3741 {
3742 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
3743 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
3744 pthread_mutex_unlock(&conn->mta_conn_mutex);
3745 }
3746 DBUG_RETURN(ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM);
3747 }
3748 db_conn = conn->db_conn;
3749 if (!result_list->current)
3750 {
3751 if (!result_list->first)
3752 {
3753 if (!(result_list->first = (SPIDER_RESULT *)
3754 spider_malloc(spider_current_trx, 4, sizeof(*result_list->first),
3755 MYF(MY_WME | MY_ZEROFILL)))
3756 ) {
3757 if (!conn->mta_conn_mutex_unlock_later)
3758 {
3759 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
3760 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
3761 pthread_mutex_unlock(&conn->mta_conn_mutex);
3762 }
3763 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3764 }
3765 TMP_TABLE_PARAM *tmp_tbl_prm = (TMP_TABLE_PARAM *)
3766 &result_list->first->result_tmp_tbl_prm;
3767 tmp_tbl_prm->init();
3768 tmp_tbl_prm->field_count = 3;
3769 result_list->last = result_list->first;
3770 result_list->current = result_list->first;
3771 } else {
3772 result_list->current = result_list->first;
3773 }
3774 result_list->bgs_current = result_list->current;
3775 current = (SPIDER_RESULT*) result_list->current;
3776 } else {
3777 if (
3778 #ifndef WITHOUT_SPIDER_BG_SEARCH
3779 result_list->bgs_phase > 0 ||
3780 #endif
3781 result_list->quick_phase > 0
3782 ) {
3783 if (result_list->bgs_current == result_list->last)
3784 {
3785 if (!(result_list->last = (SPIDER_RESULT *)
3786 spider_malloc(spider_current_trx, 5, sizeof(*result_list->last),
3787 MYF(MY_WME | MY_ZEROFILL)))
3788 ) {
3789 if (!conn->mta_conn_mutex_unlock_later)
3790 {
3791 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
3792 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
3793 pthread_mutex_unlock(&conn->mta_conn_mutex);
3794 }
3795 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3796 }
3797 TMP_TABLE_PARAM *tmp_tbl_prm = (TMP_TABLE_PARAM *)
3798 &result_list->last->result_tmp_tbl_prm;
3799 tmp_tbl_prm->init();
3800 tmp_tbl_prm->field_count = 3;
3801 result_list->bgs_current->next = result_list->last;
3802 result_list->last->prev = result_list->bgs_current;
3803 result_list->bgs_current = result_list->last;
3804 } else {
3805 result_list->bgs_current = result_list->bgs_current->next;
3806 }
3807 if (
3808 #ifndef WITHOUT_SPIDER_BG_SEARCH
3809 result_list->bgs_phase == 1 ||
3810 #endif
3811 result_list->quick_phase == 2
3812 ) {
3813 if (result_list->low_mem_read)
3814 {
3815 do {
3816 spider_db_free_one_result(result_list,
3817 (SPIDER_RESULT*) result_list->current);
3818 result_list->current = result_list->current->next;
3819 } while (result_list->current != result_list->bgs_current);
3820 } else {
3821 result_list->current = result_list->bgs_current;
3822 }
3823 result_list->quick_phase = 0;
3824 }
3825 current = (SPIDER_RESULT*) result_list->bgs_current;
3826 } else {
3827 if (result_list->current == result_list->last)
3828 {
3829 if (!(result_list->last = (SPIDER_RESULT *)
3830 spider_malloc(spider_current_trx, 6, sizeof(*result_list->last),
3831 MYF(MY_WME | MY_ZEROFILL)))
3832 ) {
3833 if (!conn->mta_conn_mutex_unlock_later)
3834 {
3835 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
3836 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
3837 pthread_mutex_unlock(&conn->mta_conn_mutex);
3838 }
3839 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3840 }
3841 TMP_TABLE_PARAM *tmp_tbl_prm = (TMP_TABLE_PARAM *)
3842 &result_list->last->result_tmp_tbl_prm;
3843 tmp_tbl_prm->init();
3844 tmp_tbl_prm->field_count = 3;
3845 result_list->current->next = result_list->last;
3846 result_list->last->prev = result_list->current;
3847 result_list->current = result_list->last;
3848 } else {
3849 result_list->current = result_list->current->next;
3850 }
3851 result_list->bgs_current = result_list->current;
3852 current = (SPIDER_RESULT*) result_list->current;
3853 }
3854 }
3855
3856 if (result_list->quick_mode == 0)
3857 {
3858 if (spider_bit_is_set(spider->db_request_phase, link_idx))
3859 {
3860 spider_clear_bit(spider->db_request_phase, link_idx);
3861 }
3862 st_spider_db_request_key request_key;
3863 request_key.spider_thread_id = spider->trx->spider_thread_id;
3864 request_key.query_id = spider->trx->thd->query_id;
3865 request_key.handler = spider;
3866 request_key.request_id = spider->db_request_id[link_idx];
3867 request_key.next = NULL;
3868 if (!(current->result = db_conn->store_result(NULL, &request_key,
3869 &error_num)))
3870 {
3871 if (error_num && error_num != HA_ERR_END_OF_FILE)
3872 {
3873 if (!conn->mta_conn_mutex_unlock_later)
3874 {
3875 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
3876 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
3877 pthread_mutex_unlock(&conn->mta_conn_mutex);
3878 }
3879 DBUG_RETURN(error_num);
3880 }
3881 bool call_db_errorno = FALSE;
3882 if (error_num != HA_ERR_END_OF_FILE)
3883 {
3884 call_db_errorno = TRUE;
3885 if ((error_num = spider_db_errorno(conn)))
3886 DBUG_RETURN(error_num);
3887 }
3888 DBUG_PRINT("info",("spider set finish_flg point 1"));
3889 DBUG_PRINT("info",("spider current->finish_flg = TRUE"));
3890 DBUG_PRINT("info",("spider result_list->finish_flg = TRUE"));
3891 current->finish_flg = TRUE;
3892 result_list->finish_flg = TRUE;
3893 #ifndef WITHOUT_SPIDER_BG_SEARCH
3894 if (result_list->bgs_phase <= 1)
3895 {
3896 #endif
3897 result_list->current_row_num = 0;
3898 table->status = STATUS_NOT_FOUND;
3899 #ifndef WITHOUT_SPIDER_BG_SEARCH
3900 }
3901 #endif
3902 if (!conn->mta_conn_mutex_unlock_later && !call_db_errorno)
3903 {
3904 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
3905 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
3906 pthread_mutex_unlock(&conn->mta_conn_mutex);
3907 }
3908 DBUG_RETURN(HA_ERR_END_OF_FILE);
3909 } else {
3910 if (!conn->mta_conn_mutex_unlock_later)
3911 {
3912 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
3913 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
3914 pthread_mutex_unlock(&conn->mta_conn_mutex);
3915 }
3916 current->record_num = current->result->num_rows();
3917 current->dbton_id = current->result->dbton_id;
3918 result_list->record_num += current->record_num;
3919 DBUG_PRINT("info",("spider current->record_num=%lld",
3920 current->record_num));
3921 DBUG_PRINT("info",("spider result_list->record_num=%lld",
3922 result_list->record_num));
3923 DBUG_PRINT("info",("spider result_list->internal_limit=%lld",
3924 result_list->internal_limit));
3925 DBUG_PRINT("info",("spider result_list->split_read=%lld",
3926 result_list->split_read));
3927 if (
3928 result_list->internal_limit <= result_list->record_num ||
3929 result_list->split_read > current->record_num
3930 ) {
3931 DBUG_PRINT("info",("spider set finish_flg point 2"));
3932 DBUG_PRINT("info",("spider current->finish_flg = TRUE"));
3933 DBUG_PRINT("info",("spider result_list->finish_flg = TRUE"));
3934 current->finish_flg = TRUE;
3935 result_list->finish_flg = TRUE;
3936 }
3937 #ifndef WITHOUT_SPIDER_BG_SEARCH
3938 if (result_list->bgs_phase <= 1)
3939 {
3940 #endif
3941 result_list->current_row_num = 0;
3942 #ifndef WITHOUT_SPIDER_BG_SEARCH
3943 }
3944 #endif
3945 }
3946 } else {
3947 /* has_result() for case of result with result_tmp_tbl */
3948 if (current->prev && current->prev->result &&
3949 current->prev->result->has_result())
3950 {
3951 current->result = current->prev->result;
3952 current->prev->result = NULL;
3953 result_list->limit_num -= current->prev->record_num;
3954 if (!conn->mta_conn_mutex_unlock_later)
3955 {
3956 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
3957 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
3958 pthread_mutex_unlock(&conn->mta_conn_mutex);
3959 }
3960 } else {
3961 if (spider_bit_is_set(spider->db_request_phase, link_idx))
3962 {
3963 spider_clear_bit(spider->db_request_phase, link_idx);
3964 }
3965 st_spider_db_request_key request_key;
3966 request_key.spider_thread_id = spider->trx->spider_thread_id;
3967 request_key.query_id = spider->trx->thd->query_id;
3968 request_key.handler = spider;
3969 request_key.request_id = spider->db_request_id[link_idx];
3970 request_key.next = NULL;
3971 if (!(current->result = conn->db_conn->use_result(&request_key,
3972 &error_num)))
3973 {
3974 if (!error_num)
3975 {
3976 error_num = spider_db_errorno(conn);
3977 } else {
3978 if (!conn->mta_conn_mutex_unlock_later)
3979 {
3980 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
3981 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
3982 pthread_mutex_unlock(&conn->mta_conn_mutex);
3983 }
3984 }
3985 DBUG_RETURN(error_num);
3986 }
3987 DBUG_PRINT("info", ("spider conn[%p]->quick_target=%p", conn, spider));
3988 conn->quick_target = spider;
3989 spider->quick_targets[link_idx] = spider;
3990 if (!conn->mta_conn_mutex_unlock_later)
3991 {
3992 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
3993 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
3994 pthread_mutex_unlock(&conn->mta_conn_mutex);
3995 }
3996 }
3997 current->dbton_id = current->result->dbton_id;
3998 SPIDER_DB_ROW *row;
3999 if (!(row = current->result->fetch_row()))
4000 {
4001 error_num = current->result->get_errno();
4002 DBUG_PRINT("info",("spider set finish_flg point 3"));
4003 DBUG_PRINT("info",("spider current->finish_flg = TRUE"));
4004 DBUG_PRINT("info",("spider result_list->finish_flg = TRUE"));
4005 current->finish_flg = TRUE;
4006 result_list->finish_flg = TRUE;
4007 current->result->free_result();
4008 delete current->result;
4009 current->result = NULL;
4010 DBUG_PRINT("info", ("spider conn[%p]->quick_target=NULL", conn));
4011 conn->quick_target = NULL;
4012 spider->quick_targets[link_idx] = NULL;
4013 if (
4014 #ifndef WITHOUT_SPIDER_BG_SEARCH
4015 result_list->bgs_phase <= 1 &&
4016 #endif
4017 result_list->quick_phase == 0
4018 ) {
4019 result_list->current_row_num = 0;
4020 table->status = STATUS_NOT_FOUND;
4021 }
4022 if (error_num)
4023 DBUG_RETURN(error_num);
4024 else if (result_list->quick_phase > 0)
4025 DBUG_RETURN(0);
4026 DBUG_RETURN(HA_ERR_END_OF_FILE);
4027 }
4028 SPIDER_DB_ROW *tmp_row;
4029 uint field_count = current->result->num_fields();
4030 SPIDER_POSITION *position;
4031 longlong page_size;
4032 int roop_count = 0;
4033 if (!result_list->quick_page_size)
4034 {
4035 if (result_list->quick_mode == 3)
4036 {
4037 page_size = 0;
4038 } else {
4039 result_list->quick_page_size = result_list->limit_num;
4040 page_size = result_list->limit_num;
4041 }
4042 } else {
4043 page_size =
4044 result_list->limit_num < result_list->quick_page_size ?
4045 result_list->limit_num : result_list->quick_page_size;
4046 }
4047 current->field_count = field_count;
4048 if (!(position = (SPIDER_POSITION *)
4049 spider_bulk_malloc(spider_current_trx, 7, MYF(MY_WME | MY_ZEROFILL),
4050 &position, sizeof(SPIDER_POSITION) * page_size,
4051 &tmp_row, sizeof(char*) * field_count,
4052 NullS))
4053 )
4054 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4055 current->pos_page_size = (int) page_size;
4056 current->first_position = position;
4057 current->tmp_tbl_row = tmp_row;
4058 if (result_list->quick_mode == 3)
4059 {
4060 while (page_size > roop_count && row)
4061 {
4062 if (result_list->quick_page_byte < row->get_byte_size())
4063 {
4064 current->pos_page_size = roop_count;
4065 page_size = roop_count;
4066 result_list->quick_page_size = roop_count;
4067 result_list->quick_page_byte = 0;
4068 break;
4069 } else {
4070 result_list->quick_page_byte -= row->get_byte_size();
4071 }
4072 if (!(position->row = row->clone()))
4073 {
4074 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4075 }
4076 position++;
4077 roop_count++;
4078 row = current->result->fetch_row();
4079 }
4080 } else {
4081 do {
4082 if (!(position->row = row->clone()))
4083 {
4084 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4085 }
4086 position++;
4087 roop_count++;
4088 if (result_list->quick_page_byte < row->get_byte_size())
4089 {
4090 current->pos_page_size = roop_count;
4091 page_size = roop_count;
4092 result_list->quick_page_size = roop_count;
4093 result_list->quick_page_byte = 0;
4094 break;
4095 } else {
4096 result_list->quick_page_byte -= row->get_byte_size();
4097 }
4098 } while (
4099 page_size > roop_count &&
4100 (row = current->result->fetch_row())
4101 );
4102 }
4103 if (
4104 result_list->quick_mode == 3 &&
4105 page_size == roop_count &&
4106 result_list->limit_num > roop_count &&
4107 row
4108 ) {
4109 THD *thd = current_thd;
4110 char buf[MAX_FIELD_WIDTH];
4111 spider_string tmp_str(buf, MAX_FIELD_WIDTH, &my_charset_bin);
4112 tmp_str.init_calc_mem(120);
4113
4114 DBUG_PRINT("info",("spider store result to temporary table"));
4115 DBUG_ASSERT(!current->result_tmp_tbl);
4116 #ifdef SPIDER_use_LEX_CSTRING_for_Field_blob_constructor
4117 LEX_CSTRING field_name1 = {STRING_WITH_LEN("a")};
4118 LEX_CSTRING field_name2 = {STRING_WITH_LEN("b")};
4119 LEX_CSTRING field_name3 = {STRING_WITH_LEN("c")};
4120 if (!(current->result_tmp_tbl = spider_mk_sys_tmp_table_for_result(
4121 thd, table, ¤t->result_tmp_tbl_prm, &field_name1, &field_name2,
4122 &field_name3, &my_charset_bin)))
4123 #else
4124 if (!(current->result_tmp_tbl = spider_mk_sys_tmp_table_for_result(
4125 thd, table, ¤t->result_tmp_tbl_prm, "a", "b", "c",
4126 &my_charset_bin)))
4127 #endif
4128 {
4129 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4130 }
4131 current->result_tmp_tbl_thd = thd;
4132 TABLE *tmp_tbl = current->result_tmp_tbl;
4133 tmp_tbl->file->extra(HA_EXTRA_WRITE_CACHE);
4134 tmp_tbl->file->ha_start_bulk_insert((ha_rows) 0);
4135 do {
4136 if ((error_num = row->store_to_tmp_table(tmp_tbl, &tmp_str)))
4137 {
4138 tmp_tbl->file->ha_end_bulk_insert();
4139 DBUG_RETURN(error_num);
4140 }
4141 roop_count++;
4142 } while (
4143 result_list->limit_num > roop_count &&
4144 (row = current->result->fetch_row())
4145 );
4146 tmp_tbl->file->ha_end_bulk_insert();
4147 page_size = result_list->limit_num;
4148 }
4149 current->record_num = roop_count;
4150 result_list->record_num += roop_count;
4151 if (
4152 result_list->internal_limit <= result_list->record_num ||
4153 page_size > roop_count ||
4154 (
4155 result_list->quick_mode == 3 &&
4156 result_list->limit_num > roop_count
4157 )
4158 ) {
4159 DBUG_PRINT("info",("spider set finish_flg point 4"));
4160 DBUG_PRINT("info",("spider current->finish_flg = TRUE"));
4161 DBUG_PRINT("info",("spider result_list->finish_flg = TRUE"));
4162 current->finish_flg = TRUE;
4163 result_list->finish_flg = TRUE;
4164 current->result->free_result();
4165 if (!current->result_tmp_tbl)
4166 {
4167 delete current->result;
4168 current->result = NULL;
4169 }
4170 DBUG_PRINT("info", ("spider conn[%p]->quick_target=NULL", conn));
4171 conn->quick_target = NULL;
4172 spider->quick_targets[link_idx] = NULL;
4173 } else if (
4174 result_list->quick_mode == 3 ||
4175 result_list->limit_num == roop_count
4176 ) {
4177 current->result->free_result();
4178 if (!current->result_tmp_tbl)
4179 {
4180 delete current->result;
4181 current->result = NULL;
4182 }
4183 DBUG_PRINT("info", ("spider conn[%p]->quick_target=NULL", conn));
4184 conn->quick_target = NULL;
4185 spider->quick_targets[link_idx] = NULL;
4186 }
4187 #ifndef WITHOUT_SPIDER_BG_SEARCH
4188 DBUG_PRINT("info", ("spider bgs_phase=%d", result_list->bgs_phase));
4189 #endif
4190 DBUG_PRINT("info", ("spider quick_phase=%d", result_list->quick_phase));
4191 if (
4192 #ifndef WITHOUT_SPIDER_BG_SEARCH
4193 result_list->bgs_phase <= 1 &&
4194 #endif
4195 result_list->quick_phase == 0
4196 ) {
4197 result_list->current_row_num = 0;
4198 }
4199 DBUG_PRINT("info", ("spider result_list->current=%p", result_list->current));
4200 DBUG_PRINT("info", ("spider current=%p", current));
4201 DBUG_PRINT("info", ("spider first_position=%p", current->first_position));
4202 DBUG_PRINT("info", ("spider current_row_num=%lld", result_list->current_row_num));
4203 DBUG_PRINT("info", ("spider first_position[]=%p", ¤t->first_position[result_list->current_row_num]));
4204 DBUG_PRINT("info", ("spider row=%p", current->first_position[result_list->current_row_num].row));
4205 }
4206 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
4207 } else {
4208 if (spider->conn_kind[link_idx] == SPIDER_CONN_KIND_HS_READ)
4209 conn = spider->hs_r_conns[link_idx];
4210 else
4211 conn = spider->hs_w_conns[link_idx];
4212 DBUG_PRINT("info",("spider conn=%p", conn));
4213 DBUG_PRINT("info",("spider conn->connection_id=%llu",
4214 conn->connection_id));
4215 DBUG_PRINT("info",("spider spider->connection_ids[%d]=%llu",
4216 link_idx, spider->connection_ids[link_idx]));
4217 if (conn->connection_id != spider->connection_ids[link_idx])
4218 {
4219 my_message(ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM,
4220 ER_SPIDER_REMOTE_SERVER_GONE_AWAY_STR, MYF(0));
4221 if (!conn->mta_conn_mutex_unlock_later)
4222 {
4223 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
4224 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
4225 pthread_mutex_unlock(&conn->mta_conn_mutex);
4226 }
4227 DBUG_RETURN(ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM);
4228 }
4229 if (spider_bit_is_set(spider->db_request_phase, link_idx))
4230 {
4231 spider_clear_bit(spider->db_request_phase, link_idx);
4232 }
4233 st_spider_db_request_key request_key;
4234 request_key.spider_thread_id = spider->trx->spider_thread_id;
4235 request_key.query_id = spider->trx->thd->query_id;
4236 request_key.handler = spider;
4237 request_key.request_id = spider->db_request_id[link_idx];
4238 request_key.next = NULL;
4239 if (!(result_list->hs_result = conn->db_conn->store_result(
4240 &result_list->hs_result_buf, &request_key, &error_num)))
4241 {
4242 if (!error_num)
4243 {
4244 spider_db_errorno(conn);
4245 DBUG_RETURN(ER_SPIDER_HS_NUM);
4246 } else {
4247 if (!conn->mta_conn_mutex_unlock_later)
4248 {
4249 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
4250 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
4251 pthread_mutex_unlock(&conn->mta_conn_mutex);
4252 }
4253 }
4254 DBUG_RETURN(error_num);
4255 }
4256 result_list->hs_conn = conn->db_conn;
4257 result_list->hs_has_result = TRUE;
4258 if (!conn->mta_conn_mutex_unlock_later)
4259 {
4260 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
4261 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
4262 pthread_mutex_unlock(&conn->mta_conn_mutex);
4263 }
4264 }
4265 #endif
4266 DBUG_RETURN(0);
4267 }
4268
spider_db_discard_result(ha_spider * spider,int link_idx,SPIDER_CONN * conn)4269 void spider_db_discard_result(
4270 ha_spider *spider,
4271 int link_idx,
4272 SPIDER_CONN *conn
4273 ) {
4274 int error_num;
4275 SPIDER_DB_RESULT *result;
4276 DBUG_ENTER("spider_db_discard_result");
4277 if (spider_bit_is_set(spider->db_request_phase, link_idx))
4278 {
4279 spider_clear_bit(spider->db_request_phase, link_idx);
4280 }
4281 st_spider_db_request_key request_key;
4282 request_key.spider_thread_id = spider->trx->spider_thread_id;
4283 request_key.query_id = spider->trx->thd->query_id;
4284 request_key.handler = spider;
4285 request_key.request_id = spider->db_request_id[link_idx];
4286 request_key.next = NULL;
4287 if ((result = conn->db_conn->use_result(&request_key, &error_num)))
4288 {
4289 result->free_result();
4290 delete result;
4291 }
4292 DBUG_VOID_RETURN;
4293 }
4294
spider_db_discard_multiple_result(ha_spider * spider,int link_idx,SPIDER_CONN * conn)4295 void spider_db_discard_multiple_result(
4296 ha_spider *spider,
4297 int link_idx,
4298 SPIDER_CONN *conn
4299 ) {
4300 int error_num;
4301 SPIDER_DB_RESULT *result;
4302 st_spider_db_request_key request_key;
4303 DBUG_ENTER("spider_db_discard_multiple_result");
4304 if (spider_bit_is_set(spider->db_request_phase, link_idx))
4305 {
4306 spider_clear_bit(spider->db_request_phase, link_idx);
4307 }
4308 request_key.spider_thread_id = spider->trx->spider_thread_id;
4309 request_key.query_id = spider->trx->thd->query_id;
4310 request_key.handler = spider;
4311 request_key.request_id = spider->db_request_id[link_idx];
4312 request_key.next = NULL;
4313 do
4314 {
4315 if (!conn->db_conn->cmp_request_key_to_snd(&request_key))
4316 break;
4317 if ((result = conn->db_conn->use_result(&request_key, &error_num)))
4318 {
4319 result->free_result();
4320 delete result;
4321 }
4322 } while (!conn->db_conn->next_result());
4323 DBUG_VOID_RETURN;
4324 }
4325
4326 #ifdef HA_CAN_BULK_ACCESS
spider_db_bulk_store_result(ha_spider * spider,SPIDER_CONN * conn,int link_idx,bool discard_result)4327 int spider_db_bulk_store_result(
4328 ha_spider *spider,
4329 SPIDER_CONN *conn,
4330 int link_idx,
4331 bool discard_result
4332 ) {
4333 int error_num, tmp_error_num;
4334 DBUG_ENTER("spider_db_bulk_store_result");
4335 DBUG_PRINT("info",("spider spider=%p", spider));
4336 DBUG_PRINT("info",("spider conn=%p", conn));
4337 DBUG_PRINT("info",("spider link_idx=%d", link_idx));
4338 if (conn->conn_kind == SPIDER_CONN_KIND_MYSQL)
4339 {
4340 /* already stored */
4341 DBUG_RETURN(0);
4342 }
4343 error_num = spider_db_bulk_open_handler(spider, conn, link_idx);
4344 if (!discard_result)
4345 {
4346 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
4347 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
4348 conn->mta_conn_mutex_unlock_later = TRUE;
4349 if ((tmp_error_num = spider_db_store_result(spider, link_idx,
4350 spider->get_table())))
4351 {
4352 error_num = tmp_error_num;
4353 }
4354 conn->mta_conn_mutex_unlock_later = FALSE;
4355 } else {
4356 if (spider->connection_ids[link_idx] == conn->connection_id)
4357 spider_db_discard_result(spider, link_idx, conn);
4358 }
4359 DBUG_RETURN(error_num);
4360 }
4361 #endif
4362
spider_db_fetch(uchar * buf,ha_spider * spider,TABLE * table)4363 int spider_db_fetch(
4364 uchar *buf,
4365 ha_spider *spider,
4366 TABLE *table
4367 ) {
4368 int error_num;
4369 SPIDER_RESULT_LIST *result_list = &spider->result_list;
4370 DBUG_ENTER("spider_db_fetch");
4371 if (spider->sql_kind[spider->result_link_idx] == SPIDER_SQL_KIND_SQL)
4372 {
4373 if (!spider->select_column_mode) {
4374 if (result_list->keyread)
4375 error_num = spider_db_fetch_key(spider, buf, table,
4376 result_list->key_info, result_list);
4377 else
4378 error_num = spider_db_fetch_table(spider, buf, table,
4379 result_list);
4380 } else
4381 error_num = spider_db_fetch_minimum_columns(spider, buf, table,
4382 result_list);
4383 } else {
4384 error_num = spider_db_fetch_table(spider, buf, table,
4385 result_list);
4386 }
4387 result_list->current_row_num++;
4388 DBUG_PRINT("info",("spider error_num=%d", error_num));
4389 spider->pushed_pos = NULL;
4390 DBUG_RETURN(error_num);
4391 }
4392
spider_db_seek_prev(uchar * buf,ha_spider * spider,TABLE * table)4393 int spider_db_seek_prev(
4394 uchar *buf,
4395 ha_spider *spider,
4396 TABLE *table
4397 ) {
4398 SPIDER_RESULT_LIST *result_list = &spider->result_list;
4399 DBUG_ENTER("spider_db_seek_prev");
4400 if (result_list->current_row_num <= 1)
4401 {
4402 if (result_list->current == result_list->first)
4403 {
4404 table->status = STATUS_NOT_FOUND;
4405 DBUG_RETURN(HA_ERR_END_OF_FILE);
4406 }
4407 if (result_list->low_mem_read == 1)
4408 {
4409 my_message(ER_SPIDER_LOW_MEM_READ_PREV_NUM,
4410 ER_SPIDER_LOW_MEM_READ_PREV_STR, MYF(0));
4411 DBUG_RETURN(ER_SPIDER_LOW_MEM_READ_PREV_NUM);
4412 }
4413 result_list->current = result_list->current->prev;
4414 result_list->current_row_num = result_list->current->record_num - 1;
4415 } else {
4416 result_list->current_row_num -= 2;
4417 }
4418 if (result_list->quick_mode == 0)
4419 result_list->current->result->move_to_pos(result_list->current_row_num);
4420 DBUG_RETURN(spider_db_fetch(buf, spider, table));
4421 }
4422
spider_db_seek_next(uchar * buf,ha_spider * spider,int link_idx,TABLE * table)4423 int spider_db_seek_next(
4424 uchar *buf,
4425 ha_spider *spider,
4426 int link_idx,
4427 TABLE *table
4428 ) {
4429 int error_num;
4430 SPIDER_SHARE *share = spider->share;
4431 SPIDER_CONN *conn = spider->conns[link_idx];
4432 SPIDER_RESULT_LIST *result_list = &spider->result_list;
4433 DBUG_ENTER("spider_db_seek_next");
4434 if (
4435 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
4436 spider->conn_kind[spider->result_link_idx] == SPIDER_CONN_KIND_MYSQL &&
4437 #endif
4438 result_list->current_row_num >= result_list->current->record_num
4439 ) {
4440 DBUG_PRINT("info",("spider result_list->current_row_num=%lld",
4441 result_list->current_row_num));
4442 DBUG_PRINT("info",("spider result_list->current->record_num=%lld",
4443 result_list->current->record_num));
4444 if (result_list->low_mem_read)
4445 spider_db_free_one_result(result_list,
4446 (SPIDER_RESULT*) result_list->current);
4447
4448 int roop_start = 0, roop_end = 1, roop_count, lock_mode, link_ok = 0;
4449 #ifdef SPIDER_HAS_GROUP_BY_HANDLER
4450 if (!spider->use_fields)
4451 {
4452 #endif
4453 lock_mode = spider_conn_lock_mode(spider);
4454 if (lock_mode)
4455 {
4456 /* "for update" or "lock in share mode" */
4457 link_ok = spider_conn_link_idx_next(share->link_statuses,
4458 spider->conn_link_idx, -1, share->link_count,
4459 SPIDER_LINK_STATUS_OK);
4460 roop_start = spider_conn_link_idx_next(share->link_statuses,
4461 spider->conn_link_idx, -1, share->link_count,
4462 SPIDER_LINK_STATUS_RECOVERY);
4463 roop_end = spider->share->link_count;
4464 } else {
4465 link_ok = link_idx;
4466 roop_start = link_idx;
4467 roop_end = link_idx + 1;
4468 }
4469 #ifdef SPIDER_HAS_GROUP_BY_HANDLER
4470 }
4471 #endif
4472
4473 #ifndef WITHOUT_SPIDER_BG_SEARCH
4474 if (result_list->bgs_phase > 0)
4475 {
4476 #ifdef SPIDER_HAS_GROUP_BY_HANDLER
4477 if (spider->use_fields)
4478 {
4479 SPIDER_LINK_IDX_CHAIN *link_idx_chain;
4480 SPIDER_LINK_IDX_HOLDER *link_idx_holder;
4481 spider_fields *fields = spider->fields;
4482 fields->set_pos_to_first_link_idx_chain();
4483 while ((link_idx_chain = fields->get_next_link_idx_chain()))
4484 {
4485 conn = link_idx_chain->conn;
4486 link_idx_holder = link_idx_chain->link_idx_holder;
4487 spider_db_handler *dbton_hdl =
4488 spider->dbton_handler[conn->dbton_id];
4489 spider->link_idx_chain = link_idx_chain;
4490 if ((error_num = spider_bg_conn_search(spider,
4491 link_idx_holder->link_idx, dbton_hdl->first_link_idx,
4492 FALSE, FALSE,
4493 !fields->is_first_link_ok_chain(link_idx_chain))))
4494 {
4495 DBUG_PRINT("info",("spider error_num 1=%d", error_num));
4496 DBUG_RETURN(error_num);
4497 }
4498 }
4499 } else {
4500 #endif
4501 for (roop_count = roop_start; roop_count < roop_end;
4502 roop_count = spider_conn_link_idx_next(share->link_statuses,
4503 spider->conn_link_idx, roop_count, share->link_count,
4504 SPIDER_LINK_STATUS_RECOVERY)
4505 ) {
4506 if ((error_num = spider_bg_conn_search(spider, roop_count, roop_start,
4507 FALSE, FALSE, (roop_count != link_ok))))
4508 {
4509 DBUG_PRINT("info",("spider error_num 1=%d", error_num));
4510 DBUG_RETURN(error_num);
4511 }
4512 }
4513 #ifdef SPIDER_HAS_GROUP_BY_HANDLER
4514 }
4515 #endif
4516 } else {
4517 #endif
4518 if (result_list->current == result_list->bgs_current)
4519 {
4520 if (result_list->finish_flg)
4521 {
4522 table->status = STATUS_NOT_FOUND;
4523 DBUG_PRINT("info",("spider error_num 2=%d", HA_ERR_END_OF_FILE));
4524 DBUG_RETURN(HA_ERR_END_OF_FILE);
4525 }
4526 spider_next_split_read_param(spider);
4527 if (
4528 result_list->quick_mode == 0 ||
4529 result_list->quick_mode == 3 ||
4530 !result_list->current->result
4531 ) {
4532 result_list->limit_num =
4533 result_list->internal_limit - result_list->record_num >=
4534 result_list->split_read ?
4535 result_list->split_read :
4536 result_list->internal_limit - result_list->record_num;
4537 if (spider->sql_kinds & SPIDER_SQL_KIND_SQL)
4538 {
4539 if ((error_num = spider->reappend_limit_sql_part(
4540 result_list->record_num, result_list->limit_num,
4541 SPIDER_SQL_TYPE_SELECT_SQL)))
4542 {
4543 DBUG_PRINT("info",("spider error_num 3=%d", error_num));
4544 DBUG_RETURN(error_num);
4545 }
4546 if (
4547 !result_list->use_union &&
4548 (error_num = spider->append_select_lock_sql_part(
4549 SPIDER_SQL_TYPE_SELECT_SQL))
4550 ) {
4551 DBUG_PRINT("info",("spider error_num 4=%d", error_num));
4552 DBUG_RETURN(error_num);
4553 }
4554 }
4555 if (spider->sql_kinds & SPIDER_SQL_KIND_HANDLER)
4556 {
4557 spider_db_append_handler_next(spider);
4558 if ((error_num = spider->reappend_limit_sql_part(
4559 0, result_list->limit_num,
4560 SPIDER_SQL_TYPE_HANDLER)))
4561 {
4562 DBUG_PRINT("info",("spider error_num 5=%d", error_num));
4563 DBUG_RETURN(error_num);
4564 }
4565 }
4566
4567 #ifdef SPIDER_HAS_GROUP_BY_HANDLER
4568 if (spider->use_fields)
4569 {
4570 SPIDER_LINK_IDX_CHAIN *link_idx_chain;
4571 SPIDER_LINK_IDX_HOLDER *link_idx_holder;
4572 spider_fields *fields = spider->fields;
4573 fields->set_pos_to_first_link_idx_chain();
4574 while ((link_idx_chain = fields->get_next_link_idx_chain()))
4575 {
4576 ulong sql_type;
4577 conn = link_idx_chain->conn;
4578 sql_type = SPIDER_SQL_TYPE_SELECT_SQL;
4579 link_idx_holder = link_idx_chain->link_idx_holder;
4580 link_idx = link_idx_holder->link_idx;
4581 spider_db_handler *dbton_handler =
4582 spider->dbton_handler[conn->dbton_id];
4583 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
4584 if (dbton_handler->need_lock_before_set_sql_for_exec(sql_type))
4585 {
4586 pthread_mutex_lock(&conn->mta_conn_mutex);
4587 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
4588 }
4589 if ((error_num = dbton_handler->set_sql_for_exec(sql_type,
4590 link_idx)))
4591 {
4592 if (dbton_handler->need_lock_before_set_sql_for_exec(sql_type))
4593 {
4594 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
4595 pthread_mutex_unlock(&conn->mta_conn_mutex);
4596 }
4597 DBUG_PRINT("info",("spider error_num 6=%d", error_num));
4598 DBUG_RETURN(error_num);
4599 }
4600 if (!dbton_handler->need_lock_before_set_sql_for_exec(sql_type))
4601 {
4602 pthread_mutex_lock(&conn->mta_conn_mutex);
4603 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
4604 }
4605 conn->need_mon = &spider->need_mons[link_idx];
4606 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
4607 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
4608 conn->mta_conn_mutex_lock_already = TRUE;
4609 conn->mta_conn_mutex_unlock_later = TRUE;
4610 if ((error_num = spider_db_set_names(spider, conn, link_idx)))
4611 {
4612 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
4613 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
4614 conn->mta_conn_mutex_lock_already = FALSE;
4615 conn->mta_conn_mutex_unlock_later = FALSE;
4616 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
4617 pthread_mutex_unlock(&conn->mta_conn_mutex);
4618 if (
4619 spider->need_mons[link_idx]
4620 ) {
4621 error_num = fields->ping_table_mon_from_table(link_idx_chain);
4622 }
4623 DBUG_PRINT("info",("spider error_num 7a=%d", error_num));
4624 DBUG_RETURN(error_num);
4625 }
4626 spider_conn_set_timeout_from_share(conn, link_idx,
4627 spider->trx->thd, share);
4628 if (dbton_handler->execute_sql(
4629 sql_type,
4630 conn,
4631 result_list->quick_mode,
4632 &spider->need_mons[link_idx])
4633 ) {
4634 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
4635 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
4636 conn->mta_conn_mutex_lock_already = FALSE;
4637 conn->mta_conn_mutex_unlock_later = FALSE;
4638 error_num = spider_db_errorno(conn);
4639 if (
4640 spider->need_mons[link_idx]
4641 ) {
4642 error_num = fields->ping_table_mon_from_table(link_idx_chain);
4643 }
4644 DBUG_PRINT("info",("spider error_num 8a=%d", error_num));
4645 DBUG_RETURN(error_num);
4646 }
4647 spider->connection_ids[link_idx] = conn->connection_id;
4648 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
4649 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
4650 conn->mta_conn_mutex_lock_already = FALSE;
4651 conn->mta_conn_mutex_unlock_later = FALSE;
4652 if (fields->is_first_link_ok_chain(link_idx_chain))
4653 {
4654 if ((error_num = spider_db_store_result(spider, link_idx,
4655 table)))
4656 {
4657 if (
4658 error_num != HA_ERR_END_OF_FILE &&
4659 spider->need_mons[link_idx]
4660 ) {
4661 error_num =
4662 fields->ping_table_mon_from_table(link_idx_chain);
4663 }
4664 DBUG_PRINT("info",("spider error_num 9a=%d", error_num));
4665 DBUG_RETURN(error_num);
4666 }
4667 spider->result_link_idx = link_ok;
4668 } else {
4669 spider_db_discard_result(spider, link_idx, conn);
4670 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
4671 pthread_mutex_unlock(&conn->mta_conn_mutex);
4672 }
4673 }
4674 } else {
4675 #endif
4676 for (roop_count = roop_start; roop_count < roop_end;
4677 roop_count = spider_conn_link_idx_next(share->link_statuses,
4678 spider->conn_link_idx, roop_count, share->link_count,
4679 SPIDER_LINK_STATUS_RECOVERY)
4680 ) {
4681 ulong sql_type;
4682 conn = spider->conns[roop_count];
4683 if (spider->sql_kind[roop_count] == SPIDER_SQL_KIND_SQL)
4684 {
4685 sql_type = SPIDER_SQL_TYPE_SELECT_SQL;
4686 } else {
4687 sql_type = SPIDER_SQL_TYPE_HANDLER;
4688 }
4689 spider_db_handler *dbton_handler =
4690 spider->dbton_handler[conn->dbton_id];
4691 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
4692 if (dbton_handler->need_lock_before_set_sql_for_exec(sql_type))
4693 {
4694 pthread_mutex_lock(&conn->mta_conn_mutex);
4695 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
4696 }
4697 if ((error_num = dbton_handler->set_sql_for_exec(sql_type,
4698 roop_count)))
4699 {
4700 if (dbton_handler->need_lock_before_set_sql_for_exec(sql_type))
4701 {
4702 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
4703 pthread_mutex_unlock(&conn->mta_conn_mutex);
4704 }
4705 DBUG_PRINT("info",("spider error_num 6=%d", error_num));
4706 DBUG_RETURN(error_num);
4707 }
4708 if (!dbton_handler->need_lock_before_set_sql_for_exec(sql_type))
4709 {
4710 pthread_mutex_lock(&conn->mta_conn_mutex);
4711 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
4712 }
4713 conn->need_mon = &spider->need_mons[roop_count];
4714 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
4715 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
4716 conn->mta_conn_mutex_lock_already = TRUE;
4717 conn->mta_conn_mutex_unlock_later = TRUE;
4718 if ((error_num = spider_db_set_names(spider, conn, roop_count)))
4719 {
4720 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
4721 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
4722 conn->mta_conn_mutex_lock_already = FALSE;
4723 conn->mta_conn_mutex_unlock_later = FALSE;
4724 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
4725 pthread_mutex_unlock(&conn->mta_conn_mutex);
4726 if (
4727 share->monitoring_kind[roop_count] &&
4728 spider->need_mons[roop_count]
4729 ) {
4730 error_num = spider_ping_table_mon_from_table(
4731 spider->trx,
4732 spider->trx->thd,
4733 share,
4734 roop_count,
4735 (uint32) share->monitoring_sid[roop_count],
4736 share->table_name,
4737 share->table_name_length,
4738 spider->conn_link_idx[roop_count],
4739 NULL,
4740 0,
4741 share->monitoring_kind[roop_count],
4742 share->monitoring_limit[roop_count],
4743 share->monitoring_flag[roop_count],
4744 TRUE
4745 );
4746 }
4747 DBUG_PRINT("info",("spider error_num 7=%d", error_num));
4748 DBUG_RETURN(error_num);
4749 }
4750 spider_conn_set_timeout_from_share(conn, roop_count,
4751 spider->trx->thd, share);
4752 if (dbton_handler->execute_sql(
4753 sql_type,
4754 conn,
4755 result_list->quick_mode,
4756 &spider->need_mons[roop_count])
4757 ) {
4758 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
4759 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
4760 conn->mta_conn_mutex_lock_already = FALSE;
4761 conn->mta_conn_mutex_unlock_later = FALSE;
4762 error_num = spider_db_errorno(conn);
4763 if (
4764 share->monitoring_kind[roop_count] &&
4765 spider->need_mons[roop_count]
4766 ) {
4767 error_num = spider_ping_table_mon_from_table(
4768 spider->trx,
4769 spider->trx->thd,
4770 share,
4771 roop_count,
4772 (uint32) share->monitoring_sid[roop_count],
4773 share->table_name,
4774 share->table_name_length,
4775 spider->conn_link_idx[roop_count],
4776 NULL,
4777 0,
4778 share->monitoring_kind[roop_count],
4779 share->monitoring_limit[roop_count],
4780 share->monitoring_flag[roop_count],
4781 TRUE
4782 );
4783 }
4784 DBUG_PRINT("info",("spider error_num 8=%d", error_num));
4785 DBUG_RETURN(error_num);
4786 }
4787 spider->connection_ids[roop_count] = conn->connection_id;
4788 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
4789 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
4790 conn->mta_conn_mutex_lock_already = FALSE;
4791 conn->mta_conn_mutex_unlock_later = FALSE;
4792 if (roop_count == link_ok)
4793 {
4794 if ((error_num = spider_db_store_result(spider, roop_count,
4795 table)))
4796 {
4797 if (
4798 error_num != HA_ERR_END_OF_FILE &&
4799 share->monitoring_kind[roop_count] &&
4800 spider->need_mons[roop_count]
4801 ) {
4802 error_num = spider_ping_table_mon_from_table(
4803 spider->trx,
4804 spider->trx->thd,
4805 share,
4806 roop_count,
4807 (uint32) share->monitoring_sid[roop_count],
4808 share->table_name,
4809 share->table_name_length,
4810 spider->conn_link_idx[roop_count],
4811 NULL,
4812 0,
4813 share->monitoring_kind[roop_count],
4814 share->monitoring_limit[roop_count],
4815 share->monitoring_flag[roop_count],
4816 TRUE
4817 );
4818 }
4819 DBUG_PRINT("info",("spider error_num 9=%d", error_num));
4820 DBUG_RETURN(error_num);
4821 }
4822 spider->result_link_idx = link_ok;
4823 } else {
4824 spider_db_discard_result(spider, roop_count, conn);
4825 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
4826 pthread_mutex_unlock(&conn->mta_conn_mutex);
4827 }
4828 }
4829 #ifdef SPIDER_HAS_GROUP_BY_HANDLER
4830 }
4831 #endif
4832 } else {
4833 spider->connection_ids[link_idx] = conn->connection_id;
4834 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
4835 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
4836 conn->mta_conn_mutex_unlock_later = TRUE;
4837 if ((error_num = spider_db_store_result(spider, link_idx, table)))
4838 {
4839 conn->mta_conn_mutex_unlock_later = FALSE;
4840 DBUG_PRINT("info",("spider error_num 10=%d", error_num));
4841 DBUG_RETURN(error_num);
4842 }
4843 conn->mta_conn_mutex_unlock_later = FALSE;
4844 }
4845 } else {
4846 result_list->current = result_list->current->next;
4847 result_list->current_row_num = 0;
4848 if (
4849 result_list->current == result_list->bgs_current &&
4850 result_list->finish_flg
4851 ) {
4852 table->status = STATUS_NOT_FOUND;
4853 DBUG_PRINT("info",("spider error_num 11=%d", HA_ERR_END_OF_FILE));
4854 DBUG_RETURN(HA_ERR_END_OF_FILE);
4855 }
4856 }
4857 #ifndef WITHOUT_SPIDER_BG_SEARCH
4858 }
4859 #endif
4860 DBUG_RETURN(spider_db_fetch(buf, spider, table));
4861 } else
4862 DBUG_RETURN(spider_db_fetch(buf, spider, table));
4863 }
4864
spider_db_seek_last(uchar * buf,ha_spider * spider,int link_idx,TABLE * table)4865 int spider_db_seek_last(
4866 uchar *buf,
4867 ha_spider *spider,
4868 int link_idx,
4869 TABLE *table
4870 ) {
4871 int error_num;
4872 SPIDER_SHARE *share = spider->share;
4873 SPIDER_CONN *conn;
4874 SPIDER_RESULT_LIST *result_list = &spider->result_list;
4875 DBUG_ENTER("spider_db_seek_last");
4876 if (result_list->finish_flg)
4877 {
4878 if (result_list->low_mem_read == 1)
4879 {
4880 my_message(ER_SPIDER_LOW_MEM_READ_PREV_NUM,
4881 ER_SPIDER_LOW_MEM_READ_PREV_STR, MYF(0));
4882 DBUG_RETURN(ER_SPIDER_LOW_MEM_READ_PREV_NUM);
4883 }
4884 result_list->current = result_list->last;
4885 result_list->current_row_num = result_list->current->record_num - 1;
4886 if (result_list->quick_mode == 0)
4887 result_list->current->result->move_to_pos(result_list->current_row_num);
4888 DBUG_RETURN(spider_db_fetch(buf, spider, table));
4889 } else if (!result_list->sorted ||
4890 result_list->internal_limit <= result_list->record_num * 2)
4891 {
4892 if (result_list->low_mem_read == 1)
4893 {
4894 my_message(ER_SPIDER_LOW_MEM_READ_PREV_NUM,
4895 ER_SPIDER_LOW_MEM_READ_PREV_STR, MYF(0));
4896 DBUG_RETURN(ER_SPIDER_LOW_MEM_READ_PREV_NUM);
4897 }
4898 spider_next_split_read_param(spider);
4899 result_list->limit_num =
4900 result_list->internal_limit - result_list->record_num;
4901 if (spider->sql_kinds & SPIDER_SQL_KIND_SQL)
4902 {
4903 if ((error_num = spider->reappend_limit_sql_part(
4904 result_list->internal_offset + result_list->record_num,
4905 result_list->limit_num,
4906 SPIDER_SQL_TYPE_SELECT_SQL)))
4907 DBUG_RETURN(error_num);
4908 if (
4909 !result_list->use_union &&
4910 (error_num = spider->append_select_lock_sql_part(
4911 SPIDER_SQL_TYPE_SELECT_SQL))
4912 )
4913 DBUG_RETURN(error_num);
4914 }
4915 if (spider->sql_kinds & SPIDER_SQL_KIND_HANDLER)
4916 {
4917 spider_db_append_handler_next(spider);
4918 if ((error_num = spider->reappend_limit_sql_part(
4919 result_list->internal_offset + result_list->record_num,
4920 result_list->limit_num,
4921 SPIDER_SQL_TYPE_HANDLER)))
4922 DBUG_RETURN(error_num);
4923 if (
4924 !result_list->use_union &&
4925 (error_num = spider->append_select_lock_sql_part(
4926 SPIDER_SQL_TYPE_HANDLER))
4927 )
4928 DBUG_RETURN(error_num);
4929 }
4930
4931 int roop_start, roop_end, roop_count, lock_mode, link_ok;
4932 lock_mode = spider_conn_lock_mode(spider);
4933 if (lock_mode)
4934 {
4935 /* "for update" or "lock in share mode" */
4936 link_ok = spider_conn_link_idx_next(share->link_statuses,
4937 spider->conn_link_idx, -1, share->link_count,
4938 SPIDER_LINK_STATUS_OK);
4939 roop_start = spider_conn_link_idx_next(share->link_statuses,
4940 spider->conn_link_idx, -1, share->link_count,
4941 SPIDER_LINK_STATUS_RECOVERY);
4942 roop_end = spider->share->link_count;
4943 } else {
4944 link_ok = link_idx;
4945 roop_start = link_idx;
4946 roop_end = link_idx + 1;
4947 }
4948 for (roop_count = roop_start; roop_count < roop_end;
4949 roop_count = spider_conn_link_idx_next(share->link_statuses,
4950 spider->conn_link_idx, roop_count, share->link_count,
4951 SPIDER_LINK_STATUS_RECOVERY)
4952 ) {
4953 ulong sql_type;
4954 if (spider->sql_kind[roop_count] == SPIDER_SQL_KIND_SQL)
4955 {
4956 sql_type = SPIDER_SQL_TYPE_SELECT_SQL;
4957 } else {
4958 sql_type = SPIDER_SQL_TYPE_HANDLER;
4959 }
4960 conn = spider->conns[roop_count];
4961 spider_db_handler *dbton_handler = spider->dbton_handler[conn->dbton_id];
4962 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
4963 if (dbton_handler->need_lock_before_set_sql_for_exec(sql_type))
4964 {
4965 pthread_mutex_lock(&conn->mta_conn_mutex);
4966 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
4967 }
4968 if ((error_num = dbton_handler->set_sql_for_exec(sql_type, roop_count)))
4969 {
4970 if (dbton_handler->need_lock_before_set_sql_for_exec(sql_type))
4971 {
4972 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
4973 pthread_mutex_unlock(&conn->mta_conn_mutex);
4974 }
4975 DBUG_RETURN(error_num);
4976 }
4977 if (!dbton_handler->need_lock_before_set_sql_for_exec(sql_type))
4978 {
4979 pthread_mutex_lock(&conn->mta_conn_mutex);
4980 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
4981 }
4982 DBUG_PRINT("info",("spider sql_type=%lu", sql_type));
4983 conn->need_mon = &spider->need_mons[roop_count];
4984 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
4985 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
4986 conn->mta_conn_mutex_lock_already = TRUE;
4987 conn->mta_conn_mutex_unlock_later = TRUE;
4988 if ((error_num = spider_db_set_names(spider, conn, roop_count)))
4989 {
4990 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
4991 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
4992 conn->mta_conn_mutex_lock_already = FALSE;
4993 conn->mta_conn_mutex_unlock_later = FALSE;
4994 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
4995 pthread_mutex_unlock(&conn->mta_conn_mutex);
4996 if (
4997 share->monitoring_kind[roop_count] &&
4998 spider->need_mons[roop_count]
4999 ) {
5000 error_num = spider_ping_table_mon_from_table(
5001 spider->trx,
5002 spider->trx->thd,
5003 share,
5004 roop_count,
5005 (uint32) share->monitoring_sid[roop_count],
5006 share->table_name,
5007 share->table_name_length,
5008 spider->conn_link_idx[roop_count],
5009 NULL,
5010 0,
5011 share->monitoring_kind[roop_count],
5012 share->monitoring_limit[roop_count],
5013 share->monitoring_flag[roop_count],
5014 TRUE
5015 );
5016 }
5017 DBUG_RETURN(error_num);
5018 }
5019 spider_conn_set_timeout_from_share(conn, roop_count, spider->trx->thd,
5020 share);
5021 if (dbton_handler->execute_sql(
5022 sql_type,
5023 conn,
5024 result_list->quick_mode,
5025 &spider->need_mons[roop_count])
5026 ) {
5027 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
5028 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
5029 conn->mta_conn_mutex_lock_already = FALSE;
5030 conn->mta_conn_mutex_unlock_later = FALSE;
5031 error_num = spider_db_errorno(conn);
5032 if (
5033 share->monitoring_kind[roop_count] &&
5034 spider->need_mons[roop_count]
5035 ) {
5036 error_num = spider_ping_table_mon_from_table(
5037 spider->trx,
5038 spider->trx->thd,
5039 share,
5040 roop_count,
5041 (uint32) share->monitoring_sid[roop_count],
5042 share->table_name,
5043 share->table_name_length,
5044 spider->conn_link_idx[roop_count],
5045 NULL,
5046 0,
5047 share->monitoring_kind[roop_count],
5048 share->monitoring_limit[roop_count],
5049 share->monitoring_flag[roop_count],
5050 TRUE
5051 );
5052 }
5053 DBUG_RETURN(error_num);
5054 }
5055 spider->connection_ids[roop_count] = conn->connection_id;
5056 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
5057 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
5058 conn->mta_conn_mutex_lock_already = FALSE;
5059 conn->mta_conn_mutex_unlock_later = FALSE;
5060 if (roop_count == link_ok)
5061 {
5062 if ((error_num = spider_db_store_result(spider, roop_count, table)))
5063 {
5064 if (
5065 error_num != HA_ERR_END_OF_FILE &&
5066 share->monitoring_kind[roop_count] &&
5067 spider->need_mons[roop_count]
5068 ) {
5069 error_num = spider_ping_table_mon_from_table(
5070 spider->trx,
5071 spider->trx->thd,
5072 share,
5073 roop_count,
5074 (uint32) share->monitoring_sid[roop_count],
5075 share->table_name,
5076 share->table_name_length,
5077 spider->conn_link_idx[roop_count],
5078 NULL,
5079 0,
5080 share->monitoring_kind[roop_count],
5081 share->monitoring_limit[roop_count],
5082 share->monitoring_flag[roop_count],
5083 TRUE
5084 );
5085 }
5086 DBUG_RETURN(error_num);
5087 }
5088 spider->result_link_idx = link_ok;
5089 } else {
5090 spider_db_discard_result(spider, roop_count, conn);
5091 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
5092 pthread_mutex_unlock(&conn->mta_conn_mutex);
5093 }
5094 }
5095 result_list->current_row_num = result_list->current->record_num - 1;
5096 if (result_list->quick_mode == 0)
5097 result_list->current->result->move_to_pos(result_list->current_row_num);
5098 DBUG_RETURN(spider_db_fetch(buf, spider, table));
5099 }
5100 if ((error_num = spider_db_free_result(spider, FALSE)))
5101 DBUG_RETURN(error_num);
5102 spider_first_split_read_param(spider);
5103 result_list->desc_flg = !(result_list->desc_flg);
5104 result_list->limit_num =
5105 result_list->internal_limit >= result_list->split_read ?
5106 result_list->split_read : result_list->internal_limit;
5107 if (spider->sql_kinds & SPIDER_SQL_KIND_SQL)
5108 {
5109 spider->set_order_to_pos_sql(SPIDER_SQL_TYPE_SELECT_SQL);
5110 if (
5111 (error_num = spider->append_key_order_with_alias_sql_part(
5112 NULL, 0, SPIDER_SQL_TYPE_SELECT_SQL)) ||
5113 (error_num = spider->append_limit_sql_part(
5114 result_list->internal_offset,
5115 result_list->limit_num, SPIDER_SQL_TYPE_SELECT_SQL)) ||
5116 (
5117 !result_list->use_union &&
5118 (spider->sql_kinds & SPIDER_SQL_KIND_SQL) &&
5119 (error_num = spider->append_select_lock_sql_part(
5120 SPIDER_SQL_TYPE_SELECT_SQL))
5121 )
5122 )
5123 DBUG_RETURN(error_num);
5124 }
5125 if (spider->sql_kinds & SPIDER_SQL_KIND_HANDLER)
5126 {
5127 const char *alias;
5128 uint alias_length;
5129 if (result_list->sorted && result_list->desc_flg)
5130 {
5131 alias = SPIDER_SQL_LAST_STR;
5132 alias_length = SPIDER_SQL_LAST_LEN;
5133 } else {
5134 alias = SPIDER_SQL_FIRST_STR;
5135 alias_length = SPIDER_SQL_FIRST_LEN;
5136 }
5137 spider->set_order_to_pos_sql(SPIDER_SQL_TYPE_HANDLER);
5138 if (
5139 (error_num = spider->append_key_order_with_alias_sql_part(
5140 alias, alias_length, SPIDER_SQL_TYPE_HANDLER)) ||
5141 (error_num = spider->reappend_limit_sql_part(
5142 result_list->internal_offset,
5143 result_list->limit_num, SPIDER_SQL_TYPE_HANDLER))
5144 )
5145 DBUG_RETURN(error_num);
5146 }
5147
5148 int roop_start, roop_end, roop_count, lock_mode, link_ok;
5149 lock_mode = spider_conn_lock_mode(spider);
5150 if (lock_mode)
5151 {
5152 /* "for update" or "lock in share mode" */
5153 link_ok = spider_conn_link_idx_next(share->link_statuses,
5154 spider->conn_link_idx, -1, share->link_count,
5155 SPIDER_LINK_STATUS_OK);
5156 roop_start = spider_conn_link_idx_next(share->link_statuses,
5157 spider->conn_link_idx, -1, share->link_count,
5158 SPIDER_LINK_STATUS_RECOVERY);
5159 roop_end = spider->share->link_count;
5160 } else {
5161 link_ok = link_idx;
5162 roop_start = link_idx;
5163 roop_end = link_idx + 1;
5164 }
5165 for (roop_count = roop_start; roop_count < roop_end;
5166 roop_count = spider_conn_link_idx_next(share->link_statuses,
5167 spider->conn_link_idx, roop_count, share->link_count,
5168 SPIDER_LINK_STATUS_RECOVERY)
5169 ) {
5170 ulong sql_type;
5171 if (spider->sql_kind[roop_count] == SPIDER_SQL_KIND_SQL)
5172 {
5173 sql_type = SPIDER_SQL_TYPE_SELECT_SQL;
5174 } else {
5175 sql_type = SPIDER_SQL_TYPE_HANDLER;
5176 }
5177 conn = spider->conns[roop_count];
5178 spider_db_handler *dbton_handler = spider->dbton_handler[conn->dbton_id];
5179 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
5180 if (dbton_handler->need_lock_before_set_sql_for_exec(sql_type))
5181 {
5182 pthread_mutex_lock(&conn->mta_conn_mutex);
5183 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
5184 }
5185 if ((error_num = dbton_handler->set_sql_for_exec(sql_type, roop_count)))
5186 {
5187 if (dbton_handler->need_lock_before_set_sql_for_exec(sql_type))
5188 {
5189 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
5190 pthread_mutex_unlock(&conn->mta_conn_mutex);
5191 }
5192 DBUG_RETURN(error_num);
5193 }
5194 if (!dbton_handler->need_lock_before_set_sql_for_exec(sql_type))
5195 {
5196 pthread_mutex_lock(&conn->mta_conn_mutex);
5197 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
5198 }
5199 DBUG_PRINT("info",("spider sql_type=%lu", sql_type));
5200 conn->need_mon = &spider->need_mons[roop_count];
5201 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
5202 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
5203 conn->mta_conn_mutex_lock_already = TRUE;
5204 conn->mta_conn_mutex_unlock_later = TRUE;
5205 if ((error_num = spider_db_set_names(spider, conn, roop_count)))
5206 {
5207 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
5208 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
5209 conn->mta_conn_mutex_lock_already = FALSE;
5210 conn->mta_conn_mutex_unlock_later = FALSE;
5211 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
5212 pthread_mutex_unlock(&conn->mta_conn_mutex);
5213 if (
5214 share->monitoring_kind[roop_count] &&
5215 spider->need_mons[roop_count]
5216 ) {
5217 error_num = spider_ping_table_mon_from_table(
5218 spider->trx,
5219 spider->trx->thd,
5220 share,
5221 roop_count,
5222 (uint32) share->monitoring_sid[roop_count],
5223 share->table_name,
5224 share->table_name_length,
5225 spider->conn_link_idx[roop_count],
5226 NULL,
5227 0,
5228 share->monitoring_kind[roop_count],
5229 share->monitoring_limit[roop_count],
5230 share->monitoring_flag[roop_count],
5231 TRUE
5232 );
5233 }
5234 DBUG_RETURN(error_num);
5235 }
5236 spider_conn_set_timeout_from_share(conn, roop_count, spider->trx->thd,
5237 share);
5238 if (dbton_handler->execute_sql(
5239 sql_type,
5240 conn,
5241 result_list->quick_mode,
5242 &spider->need_mons[roop_count])
5243 ) {
5244 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
5245 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
5246 conn->mta_conn_mutex_lock_already = FALSE;
5247 conn->mta_conn_mutex_unlock_later = FALSE;
5248 error_num = spider_db_errorno(conn);
5249 if (
5250 share->monitoring_kind[roop_count] &&
5251 spider->need_mons[roop_count]
5252 ) {
5253 error_num = spider_ping_table_mon_from_table(
5254 spider->trx,
5255 spider->trx->thd,
5256 share,
5257 roop_count,
5258 (uint32) share->monitoring_sid[roop_count],
5259 share->table_name,
5260 share->table_name_length,
5261 spider->conn_link_idx[roop_count],
5262 NULL,
5263 0,
5264 share->monitoring_kind[roop_count],
5265 share->monitoring_limit[roop_count],
5266 share->monitoring_flag[roop_count],
5267 TRUE
5268 );
5269 }
5270 DBUG_RETURN(error_num);
5271 }
5272 spider->connection_ids[roop_count] = conn->connection_id;
5273 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
5274 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
5275 conn->mta_conn_mutex_lock_already = FALSE;
5276 conn->mta_conn_mutex_unlock_later = FALSE;
5277 if (roop_count == link_ok)
5278 {
5279 if ((error_num = spider_db_store_result(spider, roop_count, table)))
5280 {
5281 if (
5282 error_num != HA_ERR_END_OF_FILE &&
5283 share->monitoring_kind[roop_count] &&
5284 spider->need_mons[roop_count]
5285 ) {
5286 error_num = spider_ping_table_mon_from_table(
5287 spider->trx,
5288 spider->trx->thd,
5289 share,
5290 roop_count,
5291 (uint32) share->monitoring_sid[roop_count],
5292 share->table_name,
5293 share->table_name_length,
5294 spider->conn_link_idx[roop_count],
5295 NULL,
5296 0,
5297 share->monitoring_kind[roop_count],
5298 share->monitoring_limit[roop_count],
5299 share->monitoring_flag[roop_count],
5300 TRUE
5301 );
5302 }
5303 DBUG_RETURN(error_num);
5304 }
5305 spider->result_link_idx = link_ok;
5306 } else {
5307 spider_db_discard_result(spider, roop_count, conn);
5308 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
5309 pthread_mutex_unlock(&conn->mta_conn_mutex);
5310 }
5311 }
5312 DBUG_RETURN(spider_db_fetch(buf, spider, table));
5313 }
5314
spider_db_seek_first(uchar * buf,ha_spider * spider,TABLE * table)5315 int spider_db_seek_first(
5316 uchar *buf,
5317 ha_spider *spider,
5318 TABLE *table
5319 ) {
5320 SPIDER_RESULT_LIST *result_list = &spider->result_list;
5321 DBUG_ENTER("spider_db_seek_first");
5322 if (
5323 result_list->current != result_list->first &&
5324 result_list->low_mem_read == 1
5325 ) {
5326 my_message(ER_SPIDER_LOW_MEM_READ_PREV_NUM, ER_SPIDER_LOW_MEM_READ_PREV_STR, MYF(0));
5327 DBUG_RETURN(ER_SPIDER_LOW_MEM_READ_PREV_NUM);
5328 }
5329 result_list->current = result_list->first;
5330 spider_db_set_pos_to_first_row(result_list);
5331 DBUG_RETURN(spider_db_fetch(buf, spider, table));
5332 }
5333
spider_db_set_pos_to_first_row(SPIDER_RESULT_LIST * result_list)5334 void spider_db_set_pos_to_first_row(
5335 SPIDER_RESULT_LIST *result_list
5336 ) {
5337 DBUG_ENTER("spider_db_set_pos_to_first_row");
5338 result_list->current_row_num = 0;
5339 if (result_list->quick_mode == 0)
5340 result_list->current->result->move_to_pos(0);
5341 DBUG_VOID_RETURN;
5342 }
5343
spider_db_create_position(ha_spider * spider,SPIDER_POSITION * pos)5344 void spider_db_create_position(
5345 ha_spider *spider,
5346 SPIDER_POSITION *pos
5347 ) {
5348 SPIDER_RESULT_LIST *result_list = &spider->result_list;
5349 SPIDER_RESULT *current = (SPIDER_RESULT*) result_list->current;
5350 DBUG_ENTER("spider_db_create_position");
5351 if (result_list->quick_mode == 0)
5352 {
5353 SPIDER_DB_RESULT *result = current->result;
5354 pos->row = result->current_row();
5355 pos->pos_mode = 2;
5356 pos->row->next_pos = result_list->tmp_pos_row_first;
5357 result_list->tmp_pos_row_first = pos->row;
5358 } else {
5359 if (result_list->current_row_num <= result_list->quick_page_size)
5360 {
5361 SPIDER_POSITION *tmp_pos =
5362 ¤t->first_position[result_list->current_row_num - 1];
5363 memcpy(pos, tmp_pos, sizeof(SPIDER_POSITION));
5364 tmp_pos->use_position = TRUE;
5365 tmp_pos->pos_mode = 0;
5366 pos->pos_mode = 0;
5367 current->first_pos_use_position = TRUE;
5368 } else {
5369 TABLE *tmp_tbl = current->result_tmp_tbl;
5370 pos->row = NULL;
5371 pos->pos_mode = 1;
5372 DBUG_PRINT("info",("spider tmp_tbl=%p", tmp_tbl));
5373 DBUG_PRINT("info",("spider tmp_tbl->file=%p", tmp_tbl->file));
5374 DBUG_PRINT("info",("spider tmp_tbl->file->ref=%p", tmp_tbl->file->ref));
5375 tmp_tbl->file->ref = (uchar *) &pos->tmp_tbl_pos;
5376 tmp_tbl->file->position(tmp_tbl->record[0]);
5377 current->tmp_tbl_use_position = TRUE;
5378 }
5379 }
5380 current->use_position = TRUE;
5381 pos->use_position = TRUE;
5382 pos->mrr_with_cnt = spider->mrr_with_cnt;
5383 #ifdef HANDLER_HAS_DIRECT_AGGREGATE
5384 pos->direct_aggregate = result_list->direct_aggregate;
5385 #endif
5386 pos->sql_kind = spider->sql_kind[spider->result_link_idx];
5387 pos->position_bitmap = spider->position_bitmap;
5388 pos->ft_first = spider->ft_first;
5389 pos->ft_current = spider->ft_current;
5390 pos->result = current;
5391 DBUG_VOID_RETURN;
5392 }
5393
spider_db_seek_tmp(uchar * buf,SPIDER_POSITION * pos,ha_spider * spider,TABLE * table)5394 int spider_db_seek_tmp(
5395 uchar *buf,
5396 SPIDER_POSITION *pos,
5397 ha_spider *spider,
5398 TABLE *table
5399 ) {
5400 int error_num;
5401 SPIDER_RESULT_LIST *result_list = &spider->result_list;
5402 DBUG_ENTER("spider_db_seek_tmp");
5403 if (pos->pos_mode != 1)
5404 {
5405 if (!pos->row)
5406 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5407 pos->row->first();
5408 }
5409 if (pos->sql_kind == SPIDER_SQL_KIND_SQL)
5410 {
5411 if (!spider->select_column_mode)
5412 {
5413 if (result_list->keyread)
5414 error_num = spider_db_seek_tmp_key(buf, pos, spider, table,
5415 result_list->key_info);
5416 else
5417 error_num = spider_db_seek_tmp_table(buf, pos, spider, table);
5418 } else
5419 error_num = spider_db_seek_tmp_minimum_columns(buf, pos, spider, table);
5420 } else
5421 error_num = spider_db_seek_tmp_table(buf, pos, spider, table);
5422
5423 DBUG_PRINT("info",("spider error_num=%d", error_num));
5424 DBUG_RETURN(error_num);
5425 }
5426
spider_db_seek_tmp_table(uchar * buf,SPIDER_POSITION * pos,ha_spider * spider,TABLE * table)5427 int spider_db_seek_tmp_table(
5428 uchar *buf,
5429 SPIDER_POSITION *pos,
5430 ha_spider *spider,
5431 TABLE *table
5432 ) {
5433 int error_num;
5434 Field **field;
5435 SPIDER_DB_ROW *row = pos->row;
5436 my_ptrdiff_t ptr_diff = PTR_BYTE_DIFF(buf, table->record[0]);
5437 DBUG_ENTER("spider_db_seek_tmp_table");
5438 if (pos->pos_mode == 1)
5439 {
5440 if ((error_num = spider_db_get_row_from_tmp_tbl_pos(pos, &row)))
5441 DBUG_RETURN(error_num);
5442 } else if (pos->pos_mode == 2)
5443 {
5444 /*
5445 SPIDER_DB_RESULT *result = pos->result->result;
5446 result->current_row = row;
5447 */
5448 }
5449
5450 DBUG_PRINT("info", ("spider row=%p", row));
5451 #ifdef HANDLER_HAS_DIRECT_AGGREGATE
5452 if (!spider->result_list.in_cmp_ref)
5453 {
5454 DBUG_PRINT("info", ("spider direct_aggregate=%s",
5455 pos->direct_aggregate ? "TRUE" : "FALSE"));
5456 spider->result_list.snap_mrr_with_cnt = pos->mrr_with_cnt;
5457 spider->result_list.snap_direct_aggregate = pos->direct_aggregate;
5458 spider->result_list.snap_row = row;
5459 }
5460 #endif
5461
5462 /* for mrr */
5463 if (pos->mrr_with_cnt)
5464 {
5465 DBUG_PRINT("info", ("spider mrr_with_cnt"));
5466 if (pos->sql_kind == SPIDER_SQL_KIND_SQL)
5467 {
5468 row->next();
5469 } else {
5470 #ifdef HANDLER_HAS_DIRECT_AGGREGATE
5471 spider->result_list.snap_mrr_with_cnt = FALSE;
5472 #endif
5473 }
5474 }
5475
5476 #ifdef HANDLER_HAS_DIRECT_AGGREGATE
5477 /* for direct_aggregate */
5478 if (pos->direct_aggregate)
5479 {
5480 if ((error_num = spider_db_fetch_for_item_sum_funcs(row, spider)))
5481 DBUG_RETURN(error_num);
5482 }
5483 #endif
5484
5485 if ((error_num = spider_db_append_match_fetch(spider,
5486 pos->ft_first, pos->ft_current, row)))
5487 DBUG_RETURN(error_num);
5488
5489 for (
5490 field = table->field;
5491 *field;
5492 field++
5493 ) {
5494 if ((
5495 bitmap_is_set(table->read_set, (*field)->field_index) |
5496 bitmap_is_set(table->write_set, (*field)->field_index)
5497 )) {
5498 #ifndef DBUG_OFF
5499 MY_BITMAP *tmp_map =
5500 dbug_tmp_use_all_columns(table, &table->write_set);
5501 #endif
5502 DBUG_PRINT("info", ("spider bitmap is set %s",
5503 SPIDER_field_name_str(*field)));
5504 if ((error_num =
5505 spider_db_fetch_row(spider->share, *field, row, ptr_diff)))
5506 DBUG_RETURN(error_num);
5507 #ifndef DBUG_OFF
5508 dbug_tmp_restore_column_map(&table->write_set, tmp_map);
5509 #endif
5510 }
5511 row->next();
5512 }
5513 DBUG_RETURN(0);
5514 }
5515
spider_db_seek_tmp_key(uchar * buf,SPIDER_POSITION * pos,ha_spider * spider,TABLE * table,const KEY * key_info)5516 int spider_db_seek_tmp_key(
5517 uchar *buf,
5518 SPIDER_POSITION *pos,
5519 ha_spider *spider,
5520 TABLE *table,
5521 const KEY *key_info
5522 ) {
5523 int error_num;
5524 KEY_PART_INFO *key_part;
5525 uint part_num;
5526 SPIDER_DB_ROW *row = pos->row;
5527 Field *field;
5528 my_ptrdiff_t ptr_diff = PTR_BYTE_DIFF(buf, table->record[0]);
5529 DBUG_ENTER("spider_db_seek_tmp_key");
5530 if (pos->pos_mode == 1)
5531 {
5532 if ((error_num = spider_db_get_row_from_tmp_tbl_pos(pos, &row)))
5533 DBUG_RETURN(error_num);
5534 } else if (pos->pos_mode == 2)
5535 {
5536 /*
5537 SPIDER_DB_RESULT *result = pos->result->result;
5538 result->current_row = row;
5539 */
5540 }
5541
5542 DBUG_PRINT("info", ("spider row=%p", row));
5543 #ifdef HANDLER_HAS_DIRECT_AGGREGATE
5544 if (!spider->result_list.in_cmp_ref)
5545 {
5546 DBUG_PRINT("info", ("spider direct_aggregate=%s",
5547 pos->direct_aggregate ? "TRUE" : "FALSE"));
5548 spider->result_list.snap_mrr_with_cnt = pos->mrr_with_cnt;
5549 spider->result_list.snap_direct_aggregate = pos->direct_aggregate;
5550 spider->result_list.snap_row = row;
5551 }
5552 #endif
5553
5554 /* for mrr */
5555 if (pos->mrr_with_cnt)
5556 {
5557 DBUG_PRINT("info", ("spider mrr_with_cnt"));
5558 row->next();
5559 }
5560
5561 #ifdef HANDLER_HAS_DIRECT_AGGREGATE
5562 /* for direct_aggregate */
5563 if (pos->direct_aggregate)
5564 {
5565 if ((error_num = spider_db_fetch_for_item_sum_funcs(row, spider)))
5566 DBUG_RETURN(error_num);
5567 }
5568 #endif
5569
5570 if ((error_num = spider_db_append_match_fetch(spider,
5571 pos->ft_first, pos->ft_current, row)))
5572 DBUG_RETURN(error_num);
5573
5574 for (
5575 key_part = key_info->key_part,
5576 part_num = 0;
5577 part_num < spider_user_defined_key_parts(key_info);
5578 key_part++,
5579 part_num++
5580 ) {
5581 field = key_part->field;
5582 if ((
5583 bitmap_is_set(table->read_set, field->field_index) |
5584 bitmap_is_set(table->write_set, field->field_index)
5585 )) {
5586 #ifndef DBUG_OFF
5587 MY_BITMAP *tmp_map =
5588 dbug_tmp_use_all_columns(table, &table->write_set);
5589 #endif
5590 DBUG_PRINT("info", ("spider bitmap is set %s",
5591 SPIDER_field_name_str(field)));
5592 if ((error_num =
5593 spider_db_fetch_row(spider->share, field, row, ptr_diff)))
5594 DBUG_RETURN(error_num);
5595 #ifndef DBUG_OFF
5596 dbug_tmp_restore_column_map(&table->write_set, tmp_map);
5597 #endif
5598 }
5599 row->next();
5600 }
5601 DBUG_RETURN(0);
5602 }
5603
spider_db_seek_tmp_minimum_columns(uchar * buf,SPIDER_POSITION * pos,ha_spider * spider,TABLE * table)5604 int spider_db_seek_tmp_minimum_columns(
5605 uchar *buf,
5606 SPIDER_POSITION *pos,
5607 ha_spider *spider,
5608 TABLE *table
5609 ) {
5610 int error_num;
5611 Field **field;
5612 SPIDER_DB_ROW *row = pos->row;
5613 my_ptrdiff_t ptr_diff = PTR_BYTE_DIFF(buf, table->record[0]);
5614 DBUG_ENTER("spider_db_seek_tmp_minimum_columns");
5615 if (pos->pos_mode == 1)
5616 {
5617 if ((error_num = spider_db_get_row_from_tmp_tbl_pos(pos, &row)))
5618 DBUG_RETURN(error_num);
5619 } else if (pos->pos_mode == 2)
5620 {
5621 /*
5622 SPIDER_DB_RESULT *result = pos->result->result;
5623 result->current_row = row;
5624 */
5625 }
5626
5627 DBUG_PRINT("info", ("spider row=%p", row));
5628 #ifdef HANDLER_HAS_DIRECT_AGGREGATE
5629 if (!spider->result_list.in_cmp_ref)
5630 {
5631 DBUG_PRINT("info", ("spider direct_aggregate=%s",
5632 pos->direct_aggregate ? "TRUE" : "FALSE"));
5633 spider->result_list.snap_mrr_with_cnt = pos->mrr_with_cnt;
5634 spider->result_list.snap_direct_aggregate = pos->direct_aggregate;
5635 spider->result_list.snap_row = row;
5636 }
5637 #endif
5638
5639 /* for mrr */
5640 if (pos->mrr_with_cnt)
5641 {
5642 DBUG_PRINT("info", ("spider mrr_with_cnt"));
5643 row->next();
5644 }
5645
5646 #ifdef HANDLER_HAS_DIRECT_AGGREGATE
5647 /* for direct_aggregate */
5648 if (pos->direct_aggregate)
5649 {
5650 if ((error_num = spider_db_fetch_for_item_sum_funcs(row, spider)))
5651 DBUG_RETURN(error_num);
5652 }
5653 #endif
5654
5655 if ((error_num = spider_db_append_match_fetch(spider,
5656 pos->ft_first, pos->ft_current, row)))
5657 DBUG_RETURN(error_num);
5658
5659 for (
5660 field = table->field;
5661 *field;
5662 field++
5663 ) {
5664 DBUG_PRINT("info", ("spider field_index %u", (*field)->field_index));
5665 if (spider_bit_is_set(pos->position_bitmap, (*field)->field_index))
5666 {
5667 /*
5668 if ((
5669 bitmap_is_set(table->read_set, (*field)->field_index) |
5670 bitmap_is_set(table->write_set, (*field)->field_index)
5671 )) {
5672 DBUG_PRINT("info", ("spider read_set %u",
5673 bitmap_is_set(table->read_set, (*field)->field_index)));
5674 DBUG_PRINT("info", ("spider write_set %u",
5675 bitmap_is_set(table->write_set, (*field)->field_index)));
5676 */
5677 #ifndef DBUG_OFF
5678 MY_BITMAP *tmp_map =
5679 dbug_tmp_use_all_columns(table, &table->write_set);
5680 #endif
5681 DBUG_PRINT("info", ("spider bitmap is set %s",
5682 SPIDER_field_name_str(*field)));
5683 if ((error_num =
5684 spider_db_fetch_row(spider->share, *field, row, ptr_diff)))
5685 DBUG_RETURN(error_num);
5686 row->next();
5687 #ifndef DBUG_OFF
5688 dbug_tmp_restore_column_map(&table->write_set, tmp_map);
5689 #endif
5690 }
5691 else if (bitmap_is_set(table->read_set, (*field)->field_index))
5692 {
5693 DBUG_PRINT("info", ("spider bitmap is cleared %s",
5694 SPIDER_field_name_str(*field)));
5695 bitmap_clear_bit(table->read_set, (*field)->field_index);
5696 }
5697 }
5698 DBUG_RETURN(0);
5699 }
5700
spider_db_show_table_status(ha_spider * spider,int link_idx,int sts_mode,uint flag)5701 int spider_db_show_table_status(
5702 ha_spider *spider,
5703 int link_idx,
5704 int sts_mode,
5705 uint flag
5706 ) {
5707 int error_num;
5708 SPIDER_CONN *conn = spider->conns[link_idx];
5709 spider_db_handler *dbton_hdl = spider->dbton_handler[conn->dbton_id];
5710 DBUG_ENTER("spider_db_show_table_status");
5711 DBUG_PRINT("info",("spider sts_mode=%d", sts_mode));
5712 sts_mode = dbton_hdl->sts_mode_exchange(sts_mode);
5713 error_num = dbton_hdl->show_table_status(
5714 link_idx,
5715 sts_mode,
5716 flag
5717 );
5718 DBUG_RETURN(error_num);
5719 }
5720
spider_db_show_records(ha_spider * spider,int link_idx,bool pre_call)5721 int spider_db_show_records(
5722 ha_spider *spider,
5723 int link_idx,
5724 bool pre_call
5725 ) {
5726 int error_num;
5727 THD *thd = spider->trx->thd;
5728 SPIDER_CONN *conn;
5729 DBUG_ENTER("spider_db_show_records");
5730 if (pre_call)
5731 {
5732 if (spider_param_bgs_mode(thd, spider->share->bgs_mode))
5733 {
5734 if ((error_num = spider_check_and_get_casual_read_conn(thd, spider,
5735 link_idx)))
5736 {
5737 DBUG_RETURN(error_num);
5738 }
5739 conn = spider->conns[link_idx];
5740 if (!(error_num = spider_create_conn_thread(conn)))
5741 {
5742 spider_bg_conn_simple_action(conn, SPIDER_BG_SIMPLE_RECORDS, FALSE,
5743 spider, link_idx, (int *) &spider->result_list.bgs_error);
5744 }
5745 } else {
5746 conn = spider->conns[link_idx];
5747 error_num = spider->dbton_handler[conn->dbton_id]->show_records(
5748 link_idx
5749 );
5750 }
5751 } else {
5752 conn = spider->conns[link_idx];
5753 if (spider->use_pre_records)
5754 {
5755 if (spider_param_bgs_mode(thd, spider->share->bgs_mode))
5756 {
5757 spider_bg_conn_wait(conn);
5758 error_num = spider->result_list.bgs_error;
5759 if (conn->casual_read_base_conn)
5760 {
5761 spider->conns[link_idx] = conn->casual_read_base_conn;
5762 }
5763 } else {
5764 error_num = 0;
5765 }
5766 } else {
5767 error_num = spider->dbton_handler[conn->dbton_id]->show_records(
5768 link_idx
5769 );
5770 }
5771 }
5772 DBUG_RETURN(error_num);
5773 }
5774
spider_db_set_cardinarity(ha_spider * spider,TABLE * table)5775 void spider_db_set_cardinarity(
5776 ha_spider *spider,
5777 TABLE *table
5778 ) {
5779 int roop_count, roop_count2;
5780 SPIDER_SHARE *share = spider->share;
5781 KEY *key_info;
5782 KEY_PART_INFO *key_part;
5783 Field *field;
5784 ha_rows rec_per_key;
5785 DBUG_ENTER("spider_db_set_cardinarity");
5786 for (roop_count = 0; roop_count < (int) table->s->keys; roop_count++)
5787 {
5788 key_info = &table->key_info[roop_count];
5789 for (roop_count2 = 0;
5790 roop_count2 < (int) spider_user_defined_key_parts(key_info);
5791 roop_count2++)
5792 {
5793 key_part = &key_info->key_part[roop_count2];
5794 field = key_part->field;
5795 rec_per_key = (ha_rows) share->records /
5796 share->cardinality[field->field_index];
5797 if (rec_per_key > ~(ulong) 0)
5798 key_info->rec_per_key[roop_count2] = ~(ulong) 0;
5799 else if (rec_per_key == 0)
5800 key_info->rec_per_key[roop_count2] = 1;
5801 else
5802 key_info->rec_per_key[roop_count2] = (ulong) rec_per_key;
5803 DBUG_PRINT("info",
5804 ("spider column id=%d", field->field_index));
5805 DBUG_PRINT("info",
5806 ("spider cardinality=%lld",
5807 share->cardinality[field->field_index]));
5808 DBUG_PRINT("info",
5809 ("spider rec_per_key=%lu",
5810 key_info->rec_per_key[roop_count2]));
5811 }
5812 }
5813 DBUG_VOID_RETURN;
5814 }
5815
spider_db_show_index(ha_spider * spider,int link_idx,TABLE * table,int crd_mode)5816 int spider_db_show_index(
5817 ha_spider *spider,
5818 int link_idx,
5819 TABLE *table,
5820 int crd_mode
5821 ) {
5822 int error_num;
5823 SPIDER_CONN *conn = spider->conns[link_idx];
5824 spider_db_handler *dbton_hdl = spider->dbton_handler[conn->dbton_id];
5825 DBUG_ENTER("spider_db_show_index");
5826 crd_mode = dbton_hdl->crd_mode_exchange(crd_mode);
5827 error_num = spider->dbton_handler[conn->dbton_id]->show_index(
5828 link_idx,
5829 crd_mode
5830 );
5831 DBUG_RETURN(error_num);
5832 }
5833
spider_db_explain_select(key_range * start_key,key_range * end_key,ha_spider * spider,int link_idx)5834 ha_rows spider_db_explain_select(
5835 key_range *start_key,
5836 key_range *end_key,
5837 ha_spider *spider,
5838 int link_idx
5839 ) {
5840 SPIDER_CONN *conn = spider->conns[link_idx];
5841 ha_rows rows;
5842 DBUG_ENTER("spider_db_explain_select");
5843 rows = spider->dbton_handler[conn->dbton_id]->explain_select(
5844 start_key,
5845 end_key,
5846 link_idx
5847 );
5848 DBUG_RETURN(rows);
5849 }
5850
spider_db_bulk_insert_init(ha_spider * spider,const TABLE * table)5851 int spider_db_bulk_insert_init(
5852 ha_spider *spider,
5853 const TABLE *table
5854 ) {
5855 int error_num, roop_count;
5856 SPIDER_SHARE *share = spider->share;
5857 DBUG_ENTER("spider_db_bulk_insert_init");
5858 spider->sql_kinds = 0;
5859 spider->reset_sql_sql(SPIDER_SQL_TYPE_INSERT_SQL);
5860 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
5861 spider->reset_hs_sql(SPIDER_SQL_TYPE_OTHER_HS);
5862 #endif
5863 for (
5864 roop_count = spider_conn_link_idx_next(share->link_statuses,
5865 spider->conn_link_idx, -1, share->link_count,
5866 SPIDER_LINK_STATUS_RECOVERY);
5867 roop_count < (int) share->link_count;
5868 roop_count = spider_conn_link_idx_next(share->link_statuses,
5869 spider->conn_link_idx, roop_count, share->link_count,
5870 SPIDER_LINK_STATUS_RECOVERY)
5871 ) {
5872 if (spider->conns[roop_count])
5873 spider->conns[roop_count]->ignore_dup_key = spider->ignore_dup_key;
5874 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
5875 if (
5876 spider_conn_use_handler(spider, spider->lock_mode, roop_count) &&
5877 (
5878 !spider->handler_opened(roop_count, SPIDER_CONN_KIND_HS_WRITE) ||
5879 #ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
5880 spider->hs_w_ret_fields_num[roop_count] < MAX_FIELDS ||
5881 #endif
5882 spider->hs_w_conns[roop_count]->server_lost
5883 )
5884 ) {
5885 if ((error_num = spider_db_open_handler(spider,
5886 spider->hs_w_conns[roop_count], roop_count)))
5887 {
5888 if (
5889 share->monitoring_kind[roop_count] &&
5890 spider->need_mons[roop_count]
5891 ) {
5892 error_num = spider_ping_table_mon_from_table(
5893 spider->trx,
5894 spider->trx->thd,
5895 share,
5896 roop_count,
5897 (uint32) share->monitoring_sid[roop_count],
5898 share->table_name,
5899 share->table_name_length,
5900 spider->conn_link_idx[roop_count],
5901 NULL,
5902 0,
5903 share->monitoring_kind[roop_count],
5904 share->monitoring_limit[roop_count],
5905 share->monitoring_flag[roop_count],
5906 TRUE
5907 );
5908 }
5909 DBUG_RETURN(error_num);
5910 }
5911 spider->set_handler_opened(roop_count);
5912 }
5913 #else
5914 spider_conn_use_handler(spider, spider->lock_mode, roop_count);
5915 #endif
5916 }
5917 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
5918 if (spider->sql_kinds & SPIDER_SQL_KIND_SQL)
5919 {
5920 #endif
5921 if (
5922 (error_num = spider->append_insert_sql_part()) ||
5923 (error_num = spider->append_into_sql_part(
5924 SPIDER_SQL_TYPE_INSERT_SQL))
5925 )
5926 DBUG_RETURN(error_num);
5927 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
5928 }
5929 if (spider->sql_kinds & SPIDER_SQL_KIND_HS)
5930 {
5931 spider->result_list.hs_upd_rows = 0;
5932 }
5933 #endif
5934 DBUG_RETURN(0);
5935 }
5936
spider_db_bulk_insert(ha_spider * spider,TABLE * table,bool bulk_end)5937 int spider_db_bulk_insert(
5938 ha_spider *spider,
5939 TABLE *table,
5940 bool bulk_end
5941 ) {
5942 int error_num, first_insert_link_idx = -1;
5943 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
5944 SPIDER_RESULT_LIST *result_list = &spider->result_list;
5945 #endif
5946 SPIDER_SHARE *share = spider->share;
5947 THD *thd = spider->trx->thd;
5948 DBUG_ENTER("spider_db_bulk_insert");
5949
5950 if (!bulk_end)
5951 {
5952 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
5953 if (spider->sql_kinds & SPIDER_SQL_KIND_SQL)
5954 {
5955 #endif
5956 if ((error_num = spider->append_insert_values_sql_part(
5957 SPIDER_SQL_TYPE_INSERT_SQL)))
5958 DBUG_RETURN(error_num);
5959 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
5960 }
5961 if (spider->sql_kinds & SPIDER_SQL_KIND_HS)
5962 {
5963 if ((error_num = spider->append_insert_values_hs_part(
5964 SPIDER_SQL_TYPE_INSERT_HS)))
5965 DBUG_RETURN(error_num);
5966 result_list->hs_upd_rows++;
5967 }
5968 #endif
5969 }
5970
5971 if (spider->is_bulk_insert_exec_period(bulk_end))
5972 {
5973 int roop_count2;
5974 SPIDER_CONN *conn, *first_insert_conn = NULL;
5975 if ((error_num = spider->append_insert_terminator_sql_part(
5976 SPIDER_SQL_TYPE_INSERT_SQL)))
5977 {
5978 DBUG_RETURN(error_num);
5979 }
5980 #ifdef HA_CAN_BULK_ACCESS
5981 if (!spider->is_bulk_access_clone)
5982 {
5983 #endif
5984 for (
5985 roop_count2 = spider_conn_link_idx_next(share->link_statuses,
5986 spider->conn_link_idx, -1, share->link_count,
5987 SPIDER_LINK_STATUS_RECOVERY);
5988 roop_count2 < (int) share->link_count;
5989 roop_count2 = spider_conn_link_idx_next(share->link_statuses,
5990 spider->conn_link_idx, roop_count2, share->link_count,
5991 SPIDER_LINK_STATUS_RECOVERY)
5992 ) {
5993 ulong sql_type;
5994 spider_db_handler *dbton_handler;
5995 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
5996 if (spider->conn_kind[roop_count2] == SPIDER_CONN_KIND_MYSQL)
5997 {
5998 #endif
5999 sql_type = SPIDER_SQL_TYPE_INSERT_SQL;
6000 conn = spider->conns[roop_count2];
6001 dbton_handler = spider->dbton_handler[conn->dbton_id];
6002 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
6003 if (dbton_handler->need_lock_before_set_sql_for_exec(sql_type))
6004 {
6005 pthread_mutex_lock(&conn->mta_conn_mutex);
6006 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
6007 }
6008 if ((error_num = dbton_handler->set_sql_for_exec(sql_type,
6009 roop_count2)))
6010 {
6011 if (dbton_handler->need_lock_before_set_sql_for_exec(sql_type))
6012 {
6013 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
6014 pthread_mutex_unlock(&conn->mta_conn_mutex);
6015 }
6016 DBUG_RETURN(error_num);
6017 }
6018 if (!dbton_handler->need_lock_before_set_sql_for_exec(sql_type))
6019 {
6020 pthread_mutex_lock(&conn->mta_conn_mutex);
6021 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
6022 }
6023 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
6024 } else {
6025 sql_type = SPIDER_SQL_TYPE_INSERT_HS;
6026 conn = spider->hs_w_conns[roop_count2];
6027 dbton_handler = spider->dbton_handler[conn->dbton_id];
6028 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
6029 pthread_mutex_lock(&conn->mta_conn_mutex);
6030 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
6031 }
6032 #endif
6033 conn->need_mon = &spider->need_mons[roop_count2];
6034 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
6035 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
6036 conn->mta_conn_mutex_lock_already = TRUE;
6037 conn->mta_conn_mutex_unlock_later = TRUE;
6038 if ((error_num = spider_db_set_names(spider, conn, roop_count2)))
6039 {
6040 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
6041 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
6042 conn->mta_conn_mutex_lock_already = FALSE;
6043 conn->mta_conn_mutex_unlock_later = FALSE;
6044 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
6045 pthread_mutex_unlock(&conn->mta_conn_mutex);
6046 if (
6047 share->monitoring_kind[roop_count2] &&
6048 spider->need_mons[roop_count2]
6049 ) {
6050 error_num = spider_ping_table_mon_from_table(
6051 spider->trx,
6052 spider->trx->thd,
6053 share,
6054 roop_count2,
6055 (uint32) share->monitoring_sid[roop_count2],
6056 share->table_name,
6057 share->table_name_length,
6058 spider->conn_link_idx[roop_count2],
6059 NULL,
6060 0,
6061 share->monitoring_kind[roop_count2],
6062 share->monitoring_limit[roop_count2],
6063 share->monitoring_flag[roop_count2],
6064 TRUE
6065 );
6066 }
6067 DBUG_RETURN(error_num);
6068 }
6069 spider_conn_set_timeout_from_share(conn, roop_count2, spider->trx->thd,
6070 share);
6071 if (dbton_handler->execute_sql(
6072 sql_type,
6073 conn,
6074 -1,
6075 &spider->need_mons[roop_count2])
6076 ) {
6077 if (spider->sql_kinds & SPIDER_SQL_KIND_SQL)
6078 spider->set_insert_to_pos_sql(SPIDER_SQL_TYPE_INSERT_SQL);
6079 error_num = spider_db_errorno(conn);
6080 if (error_num == HA_ERR_FOUND_DUPP_KEY)
6081 {
6082 conn->db_conn->set_dup_key_idx(spider, roop_count2);
6083 }
6084 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
6085 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
6086 conn->mta_conn_mutex_lock_already = FALSE;
6087 conn->mta_conn_mutex_unlock_later = FALSE;
6088 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
6089 pthread_mutex_unlock(&conn->mta_conn_mutex);
6090 if (
6091 error_num != ER_DUP_ENTRY &&
6092 error_num != ER_DUP_KEY &&
6093 error_num != HA_ERR_FOUND_DUPP_KEY &&
6094 share->monitoring_kind[roop_count2] &&
6095 spider->need_mons[roop_count2]
6096 ) {
6097 error_num = spider_ping_table_mon_from_table(
6098 spider->trx,
6099 spider->trx->thd,
6100 share,
6101 roop_count2,
6102 (uint32) share->monitoring_sid[roop_count2],
6103 share->table_name,
6104 share->table_name_length,
6105 spider->conn_link_idx[roop_count2],
6106 NULL,
6107 0,
6108 share->monitoring_kind[roop_count2],
6109 share->monitoring_limit[roop_count2],
6110 share->monitoring_flag[roop_count2],
6111 TRUE
6112 );
6113 }
6114 DBUG_RETURN(error_num);
6115 }
6116 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
6117 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
6118 conn->mta_conn_mutex_lock_already = FALSE;
6119 conn->mta_conn_mutex_unlock_later = FALSE;
6120 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
6121 if (conn->conn_kind != SPIDER_CONN_KIND_MYSQL)
6122 {
6123 uint roop_count;
6124 DBUG_PRINT("info",("spider conn=%p", conn));
6125 DBUG_PRINT("info",("spider result_list->hs_upd_rows=%llu",
6126 result_list->hs_upd_rows));
6127 for (roop_count = 0; roop_count < result_list->hs_upd_rows;
6128 roop_count++)
6129 {
6130 SPIDER_DB_RESULT *result;
6131 if (spider_bit_is_set(spider->db_request_phase, roop_count2))
6132 {
6133 spider_clear_bit(spider->db_request_phase, roop_count2);
6134 }
6135 st_spider_db_request_key request_key;
6136 request_key.spider_thread_id = spider->trx->spider_thread_id;
6137 request_key.query_id = spider->trx->thd->query_id;
6138 request_key.handler = spider;
6139 request_key.request_id = spider->db_request_id[roop_count2];
6140 request_key.next = NULL;
6141 if ((result = conn->db_conn->use_result(&request_key, &error_num)))
6142 {
6143 result->free_result();
6144 delete result;
6145 } else {
6146 if (!error_num)
6147 {
6148 error_num = spider_db_errorno(conn);
6149 }
6150 DBUG_RETURN(error_num);
6151 }
6152 }
6153 }
6154 #endif
6155 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
6156 pthread_mutex_unlock(&conn->mta_conn_mutex);
6157 if (first_insert_link_idx == -1)
6158 {
6159 first_insert_link_idx = roop_count2;
6160 first_insert_conn = conn;
6161 }
6162 }
6163
6164 conn = first_insert_conn;
6165 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
6166 pthread_mutex_lock(&conn->mta_conn_mutex);
6167 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
6168 conn->need_mon = &spider->need_mons[first_insert_link_idx];
6169 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
6170 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
6171 conn->mta_conn_mutex_lock_already = TRUE;
6172 conn->mta_conn_mutex_unlock_later = TRUE;
6173 if (spider->sql_kinds & SPIDER_SQL_KIND_SQL)
6174 spider->set_insert_to_pos_sql(SPIDER_SQL_TYPE_INSERT_SQL);
6175 if (table->next_number_field &&
6176 (
6177 !table->auto_increment_field_not_null ||
6178 (
6179 !table->next_number_field->val_int() &&
6180 !(thd->variables.sql_mode & MODE_NO_AUTO_VALUE_ON_ZERO)
6181 )
6182 )
6183 ) {
6184 ulonglong last_insert_id;
6185 spider_db_handler *dbton_handler =
6186 spider->dbton_handler[conn->dbton_id];
6187 if (spider->store_last_insert_id)
6188 last_insert_id = spider->store_last_insert_id;
6189 else if ((error_num = dbton_handler->
6190 show_last_insert_id(first_insert_link_idx, last_insert_id)))
6191 {
6192 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
6193 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
6194 conn->mta_conn_mutex_lock_already = FALSE;
6195 conn->mta_conn_mutex_unlock_later = FALSE;
6196 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
6197 pthread_mutex_unlock(&conn->mta_conn_mutex);
6198 DBUG_RETURN(error_num);
6199 }
6200 table->next_number_field->set_notnull();
6201 if (
6202 (error_num = spider_db_update_auto_increment(spider,
6203 first_insert_link_idx)) ||
6204 (error_num = table->next_number_field->store(
6205 last_insert_id, TRUE))
6206 ) {
6207 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
6208 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
6209 conn->mta_conn_mutex_lock_already = FALSE;
6210 conn->mta_conn_mutex_unlock_later = FALSE;
6211 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
6212 pthread_mutex_unlock(&conn->mta_conn_mutex);
6213 DBUG_RETURN(error_num);
6214 }
6215 }
6216 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
6217 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
6218 conn->mta_conn_mutex_lock_already = FALSE;
6219 conn->mta_conn_mutex_unlock_later = FALSE;
6220 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
6221 pthread_mutex_unlock(&conn->mta_conn_mutex);
6222 spider->store_last_insert_id = 0;
6223 #ifdef HA_CAN_BULK_ACCESS
6224 }
6225 #endif
6226 }
6227 if (
6228 (bulk_end || !spider->bulk_insert) &&
6229 (error_num = spider_trx_check_link_idx_failed(spider))
6230 )
6231 DBUG_RETURN(error_num);
6232 DBUG_RETURN(0);
6233 }
6234
6235 #ifdef HA_CAN_BULK_ACCESS
spider_db_bulk_bulk_insert(ha_spider * spider)6236 int spider_db_bulk_bulk_insert(
6237 ha_spider *spider
6238 ) {
6239 int error_num = 0, first_insert_link_idx = -1, tmp_error_num;
6240 int roop_count2;
6241 SPIDER_SHARE *share = spider->share;
6242 SPIDER_CONN *conn, *first_insert_conn = NULL;
6243 TABLE *table = spider->get_table();
6244 THD *thd = spider->trx->thd;
6245 DBUG_ENTER("spider_db_bulk_bulk_insert");
6246 for (
6247 roop_count2 = spider_conn_link_idx_next(share->link_statuses,
6248 spider->conn_link_idx, -1, share->link_count,
6249 SPIDER_LINK_STATUS_RECOVERY);
6250 roop_count2 < (int) share->link_count;
6251 roop_count2 = spider_conn_link_idx_next(share->link_statuses,
6252 spider->conn_link_idx, roop_count2, share->link_count,
6253 SPIDER_LINK_STATUS_RECOVERY)
6254 ) {
6255 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
6256 if (spider->conn_kind[roop_count2] == SPIDER_CONN_KIND_MYSQL)
6257 {
6258 #endif
6259 conn = spider->conns[roop_count2];
6260 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
6261 } else {
6262 conn = spider->hs_w_conns[roop_count2];
6263 }
6264 #endif
6265 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
6266 pthread_mutex_lock(&conn->mta_conn_mutex);
6267 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
6268 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
6269 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
6270 conn->mta_conn_mutex_lock_already = TRUE;
6271 conn->mta_conn_mutex_unlock_later = TRUE;
6272 if ((tmp_error_num = spider_db_bulk_open_handler(spider, conn,
6273 roop_count2)))
6274 {
6275 error_num = tmp_error_num;
6276 }
6277 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
6278 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
6279 conn->mta_conn_mutex_lock_already = FALSE;
6280 conn->mta_conn_mutex_unlock_later = FALSE;
6281 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
6282 if (conn->conn_kind != SPIDER_CONN_KIND_MYSQL)
6283 {
6284 uint roop_count;
6285 SPIDER_RESULT_LIST *result_list = &spider->result_list;
6286 DBUG_PRINT("info",("spider conn=%p", conn));
6287 DBUG_PRINT("info",("spider result_list->hs_upd_rows=%llu",
6288 result_list->hs_upd_rows));
6289 for (roop_count = 0; roop_count < result_list->hs_upd_rows;
6290 roop_count++)
6291 {
6292 SPIDER_DB_RESULT *result;
6293 if (spider_bit_is_set(spider->db_request_phase, roop_count2))
6294 {
6295 spider_clear_bit(spider->db_request_phase, roop_count2);
6296 }
6297 st_spider_db_request_key request_key;
6298 request_key.spider_thread_id = spider->trx->spider_thread_id;
6299 request_key.query_id = spider->trx->thd->query_id;
6300 request_key.handler = spider;
6301 request_key.request_id = spider->db_request_id[roop_count2];
6302 request_key.next = NULL;
6303 if ((result = conn->db_conn->use_result(&request_key, &error_num)))
6304 {
6305 result->free_result();
6306 delete result;
6307 } else {
6308 if (!error_num)
6309 {
6310 error_num = spider_db_errorno(conn);
6311 }
6312 DBUG_RETURN(error_num);
6313 }
6314 }
6315 }
6316 #endif
6317 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
6318 pthread_mutex_unlock(&conn->mta_conn_mutex);
6319 if (first_insert_link_idx == -1)
6320 {
6321 first_insert_link_idx = roop_count2;
6322 first_insert_conn = conn;
6323 }
6324 }
6325
6326 conn = first_insert_conn;
6327 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
6328 pthread_mutex_lock(&conn->mta_conn_mutex);
6329 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
6330 conn->need_mon = &spider->need_mons[first_insert_link_idx];
6331 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
6332 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
6333 conn->mta_conn_mutex_lock_already = TRUE;
6334 conn->mta_conn_mutex_unlock_later = TRUE;
6335 if (table->next_number_field &&
6336 (
6337 !table->auto_increment_field_not_null ||
6338 (
6339 !table->next_number_field->val_int() &&
6340 !(thd->variables.sql_mode & MODE_NO_AUTO_VALUE_ON_ZERO)
6341 )
6342 )
6343 ) {
6344 ulonglong last_insert_id;
6345 if (spider->store_last_insert_id)
6346 last_insert_id = spider->store_last_insert_id;
6347 else
6348 last_insert_id = conn->db_conn->last_insert_id();
6349 table->next_number_field->set_notnull();
6350 if (
6351 (tmp_error_num = spider_db_update_auto_increment(spider,
6352 first_insert_link_idx)) ||
6353 (tmp_error_num = table->next_number_field->store(
6354 last_insert_id, TRUE))
6355 ) {
6356 error_num = tmp_error_num;
6357 }
6358 }
6359 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
6360 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
6361 conn->mta_conn_mutex_lock_already = FALSE;
6362 conn->mta_conn_mutex_unlock_later = FALSE;
6363 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
6364 pthread_mutex_unlock(&conn->mta_conn_mutex);
6365 spider->store_last_insert_id = 0;
6366 DBUG_RETURN(error_num);
6367 }
6368 #endif
6369
spider_db_update_auto_increment(ha_spider * spider,int link_idx)6370 int spider_db_update_auto_increment(
6371 ha_spider *spider,
6372 int link_idx
6373 ) {
6374 int roop_count;
6375 THD *thd = spider->trx->thd;
6376 ulonglong last_insert_id, affected_rows;
6377 SPIDER_SHARE *share = spider->share;
6378 TABLE *table = spider->get_table();
6379 int auto_increment_mode = spider_param_auto_increment_mode(thd,
6380 share->auto_increment_mode);
6381 DBUG_ENTER("spider_db_update_auto_increment");
6382 if (
6383 auto_increment_mode == 2 ||
6384 (auto_increment_mode == 3 && !table->auto_increment_field_not_null)
6385 ) {
6386 last_insert_id = spider->conns[link_idx]->db_conn->last_insert_id();
6387 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
6388 if (spider->conn_kind[link_idx] == SPIDER_CONN_KIND_MYSQL)
6389 {
6390 #endif
6391 affected_rows = spider->conns[link_idx]->db_conn->affected_rows();
6392 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
6393 } else {
6394 affected_rows = spider->result_list.hs_upd_rows;
6395 }
6396 #endif
6397 DBUG_PRINT("info",("spider last_insert_id=%llu", last_insert_id));
6398 share->lgtm_tblhnd_share->auto_increment_value =
6399 last_insert_id + affected_rows;
6400 DBUG_PRINT("info",("spider auto_increment_value=%llu",
6401 share->lgtm_tblhnd_share->auto_increment_value));
6402 /*
6403 thd->record_first_successful_insert_id_in_cur_stmt(last_insert_id);
6404 */
6405 if (
6406 thd->first_successful_insert_id_in_cur_stmt == 0 ||
6407 thd->first_successful_insert_id_in_cur_stmt > last_insert_id
6408 ) {
6409 bool first_set = (thd->first_successful_insert_id_in_cur_stmt == 0);
6410 thd->first_successful_insert_id_in_cur_stmt = last_insert_id;
6411 if (
6412 table->s->next_number_keypart == 0 &&
6413 mysql_bin_log.is_open() &&
6414 #if MYSQL_VERSION_ID < 50500
6415 !thd->current_stmt_binlog_row_based
6416 #else
6417 !thd->is_current_stmt_binlog_format_row()
6418 #endif
6419 ) {
6420 if (
6421 spider->check_partitioned() &&
6422 thd->auto_inc_intervals_in_cur_stmt_for_binlog.nb_elements() > 0
6423 ) {
6424 DBUG_PRINT("info",("spider table partitioning"));
6425 Discrete_interval *current =
6426 thd->auto_inc_intervals_in_cur_stmt_for_binlog.get_current();
6427 current->replace(last_insert_id, affected_rows, 1);
6428 } else {
6429 DBUG_PRINT("info",("spider table"));
6430 thd->auto_inc_intervals_in_cur_stmt_for_binlog.append(
6431 last_insert_id, affected_rows, 1);
6432 }
6433 if (affected_rows > 1 || !first_set)
6434 {
6435 for (roop_count = first_set ? 1 : 0;
6436 roop_count < (int) affected_rows;
6437 roop_count++)
6438 push_warning_printf(thd, SPIDER_WARN_LEVEL_NOTE,
6439 ER_SPIDER_AUTOINC_VAL_IS_DIFFERENT_NUM,
6440 ER_SPIDER_AUTOINC_VAL_IS_DIFFERENT_STR);
6441 }
6442 }
6443 } else {
6444 if (
6445 table->s->next_number_keypart == 0 &&
6446 mysql_bin_log.is_open() &&
6447 #if MYSQL_VERSION_ID < 50500
6448 !thd->current_stmt_binlog_row_based
6449 #else
6450 !thd->is_current_stmt_binlog_format_row()
6451 #endif
6452 ) {
6453 for (roop_count = 0; roop_count < (int) affected_rows; roop_count++)
6454 push_warning_printf(thd, SPIDER_WARN_LEVEL_NOTE,
6455 ER_SPIDER_AUTOINC_VAL_IS_DIFFERENT_NUM,
6456 ER_SPIDER_AUTOINC_VAL_IS_DIFFERENT_STR);
6457 }
6458 }
6459 }
6460 DBUG_RETURN(0);
6461 }
6462
spider_db_bulk_update_size_limit(ha_spider * spider,TABLE * table)6463 int spider_db_bulk_update_size_limit(
6464 ha_spider *spider,
6465 TABLE *table
6466 ) {
6467 int error_num, roop_count;
6468 SPIDER_SHARE *share = spider->share;
6469 SPIDER_RESULT_LIST *result_list = &spider->result_list;
6470 SPIDER_CONN *conn;
6471 ha_rows dup_key_found = 0;
6472 DBUG_ENTER("spider_db_bulk_update_size_limit");
6473
6474 if (result_list->bulk_update_mode == 1)
6475 {
6476 /* execute bulk updating */
6477 for (
6478 roop_count = spider_conn_link_idx_next(share->link_statuses,
6479 spider->conn_link_idx, -1, share->link_count,
6480 SPIDER_LINK_STATUS_RECOVERY);
6481 roop_count < (int) share->link_count;
6482 roop_count = spider_conn_link_idx_next(share->link_statuses,
6483 spider->conn_link_idx, roop_count, share->link_count,
6484 SPIDER_LINK_STATUS_RECOVERY)
6485 ) {
6486 conn = spider->conns[roop_count];
6487 spider_db_handler *dbton_hdl = spider->dbton_handler[conn->dbton_id];
6488 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
6489 if (dbton_hdl->need_lock_before_set_sql_for_exec(
6490 SPIDER_SQL_TYPE_BULK_UPDATE_SQL))
6491 {
6492 pthread_mutex_lock(&conn->mta_conn_mutex);
6493 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
6494 }
6495 if ((error_num = dbton_hdl->set_sql_for_exec(
6496 SPIDER_SQL_TYPE_BULK_UPDATE_SQL, roop_count)))
6497 {
6498 if (dbton_hdl->need_lock_before_set_sql_for_exec(
6499 SPIDER_SQL_TYPE_BULK_UPDATE_SQL))
6500 {
6501 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
6502 pthread_mutex_unlock(&conn->mta_conn_mutex);
6503 }
6504 DBUG_RETURN(error_num);
6505 }
6506 if (!dbton_hdl->need_lock_before_set_sql_for_exec(
6507 SPIDER_SQL_TYPE_BULK_UPDATE_SQL))
6508 {
6509 pthread_mutex_lock(&conn->mta_conn_mutex);
6510 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
6511 }
6512 if ((error_num = spider_db_query_for_bulk_update(
6513 spider, conn, roop_count, &dup_key_found)))
6514 {
6515 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
6516 DBUG_RETURN(error_num);
6517 }
6518 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
6519 }
6520 spider->reset_sql_sql(SPIDER_SQL_TYPE_BULK_UPDATE_SQL);
6521 } else {
6522 /* store query to temporary tables */
6523 if ((error_num = spider->mk_bulk_tmp_table_and_bulk_start()))
6524 {
6525 goto error_mk_table;
6526 }
6527 if ((error_num = spider->bulk_tmp_table_insert()))
6528 {
6529 goto error_write_row;
6530 }
6531 spider->reset_sql_sql(SPIDER_SQL_TYPE_BULK_UPDATE_SQL);
6532 }
6533 DBUG_RETURN(0);
6534
6535 error_write_row:
6536 spider->bulk_tmp_table_end_bulk_insert();
6537 spider->rm_bulk_tmp_table();
6538 spider->reset_sql_sql(SPIDER_SQL_TYPE_BULK_UPDATE_SQL);
6539 error_mk_table:
6540 DBUG_RETURN(error_num);
6541 }
6542
spider_db_bulk_update_end(ha_spider * spider,ha_rows * dup_key_found)6543 int spider_db_bulk_update_end(
6544 ha_spider *spider,
6545 ha_rows *dup_key_found
6546 ) {
6547 int error_num = 0, error_num2, roop_count;
6548 THD *thd = spider->trx->thd;
6549 SPIDER_SHARE *share = spider->share;
6550 SPIDER_CONN *conn;
6551 bool is_error = thd->is_error();
6552 DBUG_ENTER("spider_db_bulk_update_end");
6553
6554 if (spider->bulk_tmp_table_created())
6555 {
6556 if ((error_num2 = spider->bulk_tmp_table_end_bulk_insert()))
6557 {
6558 error_num = error_num2;
6559 }
6560
6561 if (!is_error)
6562 {
6563 if (error_num)
6564 goto error_last_query;
6565
6566 if ((error_num = spider->bulk_tmp_table_rnd_init()))
6567 {
6568 goto error_rnd_init;
6569 }
6570
6571 while (!(error_num = spider->bulk_tmp_table_rnd_next()))
6572 {
6573 for (
6574 roop_count = spider_conn_link_idx_next(share->link_statuses,
6575 spider->conn_link_idx, -1, share->link_count,
6576 SPIDER_LINK_STATUS_RECOVERY);
6577 roop_count < (int) share->link_count;
6578 roop_count = spider_conn_link_idx_next(share->link_statuses,
6579 spider->conn_link_idx, roop_count, share->link_count,
6580 SPIDER_LINK_STATUS_RECOVERY)
6581 ) {
6582 conn = spider->conns[roop_count];
6583 spider_db_handler *dbton_hdl = spider->dbton_handler[conn->dbton_id];
6584 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
6585 if (dbton_hdl->need_lock_before_set_sql_for_exec(
6586 SPIDER_SQL_TYPE_BULK_UPDATE_SQL))
6587 {
6588 pthread_mutex_lock(&conn->mta_conn_mutex);
6589 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
6590 }
6591 if ((error_num = dbton_hdl->set_sql_for_exec(
6592 SPIDER_SQL_TYPE_BULK_UPDATE_SQL, roop_count)))
6593 {
6594 if (dbton_hdl->need_lock_before_set_sql_for_exec(
6595 SPIDER_SQL_TYPE_BULK_UPDATE_SQL))
6596 {
6597 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
6598 pthread_mutex_unlock(&conn->mta_conn_mutex);
6599 }
6600 if (error_num == ER_SPIDER_COND_SKIP_NUM)
6601 {
6602 continue;
6603 }
6604 DBUG_RETURN(error_num);
6605 }
6606 if (!dbton_hdl->need_lock_before_set_sql_for_exec(
6607 SPIDER_SQL_TYPE_BULK_UPDATE_SQL))
6608 {
6609 pthread_mutex_lock(&conn->mta_conn_mutex);
6610 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
6611 }
6612 if ((error_num = spider_db_query_for_bulk_update(
6613 spider, conn, roop_count, dup_key_found)))
6614 {
6615 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
6616 goto error_query;
6617 }
6618 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
6619 }
6620 }
6621 if (error_num != HA_ERR_END_OF_FILE)
6622 goto error_rnd_next;
6623
6624 spider->bulk_tmp_table_rnd_end();
6625 }
6626 }
6627
6628 if (!is_error)
6629 {
6630 if (!spider->sql_is_empty(SPIDER_SQL_TYPE_BULK_UPDATE_SQL))
6631 {
6632 for (
6633 roop_count = spider_conn_link_idx_next(share->link_statuses,
6634 spider->conn_link_idx, -1, share->link_count,
6635 SPIDER_LINK_STATUS_RECOVERY);
6636 roop_count < (int) share->link_count;
6637 roop_count = spider_conn_link_idx_next(share->link_statuses,
6638 spider->conn_link_idx, roop_count, share->link_count,
6639 SPIDER_LINK_STATUS_RECOVERY)
6640 ) {
6641 conn = spider->conns[roop_count];
6642 spider_db_handler *dbton_hdl = spider->dbton_handler[conn->dbton_id];
6643 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
6644 if (dbton_hdl->need_lock_before_set_sql_for_exec(
6645 SPIDER_SQL_TYPE_BULK_UPDATE_SQL))
6646 {
6647 pthread_mutex_lock(&conn->mta_conn_mutex);
6648 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
6649 }
6650 if ((error_num = dbton_hdl->set_sql_for_exec(
6651 SPIDER_SQL_TYPE_BULK_UPDATE_SQL, roop_count)))
6652 {
6653 if (dbton_hdl->need_lock_before_set_sql_for_exec(
6654 SPIDER_SQL_TYPE_BULK_UPDATE_SQL))
6655 {
6656 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
6657 pthread_mutex_unlock(&conn->mta_conn_mutex);
6658 }
6659 DBUG_RETURN(error_num);
6660 }
6661 if (!dbton_hdl->need_lock_before_set_sql_for_exec(
6662 SPIDER_SQL_TYPE_BULK_UPDATE_SQL))
6663 {
6664 pthread_mutex_lock(&conn->mta_conn_mutex);
6665 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
6666 }
6667 if ((error_num = spider_db_query_for_bulk_update(
6668 spider, conn, roop_count, dup_key_found)))
6669 {
6670 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
6671 goto error_last_query;
6672 }
6673 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
6674 }
6675 }
6676 }
6677 spider->rm_bulk_tmp_table();
6678 spider->reset_sql_sql(SPIDER_SQL_TYPE_BULK_UPDATE_SQL);
6679 DBUG_RETURN(0);
6680
6681 error_query:
6682 error_rnd_next:
6683 spider->bulk_tmp_table_rnd_end();
6684 error_rnd_init:
6685 error_last_query:
6686 spider->rm_bulk_tmp_table();
6687 spider->reset_sql_sql(SPIDER_SQL_TYPE_BULK_UPDATE_SQL);
6688 DBUG_RETURN(error_num);
6689 }
6690
spider_db_bulk_update(ha_spider * spider,TABLE * table,my_ptrdiff_t ptr_diff)6691 int spider_db_bulk_update(
6692 ha_spider *spider,
6693 TABLE *table,
6694 my_ptrdiff_t ptr_diff
6695 ) {
6696 int error_num;
6697 DBUG_ENTER("spider_db_bulk_update");
6698
6699 if ((error_num = spider->append_update_sql(table, ptr_diff, TRUE)))
6700 DBUG_RETURN(error_num);
6701
6702 if (
6703 spider->sql_is_filled_up(SPIDER_SQL_TYPE_BULK_UPDATE_SQL) &&
6704 (error_num = spider_db_bulk_update_size_limit(spider, table))
6705 )
6706 DBUG_RETURN(error_num);
6707 DBUG_RETURN(0);
6708 }
6709
spider_db_update(ha_spider * spider,TABLE * table,const uchar * old_data)6710 int spider_db_update(
6711 ha_spider *spider,
6712 TABLE *table,
6713 const uchar *old_data
6714 ) {
6715 int error_num, roop_count;
6716 SPIDER_SHARE *share = spider->share;
6717 SPIDER_CONN *conn;
6718 SPIDER_RESULT_LIST *result_list = &spider->result_list;
6719 my_ptrdiff_t ptr_diff = PTR_BYTE_DIFF(old_data, table->record[0]);
6720 DBUG_ENTER("spider_db_update");
6721 if (result_list->bulk_update_mode)
6722 DBUG_RETURN(spider_db_bulk_update(spider, table, ptr_diff));
6723
6724 if ((error_num = spider->append_update_sql(table, ptr_diff, FALSE)))
6725 DBUG_RETURN(error_num);
6726
6727 for (
6728 roop_count = spider_conn_link_idx_next(share->link_statuses,
6729 spider->conn_link_idx, -1, share->link_count,
6730 SPIDER_LINK_STATUS_RECOVERY);
6731 roop_count < (int) share->link_count;
6732 roop_count = spider_conn_link_idx_next(share->link_statuses,
6733 spider->conn_link_idx, roop_count, share->link_count,
6734 SPIDER_LINK_STATUS_RECOVERY)
6735 ) {
6736 conn = spider->conns[roop_count];
6737 spider_db_handler *dbton_hdl = spider->dbton_handler[conn->dbton_id];
6738 #if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000
6739 conn->ignore_dup_key = spider->ignore_dup_key;
6740 #endif
6741 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
6742 if (dbton_hdl->need_lock_before_set_sql_for_exec(
6743 SPIDER_SQL_TYPE_UPDATE_SQL))
6744 {
6745 pthread_mutex_lock(&conn->mta_conn_mutex);
6746 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
6747 }
6748 if ((error_num = dbton_hdl->set_sql_for_exec(
6749 SPIDER_SQL_TYPE_UPDATE_SQL, roop_count)))
6750 {
6751 if (dbton_hdl->need_lock_before_set_sql_for_exec(
6752 SPIDER_SQL_TYPE_UPDATE_SQL))
6753 {
6754 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
6755 pthread_mutex_unlock(&conn->mta_conn_mutex);
6756 }
6757 DBUG_RETURN(error_num);
6758 }
6759 if (!dbton_hdl->need_lock_before_set_sql_for_exec(
6760 SPIDER_SQL_TYPE_UPDATE_SQL))
6761 {
6762 pthread_mutex_lock(&conn->mta_conn_mutex);
6763 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
6764 }
6765 conn->need_mon = &spider->need_mons[roop_count];
6766 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
6767 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
6768 conn->mta_conn_mutex_lock_already = TRUE;
6769 conn->mta_conn_mutex_unlock_later = TRUE;
6770 if ((error_num = spider_db_set_names(spider, conn, roop_count)))
6771 {
6772 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
6773 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
6774 conn->mta_conn_mutex_lock_already = FALSE;
6775 conn->mta_conn_mutex_unlock_later = FALSE;
6776 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
6777 pthread_mutex_unlock(&conn->mta_conn_mutex);
6778 if (
6779 share->monitoring_kind[roop_count] &&
6780 spider->need_mons[roop_count]
6781 ) {
6782 error_num = spider_ping_table_mon_from_table(
6783 spider->trx,
6784 spider->trx->thd,
6785 share,
6786 roop_count,
6787 (uint32) share->monitoring_sid[roop_count],
6788 share->table_name,
6789 share->table_name_length,
6790 spider->conn_link_idx[roop_count],
6791 NULL,
6792 0,
6793 share->monitoring_kind[roop_count],
6794 share->monitoring_limit[roop_count],
6795 share->monitoring_flag[roop_count],
6796 TRUE
6797 );
6798 }
6799 DBUG_RETURN(error_num);
6800 }
6801 spider_conn_set_timeout_from_share(conn, roop_count, spider->trx->thd,
6802 share);
6803 if (dbton_hdl->execute_sql(
6804 SPIDER_SQL_TYPE_UPDATE_SQL,
6805 conn,
6806 -1,
6807 &spider->need_mons[roop_count])
6808 ) {
6809 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
6810 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
6811 conn->mta_conn_mutex_lock_already = FALSE;
6812 conn->mta_conn_mutex_unlock_later = FALSE;
6813 error_num = spider_db_errorno(conn);
6814 if (
6815 error_num != ER_DUP_ENTRY &&
6816 error_num != ER_DUP_KEY &&
6817 error_num != HA_ERR_FOUND_DUPP_KEY &&
6818 share->monitoring_kind[roop_count] &&
6819 spider->need_mons[roop_count]
6820 ) {
6821 error_num = spider_ping_table_mon_from_table(
6822 spider->trx,
6823 spider->trx->thd,
6824 share,
6825 roop_count,
6826 (uint32) share->monitoring_sid[roop_count],
6827 share->table_name,
6828 share->table_name_length,
6829 spider->conn_link_idx[roop_count],
6830 NULL,
6831 0,
6832 share->monitoring_kind[roop_count],
6833 share->monitoring_limit[roop_count],
6834 share->monitoring_flag[roop_count],
6835 TRUE
6836 );
6837 }
6838 DBUG_RETURN(error_num);
6839 }
6840
6841 if (
6842 !conn->db_conn->affected_rows() &&
6843 share->link_statuses[roop_count] == SPIDER_LINK_STATUS_RECOVERY &&
6844 spider->pk_update
6845 ) {
6846 /* insert */
6847 if ((error_num = dbton_hdl->append_insert_for_recovery(
6848 SPIDER_SQL_TYPE_INSERT_SQL, roop_count)))
6849 {
6850 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
6851 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
6852 conn->mta_conn_mutex_lock_already = FALSE;
6853 conn->mta_conn_mutex_unlock_later = FALSE;
6854 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
6855 pthread_mutex_unlock(&conn->mta_conn_mutex);
6856 DBUG_RETURN(error_num);
6857 }
6858 spider_conn_set_timeout_from_share(conn, roop_count, spider->trx->thd,
6859 share);
6860 if (dbton_hdl->execute_sql(
6861 SPIDER_SQL_TYPE_INSERT_SQL,
6862 conn,
6863 -1,
6864 &spider->need_mons[roop_count])
6865 ) {
6866 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
6867 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
6868 conn->mta_conn_mutex_lock_already = FALSE;
6869 conn->mta_conn_mutex_unlock_later = FALSE;
6870 error_num = spider_db_errorno(conn);
6871 if (
6872 error_num != ER_DUP_ENTRY &&
6873 error_num != ER_DUP_KEY &&
6874 error_num != HA_ERR_FOUND_DUPP_KEY &&
6875 share->monitoring_kind[roop_count] &&
6876 spider->need_mons[roop_count]
6877 ) {
6878 error_num = spider_ping_table_mon_from_table(
6879 spider->trx,
6880 spider->trx->thd,
6881 share,
6882 roop_count,
6883 (uint32) share->monitoring_sid[roop_count],
6884 share->table_name,
6885 share->table_name_length,
6886 spider->conn_link_idx[roop_count],
6887 NULL,
6888 0,
6889 share->monitoring_kind[roop_count],
6890 share->monitoring_limit[roop_count],
6891 share->monitoring_flag[roop_count],
6892 TRUE
6893 );
6894 }
6895 DBUG_RETURN(error_num);
6896 }
6897 }
6898 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
6899 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
6900 conn->mta_conn_mutex_lock_already = FALSE;
6901 conn->mta_conn_mutex_unlock_later = FALSE;
6902 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
6903 pthread_mutex_unlock(&conn->mta_conn_mutex);
6904 result_list->update_sqls[roop_count].length(0);
6905 }
6906 spider->reset_sql_sql(SPIDER_SQL_TYPE_UPDATE_SQL);
6907 DBUG_RETURN(0);
6908 }
6909
6910 #ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
6911 #ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS_WITH_HS
spider_db_direct_update(ha_spider * spider,TABLE * table,KEY_MULTI_RANGE * ranges,uint range_count,ha_rows * update_rows)6912 int spider_db_direct_update(
6913 ha_spider *spider,
6914 TABLE *table,
6915 KEY_MULTI_RANGE *ranges,
6916 uint range_count,
6917 ha_rows *update_rows
6918 ) {
6919 int error_num, roop_count;
6920 SPIDER_SHARE *share = spider->share;
6921 SPIDER_CONN *conn;
6922 SPIDER_RESULT_LIST *result_list = &spider->result_list;
6923 bool counted = FALSE;
6924 st_select_lex *select_lex;
6925 longlong select_limit;
6926 longlong offset_limit;
6927 DBUG_ENTER("spider_db_direct_update");
6928
6929 spider_set_result_list_param(spider);
6930 result_list->finish_flg = FALSE;
6931 DBUG_PRINT("info", ("spider do_direct_update=%s",
6932 spider->do_direct_update ? "TRUE" : "FALSE"));
6933 DBUG_PRINT("info", ("spider direct_update_kinds=%u",
6934 spider->direct_update_kinds));
6935 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
6936 if (
6937 #ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
6938 (
6939 spider->do_direct_update &&
6940 (spider->direct_update_kinds & SPIDER_SQL_KIND_SQL)
6941 ) ||
6942 (
6943 !spider->do_direct_update &&
6944 #endif
6945 (spider->sql_kinds & SPIDER_SQL_KIND_SQL)
6946 #ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
6947 )
6948 #endif
6949 ) {
6950 #endif
6951 if ((error_num = spider->append_update_sql_part()))
6952 DBUG_RETURN(error_num);
6953 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
6954 }
6955 #endif
6956
6957 /*
6958 SQL access -> SQL remote access
6959 !spider->do_direct_update &&
6960 (spider->sql_kinds & SPIDER_SQL_KIND_SQL)
6961
6962 SQL access -> SQL remote access with dirct_update
6963 spider->do_direct_update &&
6964 spider->direct_update_kinds == SPIDER_SQL_KIND_SQL &&
6965 spider->direct_update_fields
6966
6967 Handlersocket access -> SQL remote access with dirct_update
6968 spider->do_direct_update &&
6969 (spider->direct_update_kinds & SPIDER_SQL_KIND_SQL)
6970
6971 Handlersocket access -> Handlersocket access
6972 spider->do_direct_update &&
6973 (spider->direct_update_kinds & SPIDER_SQL_KIND_HS)
6974 */
6975
6976 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
6977 if (spider->hs_increment || spider->hs_decrement)
6978 {
6979 if (
6980 (spider->direct_update_kinds & SPIDER_SQL_KIND_SQL) &&
6981 (error_num = spider->append_increment_update_set_sql_part())
6982 ) {
6983 DBUG_RETURN(error_num);
6984 }
6985 } else {
6986 #endif
6987 #ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
6988 if (!spider->do_direct_update)
6989 {
6990 #endif
6991 if (
6992 (spider->sql_kinds & SPIDER_SQL_KIND_SQL) &&
6993 (error_num = spider->append_update_set_sql_part())
6994 ) {
6995 DBUG_RETURN(error_num);
6996 }
6997 #ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
6998 } else {
6999 if (
7000 (spider->direct_update_kinds & SPIDER_SQL_KIND_SQL) &&
7001 (error_num = spider->append_direct_update_set_sql_part())
7002 ) {
7003 DBUG_RETURN(error_num);
7004 }
7005 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
7006 if (
7007 (spider->direct_update_kinds & SPIDER_SQL_KIND_HS) &&
7008 (error_num = spider->append_direct_update_set_hs_part())
7009 ) {
7010 DBUG_RETURN(error_num);
7011 }
7012 #endif
7013 }
7014 #endif
7015 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
7016 }
7017 #endif
7018
7019 result_list->desc_flg = FALSE;
7020 result_list->sorted = TRUE;
7021 if (spider->active_index == MAX_KEY)
7022 result_list->key_info = NULL;
7023 else
7024 result_list->key_info = &table->key_info[spider->active_index];
7025 spider_get_select_limit(spider, &select_lex, &select_limit, &offset_limit);
7026 result_list->limit_num =
7027 result_list->internal_limit >= select_limit ?
7028 select_limit : result_list->internal_limit;
7029 result_list->internal_offset += offset_limit;
7030 if (spider->direct_update_kinds & SPIDER_SQL_KIND_SQL)
7031 {
7032 if (
7033 (error_num = spider->append_key_where_sql_part(
7034 (ranges && ranges->start_key.key) ? &ranges->start_key : NULL,
7035 (ranges && ranges->end_key.key) ? &ranges->end_key : NULL,
7036 SPIDER_SQL_TYPE_UPDATE_SQL)) ||
7037 (error_num = spider->
7038 append_key_order_for_direct_order_limit_with_alias_sql_part(
7039 NULL, 0, SPIDER_SQL_TYPE_UPDATE_SQL)) ||
7040 (error_num = spider->append_limit_sql_part(
7041 result_list->internal_offset, result_list->limit_num,
7042 SPIDER_SQL_TYPE_UPDATE_SQL))
7043 ) {
7044 DBUG_RETURN(error_num);
7045 }
7046 }
7047 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
7048 if (spider->direct_update_kinds & SPIDER_SQL_KIND_HS)
7049 {
7050 if (
7051 (error_num = spider->append_key_where_hs_part(
7052 (ranges && ranges->start_key.key) ? &ranges->start_key : NULL,
7053 (ranges && ranges->end_key.key) ? &ranges->end_key : NULL,
7054 SPIDER_SQL_TYPE_UPDATE_HS)) ||
7055 (error_num = spider->append_limit_hs_part(
7056 result_list->internal_offset, result_list->limit_num,
7057 SPIDER_SQL_TYPE_UPDATE_HS))
7058 ) {
7059 DBUG_RETURN(error_num);
7060 }
7061 }
7062 #endif
7063
7064 for (
7065 roop_count = spider_conn_link_idx_next(share->link_statuses,
7066 spider->conn_link_idx, -1, share->link_count,
7067 SPIDER_LINK_STATUS_RECOVERY);
7068 roop_count < (int) share->link_count;
7069 roop_count = spider_conn_link_idx_next(share->link_statuses,
7070 spider->conn_link_idx, roop_count, share->link_count,
7071 SPIDER_LINK_STATUS_RECOVERY)
7072 ) {
7073 ulong sql_type;
7074 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
7075 if (!spider_bit_is_set(spider->do_hs_direct_update, roop_count))
7076 {
7077 #endif
7078 DBUG_PRINT("info", ("spider exec sql"));
7079 conn = spider->conns[roop_count];
7080 sql_type = SPIDER_SQL_TYPE_UPDATE_SQL;
7081 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
7082 } else {
7083 DBUG_PRINT("info", ("spider exec hs"));
7084 conn = spider->hs_w_conns[roop_count];
7085 sql_type = SPIDER_SQL_TYPE_UPDATE_HS;
7086 }
7087 #endif
7088 spider_db_handler *dbton_hdl = spider->dbton_handler[conn->dbton_id];
7089 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
7090 if (dbton_hdl->need_lock_before_set_sql_for_exec(sql_type))
7091 {
7092 pthread_mutex_lock(&conn->mta_conn_mutex);
7093 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
7094 }
7095 if ((error_num = dbton_hdl->set_sql_for_exec(sql_type, roop_count)))
7096 {
7097 if (dbton_hdl->need_lock_before_set_sql_for_exec(sql_type))
7098 {
7099 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
7100 pthread_mutex_unlock(&conn->mta_conn_mutex);
7101 }
7102 DBUG_RETURN(error_num);
7103 }
7104 if (!dbton_hdl->need_lock_before_set_sql_for_exec(sql_type))
7105 {
7106 pthread_mutex_lock(&conn->mta_conn_mutex);
7107 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
7108 }
7109 #ifdef HA_CAN_BULK_ACCESS
7110 if (spider->is_bulk_access_clone)
7111 {
7112 spider->connection_ids[roop_count] = conn->connection_id;
7113 spider_trx_add_bulk_access_conn(spider->trx, conn);
7114 } else {
7115 #endif
7116 conn->need_mon = &spider->need_mons[roop_count];
7117 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
7118 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
7119 conn->mta_conn_mutex_lock_already = TRUE;
7120 conn->mta_conn_mutex_unlock_later = TRUE;
7121 if ((error_num = spider_db_set_names(spider, conn, roop_count)))
7122 {
7123 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
7124 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
7125 conn->mta_conn_mutex_lock_already = FALSE;
7126 conn->mta_conn_mutex_unlock_later = FALSE;
7127 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
7128 pthread_mutex_unlock(&conn->mta_conn_mutex);
7129 if (
7130 share->monitoring_kind[roop_count] &&
7131 spider->need_mons[roop_count]
7132 ) {
7133 error_num = spider_ping_table_mon_from_table(
7134 spider->trx,
7135 spider->trx->thd,
7136 share,
7137 roop_count,
7138 (uint32) share->monitoring_sid[roop_count],
7139 share->table_name,
7140 share->table_name_length,
7141 spider->conn_link_idx[roop_count],
7142 NULL,
7143 0,
7144 share->monitoring_kind[roop_count],
7145 share->monitoring_limit[roop_count],
7146 share->monitoring_flag[roop_count],
7147 TRUE
7148 );
7149 }
7150 DBUG_RETURN(error_num);
7151 }
7152 spider_conn_set_timeout_from_share(conn, roop_count, spider->trx->thd,
7153 share);
7154 if (
7155 (error_num = dbton_hdl->execute_sql(
7156 sql_type,
7157 conn,
7158 -1,
7159 &spider->need_mons[roop_count])
7160 ) &&
7161 (error_num != HA_ERR_FOUND_DUPP_KEY || !spider->ignore_dup_key)
7162 ) {
7163 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
7164 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
7165 conn->mta_conn_mutex_lock_already = FALSE;
7166 conn->mta_conn_mutex_unlock_later = FALSE;
7167 error_num = spider_db_errorno(conn);
7168 if (
7169 error_num != ER_DUP_ENTRY &&
7170 error_num != ER_DUP_KEY &&
7171 error_num != HA_ERR_FOUND_DUPP_KEY &&
7172 share->monitoring_kind[roop_count] &&
7173 spider->need_mons[roop_count]
7174 ) {
7175 error_num = spider_ping_table_mon_from_table(
7176 spider->trx,
7177 spider->trx->thd,
7178 share,
7179 roop_count,
7180 (uint32) share->monitoring_sid[roop_count],
7181 share->table_name,
7182 share->table_name_length,
7183 spider->conn_link_idx[roop_count],
7184 NULL,
7185 0,
7186 share->monitoring_kind[roop_count],
7187 share->monitoring_limit[roop_count],
7188 share->monitoring_flag[roop_count],
7189 TRUE
7190 );
7191 }
7192 DBUG_RETURN(error_num);
7193 }
7194 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
7195 if (!spider_bit_is_set(spider->do_hs_direct_update, roop_count))
7196 {
7197 #endif
7198 if (!counted)
7199 {
7200 *update_rows = spider->conns[roop_count]->db_conn->affected_rows();
7201 DBUG_PRINT("info", ("spider update_rows = %llu", *update_rows));
7202 counted = TRUE;
7203 }
7204 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
7205 } else {
7206 SPIDER_DB_RESULT *result;
7207 if (spider_bit_is_set(spider->db_request_phase, roop_count))
7208 {
7209 spider_clear_bit(spider->db_request_phase, roop_count);
7210 }
7211 st_spider_db_request_key request_key;
7212 request_key.spider_thread_id = spider->trx->spider_thread_id;
7213 request_key.query_id = spider->trx->thd->query_id;
7214 request_key.handler = spider;
7215 request_key.request_id = spider->db_request_id[roop_count];
7216 request_key.next = NULL;
7217 if ((result = conn->db_conn->use_result(&request_key, &error_num)))
7218 {
7219 if (!counted)
7220 {
7221 *update_rows = conn->db_conn->affected_rows();
7222 DBUG_PRINT("info", ("spider update_rows = %llu", *update_rows));
7223 counted = TRUE;
7224 }
7225 result->free_result();
7226 delete result;
7227 } else {
7228 if (!error_num)
7229 {
7230 error_num = spider_db_errorno(conn);
7231 }
7232 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
7233 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
7234 conn->mta_conn_mutex_lock_already = FALSE;
7235 conn->mta_conn_mutex_unlock_later = FALSE;
7236 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
7237 pthread_mutex_unlock(&conn->mta_conn_mutex);
7238 DBUG_RETURN(error_num);
7239 }
7240 }
7241 #endif
7242 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
7243 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
7244 conn->mta_conn_mutex_lock_already = FALSE;
7245 conn->mta_conn_mutex_unlock_later = FALSE;
7246 #ifdef HA_CAN_BULK_ACCESS
7247 }
7248 #endif
7249 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
7250 pthread_mutex_unlock(&conn->mta_conn_mutex);
7251 }
7252 spider->reset_sql_sql(SPIDER_SQL_TYPE_UPDATE_SQL);
7253 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
7254 spider->reset_hs_sql(SPIDER_SQL_TYPE_UPDATE_HS);
7255 spider->reset_hs_keys(SPIDER_SQL_TYPE_UPDATE_HS);
7256 spider->reset_hs_upds(SPIDER_SQL_TYPE_UPDATE_HS);
7257 #endif
7258 DBUG_RETURN(0);
7259 }
7260 #else
spider_db_direct_update(ha_spider * spider,TABLE * table,ha_rows * update_rows)7261 int spider_db_direct_update(
7262 ha_spider *spider,
7263 TABLE *table,
7264 ha_rows *update_rows
7265 ) {
7266 int error_num, roop_count;
7267 SPIDER_SHARE *share = spider->share;
7268 SPIDER_CONN *conn;
7269 SPIDER_RESULT_LIST *result_list = &spider->result_list;
7270 bool counted = FALSE;
7271 st_select_lex *select_lex;
7272 longlong select_limit;
7273 longlong offset_limit;
7274 DBUG_ENTER("spider_db_direct_update");
7275
7276 spider_set_result_list_param(spider);
7277 result_list->finish_flg = FALSE;
7278 DBUG_PRINT("info", ("spider do_direct_update=%s",
7279 spider->do_direct_update ? "TRUE" : "FALSE"));
7280 DBUG_PRINT("info", ("spider direct_update_kinds=%u",
7281 spider->direct_update_kinds));
7282 if ((error_num = spider->append_update_sql_part()))
7283 DBUG_RETURN(error_num);
7284
7285 /*
7286 SQL access -> SQL remote access
7287 !spider->do_direct_update &&
7288 (spider->sql_kinds & SPIDER_SQL_KIND_SQL)
7289
7290 SQL access -> SQL remote access with dirct_update
7291 spider->do_direct_update &&
7292 spider->direct_update_kinds == SPIDER_SQL_KIND_SQL &&
7293 spider->direct_update_fields
7294 */
7295
7296 #ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
7297 if (!spider->do_direct_update)
7298 {
7299 #endif
7300 if (
7301 (spider->sql_kinds & SPIDER_SQL_KIND_SQL) &&
7302 (error_num = spider->append_update_set_sql_part())
7303 ) {
7304 DBUG_RETURN(error_num);
7305 }
7306 #ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
7307 } else {
7308 if (
7309 (spider->direct_update_kinds & SPIDER_SQL_KIND_SQL) &&
7310 (error_num = spider->append_direct_update_set_sql_part())
7311 ) {
7312 DBUG_RETURN(error_num);
7313 }
7314 }
7315 #endif
7316
7317 result_list->desc_flg = FALSE;
7318 result_list->sorted = TRUE;
7319 if (spider->active_index == MAX_KEY)
7320 result_list->key_info = NULL;
7321 else
7322 result_list->key_info = &table->key_info[spider->active_index];
7323 spider_get_select_limit(spider, &select_lex, &select_limit, &offset_limit);
7324 result_list->limit_num =
7325 result_list->internal_limit >= select_limit ?
7326 select_limit : result_list->internal_limit;
7327 result_list->internal_offset += offset_limit;
7328 if (spider->direct_update_kinds & SPIDER_SQL_KIND_SQL)
7329 {
7330 if (
7331 (error_num = spider->append_key_where_sql_part(
7332 NULL,
7333 NULL,
7334 SPIDER_SQL_TYPE_UPDATE_SQL)) ||
7335 (error_num = spider->
7336 append_key_order_for_direct_order_limit_with_alias_sql_part(
7337 NULL, 0, SPIDER_SQL_TYPE_UPDATE_SQL)) ||
7338 (error_num = spider->append_limit_sql_part(
7339 result_list->internal_offset, result_list->limit_num,
7340 SPIDER_SQL_TYPE_UPDATE_SQL))
7341 ) {
7342 DBUG_RETURN(error_num);
7343 }
7344 }
7345
7346 for (
7347 roop_count = spider_conn_link_idx_next(share->link_statuses,
7348 spider->conn_link_idx, -1, share->link_count,
7349 SPIDER_LINK_STATUS_RECOVERY);
7350 roop_count < (int) share->link_count;
7351 roop_count = spider_conn_link_idx_next(share->link_statuses,
7352 spider->conn_link_idx, roop_count, share->link_count,
7353 SPIDER_LINK_STATUS_RECOVERY)
7354 ) {
7355 ulong sql_type;
7356 DBUG_PRINT("info", ("spider exec sql"));
7357 conn = spider->conns[roop_count];
7358 sql_type = SPIDER_SQL_TYPE_UPDATE_SQL;
7359 spider_db_handler *dbton_hdl = spider->dbton_handler[conn->dbton_id];
7360 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
7361 if (dbton_hdl->need_lock_before_set_sql_for_exec(sql_type))
7362 {
7363 pthread_mutex_lock(&conn->mta_conn_mutex);
7364 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
7365 }
7366 if ((error_num = dbton_hdl->set_sql_for_exec(sql_type, roop_count)))
7367 {
7368 if (dbton_hdl->need_lock_before_set_sql_for_exec(sql_type))
7369 {
7370 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
7371 pthread_mutex_unlock(&conn->mta_conn_mutex);
7372 }
7373 DBUG_RETURN(error_num);
7374 }
7375 if (!dbton_hdl->need_lock_before_set_sql_for_exec(sql_type))
7376 {
7377 pthread_mutex_lock(&conn->mta_conn_mutex);
7378 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
7379 }
7380 #ifdef HA_CAN_BULK_ACCESS
7381 if (spider->is_bulk_access_clone)
7382 {
7383 spider->connection_ids[roop_count] = conn->connection_id;
7384 spider_trx_add_bulk_access_conn(spider->trx, conn);
7385 } else {
7386 #endif
7387 conn->need_mon = &spider->need_mons[roop_count];
7388 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
7389 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
7390 conn->mta_conn_mutex_lock_already = TRUE;
7391 conn->mta_conn_mutex_unlock_later = TRUE;
7392 if ((error_num = spider_db_set_names(spider, conn, roop_count)))
7393 {
7394 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
7395 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
7396 conn->mta_conn_mutex_lock_already = FALSE;
7397 conn->mta_conn_mutex_unlock_later = FALSE;
7398 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
7399 pthread_mutex_unlock(&conn->mta_conn_mutex);
7400 if (
7401 share->monitoring_kind[roop_count] &&
7402 spider->need_mons[roop_count]
7403 ) {
7404 error_num = spider_ping_table_mon_from_table(
7405 spider->trx,
7406 spider->trx->thd,
7407 share,
7408 roop_count,
7409 (uint32) share->monitoring_sid[roop_count],
7410 share->table_name,
7411 share->table_name_length,
7412 spider->conn_link_idx[roop_count],
7413 NULL,
7414 0,
7415 share->monitoring_kind[roop_count],
7416 share->monitoring_limit[roop_count],
7417 share->monitoring_flag[roop_count],
7418 TRUE
7419 );
7420 }
7421 DBUG_RETURN(error_num);
7422 }
7423 spider_conn_set_timeout_from_share(conn, roop_count, spider->trx->thd,
7424 share);
7425 if (
7426 (error_num = dbton_hdl->execute_sql(
7427 sql_type,
7428 conn,
7429 -1,
7430 &spider->need_mons[roop_count])
7431 ) &&
7432 (error_num != HA_ERR_FOUND_DUPP_KEY || !spider->ignore_dup_key)
7433 ) {
7434 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
7435 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
7436 conn->mta_conn_mutex_lock_already = FALSE;
7437 conn->mta_conn_mutex_unlock_later = FALSE;
7438 error_num = spider_db_errorno(conn);
7439 if (
7440 error_num != ER_DUP_ENTRY &&
7441 error_num != ER_DUP_KEY &&
7442 error_num != HA_ERR_FOUND_DUPP_KEY &&
7443 share->monitoring_kind[roop_count] &&
7444 spider->need_mons[roop_count]
7445 ) {
7446 error_num = spider_ping_table_mon_from_table(
7447 spider->trx,
7448 spider->trx->thd,
7449 share,
7450 roop_count,
7451 (uint32) share->monitoring_sid[roop_count],
7452 share->table_name,
7453 share->table_name_length,
7454 spider->conn_link_idx[roop_count],
7455 NULL,
7456 0,
7457 share->monitoring_kind[roop_count],
7458 share->monitoring_limit[roop_count],
7459 share->monitoring_flag[roop_count],
7460 TRUE
7461 );
7462 }
7463 DBUG_RETURN(error_num);
7464 }
7465 if (!counted)
7466 {
7467 *update_rows = spider->conns[roop_count]->db_conn->affected_rows();
7468 DBUG_PRINT("info", ("spider update_rows = %llu", *update_rows));
7469 counted = TRUE;
7470 }
7471 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
7472 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
7473 conn->mta_conn_mutex_lock_already = FALSE;
7474 conn->mta_conn_mutex_unlock_later = FALSE;
7475 #ifdef HA_CAN_BULK_ACCESS
7476 }
7477 #endif
7478 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
7479 pthread_mutex_unlock(&conn->mta_conn_mutex);
7480 }
7481 spider->reset_sql_sql(SPIDER_SQL_TYPE_UPDATE_SQL);
7482 DBUG_RETURN(0);
7483 }
7484 #endif
7485 #endif
7486
7487 #ifdef HA_CAN_BULK_ACCESS
spider_db_bulk_direct_update(ha_spider * spider,ha_rows * update_rows)7488 int spider_db_bulk_direct_update(
7489 ha_spider *spider,
7490 ha_rows *update_rows
7491 ) {
7492 int error_num = 0, roop_count, tmp_error_num;
7493 SPIDER_SHARE *share = spider->share;
7494 SPIDER_CONN *conn;
7495 bool counted = FALSE;
7496 DBUG_ENTER("spider_db_bulk_direct_update");
7497 for (
7498 roop_count = spider_conn_link_idx_next(share->link_statuses,
7499 spider->conn_link_idx, -1, share->link_count,
7500 SPIDER_LINK_STATUS_RECOVERY);
7501 roop_count < (int) share->link_count;
7502 roop_count = spider_conn_link_idx_next(share->link_statuses,
7503 spider->conn_link_idx, roop_count, share->link_count,
7504 SPIDER_LINK_STATUS_RECOVERY)
7505 ) {
7506 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
7507 if (!spider_bit_is_set(spider->do_hs_direct_update, roop_count))
7508 {
7509 #endif
7510 DBUG_PRINT("info", ("spider exec sql"));
7511 conn = spider->conns[roop_count];
7512 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
7513 } else {
7514 DBUG_PRINT("info", ("spider exec hs"));
7515 conn = spider->hs_w_conns[roop_count];
7516 }
7517 #endif
7518 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
7519 pthread_mutex_lock(&conn->mta_conn_mutex);
7520 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
7521 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
7522 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
7523 conn->mta_conn_mutex_lock_already = TRUE;
7524 conn->mta_conn_mutex_unlock_later = TRUE;
7525 if ((tmp_error_num = spider_db_bulk_open_handler(spider, conn,
7526 roop_count)))
7527 {
7528 error_num = tmp_error_num;
7529 }
7530 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
7531 if (!spider_bit_is_set(spider->do_hs_direct_update, roop_count))
7532 {
7533 #endif
7534 if (!counted)
7535 {
7536 *update_rows = spider->conns[roop_count]->db_conn->affected_rows();
7537 DBUG_PRINT("info", ("spider update_rows = %llu", *update_rows));
7538 counted = TRUE;
7539 }
7540 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
7541 } else {
7542 SPIDER_DB_RESULT *result;
7543 if (spider_bit_is_set(spider->db_request_phase, roop_count))
7544 {
7545 spider_clear_bit(spider->db_request_phase, roop_count);
7546 }
7547 st_spider_db_request_key request_key;
7548 request_key.spider_thread_id = spider->trx->spider_thread_id;
7549 request_key.query_id = spider->trx->thd->query_id;
7550 request_key.handler = spider;
7551 request_key.request_id = spider->db_request_id[roop_count];
7552 request_key.next = NULL;
7553 if ((result = conn->db_conn->use_result(&request_key, &error_num)))
7554 {
7555 if (!counted)
7556 {
7557 *update_rows = conn->db_conn->affected_rows();
7558 DBUG_PRINT("info", ("spider update_rows = %llu", *update_rows));
7559 counted = TRUE;
7560 }
7561 result->free_result();
7562 delete result;
7563 } else {
7564 if (!error_num)
7565 {
7566 error_num = spider_db_errorno(conn);
7567 }
7568 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
7569 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
7570 conn->mta_conn_mutex_lock_already = FALSE;
7571 conn->mta_conn_mutex_unlock_later = FALSE;
7572 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
7573 pthread_mutex_unlock(&conn->mta_conn_mutex);
7574 DBUG_RETURN(error_num);
7575 }
7576 }
7577 #endif
7578 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
7579 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
7580 conn->mta_conn_mutex_lock_already = FALSE;
7581 conn->mta_conn_mutex_unlock_later = FALSE;
7582 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
7583 pthread_mutex_unlock(&conn->mta_conn_mutex);
7584 }
7585 DBUG_RETURN(error_num);
7586 }
7587 #endif
7588
spider_db_bulk_delete(ha_spider * spider,TABLE * table,my_ptrdiff_t ptr_diff)7589 int spider_db_bulk_delete(
7590 ha_spider *spider,
7591 TABLE *table,
7592 my_ptrdiff_t ptr_diff
7593 ) {
7594 int error_num;
7595 DBUG_ENTER("spider_db_bulk_delete");
7596
7597 if ((error_num = spider->append_delete_sql(table, ptr_diff, TRUE)))
7598 DBUG_RETURN(error_num);
7599
7600 if (
7601 spider->sql_is_filled_up(SPIDER_SQL_TYPE_BULK_UPDATE_SQL) &&
7602 (error_num = spider_db_bulk_update_size_limit(spider, table))
7603 )
7604 DBUG_RETURN(error_num);
7605 DBUG_RETURN(0);
7606 }
7607
spider_db_delete(ha_spider * spider,TABLE * table,const uchar * buf)7608 int spider_db_delete(
7609 ha_spider *spider,
7610 TABLE *table,
7611 const uchar *buf
7612 ) {
7613 int error_num, roop_count;
7614 SPIDER_SHARE *share = spider->share;
7615 SPIDER_CONN *conn;
7616 SPIDER_RESULT_LIST *result_list = &spider->result_list;
7617 my_ptrdiff_t ptr_diff = PTR_BYTE_DIFF(buf, table->record[0]);
7618 DBUG_ENTER("spider_db_delete");
7619 if (result_list->bulk_update_mode)
7620 DBUG_RETURN(spider_db_bulk_delete(spider, table, ptr_diff));
7621
7622 if ((error_num = spider->append_delete_sql(table, ptr_diff, FALSE)))
7623 DBUG_RETURN(error_num);
7624
7625 for (
7626 roop_count = spider_conn_link_idx_next(share->link_statuses,
7627 spider->conn_link_idx, -1, share->link_count,
7628 SPIDER_LINK_STATUS_RECOVERY);
7629 roop_count < (int) share->link_count;
7630 roop_count = spider_conn_link_idx_next(share->link_statuses,
7631 spider->conn_link_idx, roop_count, share->link_count,
7632 SPIDER_LINK_STATUS_RECOVERY)
7633 ) {
7634 conn = spider->conns[roop_count];
7635 spider_db_handler *dbton_hdl = spider->dbton_handler[conn->dbton_id];
7636 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
7637 if (dbton_hdl->need_lock_before_set_sql_for_exec(
7638 SPIDER_SQL_TYPE_DELETE_SQL))
7639 {
7640 pthread_mutex_lock(&conn->mta_conn_mutex);
7641 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
7642 }
7643 if ((error_num = dbton_hdl->set_sql_for_exec(
7644 SPIDER_SQL_TYPE_DELETE_SQL, roop_count)))
7645 {
7646 if (dbton_hdl->need_lock_before_set_sql_for_exec(
7647 SPIDER_SQL_TYPE_DELETE_SQL))
7648 {
7649 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
7650 pthread_mutex_unlock(&conn->mta_conn_mutex);
7651 }
7652 DBUG_RETURN(error_num);
7653 }
7654 if (!dbton_hdl->need_lock_before_set_sql_for_exec(
7655 SPIDER_SQL_TYPE_DELETE_SQL))
7656 {
7657 pthread_mutex_lock(&conn->mta_conn_mutex);
7658 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
7659 }
7660 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
7661 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
7662 conn->mta_conn_mutex_lock_already = TRUE;
7663 conn->mta_conn_mutex_unlock_later = TRUE;
7664 if ((error_num = spider_db_query_with_set_names(
7665 SPIDER_SQL_TYPE_DELETE_SQL, spider, conn, roop_count)))
7666 {
7667 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
7668 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
7669 conn->mta_conn_mutex_lock_already = FALSE;
7670 conn->mta_conn_mutex_unlock_later = FALSE;
7671 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
7672 pthread_mutex_unlock(&conn->mta_conn_mutex);
7673 DBUG_RETURN(error_num);
7674 }
7675 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
7676 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
7677 conn->mta_conn_mutex_lock_already = FALSE;
7678 conn->mta_conn_mutex_unlock_later = FALSE;
7679 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
7680 pthread_mutex_unlock(&conn->mta_conn_mutex);
7681 result_list->update_sqls[roop_count].length(0);
7682 }
7683 if ((error_num = spider->reset_sql_sql(SPIDER_SQL_TYPE_DELETE_SQL)))
7684 {
7685 DBUG_RETURN(error_num);
7686 }
7687 DBUG_RETURN(0);
7688 }
7689
7690 #ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
7691 #ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS_WITH_HS
spider_db_direct_delete(ha_spider * spider,TABLE * table,KEY_MULTI_RANGE * ranges,uint range_count,ha_rows * delete_rows)7692 int spider_db_direct_delete(
7693 ha_spider *spider,
7694 TABLE *table,
7695 KEY_MULTI_RANGE *ranges,
7696 uint range_count,
7697 ha_rows *delete_rows
7698 ) {
7699 int error_num, roop_count;
7700 SPIDER_SHARE *share = spider->share;
7701 SPIDER_CONN *conn;
7702 SPIDER_RESULT_LIST *result_list = &spider->result_list;
7703 bool counted = FALSE;
7704 st_select_lex *select_lex;
7705 longlong select_limit;
7706 longlong offset_limit;
7707 DBUG_ENTER("spider_db_direct_delete");
7708
7709 spider_set_result_list_param(spider);
7710 result_list->finish_flg = FALSE;
7711 result_list->desc_flg = FALSE;
7712 result_list->sorted = TRUE;
7713 if (spider->active_index == MAX_KEY)
7714 result_list->key_info = NULL;
7715 else
7716 result_list->key_info = &table->key_info[spider->active_index];
7717 spider_get_select_limit(spider, &select_lex, &select_limit, &offset_limit);
7718 result_list->limit_num =
7719 result_list->internal_limit >= select_limit ?
7720 select_limit : result_list->internal_limit;
7721 result_list->internal_offset += offset_limit;
7722 /*
7723 result_list->limit_num =
7724 result_list->internal_limit >= result_list->split_read ?
7725 result_list->split_read : result_list->internal_limit;
7726 */
7727 if (spider->direct_update_kinds & SPIDER_SQL_KIND_SQL)
7728 {
7729 if (
7730 (error_num = spider->append_delete_sql_part()) ||
7731 (error_num = spider->append_from_sql_part(SPIDER_SQL_TYPE_DELETE_SQL))
7732 ) {
7733 DBUG_RETURN(error_num);
7734 }
7735 spider->set_where_pos_sql(SPIDER_SQL_TYPE_DELETE_SQL);
7736 if (
7737 (error_num = spider->append_key_where_sql_part(
7738 (ranges && ranges->start_key.key) ? &ranges->start_key : NULL,
7739 (ranges && ranges->end_key.key) ? &ranges->end_key : NULL,
7740 SPIDER_SQL_TYPE_DELETE_SQL)) ||
7741 (error_num = spider->
7742 append_key_order_for_direct_order_limit_with_alias_sql_part(
7743 NULL, 0, SPIDER_SQL_TYPE_DELETE_SQL)) ||
7744 (error_num = spider->append_limit_sql_part(
7745 result_list->internal_offset, result_list->limit_num,
7746 SPIDER_SQL_TYPE_DELETE_SQL))
7747 ) {
7748 DBUG_RETURN(error_num);
7749 }
7750 }
7751 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
7752 if (spider->direct_update_kinds & SPIDER_SQL_KIND_HS)
7753 {
7754 if (
7755 (error_num = spider->append_key_where_hs_part(
7756 (ranges && ranges->start_key.key) ? &ranges->start_key : NULL,
7757 (ranges && ranges->end_key.key) ? &ranges->end_key : NULL,
7758 SPIDER_SQL_TYPE_DELETE_HS)) ||
7759 (error_num = spider->append_limit_hs_part(
7760 result_list->internal_offset, result_list->limit_num,
7761 SPIDER_SQL_TYPE_DELETE_HS))
7762 ) {
7763 DBUG_RETURN(error_num);
7764 }
7765 }
7766 #endif
7767
7768 for (
7769 roop_count = spider_conn_link_idx_next(share->link_statuses,
7770 spider->conn_link_idx, -1, share->link_count,
7771 SPIDER_LINK_STATUS_RECOVERY);
7772 roop_count < (int) share->link_count;
7773 roop_count = spider_conn_link_idx_next(share->link_statuses,
7774 spider->conn_link_idx, roop_count, share->link_count,
7775 SPIDER_LINK_STATUS_RECOVERY)
7776 ) {
7777 ulong sql_type;
7778 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
7779 if (!spider_bit_is_set(spider->do_hs_direct_update, roop_count))
7780 {
7781 #endif
7782 DBUG_PRINT("info", ("spider exec sql"));
7783 conn = spider->conns[roop_count];
7784 sql_type = SPIDER_SQL_TYPE_DELETE_SQL;
7785 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
7786 } else {
7787 DBUG_PRINT("info", ("spider exec hs"));
7788 conn = spider->hs_w_conns[roop_count];
7789 sql_type = SPIDER_SQL_TYPE_DELETE_HS;
7790 }
7791 #endif
7792 spider_db_handler *dbton_hdl = spider->dbton_handler[conn->dbton_id];
7793 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
7794 if (dbton_hdl->need_lock_before_set_sql_for_exec(sql_type))
7795 {
7796 pthread_mutex_lock(&conn->mta_conn_mutex);
7797 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
7798 }
7799 if ((error_num = dbton_hdl->set_sql_for_exec(sql_type, roop_count)))
7800 {
7801 if (dbton_hdl->need_lock_before_set_sql_for_exec(sql_type))
7802 {
7803 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
7804 pthread_mutex_unlock(&conn->mta_conn_mutex);
7805 }
7806 DBUG_RETURN(error_num);
7807 }
7808 if (!dbton_hdl->need_lock_before_set_sql_for_exec(sql_type))
7809 {
7810 pthread_mutex_lock(&conn->mta_conn_mutex);
7811 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
7812 }
7813 #ifdef HA_CAN_BULK_ACCESS
7814 if (spider->is_bulk_access_clone)
7815 {
7816 spider->connection_ids[roop_count] = conn->connection_id;
7817 spider_trx_add_bulk_access_conn(spider->trx, conn);
7818 } else {
7819 #endif
7820 conn->need_mon = &spider->need_mons[roop_count];
7821 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
7822 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
7823 conn->mta_conn_mutex_lock_already = TRUE;
7824 conn->mta_conn_mutex_unlock_later = TRUE;
7825 if ((error_num = spider_db_set_names(spider, conn, roop_count)))
7826 {
7827 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
7828 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
7829 conn->mta_conn_mutex_lock_already = FALSE;
7830 conn->mta_conn_mutex_unlock_later = FALSE;
7831 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
7832 pthread_mutex_unlock(&conn->mta_conn_mutex);
7833 if (
7834 share->monitoring_kind[roop_count] &&
7835 spider->need_mons[roop_count]
7836 ) {
7837 error_num = spider_ping_table_mon_from_table(
7838 spider->trx,
7839 spider->trx->thd,
7840 share,
7841 roop_count,
7842 (uint32) share->monitoring_sid[roop_count],
7843 share->table_name,
7844 share->table_name_length,
7845 spider->conn_link_idx[roop_count],
7846 NULL,
7847 0,
7848 share->monitoring_kind[roop_count],
7849 share->monitoring_limit[roop_count],
7850 share->monitoring_flag[roop_count],
7851 TRUE
7852 );
7853 }
7854 DBUG_RETURN(error_num);
7855 }
7856 spider_conn_set_timeout_from_share(conn, roop_count, spider->trx->thd,
7857 share);
7858 if (dbton_hdl->execute_sql(
7859 sql_type,
7860 conn,
7861 -1,
7862 &spider->need_mons[roop_count])
7863 ) {
7864 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
7865 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
7866 conn->mta_conn_mutex_lock_already = FALSE;
7867 conn->mta_conn_mutex_unlock_later = FALSE;
7868 error_num = spider_db_errorno(conn);
7869 if (
7870 share->monitoring_kind[roop_count] &&
7871 spider->need_mons[roop_count]
7872 ) {
7873 error_num = spider_ping_table_mon_from_table(
7874 spider->trx,
7875 spider->trx->thd,
7876 share,
7877 roop_count,
7878 (uint32) share->monitoring_sid[roop_count],
7879 share->table_name,
7880 share->table_name_length,
7881 spider->conn_link_idx[roop_count],
7882 NULL,
7883 0,
7884 share->monitoring_kind[roop_count],
7885 share->monitoring_limit[roop_count],
7886 share->monitoring_flag[roop_count],
7887 TRUE
7888 );
7889 }
7890 DBUG_RETURN(error_num);
7891 }
7892 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
7893 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
7894 conn->mta_conn_mutex_lock_already = FALSE;
7895 conn->mta_conn_mutex_unlock_later = FALSE;
7896 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
7897 if (!spider_bit_is_set(spider->do_hs_direct_update, roop_count))
7898 {
7899 #endif
7900 if (!counted)
7901 {
7902 *delete_rows = spider->conns[roop_count]->db_conn->affected_rows();
7903 DBUG_PRINT("info", ("spider delete_rows = %llu", *delete_rows));
7904 counted = TRUE;
7905 }
7906 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
7907 } else {
7908 SPIDER_DB_RESULT *result;
7909 if (spider_bit_is_set(spider->db_request_phase, roop_count))
7910 {
7911 spider_clear_bit(spider->db_request_phase, roop_count);
7912 }
7913 st_spider_db_request_key request_key;
7914 request_key.spider_thread_id = spider->trx->spider_thread_id;
7915 request_key.query_id = spider->trx->thd->query_id;
7916 request_key.handler = spider;
7917 request_key.request_id = spider->db_request_id[roop_count];
7918 request_key.next = NULL;
7919 if ((result = conn->db_conn->use_result(&request_key, &error_num)))
7920 {
7921 if (!counted)
7922 {
7923 *delete_rows = conn->db_conn->affected_rows();
7924 DBUG_PRINT("info", ("spider delete_rows = %llu", *delete_rows));
7925 counted = TRUE;
7926 }
7927 result->free_result();
7928 delete result;
7929 } else {
7930 if (!error_num)
7931 {
7932 error_num = spider_db_errorno(conn);
7933 }
7934 DBUG_RETURN(error_num);
7935 }
7936 }
7937 #endif
7938 #ifdef HA_CAN_BULK_ACCESS
7939 }
7940 #endif
7941 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
7942 pthread_mutex_unlock(&conn->mta_conn_mutex);
7943 }
7944 int error_num2 = 0;
7945 if (spider->direct_update_kinds & SPIDER_SQL_KIND_SQL)
7946 {
7947 if ((error_num = spider->reset_sql_sql(SPIDER_SQL_TYPE_DELETE_SQL)))
7948 error_num2 = error_num;
7949 }
7950 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
7951 if (spider->direct_update_kinds & SPIDER_SQL_KIND_HS)
7952 {
7953 if ((error_num = spider->reset_hs_sql(SPIDER_SQL_TYPE_DELETE_HS)))
7954 error_num2 = error_num;
7955 if ((error_num = spider->reset_hs_keys(SPIDER_SQL_TYPE_DELETE_HS)))
7956 error_num2 = error_num;
7957 }
7958 #endif
7959 DBUG_RETURN(error_num2);
7960 }
7961 #else
spider_db_direct_delete(ha_spider * spider,TABLE * table,ha_rows * delete_rows)7962 int spider_db_direct_delete(
7963 ha_spider *spider,
7964 TABLE *table,
7965 ha_rows *delete_rows
7966 ) {
7967 int error_num, roop_count;
7968 SPIDER_SHARE *share = spider->share;
7969 SPIDER_CONN *conn;
7970 SPIDER_RESULT_LIST *result_list = &spider->result_list;
7971 bool counted = FALSE;
7972 st_select_lex *select_lex;
7973 longlong select_limit;
7974 longlong offset_limit;
7975 DBUG_ENTER("spider_db_direct_delete");
7976
7977 spider_set_result_list_param(spider);
7978 result_list->finish_flg = FALSE;
7979 result_list->desc_flg = FALSE;
7980 result_list->sorted = TRUE;
7981 if (spider->active_index == MAX_KEY)
7982 result_list->key_info = NULL;
7983 else
7984 result_list->key_info = &table->key_info[spider->active_index];
7985 spider_get_select_limit(spider, &select_lex, &select_limit, &offset_limit);
7986 result_list->limit_num =
7987 result_list->internal_limit >= select_limit ?
7988 select_limit : result_list->internal_limit;
7989 result_list->internal_offset += offset_limit;
7990 if (spider->direct_update_kinds & SPIDER_SQL_KIND_SQL)
7991 {
7992 if (
7993 (error_num = spider->append_delete_sql_part()) ||
7994 (error_num = spider->append_from_sql_part(SPIDER_SQL_TYPE_DELETE_SQL))
7995 ) {
7996 DBUG_RETURN(error_num);
7997 }
7998 spider->set_where_pos_sql(SPIDER_SQL_TYPE_DELETE_SQL);
7999 if (
8000 (error_num = spider->append_key_where_sql_part(
8001 NULL,
8002 NULL,
8003 SPIDER_SQL_TYPE_DELETE_SQL)) ||
8004 (error_num = spider->
8005 append_key_order_for_direct_order_limit_with_alias_sql_part(
8006 NULL, 0, SPIDER_SQL_TYPE_DELETE_SQL)) ||
8007 (error_num = spider->append_limit_sql_part(
8008 result_list->internal_offset, result_list->limit_num,
8009 SPIDER_SQL_TYPE_DELETE_SQL))
8010 ) {
8011 DBUG_RETURN(error_num);
8012 }
8013 }
8014
8015 for (
8016 roop_count = spider_conn_link_idx_next(share->link_statuses,
8017 spider->conn_link_idx, -1, share->link_count,
8018 SPIDER_LINK_STATUS_RECOVERY);
8019 roop_count < (int) share->link_count;
8020 roop_count = spider_conn_link_idx_next(share->link_statuses,
8021 spider->conn_link_idx, roop_count, share->link_count,
8022 SPIDER_LINK_STATUS_RECOVERY)
8023 ) {
8024 ulong sql_type;
8025 DBUG_PRINT("info", ("spider exec sql"));
8026 conn = spider->conns[roop_count];
8027 sql_type = SPIDER_SQL_TYPE_DELETE_SQL;
8028 spider_db_handler *dbton_hdl = spider->dbton_handler[conn->dbton_id];
8029 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
8030 if (dbton_hdl->need_lock_before_set_sql_for_exec(sql_type))
8031 {
8032 pthread_mutex_lock(&conn->mta_conn_mutex);
8033 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
8034 }
8035 if ((error_num = dbton_hdl->set_sql_for_exec(sql_type, roop_count)))
8036 {
8037 if (dbton_hdl->need_lock_before_set_sql_for_exec(sql_type))
8038 {
8039 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
8040 pthread_mutex_unlock(&conn->mta_conn_mutex);
8041 }
8042 DBUG_RETURN(error_num);
8043 }
8044 if (!dbton_hdl->need_lock_before_set_sql_for_exec(sql_type))
8045 {
8046 pthread_mutex_lock(&conn->mta_conn_mutex);
8047 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
8048 }
8049 #ifdef HA_CAN_BULK_ACCESS
8050 if (spider->is_bulk_access_clone)
8051 {
8052 spider->connection_ids[roop_count] = conn->connection_id;
8053 spider_trx_add_bulk_access_conn(spider->trx, conn);
8054 } else {
8055 #endif
8056 conn->need_mon = &spider->need_mons[roop_count];
8057 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
8058 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
8059 conn->mta_conn_mutex_lock_already = TRUE;
8060 conn->mta_conn_mutex_unlock_later = TRUE;
8061 if ((error_num = spider_db_set_names(spider, conn, roop_count)))
8062 {
8063 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
8064 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
8065 conn->mta_conn_mutex_lock_already = FALSE;
8066 conn->mta_conn_mutex_unlock_later = FALSE;
8067 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
8068 pthread_mutex_unlock(&conn->mta_conn_mutex);
8069 if (
8070 share->monitoring_kind[roop_count] &&
8071 spider->need_mons[roop_count]
8072 ) {
8073 error_num = spider_ping_table_mon_from_table(
8074 spider->trx,
8075 spider->trx->thd,
8076 share,
8077 roop_count,
8078 (uint32) share->monitoring_sid[roop_count],
8079 share->table_name,
8080 share->table_name_length,
8081 spider->conn_link_idx[roop_count],
8082 NULL,
8083 0,
8084 share->monitoring_kind[roop_count],
8085 share->monitoring_limit[roop_count],
8086 share->monitoring_flag[roop_count],
8087 TRUE
8088 );
8089 }
8090 DBUG_RETURN(error_num);
8091 }
8092 spider_conn_set_timeout_from_share(conn, roop_count, spider->trx->thd,
8093 share);
8094 if (dbton_hdl->execute_sql(
8095 sql_type,
8096 conn,
8097 -1,
8098 &spider->need_mons[roop_count])
8099 ) {
8100 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
8101 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
8102 conn->mta_conn_mutex_lock_already = FALSE;
8103 conn->mta_conn_mutex_unlock_later = FALSE;
8104 error_num = spider_db_errorno(conn);
8105 if (
8106 share->monitoring_kind[roop_count] &&
8107 spider->need_mons[roop_count]
8108 ) {
8109 error_num = spider_ping_table_mon_from_table(
8110 spider->trx,
8111 spider->trx->thd,
8112 share,
8113 roop_count,
8114 (uint32) share->monitoring_sid[roop_count],
8115 share->table_name,
8116 share->table_name_length,
8117 spider->conn_link_idx[roop_count],
8118 NULL,
8119 0,
8120 share->monitoring_kind[roop_count],
8121 share->monitoring_limit[roop_count],
8122 share->monitoring_flag[roop_count],
8123 TRUE
8124 );
8125 }
8126 DBUG_RETURN(error_num);
8127 }
8128 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
8129 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
8130 conn->mta_conn_mutex_lock_already = FALSE;
8131 conn->mta_conn_mutex_unlock_later = FALSE;
8132 if (!counted)
8133 {
8134 *delete_rows = spider->conns[roop_count]->db_conn->affected_rows();
8135 DBUG_PRINT("info", ("spider delete_rows = %llu", *delete_rows));
8136 counted = TRUE;
8137 }
8138 #ifdef HA_CAN_BULK_ACCESS
8139 }
8140 #endif
8141 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
8142 pthread_mutex_unlock(&conn->mta_conn_mutex);
8143 }
8144 int error_num2 = 0;
8145 if (spider->direct_update_kinds & SPIDER_SQL_KIND_SQL)
8146 {
8147 if ((error_num = spider->reset_sql_sql(SPIDER_SQL_TYPE_DELETE_SQL)))
8148 error_num2 = error_num;
8149 }
8150 DBUG_RETURN(error_num2);
8151 }
8152 #endif
8153 #endif
8154
spider_db_delete_all_rows(ha_spider * spider)8155 int spider_db_delete_all_rows(
8156 ha_spider *spider
8157 ) {
8158 int error_num, roop_count;
8159 SPIDER_SHARE *share = spider->share;
8160 SPIDER_CONN *conn;
8161 DBUG_ENTER("spider_db_delete_all_rows");
8162 if ((error_num = spider->append_delete_all_rows_sql_part(
8163 SPIDER_SQL_TYPE_DELETE_SQL)))
8164 DBUG_RETURN(error_num);
8165
8166 for (
8167 roop_count = spider_conn_link_idx_next(share->link_statuses,
8168 spider->conn_link_idx, -1, share->link_count,
8169 SPIDER_LINK_STATUS_RECOVERY);
8170 roop_count < (int) share->link_count;
8171 roop_count = spider_conn_link_idx_next(share->link_statuses,
8172 spider->conn_link_idx, roop_count, share->link_count,
8173 SPIDER_LINK_STATUS_RECOVERY)
8174 ) {
8175 uint dbton_id = share->use_sql_dbton_ids[roop_count];
8176 spider_db_handler *dbton_hdl = spider->dbton_handler[dbton_id];
8177 conn = spider->conns[roop_count];
8178 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
8179 if (dbton_hdl->need_lock_before_set_sql_for_exec(
8180 SPIDER_SQL_TYPE_DELETE_SQL))
8181 {
8182 pthread_mutex_lock(&conn->mta_conn_mutex);
8183 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
8184 }
8185 if ((error_num = dbton_hdl->set_sql_for_exec(
8186 SPIDER_SQL_TYPE_DELETE_SQL, roop_count)))
8187 {
8188 if (dbton_hdl->need_lock_before_set_sql_for_exec(
8189 SPIDER_SQL_TYPE_DELETE_SQL))
8190 {
8191 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
8192 pthread_mutex_unlock(&conn->mta_conn_mutex);
8193 }
8194 DBUG_RETURN(error_num);
8195 }
8196 if (!dbton_hdl->need_lock_before_set_sql_for_exec(
8197 SPIDER_SQL_TYPE_DELETE_SQL))
8198 {
8199 pthread_mutex_lock(&conn->mta_conn_mutex);
8200 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
8201 }
8202 conn->need_mon = &spider->need_mons[roop_count];
8203 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
8204 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
8205 conn->mta_conn_mutex_lock_already = TRUE;
8206 conn->mta_conn_mutex_unlock_later = TRUE;
8207 spider_conn_set_timeout_from_share(conn, roop_count, spider->trx->thd,
8208 share);
8209 if (
8210 (error_num = spider_db_set_names(spider, conn, roop_count)) ||
8211 (
8212 dbton_hdl->execute_sql(
8213 SPIDER_SQL_TYPE_DELETE_SQL,
8214 conn,
8215 -1,
8216 &spider->need_mons[roop_count]) &&
8217 (error_num = spider_db_errorno(conn))
8218 )
8219 ) {
8220 if (
8221 error_num == ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM &&
8222 !conn->disable_reconnect
8223 ) {
8224 /* retry */
8225 if ((error_num = spider_db_ping(spider, conn, roop_count)))
8226 {
8227 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
8228 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
8229 conn->mta_conn_mutex_lock_already = FALSE;
8230 conn->mta_conn_mutex_unlock_later = FALSE;
8231 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
8232 pthread_mutex_unlock(&conn->mta_conn_mutex);
8233 if (
8234 share->monitoring_kind[roop_count] &&
8235 spider->need_mons[roop_count]
8236 ) {
8237 error_num = spider_ping_table_mon_from_table(
8238 spider->trx,
8239 spider->trx->thd,
8240 share,
8241 roop_count,
8242 (uint32) share->monitoring_sid[roop_count],
8243 share->table_name,
8244 share->table_name_length,
8245 spider->conn_link_idx[roop_count],
8246 NULL,
8247 0,
8248 share->monitoring_kind[roop_count],
8249 share->monitoring_limit[roop_count],
8250 share->monitoring_flag[roop_count],
8251 TRUE
8252 );
8253 }
8254 DBUG_RETURN(error_num);
8255 }
8256 if ((error_num = spider_db_set_names(spider, conn, roop_count)))
8257 {
8258 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
8259 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
8260 conn->mta_conn_mutex_lock_already = FALSE;
8261 conn->mta_conn_mutex_unlock_later = FALSE;
8262 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
8263 pthread_mutex_unlock(&conn->mta_conn_mutex);
8264 if (
8265 share->monitoring_kind[roop_count] &&
8266 spider->need_mons[roop_count]
8267 ) {
8268 error_num = spider_ping_table_mon_from_table(
8269 spider->trx,
8270 spider->trx->thd,
8271 share,
8272 roop_count,
8273 (uint32) share->monitoring_sid[roop_count],
8274 share->table_name,
8275 share->table_name_length,
8276 spider->conn_link_idx[roop_count],
8277 NULL,
8278 0,
8279 share->monitoring_kind[roop_count],
8280 share->monitoring_limit[roop_count],
8281 share->monitoring_flag[roop_count],
8282 TRUE
8283 );
8284 }
8285 DBUG_RETURN(error_num);
8286 }
8287 spider_conn_set_timeout_from_share(conn, roop_count, spider->trx->thd,
8288 share);
8289 if (dbton_hdl->execute_sql(
8290 SPIDER_SQL_TYPE_DELETE_SQL,
8291 conn,
8292 -1,
8293 &spider->need_mons[roop_count])
8294 ) {
8295 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
8296 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
8297 conn->mta_conn_mutex_lock_already = FALSE;
8298 conn->mta_conn_mutex_unlock_later = FALSE;
8299 error_num = spider_db_errorno(conn);
8300 if (
8301 share->monitoring_kind[roop_count] &&
8302 spider->need_mons[roop_count]
8303 ) {
8304 error_num = spider_ping_table_mon_from_table(
8305 spider->trx,
8306 spider->trx->thd,
8307 share,
8308 roop_count,
8309 (uint32) share->monitoring_sid[roop_count],
8310 share->table_name,
8311 share->table_name_length,
8312 spider->conn_link_idx[roop_count],
8313 NULL,
8314 0,
8315 share->monitoring_kind[roop_count],
8316 share->monitoring_limit[roop_count],
8317 share->monitoring_flag[roop_count],
8318 TRUE
8319 );
8320 }
8321 DBUG_RETURN(error_num);
8322 }
8323 } else {
8324 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
8325 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
8326 conn->mta_conn_mutex_lock_already = FALSE;
8327 conn->mta_conn_mutex_unlock_later = FALSE;
8328 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
8329 pthread_mutex_unlock(&conn->mta_conn_mutex);
8330 if (
8331 share->monitoring_kind[roop_count] &&
8332 spider->need_mons[roop_count]
8333 ) {
8334 error_num = spider_ping_table_mon_from_table(
8335 spider->trx,
8336 spider->trx->thd,
8337 share,
8338 roop_count,
8339 (uint32) share->monitoring_sid[roop_count],
8340 share->table_name,
8341 share->table_name_length,
8342 spider->conn_link_idx[roop_count],
8343 NULL,
8344 0,
8345 share->monitoring_kind[roop_count],
8346 share->monitoring_limit[roop_count],
8347 share->monitoring_flag[roop_count],
8348 TRUE
8349 );
8350 }
8351 DBUG_RETURN(error_num);
8352 }
8353 }
8354 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
8355 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
8356 conn->mta_conn_mutex_lock_already = FALSE;
8357 conn->mta_conn_mutex_unlock_later = FALSE;
8358 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
8359 pthread_mutex_unlock(&conn->mta_conn_mutex);
8360 }
8361 if ((error_num = spider->reset_sql_sql(SPIDER_SQL_TYPE_DELETE_SQL)))
8362 DBUG_RETURN(error_num);
8363 DBUG_RETURN(0);
8364 }
8365
spider_db_disable_keys(ha_spider * spider)8366 int spider_db_disable_keys(
8367 ha_spider *spider
8368 ) {
8369 int error_num, roop_count;
8370 SPIDER_SHARE *share = spider->share;
8371 SPIDER_CONN *conn;
8372 spider_db_handler *dbton_hdl;
8373 DBUG_ENTER("spider_db_disable_keys");
8374 if (
8375 spider_param_internal_optimize(spider->trx->thd,
8376 share->internal_optimize) == 1
8377 ) {
8378 for (
8379 roop_count = spider_conn_link_idx_next(share->link_statuses,
8380 spider->conn_link_idx, -1, share->link_count,
8381 SPIDER_LINK_STATUS_RECOVERY);
8382 roop_count < (int) share->link_count;
8383 roop_count = spider_conn_link_idx_next(share->link_statuses,
8384 spider->conn_link_idx, roop_count, share->link_count,
8385 SPIDER_LINK_STATUS_RECOVERY)
8386 ) {
8387 conn = spider->conns[roop_count];
8388 dbton_hdl = spider->dbton_handler[conn->dbton_id];
8389 if ((error_num = dbton_hdl->disable_keys(conn, roop_count)))
8390 {
8391 if (
8392 share->monitoring_kind[roop_count] &&
8393 spider->need_mons[roop_count]
8394 ) {
8395 error_num = spider_ping_table_mon_from_table(
8396 spider->trx,
8397 spider->trx->thd,
8398 share,
8399 roop_count,
8400 (uint32) share->monitoring_sid[roop_count],
8401 share->table_name,
8402 share->table_name_length,
8403 spider->conn_link_idx[roop_count],
8404 NULL,
8405 0,
8406 share->monitoring_kind[roop_count],
8407 share->monitoring_limit[roop_count],
8408 share->monitoring_flag[roop_count],
8409 TRUE
8410 );
8411 }
8412 DBUG_RETURN(error_num);
8413 }
8414 }
8415 }
8416 DBUG_RETURN(0);
8417 }
8418
spider_db_enable_keys(ha_spider * spider)8419 int spider_db_enable_keys(
8420 ha_spider *spider
8421 ) {
8422 int error_num, roop_count;
8423 SPIDER_SHARE *share = spider->share;
8424 SPIDER_CONN *conn;
8425 spider_db_handler *dbton_hdl;
8426 DBUG_ENTER("spider_db_enable_keys");
8427 if (
8428 spider_param_internal_optimize(spider->trx->thd,
8429 share->internal_optimize) == 1
8430 ) {
8431 for (
8432 roop_count = spider_conn_link_idx_next(share->link_statuses,
8433 spider->conn_link_idx, -1, share->link_count,
8434 SPIDER_LINK_STATUS_RECOVERY);
8435 roop_count < (int) share->link_count;
8436 roop_count = spider_conn_link_idx_next(share->link_statuses,
8437 spider->conn_link_idx, roop_count, share->link_count,
8438 SPIDER_LINK_STATUS_RECOVERY)
8439 ) {
8440 conn = spider->conns[roop_count];
8441 dbton_hdl = spider->dbton_handler[conn->dbton_id];
8442 if ((error_num = dbton_hdl->enable_keys(conn, roop_count)))
8443 {
8444 if (
8445 share->monitoring_kind[roop_count] &&
8446 spider->need_mons[roop_count]
8447 ) {
8448 error_num = spider_ping_table_mon_from_table(
8449 spider->trx,
8450 spider->trx->thd,
8451 share,
8452 roop_count,
8453 (uint32) share->monitoring_sid[roop_count],
8454 share->table_name,
8455 share->table_name_length,
8456 spider->conn_link_idx[roop_count],
8457 NULL,
8458 0,
8459 share->monitoring_kind[roop_count],
8460 share->monitoring_limit[roop_count],
8461 share->monitoring_flag[roop_count],
8462 TRUE
8463 );
8464 }
8465 DBUG_RETURN(error_num);
8466 }
8467 }
8468 }
8469 DBUG_RETURN(0);
8470 }
8471
spider_db_check_table(ha_spider * spider,HA_CHECK_OPT * check_opt)8472 int spider_db_check_table(
8473 ha_spider *spider,
8474 HA_CHECK_OPT* check_opt
8475 ) {
8476 int error_num, roop_count;
8477 SPIDER_SHARE *share = spider->share;
8478 SPIDER_CONN *conn;
8479 spider_db_handler *dbton_hdl;
8480 DBUG_ENTER("spider_db_check_table");
8481 if (
8482 spider_param_internal_optimize(spider->trx->thd,
8483 share->internal_optimize) == 1
8484 ) {
8485 for (
8486 roop_count = spider_conn_link_idx_next(share->link_statuses,
8487 spider->conn_link_idx, -1, share->link_count,
8488 SPIDER_LINK_STATUS_RECOVERY);
8489 roop_count < (int) share->link_count;
8490 roop_count = spider_conn_link_idx_next(share->link_statuses,
8491 spider->conn_link_idx, roop_count, share->link_count,
8492 SPIDER_LINK_STATUS_RECOVERY)
8493 ) {
8494 conn = spider->conns[roop_count];
8495 dbton_hdl = spider->dbton_handler[conn->dbton_id];
8496 if ((error_num = dbton_hdl->check_table(conn, roop_count, check_opt)))
8497 {
8498 if (
8499 share->monitoring_kind[roop_count] &&
8500 spider->need_mons[roop_count]
8501 ) {
8502 error_num = spider_ping_table_mon_from_table(
8503 spider->trx,
8504 spider->trx->thd,
8505 share,
8506 roop_count,
8507 (uint32) share->monitoring_sid[roop_count],
8508 share->table_name,
8509 share->table_name_length,
8510 spider->conn_link_idx[roop_count],
8511 NULL,
8512 0,
8513 share->monitoring_kind[roop_count],
8514 share->monitoring_limit[roop_count],
8515 share->monitoring_flag[roop_count],
8516 TRUE
8517 );
8518 }
8519 DBUG_RETURN(error_num);
8520 }
8521 }
8522 }
8523 DBUG_RETURN(0);
8524 }
8525
spider_db_repair_table(ha_spider * spider,HA_CHECK_OPT * check_opt)8526 int spider_db_repair_table(
8527 ha_spider *spider,
8528 HA_CHECK_OPT* check_opt
8529 ) {
8530 int error_num, roop_count;
8531 SPIDER_SHARE *share = spider->share;
8532 SPIDER_CONN *conn;
8533 spider_db_handler *dbton_hdl;
8534 DBUG_ENTER("spider_db_repair_table");
8535 if (
8536 spider_param_internal_optimize(spider->trx->thd,
8537 share->internal_optimize) == 1
8538 ) {
8539 for (
8540 roop_count = spider_conn_link_idx_next(share->link_statuses,
8541 spider->conn_link_idx, -1, share->link_count,
8542 SPIDER_LINK_STATUS_RECOVERY);
8543 roop_count < (int) share->link_count;
8544 roop_count = spider_conn_link_idx_next(share->link_statuses,
8545 spider->conn_link_idx, roop_count, share->link_count,
8546 SPIDER_LINK_STATUS_RECOVERY)
8547 ) {
8548 conn = spider->conns[roop_count];
8549 dbton_hdl = spider->dbton_handler[conn->dbton_id];
8550 if ((error_num = dbton_hdl->repair_table(conn, roop_count, check_opt)))
8551 {
8552 if (
8553 share->monitoring_kind[roop_count] &&
8554 spider->need_mons[roop_count]
8555 ) {
8556 error_num = spider_ping_table_mon_from_table(
8557 spider->trx,
8558 spider->trx->thd,
8559 share,
8560 roop_count,
8561 (uint32) share->monitoring_sid[roop_count],
8562 share->table_name,
8563 share->table_name_length,
8564 spider->conn_link_idx[roop_count],
8565 NULL,
8566 0,
8567 share->monitoring_kind[roop_count],
8568 share->monitoring_limit[roop_count],
8569 share->monitoring_flag[roop_count],
8570 TRUE
8571 );
8572 }
8573 DBUG_RETURN(error_num);
8574 }
8575 }
8576 }
8577 DBUG_RETURN(0);
8578 }
8579
spider_db_analyze_table(ha_spider * spider)8580 int spider_db_analyze_table(
8581 ha_spider *spider
8582 ) {
8583 int error_num, roop_count;
8584 SPIDER_SHARE *share = spider->share;
8585 SPIDER_CONN *conn;
8586 spider_db_handler *dbton_hdl;
8587 DBUG_ENTER("spider_db_analyze_table");
8588 if (
8589 spider_param_internal_optimize(spider->trx->thd,
8590 share->internal_optimize) == 1
8591 ) {
8592 for (
8593 roop_count = spider_conn_link_idx_next(share->link_statuses,
8594 spider->conn_link_idx, -1, share->link_count,
8595 SPIDER_LINK_STATUS_RECOVERY);
8596 roop_count < (int) share->link_count;
8597 roop_count = spider_conn_link_idx_next(share->link_statuses,
8598 spider->conn_link_idx, roop_count, share->link_count,
8599 SPIDER_LINK_STATUS_RECOVERY)
8600 ) {
8601 conn = spider->conns[roop_count];
8602 dbton_hdl = spider->dbton_handler[conn->dbton_id];
8603 if ((error_num = dbton_hdl->analyze_table(conn, roop_count)))
8604 {
8605 if (
8606 share->monitoring_kind[roop_count] &&
8607 spider->need_mons[roop_count]
8608 ) {
8609 error_num = spider_ping_table_mon_from_table(
8610 spider->trx,
8611 spider->trx->thd,
8612 share,
8613 roop_count,
8614 (uint32) share->monitoring_sid[roop_count],
8615 share->table_name,
8616 share->table_name_length,
8617 spider->conn_link_idx[roop_count],
8618 NULL,
8619 0,
8620 share->monitoring_kind[roop_count],
8621 share->monitoring_limit[roop_count],
8622 share->monitoring_flag[roop_count],
8623 TRUE
8624 );
8625 }
8626 DBUG_RETURN(error_num);
8627 }
8628 }
8629 }
8630 DBUG_RETURN(0);
8631 }
8632
spider_db_optimize_table(ha_spider * spider)8633 int spider_db_optimize_table(
8634 ha_spider *spider
8635 ) {
8636 int error_num, roop_count;
8637 SPIDER_SHARE *share = spider->share;
8638 SPIDER_CONN *conn;
8639 spider_db_handler *dbton_hdl;
8640 DBUG_ENTER("spider_db_optimize_table");
8641 if (
8642 spider_param_internal_optimize(spider->trx->thd,
8643 share->internal_optimize) == 1
8644 ) {
8645 for (
8646 roop_count = spider_conn_link_idx_next(share->link_statuses,
8647 spider->conn_link_idx, -1, share->link_count,
8648 SPIDER_LINK_STATUS_RECOVERY);
8649 roop_count < (int) share->link_count;
8650 roop_count = spider_conn_link_idx_next(share->link_statuses,
8651 spider->conn_link_idx, roop_count, share->link_count,
8652 SPIDER_LINK_STATUS_RECOVERY)
8653 ) {
8654 conn = spider->conns[roop_count];
8655 dbton_hdl = spider->dbton_handler[conn->dbton_id];
8656 if ((error_num = dbton_hdl->optimize_table(conn, roop_count)))
8657 {
8658 if (
8659 share->monitoring_kind[roop_count] &&
8660 spider->need_mons[roop_count]
8661 ) {
8662 error_num = spider_ping_table_mon_from_table(
8663 spider->trx,
8664 spider->trx->thd,
8665 share,
8666 roop_count,
8667 (uint32) share->monitoring_sid[roop_count],
8668 share->table_name,
8669 share->table_name_length,
8670 spider->conn_link_idx[roop_count],
8671 NULL,
8672 0,
8673 share->monitoring_kind[roop_count],
8674 share->monitoring_limit[roop_count],
8675 share->monitoring_flag[roop_count],
8676 TRUE
8677 );
8678 }
8679 DBUG_RETURN(error_num);
8680 }
8681 }
8682 }
8683 DBUG_RETURN(0);
8684 }
8685
spider_db_flush_tables(ha_spider * spider,bool lock)8686 int spider_db_flush_tables(
8687 ha_spider *spider,
8688 bool lock
8689 ) {
8690 int error_num, roop_count;
8691 SPIDER_SHARE *share = spider->share;
8692 SPIDER_CONN *conn;
8693 spider_db_handler *dbton_hdl;
8694 DBUG_ENTER("spider_db_flush_tables");
8695 for (
8696 roop_count = spider_conn_link_idx_next(share->link_statuses,
8697 spider->conn_link_idx, -1, share->link_count,
8698 SPIDER_LINK_STATUS_RECOVERY);
8699 roop_count < (int) share->link_count;
8700 roop_count = spider_conn_link_idx_next(share->link_statuses,
8701 spider->conn_link_idx, roop_count, share->link_count,
8702 SPIDER_LINK_STATUS_RECOVERY)
8703 ) {
8704 conn = spider->conns[roop_count];
8705 dbton_hdl = spider->dbton_handler[conn->dbton_id];
8706 if ((error_num = dbton_hdl->flush_tables(conn, roop_count, lock)))
8707 {
8708 if (
8709 share->monitoring_kind[roop_count] &&
8710 spider->need_mons[roop_count]
8711 ) {
8712 error_num = spider_ping_table_mon_from_table(
8713 spider->trx,
8714 spider->trx->thd,
8715 share,
8716 roop_count,
8717 (uint32) share->monitoring_sid[roop_count],
8718 share->table_name,
8719 share->table_name_length,
8720 spider->conn_link_idx[roop_count],
8721 NULL,
8722 0,
8723 share->monitoring_kind[roop_count],
8724 share->monitoring_limit[roop_count],
8725 share->monitoring_flag[roop_count],
8726 TRUE
8727 );
8728 }
8729 DBUG_RETURN(error_num);
8730 }
8731 }
8732 DBUG_RETURN(0);
8733 }
8734
spider_db_flush_logs(ha_spider * spider)8735 int spider_db_flush_logs(
8736 ha_spider *spider
8737 ) {
8738 int roop_count, error_num;
8739 SPIDER_SHARE *share = spider->share;
8740 SPIDER_CONN *conn;
8741 spider_db_handler *dbton_hdl;
8742 DBUG_ENTER("spider_db_flush_logs");
8743 for (
8744 roop_count = spider_conn_link_idx_next(share->link_statuses,
8745 spider->conn_link_idx, -1, share->link_count,
8746 SPIDER_LINK_STATUS_RECOVERY);
8747 roop_count < (int) share->link_count;
8748 roop_count = spider_conn_link_idx_next(share->link_statuses,
8749 spider->conn_link_idx, roop_count, share->link_count,
8750 SPIDER_LINK_STATUS_RECOVERY)
8751 ) {
8752 conn = spider->conns[roop_count];
8753 dbton_hdl = spider->dbton_handler[conn->dbton_id];
8754 if ((error_num = dbton_hdl->flush_logs(conn, roop_count)))
8755 {
8756 if (
8757 share->monitoring_kind[roop_count] &&
8758 spider->need_mons[roop_count]
8759 ) {
8760 error_num = spider_ping_table_mon_from_table(
8761 spider->trx,
8762 spider->trx->thd,
8763 share,
8764 roop_count,
8765 (uint32) share->monitoring_sid[roop_count],
8766 share->table_name,
8767 share->table_name_length,
8768 spider->conn_link_idx[roop_count],
8769 NULL,
8770 0,
8771 share->monitoring_kind[roop_count],
8772 share->monitoring_limit[roop_count],
8773 share->monitoring_flag[roop_count],
8774 TRUE
8775 );
8776 }
8777 DBUG_RETURN(error_num);
8778 }
8779 }
8780 DBUG_RETURN(0);
8781 }
8782
8783 /**
8784 Find the field among the items in an expression tree.
8785
8786 @param item_list List of items of the expression.
8787 @param item_count Number of items in the item list.
8788 @param start_item Index of the first item to consider.
8789 @param str String into which the expression is to be printed.
8790 @param func_name Function or operator name.
8791 @param func_name_length Length of function or operator name.
8792
8793 @return Pointer to the field in the item list if the list
8794 contains only one field; NULL otherwise.
8795 */
8796
spider_db_find_field_in_item_list(Item ** item_list,uint item_count,uint start_item,spider_string * str,const char * func_name,int func_name_length)8797 Field *spider_db_find_field_in_item_list(
8798 Item **item_list,
8799 uint item_count,
8800 uint start_item,
8801 spider_string *str,
8802 const char *func_name,
8803 int func_name_length
8804 ) {
8805 uint item_num;
8806 Item *item;
8807 Field *field = NULL;
8808 DBUG_ENTER("spider_db_find_field_in_item_list");
8809
8810 if (str && func_name_length)
8811 {
8812 if (strncasecmp(func_name, ",", 1))
8813 {
8814 /* A known function or operator */
8815 for (item_num = start_item; item_num < item_count; item_num++)
8816 {
8817 item = item_list[item_num];
8818
8819 if (item->type() == Item::FIELD_ITEM)
8820 {
8821 if (field)
8822 {
8823 /* Field is not relevant if there are multiple fields */
8824 DBUG_RETURN(NULL);
8825 }
8826
8827 field = ((Item_field *) item)->field;
8828 }
8829 }
8830 }
8831 }
8832
8833 DBUG_RETURN(field);
8834 }
8835
8836 /**
8837 Print an operand value within a statement generated for an expression.
8838
8839 @param item Operand value to print.
8840 @param field Field related to the operand value.
8841 @param spider Spider.
8842 @param str String into which the value is to be printed.
8843 @param alias Name related to the operand.
8844 @param alias_length Length of the name.
8845 @param dbton_id Spider Db/Table id.
8846 @param use_fields Use fields or exchange fields.
8847 @param fields Array of fields in the expression.
8848
8849 @return Error code.
8850 */
8851
spider_db_print_item_type(Item * item,Field * field,ha_spider * spider,spider_string * str,const char * alias,uint alias_length,uint dbton_id,bool use_fields,spider_fields * fields)8852 int spider_db_print_item_type(
8853 Item *item,
8854 Field *field,
8855 ha_spider *spider,
8856 spider_string *str,
8857 const char *alias,
8858 uint alias_length,
8859 uint dbton_id,
8860 bool use_fields,
8861 spider_fields *fields
8862 ) {
8863 DBUG_ENTER("spider_db_print_item_type");
8864 DBUG_PRINT("info",("spider COND type=%d", item->type()));
8865
8866 switch (item->type())
8867 {
8868 case Item::FUNC_ITEM:
8869 DBUG_RETURN(spider_db_open_item_func((Item_func *) item, spider, str,
8870 alias, alias_length, dbton_id, use_fields, fields));
8871 #ifdef HANDLER_HAS_DIRECT_AGGREGATE
8872 case Item::SUM_FUNC_ITEM:
8873 DBUG_RETURN(spider_db_open_item_sum_func((Item_sum *)item, spider, str,
8874 alias, alias_length, dbton_id, use_fields, fields));
8875 #endif
8876 case Item::COND_ITEM:
8877 DBUG_RETURN(spider_db_open_item_cond((Item_cond *) item, spider, str,
8878 alias, alias_length, dbton_id, use_fields, fields));
8879 case Item::FIELD_ITEM:
8880 DBUG_RETURN(spider_db_open_item_field((Item_field *) item, spider, str,
8881 alias, alias_length, dbton_id, use_fields, fields));
8882 case Item::REF_ITEM:
8883 DBUG_RETURN(spider_db_open_item_ref((Item_ref *) item, spider, str,
8884 alias, alias_length, dbton_id, use_fields, fields));
8885 case Item::ROW_ITEM:
8886 DBUG_RETURN(spider_db_open_item_row((Item_row *) item, spider, str,
8887 alias, alias_length, dbton_id, use_fields, fields));
8888 #ifdef SPIDER_USE_CONST_ITEM_FOR_STRING_INT_REAL_DECIMAL_DATE_ITEM
8889 case Item::CONST_ITEM:
8890 {
8891 switch (item->cmp_type()) {
8892 case TIME_RESULT:
8893 case STRING_RESULT:
8894 DBUG_RETURN(spider_db_open_item_string(item, field, spider, str,
8895 alias, alias_length, dbton_id, use_fields, fields));
8896 case INT_RESULT:
8897 case REAL_RESULT:
8898 case DECIMAL_RESULT:
8899 DBUG_RETURN(spider_db_open_item_int(item, field, spider, str,
8900 alias, alias_length, dbton_id, use_fields, fields));
8901 default:
8902 DBUG_ASSERT(FALSE);
8903 DBUG_RETURN(spider_db_print_item_type_default(item, spider, str));
8904 }
8905 }
8906 #else
8907 case Item::STRING_ITEM:
8908 DBUG_RETURN(spider_db_open_item_string(item, field, spider, str,
8909 alias, alias_length, dbton_id, use_fields, fields));
8910 case Item::INT_ITEM:
8911 case Item::REAL_ITEM:
8912 case Item::DECIMAL_ITEM:
8913 DBUG_RETURN(spider_db_open_item_int(item, field, spider, str,
8914 alias, alias_length, dbton_id, use_fields, fields));
8915 #endif
8916 case Item::CACHE_ITEM:
8917 DBUG_RETURN(spider_db_open_item_cache((Item_cache *) item, field, spider,
8918 str, alias, alias_length, dbton_id, use_fields, fields));
8919 case Item::INSERT_VALUE_ITEM:
8920 DBUG_RETURN(spider_db_open_item_insert_value((Item_insert_value *) item,
8921 field, spider, str, alias, alias_length, dbton_id, use_fields, fields));
8922 case Item::SUBSELECT_ITEM:
8923 case Item::TRIGGER_FIELD_ITEM:
8924 #ifdef SPIDER_HAS_EXPR_CACHE_ITEM
8925 case Item::EXPR_CACHE_ITEM:
8926 #endif
8927 DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);
8928 default:
8929 DBUG_RETURN(spider_db_print_item_type_default(item, spider, str));
8930 }
8931
8932 DBUG_RETURN(0);
8933 }
8934
spider_db_print_item_type_default(Item * item,ha_spider * spider,spider_string * str)8935 int spider_db_print_item_type_default(
8936 Item *item,
8937 ha_spider *spider,
8938 spider_string *str
8939 ) {
8940 DBUG_ENTER("spider_db_print_item_type_default");
8941 THD *thd = spider->trx->thd;
8942 SPIDER_SHARE *share = spider->share;
8943 if (spider_param_skip_default_condition(thd,
8944 share->skip_default_condition))
8945 DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);
8946 if (str)
8947 {
8948 if (spider->share->access_charset->cset == system_charset_info->cset)
8949 {
8950 #if MYSQL_VERSION_ID < 50500
8951 item->print(str->get_str(), QT_IS);
8952 #else
8953 item->print(str->get_str(), QT_TO_SYSTEM_CHARSET);
8954 #endif
8955 } else {
8956 item->print(str->get_str(), QT_ORDINARY);
8957 }
8958 str->mem_calc();
8959 }
8960 DBUG_RETURN(0);
8961 }
8962
spider_db_open_item_cond(Item_cond * item_cond,ha_spider * spider,spider_string * str,const char * alias,uint alias_length,uint dbton_id,bool use_fields,spider_fields * fields)8963 int spider_db_open_item_cond(
8964 Item_cond *item_cond,
8965 ha_spider *spider,
8966 spider_string *str,
8967 const char *alias,
8968 uint alias_length,
8969 uint dbton_id,
8970 bool use_fields,
8971 spider_fields *fields
8972 ) {
8973 int error_num = 0;
8974 List_iterator_fast<Item> lif(*(item_cond->argument_list()));
8975 Item *item;
8976 char *func_name = NULL;
8977 int func_name_length = 0, restart_pos = 0;
8978 DBUG_ENTER("spider_db_open_item_cond");
8979 if (str)
8980 {
8981 if (str->reserve(SPIDER_SQL_OPEN_PAREN_LEN))
8982 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8983 str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
8984 }
8985
8986 restart_first:
8987 if ((item = lif++))
8988 {
8989 if (str)
8990 restart_pos = str->length();
8991 if ((error_num = spider_db_print_item_type(item, NULL, spider, str,
8992 alias, alias_length, dbton_id, use_fields, fields)))
8993 {
8994 if (
8995 str &&
8996 error_num == ER_SPIDER_COND_SKIP_NUM &&
8997 item_cond->functype() == Item_func::COND_AND_FUNC
8998 ) {
8999 DBUG_PRINT("info",("spider COND skip"));
9000 str->length(restart_pos);
9001 goto restart_first;
9002 }
9003 DBUG_RETURN(error_num);
9004 }
9005 }
9006 if (error_num)
9007 DBUG_RETURN(error_num);
9008 while ((item = lif++))
9009 {
9010 if (str)
9011 {
9012 restart_pos = str->length();
9013 if (!func_name)
9014 {
9015 func_name = (char*) item_cond->func_name();
9016 func_name_length = strlen(func_name);
9017 }
9018 if (str->reserve(func_name_length + SPIDER_SQL_SPACE_LEN * 2))
9019 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9020 str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);
9021 str->q_append(func_name, func_name_length);
9022 str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);
9023 }
9024
9025 if ((error_num = spider_db_print_item_type(item, NULL, spider, str,
9026 alias, alias_length, dbton_id, use_fields, fields)))
9027 {
9028 if (
9029 str &&
9030 error_num == ER_SPIDER_COND_SKIP_NUM &&
9031 item_cond->functype() == Item_func::COND_AND_FUNC
9032 ) {
9033 DBUG_PRINT("info",("spider COND skip"));
9034 str->length(restart_pos);
9035 } else
9036 DBUG_RETURN(error_num);
9037 }
9038 }
9039 if (str)
9040 {
9041 if (str->reserve(SPIDER_SQL_CLOSE_PAREN_LEN))
9042 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9043 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN);
9044 }
9045 DBUG_RETURN(0);
9046 }
9047
spider_db_open_item_func(Item_func * item_func,ha_spider * spider,spider_string * str,const char * alias,uint alias_length,uint dbton_id,bool use_fields,spider_fields * fields)9048 int spider_db_open_item_func(
9049 Item_func *item_func,
9050 ha_spider *spider,
9051 spider_string *str,
9052 const char *alias,
9053 uint alias_length,
9054 uint dbton_id,
9055 bool use_fields,
9056 spider_fields *fields
9057 ) {
9058 DBUG_ENTER("spider_db_open_item_func");
9059 DBUG_RETURN(spider_dbton[dbton_id].db_util->open_item_func(
9060 item_func, spider, str, alias, alias_length, use_fields, fields));
9061 }
9062
9063 #ifdef HANDLER_HAS_DIRECT_AGGREGATE
spider_db_open_item_sum_func(Item_sum * item_sum,ha_spider * spider,spider_string * str,const char * alias,uint alias_length,uint dbton_id,bool use_fields,spider_fields * fields)9064 int spider_db_open_item_sum_func(
9065 Item_sum *item_sum,
9066 ha_spider *spider,
9067 spider_string *str,
9068 const char *alias,
9069 uint alias_length,
9070 uint dbton_id,
9071 bool use_fields,
9072 spider_fields *fields
9073 ) {
9074 DBUG_ENTER("spider_db_open_item_func");
9075 DBUG_RETURN(spider_dbton[dbton_id].db_util->open_item_sum_func(
9076 item_sum, spider, str, alias, alias_length, use_fields, fields));
9077 }
9078 #endif
9079
spider_db_open_item_ident(Item_ident * item_ident,ha_spider * spider,spider_string * str,const char * alias,uint alias_length,uint dbton_id,bool use_fields,spider_fields * fields)9080 int spider_db_open_item_ident(
9081 Item_ident *item_ident,
9082 ha_spider *spider,
9083 spider_string *str,
9084 const char *alias,
9085 uint alias_length,
9086 uint dbton_id,
9087 bool use_fields,
9088 spider_fields *fields
9089 ) {
9090 int error_num, field_name_length;
9091 SPIDER_SHARE *share = spider->share;
9092 DBUG_ENTER("spider_db_open_item_ident");
9093 if (
9094 item_ident->cached_field_index != NO_CACHED_FIELD_INDEX &&
9095 item_ident->cached_table
9096 ) {
9097 Field *field = item_ident->cached_table->table->field[
9098 item_ident->cached_field_index];
9099 DBUG_PRINT("info",("spider use cached_field_index"));
9100 if (!use_fields)
9101 {
9102 if (!(field = spider->field_exchange(field)))
9103 DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);
9104 if (str)
9105 {
9106 if ((error_num = share->dbton_share[dbton_id]->
9107 append_column_name_with_alias(str, field->field_index,
9108 alias, alias_length)))
9109 DBUG_RETURN(error_num);
9110 }
9111 } else {
9112 if (str)
9113 {
9114 SPIDER_FIELD_CHAIN *field_chain = fields->get_next_field_chain();
9115 SPIDER_FIELD_HOLDER *field_holder = field_chain->field_holder;
9116 spider = field_holder->spider;
9117 share = spider->share;
9118 field = spider->field_exchange(field);
9119 DBUG_ASSERT(field);
9120 if ((error_num = share->dbton_share[dbton_id]->
9121 append_column_name_with_alias(str, field->field_index,
9122 field_holder->alias->ptr(), field_holder->alias->length())))
9123 DBUG_RETURN(error_num);
9124 } else {
9125 if ((error_num = fields->add_field(field)))
9126 {
9127 DBUG_RETURN(error_num);
9128 }
9129 }
9130 }
9131 DBUG_RETURN(0);
9132 }
9133 if (str)
9134 {
9135 #ifdef SPIDER_use_LEX_CSTRING_for_KEY_Field_name
9136 if (item_ident->field_name.str)
9137 field_name_length = item_ident->field_name.length;
9138 #else
9139 if (item_ident->field_name)
9140 field_name_length = strlen(item_ident->field_name);
9141 #endif
9142 else
9143 field_name_length = 0;
9144 if (share->access_charset->cset == system_charset_info->cset)
9145 {
9146 if (str->reserve(alias_length +
9147 field_name_length + /* SPIDER_SQL_NAME_QUOTE_LEN */ 2))
9148 {
9149 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9150 }
9151 str->q_append(alias, alias_length);
9152 #ifdef SPIDER_use_LEX_CSTRING_for_KEY_Field_name
9153 if ((error_num = spider_dbton[dbton_id].db_util->
9154 append_name(str, item_ident->field_name.str, field_name_length)))
9155 #else
9156 if ((error_num = spider_dbton[dbton_id].db_util->
9157 append_name(str, item_ident->field_name, field_name_length)))
9158 #endif
9159 {
9160 DBUG_RETURN(error_num);
9161 }
9162 } else {
9163 if (str->reserve(alias_length))
9164 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9165 str->q_append(alias, alias_length);
9166 #ifdef SPIDER_use_LEX_CSTRING_for_KEY_Field_name
9167 if ((error_num = spider_dbton[dbton_id].db_util->
9168 append_name_with_charset(str, item_ident->field_name.str,
9169 field_name_length, system_charset_info)))
9170 #else
9171 if ((error_num = spider_dbton[dbton_id].db_util->
9172 append_name_with_charset(str, item_ident->field_name,
9173 field_name_length, system_charset_info)))
9174 #endif
9175 {
9176 DBUG_RETURN(error_num);
9177 }
9178 }
9179 }
9180 DBUG_RETURN(0);
9181 }
9182
spider_db_open_item_field(Item_field * item_field,ha_spider * spider,spider_string * str,const char * alias,uint alias_length,uint dbton_id,bool use_fields,spider_fields * fields)9183 int spider_db_open_item_field(
9184 Item_field *item_field,
9185 ha_spider *spider,
9186 spider_string *str,
9187 const char *alias,
9188 uint alias_length,
9189 uint dbton_id,
9190 bool use_fields,
9191 spider_fields *fields
9192 ) {
9193 int error_num;
9194 Field *field = item_field->field;
9195 SPIDER_SHARE *share = spider->share;
9196 DBUG_ENTER("spider_db_open_item_field");
9197 if (field && !field->table->const_table)
9198 {
9199 DBUG_PRINT("info",("spider field=%p", field));
9200 DBUG_PRINT("info",("spider db=%s", field->table->s->db.str));
9201 DBUG_PRINT("info",("spider table_name=%s", field->table->s->table_name.str));
9202 DBUG_PRINT("info",("spider tmp_table=%u", field->table->s->tmp_table));
9203 if (field->table->s->tmp_table != INTERNAL_TMP_TABLE)
9204 {
9205 if (!use_fields)
9206 {
9207 if (!(field = spider->field_exchange(field)))
9208 DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);
9209 if (str)
9210 {
9211 if ((error_num = share->dbton_share[dbton_id]->
9212 append_column_name_with_alias(str, field->field_index,
9213 alias, alias_length)))
9214 DBUG_RETURN(error_num);
9215 }
9216 DBUG_RETURN(0);
9217 } else {
9218 if (str)
9219 {
9220 SPIDER_FIELD_CHAIN *field_chain = fields->get_next_field_chain();
9221 SPIDER_FIELD_HOLDER *field_holder = field_chain->field_holder;
9222 spider = field_holder->spider;
9223 share = spider->share;
9224 field = spider->field_exchange(field);
9225 DBUG_ASSERT(field);
9226 if ((error_num = share->dbton_share[dbton_id]->
9227 append_column_name_with_alias(str, field->field_index,
9228 field_holder->alias->ptr(), field_holder->alias->length())))
9229 DBUG_RETURN(error_num);
9230 } else {
9231 if ((error_num = fields->add_field(field)))
9232 {
9233 DBUG_RETURN(error_num);
9234 }
9235 }
9236 DBUG_RETURN(0);
9237 }
9238 }
9239 }
9240 DBUG_RETURN(spider_db_open_item_ident(
9241 (Item_ident *) item_field, spider, str, alias, alias_length, dbton_id,
9242 use_fields, fields));
9243 }
9244
spider_db_open_item_ref(Item_ref * item_ref,ha_spider * spider,spider_string * str,const char * alias,uint alias_length,uint dbton_id,bool use_fields,spider_fields * fields)9245 int spider_db_open_item_ref(
9246 Item_ref *item_ref,
9247 ha_spider *spider,
9248 spider_string *str,
9249 const char *alias,
9250 uint alias_length,
9251 uint dbton_id,
9252 bool use_fields,
9253 spider_fields *fields
9254 ) {
9255 int error_num;
9256 DBUG_ENTER("spider_db_open_item_ref");
9257 if (item_ref->ref)
9258 {
9259 #ifdef SPIDER_use_LEX_CSTRING_for_KEY_Field_name
9260 if (
9261 (*(item_ref->ref))->type() != Item::CACHE_ITEM &&
9262 item_ref->ref_type() != Item_ref::VIEW_REF &&
9263 !item_ref->table_name &&
9264 item_ref->name.str &&
9265 item_ref->alias_name_used
9266 )
9267 #else
9268 if (
9269 (*(item_ref->ref))->type() != Item::CACHE_ITEM &&
9270 item_ref->ref_type() != Item_ref::VIEW_REF &&
9271 !item_ref->table_name &&
9272 item_ref->name &&
9273 item_ref->alias_name_used
9274 )
9275 #endif
9276 {
9277 if (str)
9278 {
9279 #ifdef SPIDER_use_LEX_CSTRING_for_KEY_Field_name
9280 uint length = item_ref->name.length;
9281 #else
9282 uint length = strlen(item_ref->name);
9283 #endif
9284 if (str->reserve(length + /* SPIDER_SQL_NAME_QUOTE_LEN */ 2))
9285 {
9286 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9287 }
9288 #ifdef SPIDER_use_LEX_CSTRING_for_KEY_Field_name
9289 if ((error_num = spider_dbton[dbton_id].db_util->
9290 append_name(str, item_ref->name.str, length)))
9291 #else
9292 if ((error_num = spider_dbton[dbton_id].db_util->
9293 append_name(str, item_ref->name, length)))
9294 #endif
9295 {
9296 DBUG_RETURN(error_num);
9297 }
9298 }
9299 DBUG_RETURN(0);
9300 }
9301 DBUG_RETURN(spider_db_print_item_type(*(item_ref->ref), NULL, spider, str,
9302 alias, alias_length, dbton_id, use_fields, fields));
9303 }
9304 DBUG_RETURN(spider_db_open_item_ident((Item_ident *) item_ref, spider, str,
9305 alias, alias_length, dbton_id, use_fields, fields));
9306 }
9307
spider_db_open_item_row(Item_row * item_row,ha_spider * spider,spider_string * str,const char * alias,uint alias_length,uint dbton_id,bool use_fields,spider_fields * fields)9308 int spider_db_open_item_row(
9309 Item_row *item_row,
9310 ha_spider *spider,
9311 spider_string *str,
9312 const char *alias,
9313 uint alias_length,
9314 uint dbton_id,
9315 bool use_fields,
9316 spider_fields *fields
9317 ) {
9318 int error_num;
9319 uint roop_count, cols = item_row->cols() - 1;
9320 Item *item;
9321 DBUG_ENTER("spider_db_open_item_row");
9322 if (str)
9323 {
9324 if (str->reserve(SPIDER_SQL_OPEN_PAREN_LEN))
9325 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9326 str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
9327 }
9328 for (roop_count = 0; roop_count < cols; roop_count++)
9329 {
9330 item = item_row->element_index(roop_count);
9331 if ((error_num = spider_db_print_item_type(item, NULL, spider, str,
9332 alias, alias_length, dbton_id, use_fields, fields)))
9333 DBUG_RETURN(error_num);
9334 if (str)
9335 {
9336 if (str->reserve(SPIDER_SQL_COMMA_LEN))
9337 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9338 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
9339 }
9340 }
9341 item = item_row->element_index(roop_count);
9342 if ((error_num = spider_db_print_item_type(item, NULL, spider, str,
9343 alias, alias_length, dbton_id, use_fields, fields)))
9344 DBUG_RETURN(error_num);
9345 if (str)
9346 {
9347 if (str->reserve(SPIDER_SQL_CLOSE_PAREN_LEN))
9348 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9349 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR,
9350 SPIDER_SQL_CLOSE_PAREN_LEN);
9351 }
9352 DBUG_RETURN(0);
9353 }
9354
9355 /**
9356 Print a string value within a generated statement.
9357
9358 @param item String value to print.
9359 @param field Field related to the string value.
9360 @param spider Spider.
9361 @param str String into which the value is to be printed.
9362 @param alias Name related to the string value.
9363 @param alias_length Length of the name.
9364 @param dbton_id Spider Db/Table id.
9365 @param use_fields Use fields or exchange fields.
9366 @param fields Array of fields in an expression containing
9367 the string value.
9368
9369 @return Error code.
9370 */
9371
spider_db_open_item_string(Item * item,Field * field,ha_spider * spider,spider_string * str,const char * alias,uint alias_length,uint dbton_id,bool use_fields,spider_fields * fields)9372 int spider_db_open_item_string(
9373 Item *item,
9374 Field *field,
9375 ha_spider *spider,
9376 spider_string *str,
9377 const char *alias,
9378 uint alias_length,
9379 uint dbton_id,
9380 bool use_fields,
9381 spider_fields *fields
9382 ) {
9383 int error_num = 0;
9384 DBUG_ENTER("spider_db_open_item_string");
9385
9386 if (str)
9387 {
9388 THD *thd = NULL;
9389 TABLE *table;
9390 MY_BITMAP *saved_map;
9391 Time_zone *saved_time_zone;
9392 String str_value;
9393 char tmp_buf[MAX_FIELD_WIDTH];
9394 spider_string tmp_str(tmp_buf, MAX_FIELD_WIDTH, str->charset());
9395 String *tmp_str2;
9396 tmp_str.init_calc_mem(126);
9397
9398 if (!(tmp_str2 = item->val_str(tmp_str.get_str())))
9399 {
9400 if (str->reserve(SPIDER_SQL_NULL_LEN))
9401 {
9402 error_num = HA_ERR_OUT_OF_MEM;
9403 goto end;
9404 }
9405 str->q_append(SPIDER_SQL_NULL_STR, SPIDER_SQL_NULL_LEN);
9406 } else {
9407 if (
9408 field &&
9409 field->type() == FIELD_TYPE_TIMESTAMP &&
9410 field->table->in_use->variables.time_zone != UTC
9411 ) {
9412 /*
9413 Store the string value in the field. This is necessary
9414 when the statement contains more than one value for the
9415 same field.
9416 */
9417 table = field->table;
9418 thd = table->in_use;
9419 saved_map = dbug_tmp_use_all_columns(table, &table->write_set);
9420 item->save_in_field(field, FALSE);
9421 saved_time_zone = thd->variables.time_zone;
9422 thd->variables.time_zone = UTC;
9423
9424 /* Retrieve the stored value converted to UTC */
9425 tmp_str2 = field->val_str(&str_value);
9426
9427 if (!tmp_str2)
9428 {
9429 error_num = HA_ERR_OUT_OF_MEM;
9430 goto end;
9431 }
9432 }
9433 if (str->reserve(SPIDER_SQL_VALUE_QUOTE_LEN * 2 +
9434 tmp_str2->length() * 2))
9435 {
9436 error_num = HA_ERR_OUT_OF_MEM;
9437 goto end;
9438 }
9439 if (!thd)
9440 tmp_str.mem_calc();
9441 str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
9442 str->append_escape_string(tmp_str2->ptr(), tmp_str2->length());
9443 if (str->reserve(SPIDER_SQL_VALUE_QUOTE_LEN))
9444 {
9445 error_num = HA_ERR_OUT_OF_MEM;
9446 goto end;
9447 }
9448 str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
9449 }
9450
9451 end:
9452 if (thd)
9453 {
9454 thd->variables.time_zone = saved_time_zone;
9455 dbug_tmp_restore_column_map(&table->write_set, saved_map);
9456 }
9457 }
9458
9459 DBUG_RETURN(error_num);
9460 }
9461
9462 /**
9463 Print an integer value within a generated statement.
9464
9465 @param item Integer value to print.
9466 @param field Field related to the integer value.
9467 @param spider Spider.
9468 @param str String into which the value is to be printed.
9469 @param alias Name related to the integer value.
9470 @param alias_length Length of the name.
9471 @param dbton_id Spider Db/Table id.
9472 @param use_fields Use fields or exchange fields.
9473 @param fields Array of fields in an expression containing
9474 the integer value.
9475
9476 @return Error code.
9477 */
9478
spider_db_open_item_int(Item * item,Field * field,ha_spider * spider,spider_string * str,const char * alias,uint alias_length,uint dbton_id,bool use_fields,spider_fields * fields)9479 int spider_db_open_item_int(
9480 Item *item,
9481 Field *field,
9482 ha_spider *spider,
9483 spider_string *str,
9484 const char *alias,
9485 uint alias_length,
9486 uint dbton_id,
9487 bool use_fields,
9488 spider_fields *fields
9489 ) {
9490 int error_num = 0;
9491 DBUG_ENTER("spider_db_open_item_int");
9492
9493 if (str)
9494 {
9495 THD *thd = NULL;
9496 TABLE *table;
9497 MY_BITMAP *saved_map;
9498 Time_zone *saved_time_zone;
9499 String str_value;
9500 bool print_quoted_string;
9501 char tmp_buf[MAX_FIELD_WIDTH];
9502 spider_string tmp_str(tmp_buf, MAX_FIELD_WIDTH, str->charset());
9503 String *tmp_str2;
9504 tmp_str.init_calc_mem(127);
9505
9506 if (!(tmp_str2 = item->val_str(tmp_str.get_str())))
9507 {
9508 error_num = HA_ERR_OUT_OF_MEM;
9509 goto end;
9510 }
9511 tmp_str.mem_calc();
9512
9513 if (
9514 field &&
9515 field->type() == FIELD_TYPE_TIMESTAMP &&
9516 field->table->in_use->variables.time_zone != UTC
9517 ) {
9518 /*
9519 Store the int value in the field. This is necessary
9520 when the statement contains more than one value for the
9521 same field.
9522 */
9523 table = field->table;
9524 thd = table->in_use;
9525 saved_map = dbug_tmp_use_all_columns(table, &table->write_set);
9526 item->save_in_field(field, FALSE);
9527 saved_time_zone = thd->variables.time_zone;
9528 thd->variables.time_zone = UTC;
9529 print_quoted_string = TRUE;
9530 } else {
9531 #ifdef SPIDER_ITEM_HAS_CMP_TYPE
9532 DBUG_PRINT("info",("spider cmp_type=%u", item->cmp_type()));
9533 if (item->cmp_type() == TIME_RESULT)
9534 print_quoted_string = TRUE;
9535 else
9536 #endif
9537 print_quoted_string = FALSE;
9538 }
9539
9540 if (print_quoted_string)
9541 {
9542 if (thd)
9543 {
9544 /* Retrieve the stored value converted to UTC */
9545 tmp_str2 = field->val_str(&str_value);
9546
9547 if (!tmp_str2)
9548 {
9549 error_num = HA_ERR_OUT_OF_MEM;
9550 goto end;
9551 }
9552 }
9553
9554 if (str->reserve(SPIDER_SQL_VALUE_QUOTE_LEN * 2 + tmp_str2->length()))
9555 {
9556 error_num = HA_ERR_OUT_OF_MEM;
9557 goto end;
9558 }
9559 str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
9560 str->append(*tmp_str2);
9561 str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
9562 } else {
9563 if (str->append(*tmp_str2))
9564 error_num = HA_ERR_OUT_OF_MEM;
9565 }
9566
9567 end:
9568 if (thd)
9569 {
9570 thd->variables.time_zone = saved_time_zone;
9571 dbug_tmp_restore_column_map(&table->write_set, saved_map);
9572 }
9573 }
9574
9575 DBUG_RETURN(error_num);
9576 }
9577
9578 /**
9579 Print a cached value within a generated statement.
9580
9581 @param item Cached value to print.
9582 @param field Field related to the cached value.
9583 @param spider Spider.
9584 @param str String into which the value is to be printed.
9585 @param alias Name related to the cached value.
9586 @param alias_length Length of the name.
9587 @param dbton_id Spider Db/Table id.
9588 @param use_fields Use fields or exchange fields.
9589 @param fields Array of fields in the expression containing
9590 the cached value.
9591
9592 @return Error code.
9593 */
9594
spider_db_open_item_cache(Item_cache * item_cache,Field * field,ha_spider * spider,spider_string * str,const char * alias,uint alias_length,uint dbton_id,bool use_fields,spider_fields * fields)9595 int spider_db_open_item_cache(
9596 Item_cache *item_cache,
9597 Field *field,
9598 ha_spider *spider,
9599 spider_string *str,
9600 const char *alias,
9601 uint alias_length,
9602 uint dbton_id,
9603 bool use_fields,
9604 spider_fields *fields
9605 ) {
9606 DBUG_ENTER("spider_db_open_item_cache");
9607 if (!item_cache->const_item())
9608 DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);
9609 DBUG_PRINT("info",("spider result_type=%u", item_cache->result_type()));
9610
9611 switch (item_cache->result_type())
9612 {
9613 case STRING_RESULT:
9614 DBUG_RETURN(spider_db_open_item_string(item_cache, field, spider, str,
9615 alias, alias_length, dbton_id, use_fields, fields));
9616 case ROW_RESULT:
9617 {
9618 int error_num;
9619 Item_cache_row *item_cache_row = (Item_cache_row *) item_cache;
9620 uint item_count = item_cache_row->cols() - 1, roop_count;
9621 if (str)
9622 {
9623 if (str->reserve(SPIDER_SQL_OPEN_PAREN_LEN))
9624 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9625 str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
9626 }
9627 for (roop_count = 0; roop_count < item_count; ++roop_count)
9628 {
9629 if ((error_num = spider_db_open_item_cache(
9630 (Item_cache *) item_cache_row->element_index(roop_count), NULL,
9631 spider, str, alias, alias_length, dbton_id, use_fields, fields
9632 ))) {
9633 DBUG_RETURN(error_num);
9634 }
9635 if (str)
9636 {
9637 if (str->reserve(SPIDER_SQL_COMMA_LEN))
9638 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9639 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
9640 }
9641 }
9642 if ((error_num = spider_db_open_item_cache(
9643 (Item_cache *) item_cache_row->element_index(roop_count), NULL,
9644 spider, str, alias, alias_length, dbton_id, use_fields, fields
9645 ))) {
9646 DBUG_RETURN(error_num);
9647 }
9648 if (str)
9649 {
9650 if (str->reserve(SPIDER_SQL_CLOSE_PAREN_LEN))
9651 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9652 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR,
9653 SPIDER_SQL_CLOSE_PAREN_LEN);
9654 }
9655 }
9656 DBUG_RETURN(0);
9657 case REAL_RESULT:
9658 case INT_RESULT:
9659 case DECIMAL_RESULT:
9660 default:
9661 break;
9662 }
9663 DBUG_RETURN(spider_db_open_item_int(item_cache, field, spider, str,
9664 alias, alias_length, dbton_id, use_fields, fields));
9665 }
9666
9667 /**
9668 Print an INSERT value within a generated INSERT statement.
9669
9670 @param item INSERT value to print.
9671 @param field Field related to the INSERT value.
9672 @param spider Spider.
9673 @param str String into which the value is to be printed.
9674 @param alias Name related to the INSERT value.
9675 @param alias_length Length of the name.
9676 @param dbton_id Spider Db/Table id.
9677 @param use_fields Use fields or exchange fields.
9678 @param fields Array of fields in the expression.
9679
9680 @return Error code.
9681 */
9682
spider_db_open_item_insert_value(Item_insert_value * item_insert_value,Field * field,ha_spider * spider,spider_string * str,const char * alias,uint alias_length,uint dbton_id,bool use_fields,spider_fields * fields)9683 int spider_db_open_item_insert_value(
9684 Item_insert_value *item_insert_value,
9685 Field *field,
9686 ha_spider *spider,
9687 spider_string *str,
9688 const char *alias,
9689 uint alias_length,
9690 uint dbton_id,
9691 bool use_fields,
9692 spider_fields *fields
9693 ) {
9694 int error_num;
9695 DBUG_ENTER("spider_db_open_item_insert_value");
9696
9697 if (item_insert_value->arg)
9698 {
9699 if (str)
9700 {
9701 if (str->reserve(SPIDER_SQL_VALUES_LEN + SPIDER_SQL_OPEN_PAREN_LEN))
9702 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9703 str->q_append(SPIDER_SQL_VALUES_STR, SPIDER_SQL_VALUES_LEN);
9704 str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
9705 }
9706 if ((error_num = spider_db_print_item_type(item_insert_value->arg, field,
9707 spider, str, alias, alias_length, dbton_id, use_fields, fields)))
9708 DBUG_RETURN(error_num);
9709 if (str)
9710 {
9711 if (str->reserve(SPIDER_SQL_CLOSE_PAREN_LEN))
9712 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9713 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN);
9714 }
9715 }
9716
9717 DBUG_RETURN(0);
9718 }
9719
spider_db_append_condition(ha_spider * spider,const char * alias,uint alias_length,bool test_flg)9720 int spider_db_append_condition(
9721 ha_spider *spider,
9722 const char *alias,
9723 uint alias_length,
9724 bool test_flg
9725 ) {
9726 int error_num;
9727 DBUG_ENTER("spider_db_append_condition");
9728 if (!test_flg)
9729 {
9730 if (spider->sql_kinds & SPIDER_SQL_KIND_SQL)
9731 {
9732 if ((error_num = spider->append_condition_sql_part(
9733 alias, alias_length, SPIDER_SQL_TYPE_SELECT_SQL, FALSE)))
9734 DBUG_RETURN(error_num);
9735 }
9736 if (spider->sql_kinds & SPIDER_SQL_KIND_HANDLER)
9737 {
9738 if ((error_num = spider->append_condition_sql_part(
9739 alias, alias_length, SPIDER_SQL_TYPE_HANDLER, FALSE)))
9740 DBUG_RETURN(error_num);
9741 }
9742 } else {
9743 if (spider->cond_check)
9744 DBUG_RETURN(spider->cond_check_error);
9745 spider->cond_check = TRUE;
9746 if ((spider->cond_check_error = spider->append_condition_sql_part(
9747 NULL, 0, SPIDER_SQL_TYPE_SELECT_SQL, TRUE)))
9748 DBUG_RETURN(spider->cond_check_error);
9749 }
9750 DBUG_RETURN(0);
9751 }
9752
9753 #ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
spider_db_append_update_columns(ha_spider * spider,spider_string * str,const char * alias,uint alias_length,uint dbton_id,bool use_fields,spider_fields * fields)9754 int spider_db_append_update_columns(
9755 ha_spider *spider,
9756 spider_string *str,
9757 const char *alias,
9758 uint alias_length,
9759 uint dbton_id,
9760 bool use_fields,
9761 spider_fields *fields
9762 ) {
9763 int error_num;
9764 bool add_comma = FALSE;
9765 List_iterator_fast<Item> fi(*spider->direct_update_fields),
9766 vi(*spider->direct_update_values);
9767 Item *field, *value;
9768 DBUG_ENTER("spider_db_append_update_columns");
9769 while ((field = fi++))
9770 {
9771 value = vi++;
9772 if ((error_num = spider_db_print_item_type(
9773 (Item *) field, NULL, spider, str, alias, alias_length, dbton_id,
9774 use_fields, fields)))
9775 {
9776 if (
9777 error_num == ER_SPIDER_COND_SKIP_NUM &&
9778 field->type() == Item::FIELD_ITEM &&
9779 ((Item_field *) field)->field
9780 ) {
9781 DBUG_PRINT("info",("spider no match field(ex. vp child table)"));
9782 continue;
9783 }
9784 DBUG_RETURN(error_num);
9785 }
9786 if (str)
9787 {
9788 if (str->reserve(SPIDER_SQL_EQUAL_LEN))
9789 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9790 str->q_append(SPIDER_SQL_EQUAL_STR, SPIDER_SQL_EQUAL_LEN);
9791 }
9792 if ((error_num = spider_db_print_item_type(
9793 (Item *) value, ((Item_field *) field)->field, spider, str,
9794 alias, alias_length, dbton_id, use_fields, fields)))
9795 DBUG_RETURN(error_num);
9796 if (str)
9797 {
9798 if (str->reserve(SPIDER_SQL_COMMA_LEN))
9799 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9800 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
9801 add_comma = TRUE;
9802 }
9803 }
9804 if (str && add_comma)
9805 str->length(str->length() - SPIDER_SQL_COMMA_LEN);
9806 DBUG_RETURN(0);
9807 }
9808 #endif
9809
spider_db_check_ft_idx(Item_func * item_func,ha_spider * spider)9810 uint spider_db_check_ft_idx(
9811 Item_func *item_func,
9812 ha_spider *spider
9813 ) {
9814 uint roop_count, roop_count2, part_num;
9815 uint item_count = item_func->argument_count();
9816 Item **item_list = item_func->arguments();
9817 Item_field *item_field;
9818 Field *field;
9819 TABLE *table = spider->get_table();
9820 TABLE_SHARE *table_share = table->s;
9821 KEY *key_info;
9822 KEY_PART_INFO *key_part;
9823 bool match1, match2;
9824 DBUG_ENTER("spider_db_check_ft_idx");
9825
9826 for (roop_count = 0; roop_count < table_share->keys; roop_count++)
9827 {
9828 key_info = &table->key_info[roop_count];
9829 if (
9830 key_info->algorithm == HA_KEY_ALG_FULLTEXT &&
9831 item_count - 1 == spider_user_defined_key_parts(key_info)
9832 ) {
9833 match1 = TRUE;
9834 for (roop_count2 = 1; roop_count2 < item_count; roop_count2++)
9835 {
9836 item_field = (Item_field *) item_list[roop_count2];
9837 field = item_field->field;
9838 if (!(field = spider->field_exchange(field)))
9839 DBUG_RETURN(MAX_KEY);
9840 match2 = FALSE;
9841 for (key_part = key_info->key_part, part_num = 0;
9842 part_num < spider_user_defined_key_parts(key_info);
9843 key_part++, part_num++)
9844 {
9845 if (key_part->field == field)
9846 {
9847 match2 = TRUE;
9848 break;
9849 }
9850 }
9851 if (!match2)
9852 {
9853 match1 = FALSE;
9854 break;
9855 }
9856 }
9857 if (match1)
9858 DBUG_RETURN(roop_count);
9859 }
9860 }
9861 DBUG_RETURN(MAX_KEY);
9862 }
9863
spider_db_udf_fetch_row(SPIDER_TRX * trx,Field * field,SPIDER_DB_ROW * row)9864 int spider_db_udf_fetch_row(
9865 SPIDER_TRX *trx,
9866 Field *field,
9867 SPIDER_DB_ROW *row
9868 ) {
9869 DBUG_ENTER("spider_db_udf_fetch_row");
9870 DBUG_RETURN(row->store_to_field(field, trx->udf_access_charset));
9871 DBUG_RETURN(0);
9872 }
9873
spider_db_udf_fetch_table(SPIDER_TRX * trx,SPIDER_CONN * conn,TABLE * table,SPIDER_DB_RESULT * result,uint set_on,uint set_off)9874 int spider_db_udf_fetch_table(
9875 SPIDER_TRX *trx,
9876 SPIDER_CONN *conn,
9877 TABLE *table,
9878 SPIDER_DB_RESULT *result,
9879 uint set_on,
9880 uint set_off
9881 ) {
9882 int error_num;
9883 SPIDER_DB_ROW *row = NULL;
9884 Field **field;
9885 uint roop_count;
9886 DBUG_ENTER("spider_db_udf_fetch_table");
9887 if (!(row = result->fetch_row()))
9888 DBUG_RETURN(HA_ERR_END_OF_FILE);
9889
9890 #ifndef DBUG_OFF
9891 MY_BITMAP *tmp_map =
9892 dbug_tmp_use_all_columns(table, &table->write_set);
9893 #endif
9894 for (
9895 roop_count = 0,
9896 field = table->field;
9897 roop_count < set_on;
9898 roop_count++,
9899 field++
9900 ) {
9901 if ((error_num =
9902 spider_db_udf_fetch_row(trx, *field, row)))
9903 {
9904 #ifndef DBUG_OFF
9905 dbug_tmp_restore_column_map(&table->write_set, tmp_map);
9906 #endif
9907 DBUG_RETURN(error_num);
9908 }
9909 row->next();
9910 }
9911
9912 for (; roop_count < set_off; roop_count++, field++)
9913 (*field)->set_default();
9914 #ifndef DBUG_OFF
9915 dbug_tmp_restore_column_map(&table->write_set, tmp_map);
9916 #endif
9917 table->status = 0;
9918 DBUG_RETURN(0);
9919 }
9920
spider_db_udf_direct_sql_connect(const SPIDER_DIRECT_SQL * direct_sql,SPIDER_CONN * conn)9921 int spider_db_udf_direct_sql_connect(
9922 const SPIDER_DIRECT_SQL *direct_sql,
9923 SPIDER_CONN *conn
9924 ) {
9925 int error_num, connect_retry_count;
9926 THD* thd = current_thd;
9927 longlong connect_retry_interval;
9928 DBUG_ENTER("spider_db_udf_direct_sql_connect");
9929
9930 if (thd)
9931 {
9932 conn->connect_timeout = spider_param_connect_timeout(thd,
9933 direct_sql->connect_timeout);
9934 conn->net_read_timeout = spider_param_net_read_timeout(thd,
9935 direct_sql->net_read_timeout);
9936 conn->net_write_timeout = spider_param_net_write_timeout(thd,
9937 direct_sql->net_write_timeout);
9938 connect_retry_interval = spider_param_connect_retry_interval(thd);
9939 connect_retry_count = spider_param_connect_retry_count(thd);
9940 } else {
9941 conn->connect_timeout = spider_param_connect_timeout(NULL,
9942 direct_sql->connect_timeout);
9943 conn->net_read_timeout = spider_param_net_read_timeout(NULL,
9944 direct_sql->net_read_timeout);
9945 conn->net_write_timeout = spider_param_net_write_timeout(NULL,
9946 direct_sql->net_write_timeout);
9947 connect_retry_interval = spider_param_connect_retry_interval(NULL);
9948 connect_retry_count = spider_param_connect_retry_count(NULL);
9949 }
9950 DBUG_PRINT("info",("spider connect_timeout=%u", conn->connect_timeout));
9951 DBUG_PRINT("info",("spider net_read_timeout=%u", conn->net_read_timeout));
9952 DBUG_PRINT("info",("spider net_write_timeout=%u", conn->net_write_timeout));
9953
9954 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
9955 if (direct_sql->access_mode == 0)
9956 {
9957 #endif
9958 if ((error_num = spider_reset_conn_setted_parameter(conn, thd)))
9959 DBUG_RETURN(error_num);
9960 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
9961 }
9962 #endif
9963
9964 if (conn->dbton_id == SPIDER_DBTON_SIZE)
9965 {
9966 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
9967 if (conn->conn_kind == SPIDER_CONN_KIND_MYSQL)
9968 {
9969 #endif
9970 my_printf_error(
9971 ER_SPIDER_SQL_WRAPPER_IS_INVALID_NUM,
9972 ER_SPIDER_SQL_WRAPPER_IS_INVALID_STR,
9973 MYF(0), conn->tgt_wrapper);
9974 DBUG_RETURN(ER_SPIDER_SQL_WRAPPER_IS_INVALID_NUM);
9975 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
9976 } else {
9977 my_printf_error(
9978 ER_SPIDER_NOSQL_WRAPPER_IS_INVALID_NUM,
9979 ER_SPIDER_NOSQL_WRAPPER_IS_INVALID_STR,
9980 MYF(0), conn->tgt_wrapper);
9981 DBUG_RETURN(ER_SPIDER_NOSQL_WRAPPER_IS_INVALID_NUM);
9982 }
9983 #endif
9984 }
9985
9986 /*
9987 if (!(conn->db_conn = spider_dbton[conn->dbton_id].create_db_conn(conn)))
9988 {
9989 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9990 }
9991 */
9992
9993 if ((error_num = conn->db_conn->connect(
9994 direct_sql->tgt_host,
9995 direct_sql->tgt_username,
9996 direct_sql->tgt_password,
9997 direct_sql->tgt_port,
9998 direct_sql->tgt_socket,
9999 direct_sql->server_name,
10000 connect_retry_count, connect_retry_interval)))
10001 {
10002 DBUG_RETURN(error_num);
10003 }
10004 ++conn->connection_id;
10005 DBUG_RETURN(0);
10006 }
10007
spider_db_udf_direct_sql_ping(SPIDER_DIRECT_SQL * direct_sql)10008 int spider_db_udf_direct_sql_ping(
10009 SPIDER_DIRECT_SQL *direct_sql
10010 ) {
10011 int error_num;
10012 SPIDER_CONN *conn = direct_sql->conn;
10013 DBUG_ENTER("spider_db_udf_direct_sql_ping");
10014 if (conn->server_lost)
10015 {
10016 if ((error_num = spider_db_udf_direct_sql_connect(direct_sql, conn)))
10017 DBUG_RETURN(error_num);
10018 conn->server_lost = FALSE;
10019 }
10020 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
10021 if (direct_sql->access_mode == 0)
10022 {
10023 #endif
10024 if ((error_num = conn->db_conn->ping()))
10025 {
10026 spider_db_disconnect(conn);
10027 if ((error_num = spider_db_udf_direct_sql_connect(direct_sql, conn)))
10028 {
10029 DBUG_PRINT("info", ("spider conn=%p SERVER_LOST", conn));
10030 conn->server_lost = TRUE;
10031 DBUG_RETURN(error_num);
10032 }
10033 if((error_num = conn->db_conn->ping()))
10034 {
10035 spider_db_disconnect(conn);
10036 DBUG_PRINT("info", ("spider conn=%p SERVER_LOST", conn));
10037 conn->server_lost = TRUE;
10038 DBUG_RETURN(error_num);
10039 }
10040 }
10041 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
10042 }
10043 #endif
10044 conn->ping_time = (time_t) time((time_t*) 0);
10045 DBUG_RETURN(0);
10046 }
10047
spider_db_udf_direct_sql(SPIDER_DIRECT_SQL * direct_sql)10048 int spider_db_udf_direct_sql(
10049 SPIDER_DIRECT_SQL *direct_sql
10050 ) {
10051 int error_num = 0, status = 0, roop_count = 0, need_mon = 0;
10052 uint udf_table_mutex_index, field_num, set_on, set_off;
10053 long long roop_count2;
10054 bool end_of_file;
10055 SPIDER_TRX *trx = direct_sql->trx;
10056 THD *thd = trx->thd, *c_thd = current_thd;
10057 SPIDER_CONN *conn = direct_sql->conn;
10058 SPIDER_DB_RESULT *result = NULL;
10059 TABLE *table;
10060 int bulk_insert_rows = (int) spider_param_udf_ds_bulk_insert_rows(thd,
10061 direct_sql->bulk_insert_rows);
10062 int table_loop_mode = spider_param_udf_ds_table_loop_mode(thd,
10063 direct_sql->table_loop_mode);
10064 double ping_interval_at_trx_start =
10065 spider_param_ping_interval_at_trx_start(thd);
10066 time_t tmp_time = (time_t) time((time_t*) 0);
10067 bool need_trx_end, need_all_commit, insert_start = FALSE;
10068 #if MYSQL_VERSION_ID < 50500
10069 #else
10070 enum_sql_command sql_command_backup;
10071 #endif
10072 DBUG_ENTER("spider_db_udf_direct_sql");
10073 #if MYSQL_VERSION_ID < 50500
10074 #else
10075 if (direct_sql->real_table_used)
10076 {
10077 if (spider_sys_open_tables(c_thd, &direct_sql->table_list_first,
10078 &direct_sql->open_tables_backup))
10079 {
10080 direct_sql->real_table_used = FALSE;
10081 DBUG_RETURN(my_errno);
10082 }
10083 for (roop_count = 0; roop_count < direct_sql->table_count; roop_count++)
10084 {
10085 if (!spider_bit_is_set(direct_sql->real_table_bitmap, roop_count))
10086 continue;
10087 direct_sql->tables[roop_count] =
10088 direct_sql->table_list[roop_count].table;
10089 }
10090 direct_sql->open_tables_thd = c_thd;
10091 roop_count = 0;
10092 }
10093 #endif
10094
10095 if (c_thd != thd)
10096 {
10097 need_all_commit = TRUE;
10098 need_trx_end = TRUE;
10099 } else {
10100 need_all_commit = FALSE;
10101 #if MYSQL_VERSION_ID < 50500
10102 #else
10103 if (direct_sql->real_table_used)
10104 {
10105 need_trx_end = TRUE;
10106 } else {
10107 #endif
10108 if (c_thd->transaction.stmt.ha_list)
10109 need_trx_end = FALSE;
10110 else
10111 need_trx_end = TRUE;
10112 #if MYSQL_VERSION_ID < 50500
10113 #else
10114 }
10115 #endif
10116 }
10117
10118 if (!conn->disable_reconnect)
10119 {
10120 if (
10121 (
10122 conn->server_lost ||
10123 difftime(tmp_time, conn->ping_time) >= ping_interval_at_trx_start
10124 ) &&
10125 (error_num = spider_db_udf_direct_sql_ping(direct_sql))
10126 )
10127 DBUG_RETURN(error_num);
10128 } else if (conn->server_lost)
10129 {
10130 my_message(ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM,
10131 ER_SPIDER_REMOTE_SERVER_GONE_AWAY_STR, MYF(0));
10132 DBUG_RETURN(ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM);
10133 }
10134
10135 #if MYSQL_VERSION_ID < 50500
10136 #else
10137 sql_command_backup = c_thd->lex->sql_command;
10138 c_thd->lex->sql_command = SQLCOM_INSERT;
10139 #endif
10140
10141 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
10142 pthread_mutex_lock(&conn->mta_conn_mutex);
10143 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
10144 conn->need_mon = &need_mon;
10145 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
10146 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
10147 conn->mta_conn_mutex_lock_already = TRUE;
10148 conn->mta_conn_mutex_unlock_later = TRUE;
10149 if (
10150 !(error_num = spider_db_udf_direct_sql_set_names(direct_sql, trx, conn)) &&
10151 !(error_num = spider_db_udf_direct_sql_select_db(direct_sql, conn))
10152 ) {
10153 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
10154 if (direct_sql->access_mode != 0)
10155 {
10156 st_spider_db_request_key request_key;
10157 request_key.spider_thread_id = direct_sql->trx->spider_thread_id;
10158 request_key.query_id = direct_sql->trx->thd->query_id;
10159 request_key.handler = direct_sql;
10160 request_key.request_id = 1;
10161 request_key.next = NULL;
10162 if ((error_num = conn->db_conn->append_sql(
10163 direct_sql->sql, direct_sql->sql_length, &request_key)))
10164 {
10165 #if MYSQL_VERSION_ID < 50500
10166 #else
10167 c_thd->lex->sql_command = sql_command_backup;
10168 #endif
10169 DBUG_RETURN(error_num);
10170 }
10171 }
10172 #endif
10173 spider_conn_set_timeout_from_direct_sql(conn, thd, direct_sql);
10174 if (spider_db_query(
10175 conn,
10176 direct_sql->sql,
10177 direct_sql->sql_length,
10178 -1,
10179 &need_mon)
10180 ) {
10181 error_num = spider_db_errorno(conn);
10182 if (error_num == ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM)
10183 my_message(ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM,
10184 ER_SPIDER_REMOTE_SERVER_GONE_AWAY_STR, MYF(0));
10185 } else {
10186 DBUG_PRINT("info",("spider conn=%p", conn));
10187 if (!direct_sql->table_count)
10188 roop_count = -1;
10189 do {
10190 if (roop_count == direct_sql->table_count)
10191 {
10192 if (table_loop_mode == 1)
10193 roop_count--;
10194 else if (table_loop_mode == 2)
10195 roop_count = 0;
10196 else
10197 roop_count = -1;
10198 }
10199 st_spider_db_request_key request_key;
10200 request_key.spider_thread_id = direct_sql->trx->spider_thread_id;
10201 request_key.query_id = direct_sql->trx->thd->query_id;
10202 request_key.handler = direct_sql;
10203 request_key.request_id = 1;
10204 request_key.next = NULL;
10205 if ((result = conn->db_conn->use_result(&request_key, &error_num)))
10206 {
10207 end_of_file = FALSE;
10208 if (roop_count >= 0)
10209 {
10210 while (!error_num && !end_of_file)
10211 {
10212 udf_table_mutex_index = spider_udf_calc_hash(
10213 direct_sql->db_names[roop_count],
10214 spider_param_udf_table_lock_mutex_count());
10215 udf_table_mutex_index += spider_udf_calc_hash(
10216 direct_sql->table_names[roop_count],
10217 spider_param_udf_table_lock_mutex_count());
10218 udf_table_mutex_index %=
10219 spider_param_udf_table_lock_mutex_count();
10220 pthread_mutex_lock(
10221 &trx->udf_table_mutexes[udf_table_mutex_index]);
10222 table = direct_sql->tables[roop_count];
10223 table->in_use = c_thd;
10224 memset((uchar *) table->null_flags, ~(uchar) 0,
10225 sizeof(uchar) * table->s->null_bytes);
10226 insert_start = TRUE;
10227
10228 field_num = result->num_fields();
10229 if (field_num > table->s->fields)
10230 {
10231 set_on = table->s->fields;
10232 set_off = table->s->fields;
10233 } else {
10234 set_on = field_num;
10235 set_off = table->s->fields;
10236 }
10237 for (roop_count2 = 0; roop_count2 < set_on; roop_count2++)
10238 bitmap_set_bit(table->write_set, (uint) roop_count2);
10239 for (; roop_count2 < set_off; roop_count2++)
10240 bitmap_clear_bit(table->write_set, (uint) roop_count2);
10241
10242 #if MYSQL_VERSION_ID < 50500
10243 if (table->file->has_transactions())
10244 #endif
10245 {
10246 THR_LOCK_DATA *to[2];
10247 table->file->store_lock(table->in_use, to,
10248 TL_WRITE_CONCURRENT_INSERT);
10249 if ((error_num = table->file->ha_external_lock(table->in_use,
10250 F_WRLCK)))
10251 {
10252 table->file->print_error(error_num, MYF(0));
10253 break;
10254 }
10255 #if MYSQL_VERSION_ID < 50500
10256 #else
10257 if (
10258 table->s->tmp_table == NO_TMP_TABLE &&
10259 table->pos_in_table_list
10260 ) {
10261 TABLE_LIST *next_tables =
10262 table->pos_in_table_list->next_global;
10263 while (next_tables && next_tables->parent_l)
10264 {
10265 DBUG_PRINT("info",("spider call child lock"));
10266 TABLE *child_table = next_tables->table;
10267 child_table->file->store_lock(child_table->in_use, to,
10268 TL_WRITE_CONCURRENT_INSERT);
10269 if ((error_num = child_table->file->ha_external_lock(
10270 child_table->in_use, F_WRLCK)))
10271 {
10272 table->file->print_error(error_num, MYF(0));
10273 break;
10274 }
10275 next_tables = next_tables->next_global;
10276 }
10277 }
10278 #endif
10279 }
10280
10281 if (direct_sql->iop)
10282 {
10283 if (direct_sql->iop[roop_count] == 1)
10284 table->file->extra(HA_EXTRA_IGNORE_DUP_KEY);
10285 else if (direct_sql->iop[roop_count] == 2)
10286 table->file->extra(HA_EXTRA_WRITE_CAN_REPLACE);
10287 }
10288 table->file->ha_start_bulk_insert(
10289 (ha_rows) bulk_insert_rows);
10290
10291 for (roop_count2 = 0;
10292 roop_count2 < bulk_insert_rows;
10293 roop_count2++)
10294 {
10295 if ((error_num = spider_db_udf_fetch_table(
10296 trx, conn, table, result, set_on, set_off)))
10297 {
10298 if (error_num == HA_ERR_END_OF_FILE)
10299 {
10300 end_of_file = TRUE;
10301 error_num = 0;
10302 }
10303 break;
10304 }
10305 if (direct_sql->iop && direct_sql->iop[roop_count] == 2)
10306 {
10307 if ((error_num = spider_sys_replace(table,
10308 &direct_sql->modified_non_trans_table)))
10309 {
10310 table->file->print_error(error_num, MYF(0));
10311 break;
10312 }
10313 } else if ((error_num =
10314 table->file->ha_write_row(table->record[0])))
10315 {
10316 /* insert */
10317 if (
10318 !direct_sql->iop || direct_sql->iop[roop_count] != 1 ||
10319 table->file->is_fatal_error(error_num, HA_CHECK_DUP)
10320 ) {
10321 DBUG_PRINT("info",("spider error_num=%d", error_num));
10322 table->file->print_error(error_num, MYF(0));
10323 break;
10324 } else
10325 error_num = 0;
10326 }
10327 }
10328
10329 if (error_num)
10330 table->file->ha_end_bulk_insert();
10331 else
10332 error_num = table->file->ha_end_bulk_insert();
10333 if (direct_sql->iop)
10334 {
10335 if (direct_sql->iop[roop_count] == 1)
10336 table->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
10337 else if (direct_sql->iop[roop_count] == 2)
10338 table->file->extra(HA_EXTRA_WRITE_CANNOT_REPLACE);
10339 }
10340 #if MYSQL_VERSION_ID < 50500
10341 if (table->file->has_transactions())
10342 #endif
10343 {
10344 table->file->ha_external_lock(table->in_use, F_UNLCK);
10345 #if MYSQL_VERSION_ID < 50500
10346 #else
10347 if (
10348 table->s->tmp_table == NO_TMP_TABLE &&
10349 table->pos_in_table_list
10350 ) {
10351 TABLE_LIST *next_tables =
10352 table->pos_in_table_list->next_global;
10353 while (next_tables && next_tables->parent_l)
10354 {
10355 DBUG_PRINT("info",("spider call child lock"));
10356 TABLE *child_table = next_tables->table;
10357 child_table->file->ha_external_lock(child_table->in_use,
10358 F_UNLCK);
10359 next_tables = next_tables->next_global;
10360 }
10361 }
10362 #endif
10363 }
10364 table->file->ha_reset();
10365 table->in_use = thd;
10366 pthread_mutex_unlock(
10367 &trx->udf_table_mutexes[udf_table_mutex_index]);
10368 }
10369 if (error_num)
10370 roop_count = -1;
10371 }
10372 result->free_result();
10373 delete result;
10374 } else {
10375 if (!error_num)
10376 {
10377 error_num = spider_db_errorno(conn);
10378 }
10379 if (error_num)
10380 {
10381 if (error_num == ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM)
10382 my_message(ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM,
10383 ER_SPIDER_REMOTE_SERVER_GONE_AWAY_STR, MYF(0));
10384 else if (error_num == HA_ERR_FOUND_DUPP_KEY)
10385 {
10386 my_printf_error(ER_SPIDER_HS_NUM, ER_SPIDER_HS_STR, MYF(0),
10387 conn->db_conn->get_errno(), conn->db_conn->get_error());
10388 }
10389 break;
10390 }
10391 }
10392 if ((status = conn->db_conn->next_result()) > 0)
10393 {
10394 error_num = status;
10395 break;
10396 }
10397 if (roop_count >= 0)
10398 roop_count++;
10399 } while (status == 0);
10400 }
10401 }
10402 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
10403 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
10404 conn->mta_conn_mutex_lock_already = FALSE;
10405 conn->mta_conn_mutex_unlock_later = FALSE;
10406 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
10407 pthread_mutex_unlock(&conn->mta_conn_mutex);
10408 if (need_trx_end && insert_start)
10409 {
10410 if (error_num)
10411 {
10412 (void) ha_rollback_trans(c_thd, FALSE);
10413 if (need_all_commit)
10414 (void) ha_rollback_trans(c_thd, TRUE);
10415 } else {
10416 if ((error_num = ha_commit_trans(c_thd, FALSE)))
10417 my_error(error_num, MYF(0));
10418 if (need_all_commit)
10419 {
10420 if ((error_num = ha_commit_trans(c_thd, TRUE)))
10421 my_error(error_num, MYF(0));
10422 }
10423 }
10424 }
10425 #if MYSQL_VERSION_ID < 50500
10426 #else
10427 c_thd->lex->sql_command = sql_command_backup;
10428 #endif
10429 DBUG_RETURN(error_num);
10430 }
10431
spider_db_udf_direct_sql_select_db(SPIDER_DIRECT_SQL * direct_sql,SPIDER_CONN * conn)10432 int spider_db_udf_direct_sql_select_db(
10433 SPIDER_DIRECT_SQL *direct_sql,
10434 SPIDER_CONN *conn
10435 ) {
10436 int error_num, need_mon = 0;
10437 SPIDER_DB_CONN *db_conn = conn->db_conn;
10438 DBUG_ENTER("spider_db_udf_direct_sql_select_db");
10439 pthread_mutex_assert_owner(&conn->mta_conn_mutex);
10440 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
10441 if (direct_sql->access_mode == 0)
10442 {
10443 #endif
10444 DBUG_ASSERT(conn->mta_conn_mutex_file_pos.file_name);
10445 if (
10446 !conn->default_database.length() ||
10447 conn->default_database.length() !=
10448 direct_sql->tgt_default_db_name_length ||
10449 memcmp(direct_sql->tgt_default_db_name, conn->default_database.ptr(),
10450 direct_sql->tgt_default_db_name_length)
10451 ) {
10452 if (
10453 (
10454 spider_db_before_query(conn, &need_mon) ||
10455 db_conn->select_db(direct_sql->tgt_default_db_name)
10456 ) &&
10457 (error_num = spider_db_errorno(conn))
10458 ) {
10459 if (
10460 error_num == ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM &&
10461 !conn->disable_reconnect
10462 )
10463 my_message(ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM,
10464 ER_SPIDER_REMOTE_SERVER_GONE_AWAY_STR, MYF(0));
10465 DBUG_RETURN(error_num);
10466 }
10467 conn->default_database.length(0);
10468 if (conn->default_database.reserve(
10469 direct_sql->tgt_default_db_name_length + 1))
10470 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
10471 conn->default_database.q_append(direct_sql->tgt_default_db_name,
10472 direct_sql->tgt_default_db_name_length + 1);
10473 conn->default_database.length(direct_sql->tgt_default_db_name_length);
10474 }
10475 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
10476 }
10477 #endif
10478 DBUG_RETURN(0);
10479 }
10480
spider_db_udf_direct_sql_set_names(SPIDER_DIRECT_SQL * direct_sql,SPIDER_TRX * trx,SPIDER_CONN * conn)10481 int spider_db_udf_direct_sql_set_names(
10482 SPIDER_DIRECT_SQL *direct_sql,
10483 SPIDER_TRX *trx,
10484 SPIDER_CONN *conn
10485 ) {
10486 int error_num, need_mon = 0;
10487 DBUG_ENTER("spider_db_udf_direct_sql_set_names");
10488 pthread_mutex_assert_owner(&conn->mta_conn_mutex);
10489 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
10490 if (direct_sql->access_mode == 0)
10491 {
10492 #endif
10493 DBUG_ASSERT(conn->mta_conn_mutex_file_pos.file_name);
10494 if (
10495 !conn->access_charset ||
10496 trx->udf_access_charset->cset != conn->access_charset->cset
10497 ) {
10498 if (
10499 (
10500 spider_db_before_query(conn, &need_mon) ||
10501 conn->db_conn->set_character_set(trx->udf_access_charset->csname)
10502 ) &&
10503 (error_num = spider_db_errorno(conn))
10504 ) {
10505 if (
10506 error_num == ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM &&
10507 !conn->disable_reconnect
10508 ) {
10509 my_message(ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM,
10510 ER_SPIDER_REMOTE_SERVER_GONE_AWAY_STR, MYF(0));
10511 }
10512 DBUG_RETURN(error_num);
10513 }
10514 conn->access_charset = trx->udf_access_charset;
10515 }
10516 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
10517 }
10518 #endif
10519 DBUG_RETURN(0);
10520 }
10521
spider_db_udf_check_and_set_set_names(SPIDER_TRX * trx)10522 int spider_db_udf_check_and_set_set_names(
10523 SPIDER_TRX *trx
10524 ) {
10525 int error_num;
10526 DBUG_ENTER("spider_db_udf_check_and_set_set_names");
10527 if (
10528 !trx->udf_access_charset ||
10529 trx->udf_access_charset->cset !=
10530 trx->thd->variables.character_set_client->cset)
10531 {
10532 trx->udf_access_charset = trx->thd->variables.character_set_client;
10533 if ((error_num = spider_db_udf_append_set_names(trx)))
10534 DBUG_RETURN(error_num);
10535 }
10536 DBUG_RETURN(0);
10537 }
10538
spider_db_udf_append_set_names(SPIDER_TRX * trx)10539 int spider_db_udf_append_set_names(
10540 SPIDER_TRX *trx
10541 ) {
10542 DBUG_ENTER("spider_db_udf_append_set_names");
10543 DBUG_RETURN(0);
10544 }
10545
spider_db_udf_free_set_names(SPIDER_TRX * trx)10546 void spider_db_udf_free_set_names(
10547 SPIDER_TRX *trx
10548 ) {
10549 DBUG_ENTER("spider_db_udf_free_set_names");
10550 DBUG_VOID_RETURN;
10551 }
10552
spider_db_udf_ping_table(SPIDER_TABLE_MON_LIST * table_mon_list,SPIDER_SHARE * share,SPIDER_TRX * trx,SPIDER_CONN * conn,char * where_clause,uint where_clause_length,bool ping_only,bool use_where,longlong limit)10553 int spider_db_udf_ping_table(
10554 SPIDER_TABLE_MON_LIST *table_mon_list,
10555 SPIDER_SHARE *share,
10556 SPIDER_TRX *trx,
10557 SPIDER_CONN *conn,
10558 char *where_clause,
10559 uint where_clause_length,
10560 bool ping_only,
10561 bool use_where,
10562 longlong limit
10563 ) {
10564 int error_num;
10565 DBUG_ENTER("spider_db_udf_ping_table");
10566 if (!pthread_mutex_trylock(&table_mon_list->monitor_mutex))
10567 {
10568 int need_mon = 0;
10569 uint tmp_conn_link_idx = 0;
10570 ha_spider spider;
10571 uchar db_request_phase = 0;
10572 ulonglong db_request_id = 0;
10573 spider.share = share;
10574 spider.trx = trx;
10575 spider.need_mons = &need_mon;
10576 spider.conn_link_idx = &tmp_conn_link_idx;
10577 spider.db_request_phase = &db_request_phase;
10578 spider.db_request_id = &db_request_id;
10579 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
10580 pthread_mutex_lock(&conn->mta_conn_mutex);
10581 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
10582 conn->need_mon = &need_mon;
10583 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
10584 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
10585 conn->mta_conn_mutex_lock_already = TRUE;
10586 conn->mta_conn_mutex_unlock_later = TRUE;
10587 if ((error_num = spider_db_ping(&spider, conn, 0)))
10588 {
10589 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
10590 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
10591 conn->mta_conn_mutex_lock_already = FALSE;
10592 conn->mta_conn_mutex_unlock_later = FALSE;
10593 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
10594 pthread_mutex_unlock(&conn->mta_conn_mutex);
10595 table_mon_list->last_mon_result = error_num;
10596 pthread_mutex_unlock(&table_mon_list->monitor_mutex);
10597 if (error_num == ER_CON_COUNT_ERROR)
10598 {
10599 my_error(ER_CON_COUNT_ERROR, MYF(0));
10600 DBUG_RETURN(ER_CON_COUNT_ERROR);
10601 }
10602 my_error(ER_CONNECT_TO_FOREIGN_DATA_SOURCE, MYF(0),
10603 share->server_names[0]);
10604 DBUG_RETURN(ER_CONNECT_TO_FOREIGN_DATA_SOURCE);
10605 }
10606 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
10607 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
10608 conn->mta_conn_mutex_lock_already = FALSE;
10609 conn->mta_conn_mutex_unlock_later = FALSE;
10610 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
10611 pthread_mutex_unlock(&conn->mta_conn_mutex);
10612 if (!ping_only)
10613 {
10614 int init_sql_alloc_size =
10615 spider_param_init_sql_alloc_size(trx->thd, share->init_sql_alloc_size);
10616 char *sql_buf = (char *) my_alloca(init_sql_alloc_size * 2);
10617 if (!sql_buf)
10618 {
10619 table_mon_list->last_mon_result = HA_ERR_OUT_OF_MEM;
10620 pthread_mutex_unlock(&table_mon_list->monitor_mutex);
10621 my_error(HA_ERR_OUT_OF_MEM, MYF(0));
10622 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
10623 }
10624 char *where_buf = sql_buf + init_sql_alloc_size;
10625 spider_string sql_str(sql_buf, sizeof(sql_buf),
10626 system_charset_info);
10627 spider_string where_str(where_buf, sizeof(where_buf),
10628 system_charset_info);
10629 sql_str.init_calc_mem(128);
10630 where_str.init_calc_mem(129);
10631 sql_str.length(0);
10632 where_str.length(0);
10633 if (
10634 use_where &&
10635 where_str.append(where_clause, where_clause_length,
10636 trx->thd->variables.character_set_client)
10637 ) {
10638 table_mon_list->last_mon_result = HA_ERR_OUT_OF_MEM;
10639 pthread_mutex_unlock(&table_mon_list->monitor_mutex);
10640 my_error(HA_ERR_OUT_OF_MEM, MYF(0));
10641 my_afree(sql_buf);
10642 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
10643 }
10644 share->access_charset = system_charset_info;
10645 if ((error_num = spider_db_udf_ping_table_append_select(&sql_str,
10646 share, trx, &where_str, use_where, limit, conn->dbton_id)))
10647 {
10648 table_mon_list->last_mon_result = error_num;
10649 pthread_mutex_unlock(&table_mon_list->monitor_mutex);
10650 my_error(error_num, MYF(0));
10651 my_afree(sql_buf);
10652 DBUG_RETURN(error_num);
10653 }
10654 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
10655 pthread_mutex_lock(&conn->mta_conn_mutex);
10656 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
10657 conn->need_mon = &need_mon;
10658 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
10659 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
10660 conn->mta_conn_mutex_lock_already = TRUE;
10661 conn->mta_conn_mutex_unlock_later = TRUE;
10662 if ((error_num = spider_db_set_names(&spider, conn, 0)))
10663 {
10664 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
10665 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
10666 conn->mta_conn_mutex_lock_already = FALSE;
10667 conn->mta_conn_mutex_unlock_later = FALSE;
10668 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
10669 pthread_mutex_unlock(&conn->mta_conn_mutex);
10670 table_mon_list->last_mon_result = error_num;
10671 pthread_mutex_unlock(&table_mon_list->monitor_mutex);
10672 DBUG_PRINT("info",("spider error_num=%d", error_num));
10673 my_afree(sql_buf);
10674 DBUG_RETURN(error_num);
10675 }
10676 spider_conn_set_timeout_from_share(conn, 0, trx->thd, share);
10677 if (spider_db_query(
10678 conn,
10679 sql_str.ptr(),
10680 sql_str.length(),
10681 -1,
10682 &need_mon)
10683 ) {
10684 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
10685 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
10686 conn->mta_conn_mutex_lock_already = FALSE;
10687 conn->mta_conn_mutex_unlock_later = FALSE;
10688 error_num = spider_db_errorno(conn);
10689 table_mon_list->last_mon_result = error_num;
10690 pthread_mutex_unlock(&table_mon_list->monitor_mutex);
10691 DBUG_PRINT("info",("spider error_num=%d", error_num));
10692 my_afree(sql_buf);
10693 DBUG_RETURN(error_num);
10694 }
10695 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
10696 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
10697 conn->mta_conn_mutex_lock_already = FALSE;
10698 conn->mta_conn_mutex_unlock_later = FALSE;
10699 spider_db_discard_result(&spider, 0, conn);
10700 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
10701 pthread_mutex_unlock(&conn->mta_conn_mutex);
10702 my_afree(sql_buf);
10703 }
10704 table_mon_list->last_mon_result = 0;
10705 pthread_mutex_unlock(&table_mon_list->monitor_mutex);
10706 } else {
10707 pthread_mutex_lock(&table_mon_list->monitor_mutex);
10708 error_num = table_mon_list->last_mon_result;
10709 pthread_mutex_unlock(&table_mon_list->monitor_mutex);
10710 DBUG_RETURN(error_num);
10711 }
10712
10713 DBUG_RETURN(0);
10714 }
10715
spider_db_udf_ping_table_append_mon_next(spider_string * str,char * child_table_name,uint child_table_name_length,int link_id,char * static_link_id,uint static_link_id_length,char * where_clause,uint where_clause_length,longlong first_sid,int full_mon_count,int current_mon_count,int success_count,int fault_count,int flags,longlong limit)10716 int spider_db_udf_ping_table_append_mon_next(
10717 spider_string *str,
10718 char *child_table_name,
10719 uint child_table_name_length,
10720 int link_id,
10721 char *static_link_id,
10722 uint static_link_id_length,
10723 char *where_clause,
10724 uint where_clause_length,
10725 longlong first_sid,
10726 int full_mon_count,
10727 int current_mon_count,
10728 int success_count,
10729 int fault_count,
10730 int flags,
10731 longlong limit
10732 ) {
10733 char limit_str[SPIDER_SQL_INT_LEN], sid_str[SPIDER_SQL_INT_LEN];
10734 int limit_str_length, sid_str_length;
10735 spider_string child_table_name_str(child_table_name,
10736 child_table_name_length + 1, str->charset());
10737 spider_string where_clause_str(where_clause ? where_clause : "",
10738 where_clause_length + 1, str->charset());
10739 DBUG_ENTER("spider_db_udf_ping_table_append_mon_next");
10740 child_table_name_str.init_calc_mem(130);
10741 where_clause_str.init_calc_mem(131);
10742 child_table_name_str.length(child_table_name_length);
10743 where_clause_str.length(where_clause_length);
10744 limit_str_length = my_sprintf(limit_str, (limit_str, "%lld", limit));
10745 sid_str_length = my_sprintf(sid_str, (sid_str, "%lld", first_sid));
10746 if (str->reserve(
10747 SPIDER_SQL_SELECT_LEN +
10748 SPIDER_SQL_PING_TABLE_LEN +
10749 (child_table_name_length * 2) +
10750 (
10751 static_link_id ?
10752 (SPIDER_SQL_INT_LEN * 5) +
10753 (SPIDER_SQL_VALUE_QUOTE_LEN * 2) +
10754 (static_link_id_length * 2) :
10755 (SPIDER_SQL_INT_LEN * 6)
10756 ) +
10757 sid_str_length +
10758 limit_str_length +
10759 (where_clause_length * 2) +
10760 (SPIDER_SQL_VALUE_QUOTE_LEN * 4) +
10761 (SPIDER_SQL_COMMA_LEN * 9) +
10762 SPIDER_SQL_CLOSE_PAREN_LEN
10763 ))
10764 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
10765 str->q_append(SPIDER_SQL_SELECT_STR, SPIDER_SQL_SELECT_LEN);
10766 str->q_append(SPIDER_SQL_PING_TABLE_STR, SPIDER_SQL_PING_TABLE_LEN);
10767 str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
10768 str->append_escape_string(child_table_name_str.ptr(), child_table_name_str.length());
10769 str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
10770 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
10771 if (static_link_id)
10772 {
10773 str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
10774 str->append_for_single_quote(static_link_id, static_link_id_length);
10775 str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
10776 } else {
10777 str->qs_append(link_id);
10778 }
10779 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
10780 str->qs_append(flags);
10781 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
10782 str->q_append(limit_str, limit_str_length);
10783 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
10784 str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
10785 str->append_escape_string(where_clause_str.ptr(), where_clause_str.length());
10786 str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
10787 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
10788 str->q_append(sid_str, sid_str_length);
10789 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
10790 str->qs_append(full_mon_count);
10791 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
10792 str->qs_append(current_mon_count);
10793 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
10794 str->qs_append(success_count);
10795 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
10796 str->qs_append(fault_count);
10797 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN);
10798 DBUG_RETURN(0);
10799 }
10800
spider_db_udf_ping_table_append_select(spider_string * str,SPIDER_SHARE * share,SPIDER_TRX * trx,spider_string * where_str,bool use_where,longlong limit,uint dbton_id)10801 int spider_db_udf_ping_table_append_select(
10802 spider_string *str,
10803 SPIDER_SHARE *share,
10804 SPIDER_TRX *trx,
10805 spider_string *where_str,
10806 bool use_where,
10807 longlong limit,
10808 uint dbton_id
10809 ) {
10810 int error_num;
10811 char limit_str[SPIDER_SQL_INT_LEN];
10812 int limit_str_length;
10813 DBUG_ENTER("spider_db_udf_ping_table_append_select");
10814 if (str->reserve(SPIDER_SQL_SELECT_LEN + SPIDER_SQL_ONE_LEN +
10815 SPIDER_SQL_FROM_LEN))
10816 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
10817 str->q_append(SPIDER_SQL_SELECT_STR, SPIDER_SQL_SELECT_LEN);
10818 str->q_append(SPIDER_SQL_ONE_STR, SPIDER_SQL_ONE_LEN);
10819 str->q_append(SPIDER_SQL_FROM_STR, SPIDER_SQL_FROM_LEN);
10820 if ((error_num = spider_db_append_name_with_quote_str(str,
10821 share->tgt_dbs[0], dbton_id)))
10822 DBUG_RETURN(error_num);
10823 if (str->reserve(SPIDER_SQL_DOT_LEN))
10824 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
10825 str->q_append(SPIDER_SQL_DOT_STR, SPIDER_SQL_DOT_LEN);
10826 if ((error_num = spider_db_append_name_with_quote_str(str,
10827 share->tgt_table_names[0], share->sql_dbton_ids[0])))
10828 DBUG_RETURN(error_num);
10829
10830 limit_str_length = my_sprintf(limit_str, (limit_str, "%lld", limit));
10831 if (str->reserve(
10832 (use_where ? (where_str->length() * 2) : 0) +
10833 SPIDER_SQL_LIMIT_LEN + limit_str_length
10834 ))
10835 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
10836 if (use_where)
10837 {
10838 str->append_escape_string(where_str->ptr(), where_str->length());
10839 }
10840 str->q_append(SPIDER_SQL_LIMIT_STR, SPIDER_SQL_LIMIT_LEN);
10841 str->q_append(limit_str, limit_str_length);
10842 DBUG_RETURN(0);
10843 }
10844
spider_db_udf_ping_table_mon_next(THD * thd,SPIDER_TABLE_MON * table_mon,SPIDER_CONN * conn,SPIDER_MON_TABLE_RESULT * mon_table_result,char * child_table_name,uint child_table_name_length,int link_id,char * where_clause,uint where_clause_length,longlong first_sid,int full_mon_count,int current_mon_count,int success_count,int fault_count,int flags,longlong limit)10845 int spider_db_udf_ping_table_mon_next(
10846 THD *thd,
10847 SPIDER_TABLE_MON *table_mon,
10848 SPIDER_CONN *conn,
10849 SPIDER_MON_TABLE_RESULT *mon_table_result,
10850 char *child_table_name,
10851 uint child_table_name_length,
10852 int link_id,
10853 char *where_clause,
10854 uint where_clause_length,
10855 longlong first_sid,
10856 int full_mon_count,
10857 int current_mon_count,
10858 int success_count,
10859 int fault_count,
10860 int flags,
10861 longlong limit
10862 ) {
10863 int error_num, need_mon = 0;
10864 uint tmp_conn_link_idx = 0;
10865 SPIDER_DB_RESULT *res;
10866 SPIDER_SHARE *share = table_mon->share;
10867 int init_sql_alloc_size =
10868 spider_param_init_sql_alloc_size(thd, share->init_sql_alloc_size);
10869 ha_spider spider;
10870 SPIDER_TRX trx;
10871 DBUG_ENTER("spider_db_udf_ping_table_mon_next");
10872 char *sql_buf = (char *) my_alloca(init_sql_alloc_size);
10873 if (!sql_buf)
10874 {
10875 my_error(HA_ERR_OUT_OF_MEM, MYF(0));
10876 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
10877 }
10878 spider_string sql_str(sql_buf, sizeof(sql_buf),
10879 thd->variables.character_set_client);
10880 sql_str.init_calc_mem(132);
10881 sql_str.length(0);
10882 trx.thd = thd;
10883 spider.share = share;
10884 spider.trx = &trx;
10885 spider.need_mons = &need_mon;
10886 spider.conn_link_idx = &tmp_conn_link_idx;
10887
10888 share->access_charset = thd->variables.character_set_client;
10889 if ((error_num = spider_db_udf_ping_table_append_mon_next(&sql_str,
10890 child_table_name, child_table_name_length, link_id,
10891 table_mon->parent->share->static_link_ids[0],
10892 table_mon->parent->share->static_link_ids_lengths[0],
10893 where_clause,
10894 where_clause_length, first_sid, full_mon_count, current_mon_count,
10895 success_count, fault_count, flags, limit)))
10896 {
10897 my_error(error_num, MYF(0));
10898 my_afree(sql_buf);
10899 DBUG_RETURN(error_num);
10900 }
10901
10902 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
10903 pthread_mutex_lock(&conn->mta_conn_mutex);
10904 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
10905 conn->need_mon = &need_mon;
10906 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
10907 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
10908 conn->mta_conn_mutex_lock_already = TRUE;
10909 conn->mta_conn_mutex_unlock_later = TRUE;
10910 if ((error_num = spider_db_ping(&spider, conn, 0)))
10911 {
10912 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
10913 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
10914 conn->mta_conn_mutex_lock_already = FALSE;
10915 conn->mta_conn_mutex_unlock_later = FALSE;
10916 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
10917 pthread_mutex_unlock(&conn->mta_conn_mutex);
10918 my_error(ER_CONNECT_TO_FOREIGN_DATA_SOURCE, MYF(0),
10919 share->server_names[0]);
10920 my_afree(sql_buf);
10921 DBUG_RETURN(ER_CONNECT_TO_FOREIGN_DATA_SOURCE);
10922 }
10923 if ((error_num = spider_db_set_names(&spider, conn, 0)))
10924 {
10925 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
10926 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
10927 conn->mta_conn_mutex_lock_already = FALSE;
10928 conn->mta_conn_mutex_unlock_later = FALSE;
10929 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
10930 pthread_mutex_unlock(&conn->mta_conn_mutex);
10931 my_afree(sql_buf);
10932 DBUG_RETURN(error_num);
10933 }
10934 spider_conn_set_timeout_from_share(conn, 0, thd, share);
10935 if (spider_db_query(
10936 conn,
10937 sql_str.ptr(),
10938 sql_str.length(),
10939 -1,
10940 &need_mon)
10941 ) {
10942 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
10943 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
10944 conn->mta_conn_mutex_lock_already = FALSE;
10945 conn->mta_conn_mutex_unlock_later = FALSE;
10946 my_afree(sql_buf);
10947 DBUG_RETURN(spider_db_errorno(conn));
10948 }
10949 st_spider_db_request_key request_key;
10950 request_key.spider_thread_id = trx.spider_thread_id;
10951 request_key.query_id = trx.thd->query_id;
10952 request_key.handler = table_mon;
10953 request_key.request_id = 1;
10954 request_key.next = NULL;
10955 if (!(res = conn->db_conn->store_result(NULL, &request_key, &error_num)))
10956 {
10957 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
10958 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
10959 conn->mta_conn_mutex_lock_already = FALSE;
10960 conn->mta_conn_mutex_unlock_later = FALSE;
10961 if (error_num)
10962 {
10963 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
10964 pthread_mutex_unlock(&conn->mta_conn_mutex);
10965 my_afree(sql_buf);
10966 DBUG_RETURN(error_num);
10967 }
10968 else if ((error_num = spider_db_errorno(conn)))
10969 {
10970 my_afree(sql_buf);
10971 DBUG_RETURN(error_num);
10972 }
10973 my_error(HA_ERR_OUT_OF_MEM, MYF(0));
10974 my_afree(sql_buf);
10975 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
10976 }
10977 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
10978 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
10979 conn->mta_conn_mutex_lock_already = FALSE;
10980 conn->mta_conn_mutex_unlock_later = FALSE;
10981 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
10982 pthread_mutex_unlock(&conn->mta_conn_mutex);
10983 my_afree(sql_buf);
10984 error_num = res->fetch_table_mon_status(mon_table_result->result_status);
10985 res->free_result();
10986 delete res;
10987 DBUG_RETURN(error_num);
10988 }
10989
spider_db_udf_copy_key_row(spider_string * str,spider_string * source_str,Field * field,ulong * row_pos,ulong * length,const char * joint_str,const int joint_length,uint dbton_id)10990 int spider_db_udf_copy_key_row(
10991 spider_string *str,
10992 spider_string *source_str,
10993 Field *field,
10994 ulong *row_pos,
10995 ulong *length,
10996 const char *joint_str,
10997 const int joint_length,
10998 uint dbton_id
10999 ) {
11000 int error_num;
11001 DBUG_ENTER("spider_db_udf_copy_key_row");
11002 #ifdef SPIDER_use_LEX_CSTRING_for_KEY_Field_name
11003 if ((error_num = spider_db_append_name_with_quote_str(str,
11004 (char *) field->field_name.str, dbton_id)))
11005 #else
11006 if ((error_num = spider_db_append_name_with_quote_str(str,
11007 (char *) field->field_name, dbton_id)))
11008 #endif
11009 DBUG_RETURN(error_num);
11010 if (str->reserve(joint_length + *length + SPIDER_SQL_AND_LEN))
11011 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
11012 str->q_append(joint_str, joint_length);
11013 str->q_append(source_str->ptr() + *row_pos, *length);
11014 str->q_append(SPIDER_SQL_AND_STR, SPIDER_SQL_AND_LEN);
11015 DBUG_RETURN(0);
11016 }
11017
spider_db_udf_copy_tables(SPIDER_COPY_TABLES * copy_tables,ha_spider * spider,TABLE * table,longlong bulk_insert_rows)11018 int spider_db_udf_copy_tables(
11019 SPIDER_COPY_TABLES *copy_tables,
11020 ha_spider *spider,
11021 TABLE *table,
11022 longlong bulk_insert_rows
11023 ) {
11024 int error_num = 0, roop_count;
11025 bool end_of_file = FALSE;
11026 ulong *last_lengths, *last_row_pos = NULL;
11027 ha_spider *tmp_spider;
11028 SPIDER_CONN *tmp_conn;
11029 int all_link_cnt =
11030 copy_tables->link_idx_count[0] + copy_tables->link_idx_count[1];
11031 SPIDER_COPY_TABLE_CONN *src_tbl_conn = copy_tables->table_conn[0];
11032 SPIDER_COPY_TABLE_CONN *dst_tbl_conn;
11033 spider_db_copy_table *select_ct = src_tbl_conn->copy_table;
11034 spider_db_copy_table *insert_ct = NULL;
11035 KEY *key_info = &table->key_info[table->s->primary_key];
11036 int bulk_insert_interval;
11037 DBUG_ENTER("spider_db_udf_copy_tables");
11038 if (!(last_row_pos = (ulong *)
11039 spider_bulk_malloc(spider_current_trx, 30, MYF(MY_WME),
11040 &last_row_pos, sizeof(ulong) * table->s->fields,
11041 &last_lengths, sizeof(ulong) * table->s->fields,
11042 NullS))
11043 ) {
11044 my_error(ER_OUT_OF_RESOURCES, MYF(0), HA_ERR_OUT_OF_MEM);
11045 goto error;
11046 }
11047 while (!end_of_file)
11048 {
11049 if (copy_tables->trx->thd->killed)
11050 {
11051 my_error(ER_QUERY_INTERRUPTED, MYF(0));
11052 error_num = ER_QUERY_INTERRUPTED;
11053 goto error_killed;
11054 }
11055 if (copy_tables->use_transaction)
11056 {
11057 for (roop_count = 0; roop_count < all_link_cnt; roop_count++)
11058 {
11059 tmp_spider = &spider[roop_count];
11060 tmp_conn = tmp_spider->conns[0];
11061 /* disable transaction */
11062 spider_conn_clear_queue_at_commit(tmp_conn);
11063 if (!tmp_conn->trx_start)
11064 {
11065 pthread_mutex_assert_not_owner(&tmp_conn->mta_conn_mutex);
11066 pthread_mutex_lock(&tmp_conn->mta_conn_mutex);
11067 SPIDER_SET_FILE_POS(&tmp_conn->mta_conn_mutex_file_pos);
11068 tmp_conn->need_mon = &tmp_spider->need_mons[0];
11069 DBUG_ASSERT(!tmp_conn->mta_conn_mutex_lock_already);
11070 DBUG_ASSERT(!tmp_conn->mta_conn_mutex_unlock_later);
11071 tmp_conn->mta_conn_mutex_lock_already = TRUE;
11072 tmp_conn->mta_conn_mutex_unlock_later = TRUE;
11073 if (spider_db_ping(tmp_spider, tmp_conn, 0))
11074 {
11075 DBUG_ASSERT(tmp_conn->mta_conn_mutex_lock_already);
11076 DBUG_ASSERT(tmp_conn->mta_conn_mutex_unlock_later);
11077 tmp_conn->mta_conn_mutex_lock_already = FALSE;
11078 tmp_conn->mta_conn_mutex_unlock_later = FALSE;
11079 SPIDER_CLEAR_FILE_POS(&tmp_conn->mta_conn_mutex_file_pos);
11080 pthread_mutex_unlock(&tmp_conn->mta_conn_mutex);
11081 my_error(ER_CONNECT_TO_FOREIGN_DATA_SOURCE, MYF(0),
11082 tmp_spider->share->server_names[0]);
11083 error_num = ER_CONNECT_TO_FOREIGN_DATA_SOURCE;
11084 goto error_db_ping;
11085 }
11086 if (
11087 (error_num = spider_db_set_names(tmp_spider, tmp_conn, 0)) ||
11088 (error_num = spider_db_start_transaction(tmp_conn,
11089 tmp_spider->need_mons))
11090 ) {
11091 DBUG_ASSERT(tmp_conn->mta_conn_mutex_lock_already);
11092 DBUG_ASSERT(tmp_conn->mta_conn_mutex_unlock_later);
11093 tmp_conn->mta_conn_mutex_lock_already = FALSE;
11094 tmp_conn->mta_conn_mutex_unlock_later = FALSE;
11095 SPIDER_CLEAR_FILE_POS(&tmp_conn->mta_conn_mutex_file_pos);
11096 pthread_mutex_unlock(&tmp_conn->mta_conn_mutex);
11097 goto error_start_transaction;
11098 }
11099 DBUG_ASSERT(tmp_conn->mta_conn_mutex_lock_already);
11100 DBUG_ASSERT(tmp_conn->mta_conn_mutex_unlock_later);
11101 tmp_conn->mta_conn_mutex_lock_already = FALSE;
11102 tmp_conn->mta_conn_mutex_unlock_later = FALSE;
11103 SPIDER_CLEAR_FILE_POS(&tmp_conn->mta_conn_mutex_file_pos);
11104 pthread_mutex_unlock(&tmp_conn->mta_conn_mutex);
11105 }
11106 }
11107 } else {
11108 for (roop_count = 0; roop_count < all_link_cnt; roop_count++)
11109 {
11110 tmp_spider = &spider[roop_count];
11111 tmp_conn = tmp_spider->conns[0];
11112 /* disable transaction */
11113 spider_conn_clear_queue_at_commit(tmp_conn);
11114 spider_db_handler *tmp_dbton_hdl =
11115 tmp_spider->dbton_handler[tmp_conn->dbton_id];
11116 if ((error_num = tmp_dbton_hdl->insert_lock_tables_list(tmp_conn, 0)))
11117 goto error_lock_table_hash;
11118 tmp_conn->table_lock = 2;
11119 }
11120 for (roop_count = 0; roop_count < all_link_cnt; roop_count++)
11121 {
11122 tmp_spider = &spider[roop_count];
11123 tmp_conn = tmp_spider->conns[0];
11124 pthread_mutex_assert_not_owner(&tmp_conn->mta_conn_mutex);
11125 pthread_mutex_lock(&tmp_conn->mta_conn_mutex);
11126 SPIDER_SET_FILE_POS(&tmp_conn->mta_conn_mutex_file_pos);
11127 tmp_conn->need_mon = &tmp_spider->need_mons[0];
11128 DBUG_ASSERT(!tmp_conn->mta_conn_mutex_lock_already);
11129 DBUG_ASSERT(!tmp_conn->mta_conn_mutex_unlock_later);
11130 tmp_conn->mta_conn_mutex_lock_already = TRUE;
11131 tmp_conn->mta_conn_mutex_unlock_later = TRUE;
11132 if (spider_db_ping(tmp_spider, tmp_conn, 0))
11133 {
11134 DBUG_ASSERT(tmp_conn->mta_conn_mutex_lock_already);
11135 DBUG_ASSERT(tmp_conn->mta_conn_mutex_unlock_later);
11136 tmp_conn->mta_conn_mutex_lock_already = FALSE;
11137 tmp_conn->mta_conn_mutex_unlock_later = FALSE;
11138 SPIDER_CLEAR_FILE_POS(&tmp_conn->mta_conn_mutex_file_pos);
11139 pthread_mutex_unlock(&tmp_conn->mta_conn_mutex);
11140 my_error(ER_CONNECT_TO_FOREIGN_DATA_SOURCE, MYF(0),
11141 tmp_spider->share->server_names[0]);
11142 error_num = ER_CONNECT_TO_FOREIGN_DATA_SOURCE;
11143 goto error_db_ping;
11144 }
11145 if (
11146 tmp_conn->db_conn->have_lock_table_list() &&
11147 (
11148 (error_num = spider_db_set_names(tmp_spider, tmp_conn, 0)) ||
11149 (error_num = spider_db_lock_tables(tmp_spider, 0))
11150 )
11151 ) {
11152 DBUG_ASSERT(tmp_conn->mta_conn_mutex_lock_already);
11153 DBUG_ASSERT(tmp_conn->mta_conn_mutex_unlock_later);
11154 tmp_conn->mta_conn_mutex_lock_already = FALSE;
11155 tmp_conn->mta_conn_mutex_unlock_later = FALSE;
11156 SPIDER_CLEAR_FILE_POS(&tmp_conn->mta_conn_mutex_file_pos);
11157 pthread_mutex_unlock(&tmp_conn->mta_conn_mutex);
11158 tmp_conn->table_lock = 0;
11159 if (error_num == HA_ERR_OUT_OF_MEM)
11160 my_error(ER_OUT_OF_RESOURCES, MYF(0), HA_ERR_OUT_OF_MEM);
11161 goto error_lock_tables;
11162 }
11163 DBUG_ASSERT(tmp_conn->mta_conn_mutex_lock_already);
11164 DBUG_ASSERT(tmp_conn->mta_conn_mutex_unlock_later);
11165 tmp_conn->mta_conn_mutex_lock_already = FALSE;
11166 tmp_conn->mta_conn_mutex_unlock_later = FALSE;
11167 SPIDER_CLEAR_FILE_POS(&tmp_conn->mta_conn_mutex_file_pos);
11168 pthread_mutex_unlock(&tmp_conn->mta_conn_mutex);
11169 tmp_conn->table_lock = 1;
11170 }
11171 }
11172
11173 tmp_conn = src_tbl_conn->conn;
11174 spider_conn_set_timeout_from_share(tmp_conn, 0,
11175 copy_tables->trx->thd, src_tbl_conn->share);
11176 pthread_mutex_assert_not_owner(&tmp_conn->mta_conn_mutex);
11177 pthread_mutex_lock(&tmp_conn->mta_conn_mutex);
11178 SPIDER_SET_FILE_POS(&tmp_conn->mta_conn_mutex_file_pos);
11179 tmp_conn->need_mon = &src_tbl_conn->need_mon;
11180 DBUG_ASSERT(!tmp_conn->mta_conn_mutex_lock_already);
11181 DBUG_ASSERT(!tmp_conn->mta_conn_mutex_unlock_later);
11182 tmp_conn->mta_conn_mutex_lock_already = TRUE;
11183 tmp_conn->mta_conn_mutex_unlock_later = TRUE;
11184 if (select_ct->exec_query(
11185 tmp_conn,
11186 -1,
11187 &src_tbl_conn->need_mon)
11188 ) {
11189 DBUG_ASSERT(tmp_conn->mta_conn_mutex_lock_already);
11190 DBUG_ASSERT(tmp_conn->mta_conn_mutex_unlock_later);
11191 tmp_conn->mta_conn_mutex_lock_already = FALSE;
11192 tmp_conn->mta_conn_mutex_unlock_later = FALSE;
11193 error_num = spider_db_errorno(tmp_conn);
11194 if (error_num == ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM)
11195 my_message(ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM,
11196 ER_SPIDER_REMOTE_SERVER_GONE_AWAY_STR, MYF(0));
11197 goto error_db_query;
11198 } else {
11199 SPIDER_DB_RESULT *result;
11200 st_spider_db_request_key request_key;
11201 request_key.spider_thread_id = copy_tables->trx->spider_thread_id;
11202 request_key.query_id = copy_tables->trx->thd->query_id;
11203 request_key.handler = copy_tables;
11204 request_key.request_id = 1;
11205 request_key.next = NULL;
11206 if ((result = tmp_conn->db_conn->use_result(&request_key, &error_num)))
11207 {
11208 SPIDER_DB_ROW *row;
11209 roop_count = 0;
11210 while ((row = result->fetch_row()))
11211 {
11212 dst_tbl_conn = copy_tables->table_conn[1];
11213 insert_ct = dst_tbl_conn->copy_table;
11214 if ((error_num = insert_ct->copy_rows(table, row,
11215 &last_row_pos, &last_lengths)))
11216 {
11217 if (error_num == HA_ERR_OUT_OF_MEM)
11218 my_error(ER_OUT_OF_RESOURCES, MYF(0), HA_ERR_OUT_OF_MEM);
11219 result->free_result();
11220 delete result;
11221 DBUG_ASSERT(tmp_conn->mta_conn_mutex_lock_already);
11222 DBUG_ASSERT(tmp_conn->mta_conn_mutex_unlock_later);
11223 tmp_conn->mta_conn_mutex_lock_already = FALSE;
11224 tmp_conn->mta_conn_mutex_unlock_later = FALSE;
11225 SPIDER_CLEAR_FILE_POS(&tmp_conn->mta_conn_mutex_file_pos);
11226 pthread_mutex_unlock(&tmp_conn->mta_conn_mutex);
11227 goto error_db_query;
11228 }
11229 for (dst_tbl_conn = dst_tbl_conn->next; dst_tbl_conn;
11230 dst_tbl_conn = dst_tbl_conn->next)
11231 {
11232 row->first();
11233 insert_ct = dst_tbl_conn->copy_table;
11234 if ((error_num = insert_ct->copy_rows(table, row)))
11235 {
11236 if (error_num == HA_ERR_OUT_OF_MEM)
11237 my_error(ER_OUT_OF_RESOURCES, MYF(0), HA_ERR_OUT_OF_MEM);
11238 result->free_result();
11239 delete result;
11240 DBUG_ASSERT(tmp_conn->mta_conn_mutex_lock_already);
11241 DBUG_ASSERT(tmp_conn->mta_conn_mutex_unlock_later);
11242 tmp_conn->mta_conn_mutex_lock_already = FALSE;
11243 tmp_conn->mta_conn_mutex_unlock_later = FALSE;
11244 SPIDER_CLEAR_FILE_POS(&tmp_conn->mta_conn_mutex_file_pos);
11245 pthread_mutex_unlock(&tmp_conn->mta_conn_mutex);
11246 goto error_db_query;
11247 }
11248 }
11249 ++roop_count;
11250 }
11251 error_num = result->get_errno();
11252 if (error_num == HA_ERR_END_OF_FILE)
11253 {
11254 if (roop_count < copy_tables->bulk_insert_rows)
11255 {
11256 end_of_file = TRUE;
11257 if (roop_count)
11258 error_num = 0;
11259 } else {
11260 /* add next where clause */
11261 select_ct->set_sql_to_pos();
11262 error_num = select_ct->append_copy_where(insert_ct, key_info,
11263 last_row_pos, last_lengths);
11264 if (error_num)
11265 {
11266 if (error_num == HA_ERR_OUT_OF_MEM)
11267 my_error(ER_OUT_OF_RESOURCES, MYF(0), HA_ERR_OUT_OF_MEM);
11268 result->free_result();
11269 delete result;
11270 DBUG_ASSERT(tmp_conn->mta_conn_mutex_lock_already);
11271 DBUG_ASSERT(tmp_conn->mta_conn_mutex_unlock_later);
11272 tmp_conn->mta_conn_mutex_lock_already = FALSE;
11273 tmp_conn->mta_conn_mutex_unlock_later = FALSE;
11274 SPIDER_CLEAR_FILE_POS(&tmp_conn->mta_conn_mutex_file_pos);
11275 pthread_mutex_unlock(&tmp_conn->mta_conn_mutex);
11276 goto error_db_query;
11277 }
11278 bulk_insert_rows = spider_param_udf_ct_bulk_insert_rows(
11279 copy_tables->bulk_insert_rows);
11280 if (
11281 select_ct->append_key_order_str(key_info, 0, FALSE) ||
11282 select_ct->append_limit(0, bulk_insert_rows) ||
11283 (
11284 copy_tables->use_transaction &&
11285 select_ct->append_select_lock_str(SPIDER_LOCK_MODE_SHARED)
11286 )
11287 ) {
11288 my_error(ER_OUT_OF_RESOURCES, MYF(0), HA_ERR_OUT_OF_MEM);
11289 result->free_result();
11290 delete result;
11291 DBUG_ASSERT(tmp_conn->mta_conn_mutex_lock_already);
11292 DBUG_ASSERT(tmp_conn->mta_conn_mutex_unlock_later);
11293 tmp_conn->mta_conn_mutex_lock_already = FALSE;
11294 tmp_conn->mta_conn_mutex_unlock_later = FALSE;
11295 SPIDER_CLEAR_FILE_POS(&tmp_conn->mta_conn_mutex_file_pos);
11296 pthread_mutex_unlock(&tmp_conn->mta_conn_mutex);
11297 error_num = ER_OUT_OF_RESOURCES;
11298 goto error_db_query;
11299 }
11300 error_num = 0;
11301 }
11302 } else {
11303 if (error_num == HA_ERR_OUT_OF_MEM)
11304 my_error(ER_OUT_OF_RESOURCES, MYF(0), HA_ERR_OUT_OF_MEM);
11305 result->free_result();
11306 delete result;
11307 DBUG_ASSERT(tmp_conn->mta_conn_mutex_lock_already);
11308 DBUG_ASSERT(tmp_conn->mta_conn_mutex_unlock_later);
11309 tmp_conn->mta_conn_mutex_lock_already = FALSE;
11310 tmp_conn->mta_conn_mutex_unlock_later = FALSE;
11311 SPIDER_CLEAR_FILE_POS(&tmp_conn->mta_conn_mutex_file_pos);
11312 pthread_mutex_unlock(&tmp_conn->mta_conn_mutex);
11313 goto error_db_query;
11314 }
11315 result->free_result();
11316 delete result;
11317 DBUG_ASSERT(tmp_conn->mta_conn_mutex_lock_already);
11318 DBUG_ASSERT(tmp_conn->mta_conn_mutex_unlock_later);
11319 tmp_conn->mta_conn_mutex_lock_already = FALSE;
11320 tmp_conn->mta_conn_mutex_unlock_later = FALSE;
11321 SPIDER_CLEAR_FILE_POS(&tmp_conn->mta_conn_mutex_file_pos);
11322 pthread_mutex_unlock(&tmp_conn->mta_conn_mutex);
11323 for (dst_tbl_conn = copy_tables->table_conn[1]; dst_tbl_conn;
11324 dst_tbl_conn = dst_tbl_conn->next)
11325 {
11326 insert_ct = dst_tbl_conn->copy_table;
11327 if ((error_num = insert_ct->append_insert_terminator()))
11328 {
11329 if (error_num == HA_ERR_OUT_OF_MEM)
11330 my_error(ER_OUT_OF_RESOURCES, MYF(0), HA_ERR_OUT_OF_MEM);
11331 goto error_db_query;
11332 }
11333 }
11334 } else {
11335 if (!error_num)
11336 {
11337 error_num = spider_db_errorno(tmp_conn);
11338 }
11339 if (error_num)
11340 {
11341 DBUG_ASSERT(tmp_conn->mta_conn_mutex_lock_already);
11342 DBUG_ASSERT(tmp_conn->mta_conn_mutex_unlock_later);
11343 tmp_conn->mta_conn_mutex_lock_already = FALSE;
11344 tmp_conn->mta_conn_mutex_unlock_later = FALSE;
11345 SPIDER_CLEAR_FILE_POS(&tmp_conn->mta_conn_mutex_file_pos);
11346 pthread_mutex_unlock(&tmp_conn->mta_conn_mutex);
11347 if (error_num == ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM)
11348 my_message(ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM,
11349 ER_SPIDER_REMOTE_SERVER_GONE_AWAY_STR, MYF(0));
11350 goto error_db_query;
11351 }
11352 error_num = HA_ERR_END_OF_FILE;
11353 end_of_file = TRUE;
11354 DBUG_ASSERT(tmp_conn->mta_conn_mutex_lock_already);
11355 DBUG_ASSERT(tmp_conn->mta_conn_mutex_unlock_later);
11356 tmp_conn->mta_conn_mutex_lock_already = FALSE;
11357 tmp_conn->mta_conn_mutex_unlock_later = FALSE;
11358 SPIDER_CLEAR_FILE_POS(&tmp_conn->mta_conn_mutex_file_pos);
11359 pthread_mutex_unlock(&tmp_conn->mta_conn_mutex);
11360 }
11361 }
11362
11363 if (!error_num && roop_count)
11364 {
11365 /*
11366 dst_tbl_conn = copy_tables->table_conn[1];
11367 spider_db_copy_table *source_ct = dst_tbl_conn->copy_table;
11368 for (dst_tbl_conn = dst_tbl_conn->next; dst_tbl_conn;
11369 dst_tbl_conn = dst_tbl_conn->next)
11370 {
11371 insert_ct = dst_tbl_conn->copy_table;
11372 if (insert_ct->copy_insert_values(source_ct))
11373 {
11374 my_error(ER_OUT_OF_RESOURCES, MYF(0), HA_ERR_OUT_OF_MEM);
11375 error_num = ER_OUT_OF_RESOURCES;
11376 goto error_db_query;
11377 }
11378 }
11379 */
11380 #ifndef WITHOUT_SPIDER_BG_SEARCH
11381 if (copy_tables->bg_mode)
11382 {
11383 for (dst_tbl_conn = copy_tables->table_conn[1]; dst_tbl_conn;
11384 dst_tbl_conn = dst_tbl_conn->next)
11385 {
11386 if (spider_udf_bg_copy_exec_sql(dst_tbl_conn))
11387 {
11388 my_error(ER_OUT_OF_RESOURCES, MYF(0), HA_ERR_OUT_OF_MEM);
11389 error_num = ER_OUT_OF_RESOURCES;
11390 goto error_db_query;
11391 }
11392 }
11393 } else {
11394 #endif
11395 for (dst_tbl_conn = copy_tables->table_conn[1]; dst_tbl_conn;
11396 dst_tbl_conn = dst_tbl_conn->next)
11397 {
11398 tmp_conn = dst_tbl_conn->conn;
11399 insert_ct = dst_tbl_conn->copy_table;
11400 pthread_mutex_assert_not_owner(&tmp_conn->mta_conn_mutex);
11401 pthread_mutex_lock(&tmp_conn->mta_conn_mutex);
11402 SPIDER_SET_FILE_POS(&tmp_conn->mta_conn_mutex_file_pos);
11403 tmp_conn->need_mon = &dst_tbl_conn->need_mon;
11404 DBUG_ASSERT(!tmp_conn->mta_conn_mutex_lock_already);
11405 DBUG_ASSERT(!tmp_conn->mta_conn_mutex_unlock_later);
11406 tmp_conn->mta_conn_mutex_lock_already = TRUE;
11407 tmp_conn->mta_conn_mutex_unlock_later = TRUE;
11408 spider_conn_set_timeout_from_share(tmp_conn, 0,
11409 copy_tables->trx->thd, dst_tbl_conn->share);
11410 if (insert_ct->exec_query(
11411 tmp_conn,
11412 -1,
11413 &dst_tbl_conn->need_mon)
11414 ) {
11415 DBUG_ASSERT(tmp_conn->mta_conn_mutex_lock_already);
11416 DBUG_ASSERT(tmp_conn->mta_conn_mutex_unlock_later);
11417 tmp_conn->mta_conn_mutex_lock_already = FALSE;
11418 tmp_conn->mta_conn_mutex_unlock_later = FALSE;
11419 error_num = spider_db_errorno(tmp_conn);
11420 if (error_num == ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM)
11421 my_message(ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM,
11422 ER_SPIDER_REMOTE_SERVER_GONE_AWAY_STR, MYF(0));
11423 goto error_db_query;
11424 } else {
11425 DBUG_ASSERT(tmp_conn->mta_conn_mutex_lock_already);
11426 DBUG_ASSERT(tmp_conn->mta_conn_mutex_unlock_later);
11427 tmp_conn->mta_conn_mutex_lock_already = FALSE;
11428 tmp_conn->mta_conn_mutex_unlock_later = FALSE;
11429 SPIDER_CLEAR_FILE_POS(&tmp_conn->mta_conn_mutex_file_pos);
11430 pthread_mutex_unlock(&tmp_conn->mta_conn_mutex);
11431 }
11432 }
11433 #ifndef WITHOUT_SPIDER_BG_SEARCH
11434 }
11435 #endif
11436
11437 #ifndef WITHOUT_SPIDER_BG_SEARCH
11438 if (copy_tables->bg_mode)
11439 {
11440 for (dst_tbl_conn = copy_tables->table_conn[1]; dst_tbl_conn;
11441 dst_tbl_conn = dst_tbl_conn->next)
11442 {
11443 tmp_conn = dst_tbl_conn->conn;
11444 if (tmp_conn->bg_exec_sql)
11445 {
11446 /* wait */
11447 pthread_mutex_lock(&tmp_conn->bg_conn_mutex);
11448 pthread_mutex_unlock(&tmp_conn->bg_conn_mutex);
11449 }
11450
11451 if (dst_tbl_conn->bg_error_num)
11452 {
11453 if (error_num == ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM)
11454 my_message(ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM,
11455 ER_SPIDER_REMOTE_SERVER_GONE_AWAY_STR, MYF(0));
11456 goto error_db_query;
11457 }
11458 }
11459 }
11460 #endif
11461 }
11462
11463 if (copy_tables->use_transaction)
11464 {
11465 for (roop_count = 0; roop_count < all_link_cnt; roop_count++)
11466 {
11467 tmp_spider = &spider[roop_count];
11468 tmp_conn = tmp_spider->conns[0];
11469 if (tmp_conn->trx_start)
11470 {
11471 if ((error_num = spider_db_commit(tmp_conn)))
11472 goto error_commit;
11473 }
11474 }
11475 } else {
11476 for (roop_count = 0; roop_count < all_link_cnt; roop_count++)
11477 {
11478 tmp_spider = &spider[roop_count];
11479 tmp_conn = tmp_spider->conns[0];
11480 if (tmp_conn->table_lock == 1)
11481 {
11482 tmp_conn->table_lock = 0;
11483 if ((error_num = spider_db_unlock_tables(tmp_spider, 0)))
11484 goto error_unlock_tables;
11485 }
11486 }
11487 }
11488 if (!end_of_file)
11489 {
11490 for (dst_tbl_conn = copy_tables->table_conn[1]; dst_tbl_conn;
11491 dst_tbl_conn = dst_tbl_conn->next)
11492 {
11493 insert_ct = dst_tbl_conn->copy_table;
11494 insert_ct->set_sql_to_pos();
11495 }
11496 DBUG_PRINT("info",("spider sleep"));
11497 bulk_insert_interval = spider_param_udf_ct_bulk_insert_interval(
11498 copy_tables->bulk_insert_interval);
11499 my_sleep(bulk_insert_interval);
11500 }
11501 }
11502 spider_free(spider_current_trx, last_row_pos, MYF(0));
11503 DBUG_RETURN(0);
11504
11505 error_db_query:
11506 #ifndef WITHOUT_SPIDER_BG_SEARCH
11507 if (copy_tables->bg_mode)
11508 {
11509 for (dst_tbl_conn = copy_tables->table_conn[1]; dst_tbl_conn;
11510 dst_tbl_conn = dst_tbl_conn->next)
11511 {
11512 tmp_conn = dst_tbl_conn->conn;
11513 if (tmp_conn->bg_exec_sql)
11514 {
11515 /* wait */
11516 pthread_mutex_lock(&tmp_conn->bg_conn_mutex);
11517 pthread_mutex_unlock(&tmp_conn->bg_conn_mutex);
11518 }
11519 }
11520 }
11521 #endif
11522 error_unlock_tables:
11523 error_commit:
11524 error_lock_tables:
11525 error_lock_table_hash:
11526 error_start_transaction:
11527 error_db_ping:
11528 error_killed:
11529 if (copy_tables->use_transaction)
11530 {
11531 for (roop_count = 0; roop_count < all_link_cnt; roop_count++)
11532 {
11533 tmp_spider = &spider[roop_count];
11534 tmp_conn = tmp_spider->conns[0];
11535 if (tmp_conn->trx_start)
11536 spider_db_rollback(tmp_conn);
11537 }
11538 } else {
11539 if (copy_tables->trx->locked_connections)
11540 {
11541 for (roop_count = 0; roop_count < all_link_cnt; roop_count++)
11542 {
11543 tmp_spider = &spider[roop_count];
11544 tmp_conn = tmp_spider->conns[0];
11545 if (tmp_conn->table_lock == 1)
11546 {
11547 tmp_conn->table_lock = 0;
11548 spider_db_unlock_tables(tmp_spider, 0);
11549 }
11550 }
11551 }
11552 }
11553 error:
11554 if (last_row_pos)
11555 {
11556 spider_free(spider_current_trx, last_row_pos, MYF(0));
11557 }
11558 DBUG_RETURN(error_num);
11559 }
11560
spider_db_open_handler(ha_spider * spider,SPIDER_CONN * conn,int link_idx)11561 int spider_db_open_handler(
11562 ha_spider *spider,
11563 SPIDER_CONN *conn,
11564 int link_idx
11565 ) {
11566 int error_num;
11567 SPIDER_SHARE *share = spider->share;
11568 uint *handler_id_ptr =
11569 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
11570 conn->conn_kind == SPIDER_CONN_KIND_MYSQL ?
11571 #endif
11572 &spider->m_handler_id[link_idx]
11573 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
11574 : conn->conn_kind == SPIDER_CONN_KIND_HS_READ ?
11575 &spider->r_handler_id[link_idx] :
11576 &spider->w_handler_id[link_idx]
11577 #endif
11578 ;
11579 spider_db_handler *dbton_hdl = spider->dbton_handler[conn->dbton_id];
11580 DBUG_ENTER("spider_db_open_handler");
11581 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
11582 pthread_mutex_lock(&conn->mta_conn_mutex);
11583 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
11584 conn->need_mon = &spider->need_mons[link_idx];
11585 DBUG_ASSERT(conn->mta_conn_mutex_file_pos.file_name);
11586 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
11587 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
11588 conn->mta_conn_mutex_lock_already = TRUE;
11589 conn->mta_conn_mutex_unlock_later = TRUE;
11590 if (!spider->handler_opened(link_idx, conn->conn_kind))
11591 *handler_id_ptr = conn->opened_handlers;
11592 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
11593 if (conn->conn_kind == SPIDER_CONN_KIND_MYSQL)
11594 {
11595 #endif
11596 if (!spider->handler_opened(link_idx, conn->conn_kind))
11597 my_sprintf(spider->m_handler_cid[link_idx],
11598 (spider->m_handler_cid[link_idx], SPIDER_SQL_HANDLER_CID_FORMAT,
11599 *handler_id_ptr));
11600
11601 if ((error_num = dbton_hdl->append_open_handler_part(
11602 SPIDER_SQL_TYPE_HANDLER, *handler_id_ptr, conn, link_idx)))
11603 {
11604 goto error;
11605 }
11606
11607 spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
11608 share);
11609 if (dbton_hdl->execute_sql(
11610 SPIDER_SQL_TYPE_HANDLER,
11611 conn,
11612 -1,
11613 &spider->need_mons[link_idx])
11614 ) {
11615 error_num = spider_db_errorno(conn);
11616 goto error;
11617 }
11618 dbton_hdl->reset_sql(SPIDER_SQL_TYPE_HANDLER);
11619 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
11620 } else {
11621 uint reconnect = 0;
11622 if (conn->hs_pre_age != conn->hs_age && conn->server_lost)
11623 {
11624 spider_conn_queue_connect(share, conn, link_idx);
11625 reconnect |= 1;
11626 }
11627 if ((error_num = spider_db_conn_queue_action(conn)))
11628 {
11629 goto error;
11630 }
11631 if (conn->hs_pre_age != conn->hs_age)
11632 {
11633 if (conn->db_conn->ping())
11634 {
11635 my_printf_error(ER_SPIDER_HS_NUM, ER_SPIDER_HS_STR, MYF(0),
11636 conn->db_conn->get_errno(), conn->db_conn->get_error());
11637 spider->need_mons[link_idx] = ER_SPIDER_HS_NUM;
11638 error_num = ER_SPIDER_HS_NUM;
11639 goto error;
11640 }
11641 conn->opened_handlers = 0;
11642 conn->db_conn->reset_opened_handler();
11643 conn->hs_age = conn->hs_pre_age;
11644 reconnect |= 2;
11645 }
11646 if (conn->conn_kind == SPIDER_CONN_KIND_HS_READ)
11647 {
11648 if (spider->hs_r_conn_ages[link_idx] != conn->hs_age)
11649 {
11650 spider->clear_handler_opened(link_idx, SPIDER_CONN_KIND_HS_READ);
11651 *handler_id_ptr = conn->opened_handlers;
11652 }
11653 } else {
11654 if (spider->hs_w_conn_ages[link_idx] != conn->hs_age)
11655 {
11656 spider->clear_handler_opened(link_idx, SPIDER_CONN_KIND_HS_WRITE);
11657 *handler_id_ptr = conn->opened_handlers;
11658 }
11659 }
11660
11661 #ifdef HA_CAN_BULK_ACCESS
11662 if (!spider->is_bulk_access_clone)
11663 {
11664 #endif
11665 conn->db_conn->reset_request_queue();
11666 #ifdef HA_CAN_BULK_ACCESS
11667 } else if (!spider->bulk_access_executing)
11668 {
11669 if (conn->conn_kind == SPIDER_CONN_KIND_HS_READ)
11670 {
11671 spider_set_bit(spider->result_list.hs_r_bulk_open_index, link_idx);
11672 } else {
11673 spider_set_bit(spider->result_list.hs_w_bulk_open_index, link_idx);
11674 }
11675 }
11676 #endif
11677 if ((error_num = dbton_hdl->append_open_handler_part(
11678 SPIDER_SQL_TYPE_OTHER_HS, *handler_id_ptr, conn, link_idx)))
11679 {
11680 goto error;
11681 }
11682 #ifdef HA_CAN_BULK_ACCESS
11683 if (spider->is_bulk_access_clone && !spider->bulk_access_executing)
11684 {
11685 spider->connection_ids[link_idx] = conn->connection_id;
11686 spider_trx_add_bulk_access_conn(spider->trx, conn);
11687 } else {
11688 #endif
11689 spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
11690 share);
11691 if (dbton_hdl->execute_sql(
11692 SPIDER_SQL_TYPE_SELECT_HS,
11693 conn,
11694 -1,
11695 &spider->need_mons[link_idx])
11696 ) {
11697 error_num = spider_db_errorno(conn);
11698 goto error;
11699 }
11700
11701 SPIDER_DB_RESULT *result;
11702 if (spider_bit_is_set(spider->db_request_phase, link_idx))
11703 {
11704 spider_clear_bit(spider->db_request_phase, link_idx);
11705 }
11706 st_spider_db_request_key request_key;
11707 request_key.spider_thread_id = spider->trx->spider_thread_id;
11708 request_key.query_id = spider->trx->thd->query_id;
11709 request_key.handler = spider;
11710 request_key.request_id = spider->db_request_id[link_idx];
11711 request_key.next = NULL;
11712 if (!(result = conn->db_conn->use_result(&request_key, &error_num)))
11713 {
11714 if (!error_num)
11715 {
11716 spider_db_errorno(conn);
11717 error_num = ER_SPIDER_HS_NUM;
11718 }
11719 goto error;
11720 } else {
11721 conn->ping_time = (time_t) time((time_t*) 0);
11722 }
11723 result->free_result();
11724 delete result;
11725 #ifdef HA_CAN_BULK_ACCESS
11726 }
11727 #endif
11728 if (conn->conn_kind == SPIDER_CONN_KIND_HS_READ)
11729 {
11730 spider->r_handler_index[link_idx] = spider->active_index;
11731 spider->hs_r_conn_ages[link_idx] = conn->hs_age;
11732 #ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
11733 if (
11734 spider->sql_command != SQLCOM_HS_INSERT &&
11735 spider->hs_pushed_ret_fields_num < MAX_FIELDS
11736 ) {
11737 spider->hs_r_ret_fields_num[link_idx] =
11738 spider->hs_pushed_ret_fields_num;
11739 memcpy(spider->hs_r_ret_fields[link_idx], spider->hs_pushed_ret_fields,
11740 sizeof(uint32) * spider->hs_pushed_ret_fields_num);
11741 } else {
11742 spider->hs_r_ret_fields_num[link_idx] = MAX_FIELDS;
11743 }
11744 #endif
11745 } else {
11746 spider->w_handler_index[link_idx] = spider->active_index;
11747 spider->hs_w_conn_ages[link_idx] = conn->hs_age;
11748 #ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
11749 if (
11750 spider->sql_command != SQLCOM_HS_INSERT &&
11751 spider->hs_pushed_ret_fields_num < MAX_FIELDS
11752 ) {
11753 spider->hs_w_ret_fields_num[link_idx] =
11754 spider->hs_pushed_ret_fields_num;
11755 memcpy(spider->hs_w_ret_fields[link_idx], spider->hs_pushed_ret_fields,
11756 sizeof(uint32) * spider->hs_pushed_ret_fields_num);
11757 } else {
11758 spider->hs_w_ret_fields_num[link_idx] = MAX_FIELDS;
11759 }
11760 #endif
11761 }
11762 }
11763 #endif
11764 if (!spider->handler_opened(link_idx, conn->conn_kind))
11765 {
11766 if ((error_num = dbton_hdl->insert_opened_handler(conn, link_idx)))
11767 goto error;
11768 conn->opened_handlers++;
11769 }
11770 DBUG_PRINT("info",("spider conn=%p", conn));
11771 DBUG_PRINT("info",("spider opened_handlers=%u", conn->opened_handlers));
11772 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
11773 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
11774 conn->mta_conn_mutex_lock_already = FALSE;
11775 conn->mta_conn_mutex_unlock_later = FALSE;
11776 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
11777 pthread_mutex_unlock(&conn->mta_conn_mutex);
11778 DBUG_RETURN(0);
11779
11780 error:
11781 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
11782 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
11783 conn->mta_conn_mutex_lock_already = FALSE;
11784 conn->mta_conn_mutex_unlock_later = FALSE;
11785 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
11786 pthread_mutex_unlock(&conn->mta_conn_mutex);
11787 DBUG_RETURN(error_num);
11788 }
11789
11790 #ifdef HA_CAN_BULK_ACCESS
spider_db_bulk_open_handler(ha_spider * spider,SPIDER_CONN * conn,int link_idx)11791 int spider_db_bulk_open_handler(
11792 ha_spider *spider,
11793 SPIDER_CONN *conn,
11794 int link_idx
11795 ) {
11796 int error_num = 0;
11797 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
11798 bool opening_index = FALSE;
11799 #endif
11800 DBUG_ENTER("spider_db_bulk_open_handler");
11801 DBUG_PRINT("info",("spider spider=%p", spider));
11802 DBUG_PRINT("info",("spider conn=%p", conn));
11803 DBUG_PRINT("info",("spider link_idx=%d", link_idx));
11804 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
11805 DBUG_ASSERT(conn->conn_kind != SPIDER_CONN_KIND_MYSQL);
11806 if (conn->conn_kind == SPIDER_CONN_KIND_HS_READ)
11807 {
11808 if (spider_bit_is_set(spider->result_list.hs_r_bulk_open_index, link_idx))
11809 {
11810 DBUG_PRINT("info",("spider SPIDER_CONN_KIND_HS_READ"));
11811 spider_clear_bit(spider->result_list.hs_r_bulk_open_index, link_idx);
11812 opening_index = TRUE;
11813 }
11814 } else {
11815 if (spider_bit_is_set(spider->result_list.hs_w_bulk_open_index, link_idx))
11816 {
11817 DBUG_PRINT("info",("spider SPIDER_CONN_KIND_HS_WRITE"));
11818 spider_clear_bit(spider->result_list.hs_w_bulk_open_index, link_idx);
11819 opening_index = TRUE;
11820 }
11821 }
11822 if (opening_index)
11823 {
11824 DBUG_PRINT("info",("spider conn->connection_id=%llu",
11825 conn->connection_id));
11826 DBUG_PRINT("info",("spider spider->connection_ids[%d]=%llu",
11827 link_idx, spider->connection_ids[link_idx]));
11828 if (conn->connection_id != spider->connection_ids[link_idx])
11829 {
11830 my_message(ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM,
11831 ER_SPIDER_REMOTE_SERVER_GONE_AWAY_STR, MYF(0));
11832 DBUG_RETURN(ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM);
11833 }
11834
11835 bool tmp_mta_conn_mutex_unlock_later;
11836 pthread_mutex_assert_owner(&conn->mta_conn_mutex);
11837 tmp_mta_conn_mutex_unlock_later = conn->mta_conn_mutex_unlock_later;
11838 conn->mta_conn_mutex_unlock_later = TRUE;
11839 SPIDER_DB_RESULT *result;
11840 if (spider_bit_is_set(spider->db_request_phase, link_idx))
11841 {
11842 spider_clear_bit(spider->db_request_phase, link_idx);
11843 }
11844 st_spider_db_request_key request_key;
11845 request_key.spider_thread_id = spider->trx->spider_thread_id;
11846 request_key.query_id = spider->trx->thd->query_id;
11847 request_key.handler = spider;
11848 request_key.request_id = spider->db_request_id[link_idx];
11849 request_key.next = NULL;
11850 if (!(result = conn->db_conn->use_result(&request_key, &error_num)))
11851 {
11852 if (!error_num)
11853 {
11854 spider_db_errorno(conn);
11855 error_num = ER_SPIDER_HS_NUM;
11856 }
11857 } else {
11858 result->free_result();
11859 delete result;
11860 }
11861 conn->mta_conn_mutex_unlock_later = tmp_mta_conn_mutex_unlock_later;
11862 }
11863 #endif
11864 DBUG_RETURN(error_num);
11865 }
11866 #endif
11867
spider_db_close_handler(ha_spider * spider,SPIDER_CONN * conn,int link_idx,uint tgt_conn_kind)11868 int spider_db_close_handler(
11869 ha_spider *spider,
11870 SPIDER_CONN *conn,
11871 int link_idx,
11872 uint tgt_conn_kind
11873 ) {
11874 int error_num;
11875 spider_db_handler *dbton_hdl = spider->dbton_handler[conn->dbton_id];
11876 DBUG_ENTER("spider_db_close_handler");
11877 DBUG_PRINT("info",("spider conn=%p", conn));
11878 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
11879 pthread_mutex_lock(&conn->mta_conn_mutex);
11880 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
11881 conn->need_mon = &spider->need_mons[link_idx];
11882 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
11883 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
11884 conn->mta_conn_mutex_lock_already = TRUE;
11885 conn->mta_conn_mutex_unlock_later = TRUE;
11886 if (spider->handler_opened(link_idx, tgt_conn_kind))
11887 {
11888 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
11889 if (conn->conn_kind == SPIDER_CONN_KIND_MYSQL)
11890 {
11891 #endif
11892 dbton_hdl->reset_sql(SPIDER_SQL_TYPE_HANDLER);
11893 if ((error_num = dbton_hdl->append_close_handler_part(
11894 SPIDER_SQL_TYPE_HANDLER, link_idx)))
11895 {
11896 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
11897 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
11898 conn->mta_conn_mutex_lock_already = FALSE;
11899 conn->mta_conn_mutex_unlock_later = FALSE;
11900 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
11901 pthread_mutex_unlock(&conn->mta_conn_mutex);
11902 DBUG_RETURN(error_num);
11903 }
11904
11905 spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
11906 spider->share);
11907 if (dbton_hdl->execute_sql(
11908 SPIDER_SQL_TYPE_HANDLER,
11909 conn,
11910 -1,
11911 &spider->need_mons[link_idx])
11912 ) {
11913 error_num = spider_db_errorno(conn);
11914 goto error;
11915 }
11916 dbton_hdl->reset_sql(SPIDER_SQL_TYPE_HANDLER);
11917 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
11918 } else {
11919 /*
11920 conn->hs_conn->close();
11921 conn->server_lost = TRUE;
11922 */
11923 }
11924 #endif
11925 if ((error_num = dbton_hdl->delete_opened_handler(conn, link_idx)))
11926 goto error;
11927 conn->opened_handlers--;
11928 DBUG_PRINT("info",("spider opened_handlers=%u", conn->opened_handlers));
11929 }
11930 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
11931 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
11932 conn->mta_conn_mutex_lock_already = FALSE;
11933 conn->mta_conn_mutex_unlock_later = FALSE;
11934 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
11935 pthread_mutex_unlock(&conn->mta_conn_mutex);
11936 DBUG_RETURN(0);
11937
11938 error:
11939 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
11940 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
11941 conn->mta_conn_mutex_lock_already = FALSE;
11942 conn->mta_conn_mutex_unlock_later = FALSE;
11943 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
11944 pthread_mutex_unlock(&conn->mta_conn_mutex);
11945 DBUG_RETURN(error_num);
11946 }
11947
11948 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
spider_db_hs_request_buf_reset(SPIDER_CONN * conn)11949 void spider_db_hs_request_buf_reset(
11950 SPIDER_CONN *conn
11951 ) {
11952 DBUG_ENTER("spider_db_hs_request_buf_reset");
11953 if (conn->bulk_access_requests)
11954 {
11955 if (conn->db_conn->is_connected())
11956 {
11957 conn->db_conn->reset_request_queue();
11958 }
11959 conn->bulk_access_requests = 0;
11960 }
11961 DBUG_VOID_RETURN;
11962 }
11963 #endif
11964
spider_db_conn_is_network_error(int error_num)11965 bool spider_db_conn_is_network_error(
11966 int error_num
11967 ) {
11968 DBUG_ENTER("spider_db_conn_is_network_error");
11969 if (
11970 error_num == ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM ||
11971 error_num == ER_CONNECT_TO_FOREIGN_DATA_SOURCE ||
11972 (
11973 error_num >= CR_MIN_ERROR &&
11974 error_num <= CR_MAX_ERROR
11975 )
11976 ) {
11977 DBUG_RETURN(TRUE);
11978 }
11979 DBUG_RETURN(FALSE);
11980 }
11981
11982