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